Relax Debuts Rust JIT Compiler Cutting Build Times to Seconds

This is the page's full text as plain HTML, for readers without JavaScript. The same text is in the README and on the plain HTML page.

Relax

Rust without the wait.

rustc builds your program, then you run it. Relax runs your program while it builds it.

Relax is a live compiler and JIT runtime for Rust, written in Rust. It runs a Cargo package straight from source, with no rustc, LLVM or linker in the loop: it compiles each function when it is first called, optimises the hot ones while the program runs, and patches your edits into the running process.

Relax vs cargo and rustc

Code generation for x86-64 and AArch64; from a fresh clone the repository builds and its tests pass on Linux x86-64 and macOS arm64. Windows isn't tested.

The tradeoffs

• Slower optimised code. Overall the code Relax runs is slower than rustc's --release: 1.12× the time on x64 and 1.24× on arm64 (geomean of 21 workloads), 1.22× and 1.25× against a native-CPU build. It is faster on only a few workloads: see where LLVM still wins.
• More memory. The compiler, its caches and every code version it publishes share your program's process, and JIT code is append-only. relax inspect <pid> memory shows the split, code the growth. The code cache in a package's target/makepad-run takes 120 to 190 MB for hello.
• relax check isn't faster than cargo check yet. On a large package a cold check takes longer and uses more memory than cargo check, and an edit can re-check more than it needs to. We're working on it.
• Not every crate runs yet. libs/relax/KNOWN_GAPS.md lists the open gaps, each with a repro.
• Not every edit patches live. Function bodies do. A changed struct layout, import, trait or impl header, or macro waits for a restart, which Relax offers: relax inspect <pid> session relaunch.
• The borrow checker runs beside the program. A run type-checks each function before it runs and borrow-checks in the background; relax run --check-first waits for the borrow checker instead.
• Not a release build. Relax is for the edit-run loop. Ship what cargo build --release builds.

What you get from a JIT

relax run prints a relax-remote: pid <pid> line. Every command below except run and test is relax inspect <pid> <command>, a question the running program answers while it runs.

relax inspect <pid> help lists the rest, among them asm <fn> vs=rustc (the JIT's machine code beside rustc's), count <fn> (exact call counts) and counters (hardware counters).

Try it

From a fresh clone, build relax and run a new package through the JIT:

git clone https://github.com/makepad/relax
cargo build --release --manifest-path relax/Cargo.toml -p relax-runner --bin relax

cargo new hello
cd hello
../relax/target/release/relax run --quiet hello    # run main under the JIT
../relax/target/release/relax test hello           # run its #[test] fns
../relax/target/release/relax check hello          # type- and borrow-check only

Run relax in the package's folder and give it the package's name, not a path. It reads Relax's std from the checkout it was built in, so keep the relax folder where it is.

Measured from a fresh clone: building relax took 53 s on a 16-core x86-64 Linux box and 78 s on a 10-core arm64 Mac with cargo held to 4 jobs. The first relax run of hello took 0.24 s and 0.97 s, the next ones 0.01 to 0.07 s. Relax keeps what it compiles in the package's target/makepad-run (relax clean removes it), so each new package starts cold.

Network. A package with no dependencies, like hello, needs none. For a crates.io dependency Relax takes the package from ~/.cargo's registry when it is there, and otherwise downloads it from crates.io itself, checked against the index's SHA-256. With MAKEPAD_RUN_OFFLINE=1 or cargo's CARGO_NET_OFFLINE it never downloads. relax fetch <git-url> (tools/run/runner/src/fetch.rs) stores a git repository as one file under ~/.makepad-run.

What it took: a new Rust toolchain

Relax isn't a wrapper around rustc or a plugin for LLVM. It replaces both, and the parts of Cargo and the linker in between, with one Rust library.

How Makepad uses Relax

Relax comes from the Makepad project. makepad run and its tooling live in Makepad's repository, not in this one; this section describes how Makepad uses Relax.

makepad is Relax's runner plus a Makepad host. A UI app started with makepad run <package> gets:

Commands other than makepad run go to makepad inspect <app>. Across a day of Makepad's agent lanes, an edit was patched 3.6 s (median) after it reached the machine, 86 s at p90 on a cold JIT or cache.

Built for AI agents

