ra-jit

Edit Rust. See it change in milliseconds, in the program that is already running.

nix run github:indexable-inc/ra-jit

That opens a Game of Life window you can edit while it runs (live on macOS Apple silicon).

For release news: Watch → Custom → Releases on GitHub.

• Live edits. Save a file and the running program has the new code about a millisecond later. Its state stays. (docs/live.md)
• Fast builds. After the first build, an edit rebuilds only the functions you changed. No rustc, no waiting.
• Same cargo. cargo ra-jit build|run|test|check in any project.

Live edit to running code, Game of Life demo (median of 20 edits, one 96-core Linux machine):

Edit, then build, on real projects at pinned commits: incremental cargo build → cargo ra-jit build, both warm, same linker, Cranelift, the median of each run's edits. Each platform is a machine of its own: compare numbers within a platform, not across.

An edit to one function, cargo → ra-jit:

• macOS arm64: MacBook Pro (Mac17,6), macOS 27.0.1, with other work running (Apple M5 Max, 18 cores, 128 GiB), ra-jit 84760c3f51 on 2026-10-21, median of 3 edits, load average 48 at the start, by hand.
• Linux aarch64: AWS c8g.16xlarge, pinned to 16 cores with taskset (Neoverse-V2, 16 of its 64 cores, 124 GiB), ra-jit 2cf189feb6 on 2026-10-22, median of 5 edits, load average 10 at the start, by hand.
• Linux x86-64: AWS c7a.48xlarge (dev-aws-8), pinned to 16 cores with taskset (AMD EPYC 9R14, 16 of its 192 cores, 370 GiB), ra-jit 2cf189feb6 on 2026-10-22, median of 5 edits, load average 13 at the start, by hand.

Measured by hand with harness/bench.py, or by the bench-readme workflow on each platform's benchmark machine once it is registered. The ra-jit measured is cargo build --release; the binaries a release ships are the dist profile with PGO, which start and edit faster (how). Cold builds, the spread of every number, the LLVM tier and how fast the built programs run: docs/benchmarks.md. Raw JSON: macOS arm64, Linux aarch64, Linux x86-64.

Memory and disk, Cranelift, from the same runs as the build table. Peak: the most every process doing the work held at once, cargo → ra-jit. For ra-jit that is the daemon, its workers and what they run, and cargo ra-jit build with any cargo it ran; for plain cargo, cargo itself, rustc, build scripts and the linker. How it is measured: docs/benchmarks.md.

Peak while an edit to one function builds, cargo → ra-jit:

How fast the programs run. Each program is built by cargo build --release and by ra-jit with LLVM at -O3, every crate of it compiled by ra-jit, with the release profile; each benchmark is then run several times, the builds taking turns, median. A run is published only when every program did what the release build's did. Each platform is a machine of its own, and each number is ra-jit's time ÷ release's on it: 1x is as fast.

≈: that benchmark's runs varied by more than 1.5× from fastest to slowest on that machine; read it as rough.

• macOS arm64: GitHub-hosted macos-15 runner, a shared VM (Apple M1 (Virtual), 3 cores, 7 GiB), ra-jit efd7e4bbeb on 2026-10-22, each benchmark run 5 times, load average 15 at the start, by CI.
• Linux aarch64: not measured yet (the machines).
• Linux x86-64: AWS c7a.48xlarge (dev-aws-8), pinned to 16 cores with taskset (AMD EPYC 9R14, 16 of its 192 cores, 370 GiB), ra-jit 2cf189feb6 on 2026-10-22, each benchmark run 5 times, load average 12 at the start, by hand.

Measured by hand with harness/bench.py --runtime (harness/runbench.py), or by the bench-readme workflow on each platform's benchmark machine once it is registered. Raw JSON: macOS arm64, Linux x86-64.

bun's Rust port, 1.4.3: 1.25M lines of Rust in 103 crates on a nightly, beside a JavaScript engine's C and C++ (what it took).

Edit, then build, bun at its pinned commit: incremental cargo build → cargo ra-jit build, both warm, same linker, Cranelift, the median of each run's edits. Each platform is a machine of its own: compare numbers within a platform, not across.

• macOS arm64: one machine (Apple M5 Max, 18 cores, 128 GiB), ra-jit 1645168dc4 on 2026-10-21, load average 28 at the start, by hand.
• Linux aarch64: not measured yet (the machines).
• Linux x86-64: not measured yet (the machines).

(c): the daemon handed this edit to cargo (a fallback, so about cargo's time).

Measured by hand with harness/bench.py, or by the bench-bun workflow on each platform's benchmark machine once it is registered. The ra-jit measured is cargo build --release; the binaries a release ships are the dist profile with PGO, which start and edit faster (how). Raw JSON: macOS arm64.

ra-jit's whole-program build of bun does not link yet: about 1,300 of its functions are not compiled (#35), so how fast it runs is not measured.

Not measured yet: test suites (#benchmarks).

nix run github:indexable-inc/ra-jit#ra-jit -- build

No nix? Put the binaries from a release on your PATH, or build them with cargo +1.99.0 install --locked --profile dist ra-jit. Then use Rust 1.99.0 with its source: rustup toolchain install 1.99.0 -c rust-src && rustup override set 1.99.0.

A release's binaries and nix build the same ra-jit: the dist profile (thin LTO), optimized with the profile of its own work that pgo/profiles.json pins (how). cargo install builds dist without that last step, which on Linux starts about 10% slower and edits about 3% slower than a release's binaries: cargo takes no compiler flags from a crate, and the crates it builds from crates.io are not the ones the profile was made of, so none could be handed to it either. (--profile dist comes with the first release after 0.1.0.)

nix profile install github:indexable-inc/ra-jit#ra-jit
ra-jit enable

From then on plain cargo build, run, test and check in any project go through ra-jit. ra-jit disable puts your cargo config back.

Add the crate and poll once per frame:

ra-jit-live = "0.1"

let mut live = ra_jit_live::Live::start().ok();
loop {
    if let Some(outcome) = live.as_mut().and_then(|it| it.poll()) {
        eprintln!("ra-jit: {outcome}");
    }
    // ...your frame
}

#[ra_jit::cache] on a pure function keeps its results across runs, until an edit changes the code it reaches (docs/fn-cache.md).

• Live edits work on macOS Apple silicon only. Elsewhere you still get fast builds.
• An edit with a borrow-check error is refused, but the borrow checker still misses about a third of rustc's errors: cargo check stays the final word.
• Rust 1.99.0 only.
• Changing a struct the program is using asks for a restart.

More: how it works, full results, what is supported.

ra-jit stands on the shoulders of giants. Thank you to the people who built:

• rust-analyzer, whose analysis and MIR ra-jit compiles from
• Cranelift (Bytecode Alliance), the fast code generator
• LLVM and inkwell, for the optimised tiers
• salsa, the incremental engine underneath
• object, for reading and writing executables
• Rust and its compiler crates
• rustd (DioxusLabs), whose code ra-jit includes

None of these projects endorses ra-jit.

Made at ix for den's native app. MIT or Apache-2.0.