indexable-inc

Blaze: Incremental Rust builds up to 92x faster than cargo/rustc

Build headlines said 92x faster. I measured my own crate first. A few weeks ago the Rust corner of my feed lit up: a new toolchain promising dramatically faster builds, one benchmark, one headline number. I have seen this movie before: a number from somebody else's crate, somebody else's machine, and then a week of arguing about whether it applies to mine. I did not want to argue about toolchains. I wanted a ruler: something that tells me, on my crate and my machine, where the seconds actually go (per crate, per build script, per link step), then tells me which fix is cheapest, and lets me verify the delta after I apply it. So I built cargoscope. It measures. It recommends. It verifies. It never touches your toolchain. The three commands cargo cargoscope measure [--json out.json] shells out to cargo build --timings twice. The first build is timed; the second is a no-change rebuild. That second run is the trick: cargo omits fresh-skipped units from the timing report, so a build-script-run unit that still shows real duration in the no-change rebuild was genuinely executed again with no source changes. Its freshness is broken: typically a script that rewrites its own rerun-if-changed inputs. That is measured, not guessed from the script source. The report shows wall time, top crates by compile time, build scripts that re-run on every build, and the codegen+link share of the final binary. On stable, the report is honest about what it cannot separate: "link step not separable on stable — the bin unit's duration covers codegen+link together." cargo cargoscope recommend ranks fixes cheapest-first with exact config snippets: cargo check for the edit loop, fixing re-running build scripts, mold/lld linker, sccache, cranelift (gated behind --nightly-ok). It changes nothing. The snippets are yours to review and apply. cargo cargoscope compare before.json after.json prints the measured delta and a verdict line. Only measured numbers; nothing is promised. A real demo, honest numbers The animated demo below is a real terminal recording on the repo's small fixture crate (verbatim transcript also in the repo). Watch the loop: measure flags a build script with RE-RUNS ON EVERY BUILD, recommend ranks the rerun-if-changed fix, I apply it, measure again, compare: !cargoscope demo (real terminal recording): measure flags a re-running build script, recommend ranks the fix, compare verifies -6.6% wall: 0.7s -> 0.7s (-6.6%) units: 5 -> 4 verdict: -6.6% wall time faster (0.7s -> 0.7s) Small crate, small numbers, no hype. The re-run flag is gone; the per-crate deltas are printed, wins and losses. That is the whole point: the tool's job is to make the second measurement possible, not to impress you with the first. The bug the nightly CI caught To separate the link step, cargoscope parses nightly -Ztime stderr. While dogfooding on a real nightly toolchain I found that rustc 1.101-nightly removed -Ztime entirely (unknown unstable option). The old code set RUSTFLAGS=-Ztime whenever it detected nightly, and cargo forwards RUSTFLAGS into its own internal rustc probe, so measure broke completely on new nightlies (cargo exit 101). The fix: probe first (rustc -Ztime --print=sysroot; --version short-circuits before -Z validation, so it cannot be the probe), set the flag only when the probe passes, and fall back gracefully otherwise. A nightly CI job now runs measure on a real nightly toolchain every night and asserts the graceful fallback. Finding your tool broken on a toolchain you claimed to support is the best possible use of a nightly job. Where the rivals beat us Honesty section, as always with my tools: - cargo-blaze wins if in-place recompilation fits your workflow: it actually makes rebuilds faster instead of measuring them. It is a young, invasive bet (replaces the compiler driver). cargoscope complements it: it can measure blaze's own delta. - cargo build --timings wins on zero install. The raw HTML timeline has everything cargoscope parses. cargoscope adds ranking, re-run detection, and before/after verification on top. - cargo-bloat answers a different question (binary size, not build time). Honest limits - It does not speed up your builds. It measures. If you want the build itself to go faster without measuring first, this is the wrong tool. - Timing numbers are your machine's, your crate's, your profile's. A −6.6% here is not a claim about any other setup. - Link-step timing needs a nightly toolchain whose rustc still accepts -Ztime (removed by 1.101-nightly; support is probed, never assumed). - cargo --timings output format is not a stable API. The parser is defensive, records the tested cargo version, and fails loudly instead of guessing. Try it The npm package is not published yet, so install from source for now: git clone https://github.com/techdevfun/cargoscope.git cd cargoscope && npm install && npm run build # then, inside any Rust crate: npx cargo-cargoscope measure Requires Node 20+ and a Rust toolchain (stable is fine). Zero runtime dependencies, MIT licensed. Repo: techdevfun/cargoscope. Issues and PRs welcome; please include your measure output (redacted paths are fine) when reporting wrong numbers. Also listed in the TECHDEV catalog.

blaze: rebuild Rust in milliseconds, 10 to 24x faster than cargo build #Shorts For your AI agent: gitnova.dev (what it is, why it's rising, how to try it) blaze by indexable-inc rebuilds Rust in milliseconds: the same commands as cargo, with blaze in front (blaze run, blaze test, blaze build). It runs beside cargo and keeps your project compiled in memory; after an edit it compiles only the functions you changed and writes them into the program cargo already built. Per the README, edits rebuild 10x faster on macOS arm64, 24x on Linux aarch64 and 11x on Linux x86-64 than with cargo build, on average over real projects. Example from its table (Linux x86-64, edit one function, then build): bun, 1.25M lines of Rust, 9.11 s with cargo build vs 451 ms with blaze build. +540 GitHub stars in 24 hours (measured by GitNova, Oct 28, 2026). How to try it: curl -fsSL ix.dev | sh (macOS on Apple silicon and Linux; per the README, Windows x86-64 also builds through blaze, tested by hand rather than in CI, with no installer yet), then in any Rust project run blaze build. Good to know, per the README: it trades memory for speed (a few GB for a small project), builds with its own nightly Rust toolchain, and is young, so keep cargo check or your CI as the final word. MIT or Apache-2.0. Repo: indexable-inc/blaze Full breakdown: gitnova.dev More tremors: gitnova.dev Star growth is a signal of interest, not a quality rating. Narration is an AI voice; the animation is drawn in code. #Shorts #GitHub #Rust

blaze: incremental compilation for Rust that’s 10x faster than rustc and also adds hot reloading it’s fast because it recompiles only the functions that changed, thus avoiding a full linker process, and also allowing the live program to be patched indexable-inc/blaze

indexable-inc/blaze: Incremental rust builds up to 92x faster than cargo/rustc indexable-inc/blaze

> The borrow checker is new: 0.1.0 has none, so an edit with a borrow error builds and runs; the one on main finds about two thirds of rustc's borrow errors. github.com/indexable-inc/blaze/blob/main/docs/usa… Hey what could go wrong? You didn't really need 33% of your borrow-checking anyways. Only one contributor with more than four commits. Initial commit was 7 days ago. I guess now we have a "vibechecker"!

Incremental rust builds up to 92x faster than cargo/rustc #HackerNews indexable-inc/blaze

Incremental rust builds up to 92x faster than cargo/rustc indexable-inc/blaze (news.ycombinator.com)

增量编译速度比 cargo, rustc 快 92x ☄️ 这就有点厉害了 indexable-inc/blaze

Incremental rust builds up to 92x faster than cargo/rustc