The topic of Building an Experimental TypeScript Cipher Inspired by 8 Dimensions is currently the subject of lively debate — readers and analysts are keeping a close eye on developments.
This is taking place in a dynamic environment: companies’ decisions and competitors’ reactions can quickly change the picture.
Over the last few days, I started an experimental study on cryptography with the goal of better understanding concepts such as symmetric encryption, S-Boxes, nonces, diffusion, confusion, permutation, avalanche effect, key derivation, and message authentication.
The idea behind Tesseract-8D/128 is to explore an experimental encryption model where each byte of a message is treated not only as a value, but also as a point inside an 8-dimensional state space.
Instead of simply transforming bytes in a linear sequence, the algorithm assigns each byte a coordinate inside a virtual structure with:
Each byte of the message is associated with a coordinate in the following format:
These coordinates are then transformed through multiple rounds using dimensional rotations, substitutions, permutations, diffusion, and key-derived masks. The goal is to study how a multidimensional representation can influence confusion and diffusion in an experimental cipher.
This project is not intended to replace established cryptographic algorithms. It is an educational experiment designed to better understand how encryption mechanisms work and why building secure cryptography is difficult.
The idea is not to claim that “8 dimensions” automatically make the algorithm secure. In fact, this was one of the first important lessons from the analysis:
In other words, the 8D model is the visual and structural inspiration, but it must contribute meaningfully to the transformation of the data.
By visual complexity, I mean something that looks sophisticated but may still be too linear or weak internally.
So v0.3 focuses on making the 8D layer affect the byte transformation more directly.
A nonce ensures that the same message encrypted with the same password produces different outputs.
This separation is important because encryption and authentication should not rely on the exact same key material.
Version v0.3 uses SHA-512 with domain separators to derive different subkeys for different purposes.
This helps avoid reusing the same key material for unrelated internal operations.
Each byte receives an 8-dimensional coordinate based on its position, the nonce, the current round, and round-specific key material.
In v0.3, this is no longer only conceptual. The coordinates are mixed using a second S-Box.
The coordinate itself does not need to be reversed during decryption because it is recalculated from the same inputs:
One of the main improvements in v0.3 is that the 8D coordinate affects the byte value directly.
This makes the 8D layer more than just a visual mapping. It becomes part of the actual byte transformation.
After transforming the values, the algorithm changes the positions of the bytes using a bijective permutation.
This is important because if two bytes were mapped to the same position, information would be lost and decryption would not work correctly.
If someone changes even one character of the ciphertext, the tag should no longer match and decryption should fail.
This is important because encryption without authentication may allow silent manipulation of encrypted data.
The project also includes a visual page that shows how the permutation layer moves a tracked bit position across rounds.
This visualization only shows the trackable positional movement through the permutation layer.
After S-Boxes, modular additions, diffusion, and block mixing, a single bit no longer keeps a clean identity. It becomes influence spread across the state.
This is only for study and should not replace real hash functions such as SHA-256, SHA-512, SHA-3, or BLAKE3.
After building the first version, I asked for a critical analysis of the idea. The main point raised was:
This is the risk of what I call visual complexity: something may look sophisticated but still fail to provide real cryptographic strength.
The goal is to keep the project simple, visual, and easy to test in the browser.
Cryptography is extremely sensitive. Secure algorithms require years of analysis, public review, attacks, tests, and validation by specialists.
What if a message could be transformed as if it were traveling through an 8-dimensional space?
However, during the study, it became clear that the visual model alone is not enough.
For an algorithm like this to become interesting from a cryptographic perspective, it needs:
It is still far from being a secure cipher, but it has already become a great exercise for understanding how modern encryption systems are designed and why creating your own cryptography is so difficult.
Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment’s permalink.
For further actions, you may consider blocking this person and/or reporting abuse
DEV Community — A space to discuss and keep up software development and manage your software career
Built on Forem — the open source software that powers DEV and other inclusive communities.
Why it matters
News like this often changes audience expectations and competitors’ plans.
When one player makes a move, others usually react — it is worth reading the event in context.
What to look out for next
The full picture will become clear in time, but the headline already shows the dynamics of the industry.
Further statements and user reactions will add to the story.