An AI agent can't feel a slow build, but it pays for every one in tokens, wall-clock and lost context. Makepad builds its apps with many AI agents working in parallel, and its dev hub, devhub, keeps each agent's app or test run alive under Relax on a warm machine.

In practice nine agent lanes run side by side, devhub handles more than 300 build and test jobs an hour, and dozens of changes land every day, each checked under Relax before it merges.

Where LLVM still wins

Relax's steady-state code is slower than LLVM's. Time of the same workload under Relax over its time under rustc (lower is better, 1.00× = rustc).

Overall, code run by Relax is slower than code built by rustc: the geomean over 21 workloads is 1.12× the time of stock --release on x64 and 1.24× on arm64, and 1.22× and 1.25× the time of a native-CPU build. Relax is faster on only a few workloads. Against stock it is faster on x64 for rigid-body physics (0.43×), game simulation tick (0.60×) and level walk (0.87×), and on arm64 for the LLM decode host path (0.87×) and level walk (0.91×). The two big x64 wins disappear against the native build (rigid-body physics 1.38×, game simulation tick 1.26×): those two wins are against a generic-CPU baseline. The worst workload is 3D model build, at about twice rustc's time.

Kernel micro-benchmarks (30): steady-state geomean 1.14× against stock and 1.24× against native on x64, about 1.23× on arm64. These are provisional until a warm-cache tier-up bug is fixed: with a warm JIT cache some hot functions never tier up to O3, so the kernel figures can read too slow and are upper bounds. The 21-workload table above is not affected.

x64: an 8-core desktop CPU, Linux; arm64: an Apple M4 laptop, macOS. rustc 1.99.1, LLVM 23.1.1. Each figure is the median of 3 rounds, measured 2026-11-12. Stock is cargo build --release for a generic CPU; native is --release with -C target-cpu=native. Relax is timed in its default mode, in steady state after tier-up. On x64 the stock and native columns come from separate runs on the same machine and binaries. On arm64 the generic CPU is already the M-series baseline, so the two columns differ only by noise.

Which --release? Both are measured: stock (cargo build --release, generic CPU) and native (-C target-cpu=native). Relax always compiles for the CPU it runs on, so native is the like-for-like column.

Where the gap comes from, from instruction-level comparisons of the same functions in one 3D-print slicer run: extra instructions rather than stalls (1.26× the instructions cost 1.15× the cycles).

Inlining isn't a cause: Relax inlines more than rustc does. Every row is a work item.

Relax is for development iteration: release builds use rustc.

Architecture

Relax owns the whole pipeline, from source bytes to executable memory, in one process. It is a stack of layers, each its own crate, building only on the ones below; the layers compile in parallel, and a change in an upper layer never rebuilds the ones below.

A function's life. Before main, the program's own crates are type-checked. The first call of a function compiles it (interpreter or O1); while it is hot, it is recompiled at O3 in the background and swapped in. When you save a change to it, Relax rechecks what changed, recompiles it and publishes the new code; the old code stays valid, and the next call runs the new function.

Design rules. Never stale: every cached result is keyed by the hashes of its inputs. Code only grows: published machine code is never freed or rewritten while it can still be on a stack, so a swap is safe where a native hot-reload hack isn't. Lazy by default: Relax compiles what you call, not everything you might. Inspectable: every phase reports what it's doing, so a stall can be explained from its record.

Repository layout

Cargo.toml                              the workspace
libs/relax/
  lex/ base/ session/ front/ types/     front end and type system
  codegen/ backend/                     middle end and machine code
  compiler/                             runtime, std (compiler/std), 96 end-to-end test packages
  attr/ native_macros/                  #[relax(..)] and native proc macros
  KNOWN_GAPS.md                         what isn't supported yet
libs/relax_api/                         #[relax_api] and per-thread heap routing
tools/run/runner/                       relax, the command-line runner
libs/ platform/ tools/ widgets/         the small support crates Relax links: token model,
                                        serialisation, remote inspection, profiling, and the
                                        native proc macros it checks against their source

The compiler is the relax_compiler library (cargo build --release -p relax-compiler); relax (tools/run/runner) is its command-line runner. Building it needs a stable Rust toolchain and nothing from crates.io.

License

MIT, see LICENSE. The std sources Relax compiles carry their own notices; see libs/relax/compiler/std/CREDITS.md and the license files beside them.