What I learned

Type System Engineering
Built a static type-checking system with inference, validation rules, and helpful error reporting.
Compiler Backend Development
Implemented a bytecode generation pipeline tailored to the language’s execution model.
Virtual Machine Design
Created a custom bytecode VM with instruction dispatch, a debugger, and execution optimizations.
Language Interoperability
Designed a clean API for embedding the language and integrating it with host applications.
Peer-to-Peer Clock Synchronization
Implemented multi-peer clock synchronization to maintain consistent timing across networked clients.

​

How it works

Fuzzy uses a custom rollback netcode implementation. With rollback netcode, you only send player input between clients, not game state. When new input is received by a client, it will rewind the game state and re-simulate using the new input, ending up at a new synced game state. 
This requires the following features:

• Full VM state snapshots: the virtual machine can serialize and restore its entire runtime state efficiently, enabling fast rewinds

• Headless frame simulation: the engine can advance the game by many frames without rendering, allowing rapid re-simulation during rollback

These features are built directly into Plink’s VM, making rollback deterministic and performant.

​​

Preventing Desyncs

Rollback netcode is extremely sensitive. Most game engines are not fully deterministic (for various reasons), so one inconsistent result can lead to a desync.
Plink avoids this by containing the entire game inside a deterministic VM. The language, APIs, and runtime are designed so that every client always produces the same results from the same inputs. If the VM runs the game, it stays synced.
It also allows developers to build online games without worrying about networking, since rollback and synchronization are handled automatically by the framework.