You pause a video game mid-level, shut down your computer, fly to another continent, boot up a different machine, and resume exactly where you left off — same health, same position, same bullet in mid-air. That's the idea behind Gabagool, except instead of save states, it's snapshotting entire WebAssembly program execution.
What It Actually Does
Gabagool is a WebAssembly interpreter written from scratch in Rust. The hook isn't speed or compatibility — it's that you can freeze any running WebAssembly program at any moment, serialize the entire execution state to disk, and restore it later on a completely different process or machine. Every variable, every stack frame, every memory location gets captured.
Think fork() but for WebAssembly programs across time and space.
Why This Matters
Most WebAssembly runtimes optimize for performance. They compile WASM bytecode to native code, use JIT compilation, and generally make programs run fast. But fast programs are hard to pause and impossible to serialize.
Gabagool takes the opposite approach. It stays as an interpreter, sacrificing speed for something more interesting: perfect state capture. You can:
- Debug by literally rewinding program execution
- Migrate long-running computations between machines
- Implement fault tolerance by checkpointing program state
- Build distributed systems where computation can move around
The creator built this because existing WebAssembly runtimes like Wasmtime have been discussing snapshotting for years but never shipped it. Turns out implementing snapshots in an optimizing runtime is genuinely hard.
Taking It For a Spin
Gabagool is surprisingly complete for a from-scratch implementation. It passes 96% of the WebAssembly spec test suite (1,960 out of 2,049 tests). The missing 4% is mostly SIMD and garbage collection — not the core execution model.
Installing requires Rust and uv (Python's fast package manager):
git clone https://github.com/friendlymatthew/gabagool
cd gabagool
# Download the WebAssembly test suite
uv run download-spec-tests.py
# Run the tests to see what works
cargo test --features core-tests
# Try a sample program
cargo run -- ./programs/stair_climb.wasm stair_climb 20
The real magic shows up when you start forking processes. The demo video shows a WebAssembly program running, then forking into multiple processes, each continuing from the exact same execution point. Not "similar" execution — literally identical down to the CPU instruction.
What impressed me: the code is clean and readable. This isn't a research prototype held together with duct tape. The author clearly understands the WebAssembly spec deeply and implemented it methodically.
The Reality Check
This is an interpreter, so it's slow. No benchmarks are published, but don't expect anything close to native performance. The author is upfront about this — optimization isn't the goal yet.
Snapshotting everything comes with overhead. Every operation needs to maintain serializable state, which means more memory usage and more bookkeeping than a typical runtime.
The ecosystem is still tiny. You won't find existing tools that understand Gabagool's snapshot format, and integrating it into larger systems means building those bridges yourself.
Who Should Care
If you're building anything where program state matters more than raw speed, this is worth exploring. Distributed computing researchers, fault-tolerant system builders, anyone working on program analysis or debugging tools.
It's also fascinating if you're learning WebAssembly internals. The code is clean enough to use as a reference implementation, and the author includes extensive reading material about the WebAssembly spec and component model.
This isn't production-ready for high-performance workloads, but it's a solid foundation for experimentation.
Go Try It
Clone the repo and run cargo test --features core-tests. Watch 1,960 tests pass and marvel that someone built a WebAssembly interpreter that actually works. Then try the stair climbing example and think about what you could build if your programs could remember everything.
Compiled by AI. Proofread by caffeine. ☕