rust-gc-vm.
Studying how language runtimes work.
Writing a garbage collector in Rust, with the goal of integrating it into the Dart VM. A long-running project to understand the runtime that Flutter is built on.
The story
This one's a research project, not a product. I wanted to understand — really understand — how the runtime under my Flutter apps actually works. Memory allocation, garbage collection, object layout. The stuff most developers never have to think about.
So I started writing a garbage collector. In Rust. With the eventual goal of plugging it into the Dart VM, which is what Flutter runs on.
What I'm building
A small, embeddable garbage collector written in Rust, with a C ABI so it can integrate into existing language runtimes through FFI.
The roadmap, in order:
- Mark & Sweep — the classic, simplest GC. Walk every live object, mark it, sweep the dead.
- C ABI — expose the GC through a stable interface that any language runtime can call.
- Generational + incremental — split objects into young and old, collect more often where most garbage lives, and avoid stop-the-world pauses.
- Dart VM prototype — actually wire it into the Dart VM via FFI.
Why this matters
Flutter feels fast because of how Dart handles memory. Understanding the runtime gives me a lens most app developers don't have — when I see a jank frame, I know whether it's the framework, the rasterizer, or a GC pause.
It's also a deliberate move into systems work. The same skills that let me reason about GPU memory in the Yahuah pipeline apply here.
Stack
Rust, C ABI / FFI, VM internals, GC algorithm research.
Status
Active, slow-burn research. I work on it in evenings and weekends. The goal isn't shipping a product — it's depth.