168. What Rust bought us

The port is done

Part X set a goal in chapter 145: the same output, the same error messages on the same lines, the same exit codes as the TypeScript VM, for all 246 corpus programs. drip-rs meets it, plus 95 programs with a collection before every allocation. It runs the benchmarks about four times as fast. Was it worth it? That depends on what you count, so this chapter counts everything it can.

What ownership forced

Four designs in drip-rs exist because of the borrowing rules, not because a VM needs them:

• Arenas and handles. Objects that point at each other in any pattern can’t be references, so each kind lives in an Arena<T> owned by the heap, and links are Gc<T> indices (chapters 138, 153).
• Explicit roots. The heap can’t borrow the VM that owns it, so the VM hands its roots to collect() as &dyn Trace (chapter 159).
• Registers. The loop can’t hold &self.chunk while it pushes, so ip and an Rc<Chunk> live in the Vm itself (chapter 150).
• Mark bits outside the objects. Marking writes and tracing reads; kept apart, they never fight over one borrow (chapter 159).

None of these is strange: clox, for one, keeps the running frame in a local variable for speed, which is the registers by another route^[2]. But the TypeScript VM could skip all four, and Rust could not.

What it caught

The earlier chapters show the compiler’s refusals: a missing opcode arm (E0004, chapter 150), a class handle passed for an instance (E0308, chapter 145), a reference into a heap that might move (E0502, chapters 150 and 153), two mutable borrows of the compiler at once (E0499, chapters 155 to 158). Each was a compile error, found in seconds. The last two, in C, could have been a dangling pointer or two writers to one object, found when something broke.

At run time, every index is checked. A freed slot holds None, so a stale handle that finds it panics with a message, and #![forbid(unsafe_code)] means no line of drip-rs can turn either check off.

What it couldn’t catch

A Gc<T> is a number. If the VM forgets a root, the program compiles, and the collector frees an object that is still in use. In normal mode the arena reuses freed slots. A later object can move into the slot, and the stale handle reads it: no crash, no undefined behaviour, just the wrong answer. Run it:

// A tiny arena that reuses freed
// slots, like drip-rs in normal mode.
struct Arena {
    slots: Vec<Option<String>>,
    free: Vec<usize>,
}

impl Arena {
    fn alloc(&mut self, s: &str)
        -> usize {
        let v = Some(s.to_string());
        if let Some(i) = self.free.pop()
        {
            self.slots[i] = v;
            return i;
        }
        self.slots.push(v);
        self.slots.len() - 1
    }
    fn free(&mut self, i: usize) {
        self.slots[i] = None;
        self.free.push(i);
    }
    fn get(&self, i: usize) -> &str {
        self.slots[i].as_deref()
            .expect("use after free")
    }
}

fn main() {
    let mut a = Arena {
        slots: vec![],
        free: vec![],
    };
    let name = a.alloc("fib");
    // The collector frees it: a root
    // was forgotten, so name lives on.
    a.free(name);
    let other = a.alloc("zoo");
    println!("{name} {other}");
    // No crash, no UB: just the wrong
    // object.
    println!("{}", a.get(name));
}

That is why drip-rs has two test modes. Debug and stress modes never reuse a slot, so the stale read finds None and panics. And the 95 stress-GC programs collect before every allocation, so a missing root shows up at its first chance. Rust made the bug safe. Making it impossible took tests.

What it cost

I counted code lines in both: not blank, not comments, and for Rust, nothing from a module’s #[cfg(test)] on (2026-10-31, with a short script):

             TypeScript   Rust
compiler            537    804
vm                  362    611
heap / gc           144    348
object + value       55    236
scanner              80    209
everything else     186    355
total             1,364  2,563

Rust has 1.88× the lines and 1.53× the non-blank characters. Lines inflate because rustfmt wraps at 90 columns; the average Rust line has 22.6 non-blank characters, the TypeScript one 27.8. Some of the extra is not about ownership at all. value.rs reimplements JavaScript’s number printing, which the TypeScript VM gets from String(n). The opcodes need a table to decode bytes. And main.rs is a 50-line CLI with no twin in ts/src/vm. The rest is the price of arenas, handles and explicit roots, and of Result on every path that can fail.

There is also time to build: a clean release build with lto took 5.4 seconds here. The TypeScript VM has no build step.

What it bought

Speed, on the committed run: 3.31× to 5.68× the TypeScript VM on the nine timed programs, geometric mean 4.00×, and about 3.6× the work on zoo_batch. The caveats from chapter 167 stay attached: one TypeScript run against best of three, timers that start in different places, a shared VM.

Where did the speed come from? Not from skipping checks: chapter 166 measured four unchecked reads and found the gain inside the noise. The biggest single win was a design decision forced by the borrow checker, the registers. Without them fib ran 39.27 billion instructions instead of 20.19, and took twice as long.

Your turn

fn counts(src: &str) -> (usize, usize) {
    let n = src.lines().count();
    (n, 0)
}

What you learned

• Ownership forced arenas and handles, explicit roots, registers and separate mark bits.
• The compiler caught exhaustiveness, handle-type and borrow errors. It couldn’t see a forgotten root: a safe, wrong read, which the stress-GC tests turn into a panic.
• The port cost 1.88× the lines (1.53× the characters), partly from formatting and work JavaScript does for free.
• It bought 3.31×–5.68× over the TypeScript VM in the committed run, most of it from design, not from removing checks.