Short answer: keep Cargo as the final authority
Rust tooling developers should evaluate indexable-inc/blaze beside Cargo; teams needing a sole compiler acceptance gate should skip that replacement. Our sandbox completed the recorded install in 12 seconds and build in 2 seconds, with a Python-classified recipe and skipped tests. The stronger reason for this recommendation comes from the Rust evidence: historical affected-test runs became shorter, but issue #84 reports a source edit that Blaze accepted and rustc rejected.
The Blaze README describes a daemon that keeps a project compiled in memory, compiles changed functions and links the program again with its own linker. The README labels its speed figures as v1 results, and says v2 has not been measured yet. That distinction changes the buying decision: a historical benchmark can suggest a useful experiment, while the artifact you install determines which behavior you actually receive.
What people use blaze for
The supplied Rust reports cover affected-test selection, application rebuilding, live editing and compiler measurement. They name projects and outcomes rather than offering one result for every Rust codebase. For an evaluation, choose the activity that costs your team time, then compare both the elapsed time and the resulting program or diagnostic. The following reports provide concrete starting points, with each result attributed to its source.
- The measurement group in issue #2204 exercised hello, ripgrep, nushell and a 19-crate synthetic workspace called the gauntlet. They subsequently adapted measurements to rebuild snapshots after much of the earlier daemon code was deleted.
- Andrew Gazelka reported affected-test selection in issue #227. A ripgrep edit ran 491 tests and skipped 677 in 12.8 seconds, against the earlier Cargo run's 78.3 seconds. A helix-core edit ran 40 tests and skipped 116 in 1.0 second, against 6.9 seconds for Cargo running all 156.
- Hexuria exercised the rox NSH chat shell on macOS aarch64 in issue #224. The application started, but source saves produced 67 refused patches and zero successful splices. Starting an application and applying its next edit were separate outcomes in that session.
- The reporter and maintainers in issue #242 benchmarked Biome after memory fixes. A later patch improved a leaf edit, while signature edits still followed the historical Cargo fallback path.
- Andrew Gazelka's standard-library report, issue #86, describes building ripgrep, nushell and helix with the earlier ra-jit implementation and obtaining output matching Cargo. Its displayed empty-store and warm-store timings differ substantially.
What happened when we ran it
Our run at c54fc99 recorded a 12-second install and 2-second build on November 18, 2026; the test step was skipped. The sandbox configuration specified 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm. The harness classified the ecosystem as Python. These identifiers describe the measured recipe and keep it distinct from the Rust compiler experiments reported by upstream investigators.
| Recorded check | Our result | What the result tells you |
|---|---|---|
| Install | Succeeded in 12 seconds | The recorded recipe completed |
| Dependencies | 34 recorded, 39 MB on disk | Footprint of that recipe's environment |
| Build | Succeeded in 2 seconds | The recorded build step completed |
| Tests | No test script or target; skipped | No passing-test result |
| pip-audit | 0 known vulnerabilities | Result of the recorded Python audit |
| Checkout | 12,660 files, approximately 3,236,332 source lines, 184.3 MB | Size observed in the repository scan |
| Repository signals | 26 CI workflow files; no Dockerfile or tests directory detected | File-discovery observations |
The archive contains a separate quickstart-lib attempt at c54fc993e6f2 on November 18, 2026. Its clone record records 9 seconds. Its run summary describes a fresh unprivileged container with 2 CPUs, 4 GB RAM, no published ports and no secrets. The different resource configuration and recipe identify another attempt, rather than additional measurements from the successful harness run.
The archived installation step attempted uv pip install blaze-scripts in a fresh environment and failed in 1 second with exit 1. The log identifies Python 3.12.12 and says blaze-scripts was absent from the package registry. The installation finding records an unsatisfiable requirement. This failed package step is an outcome in its own right; it does not describe execution of the README's Rust installer.
The archived summary says the package was installed, but the explicit step log records failure. For that attempt, the step log supports the failed-installation outcome. The teardown record reports successful cleanup. The table above retains the separately supplied harness results, so neither the contradictory summary nor the failed package step changes the successful harness timings into a Rust application benchmark.
Where people get stuck: snapshots, manifests and cached code
Issue #2204 reports four crates stopping unmodified workspace checking on Linux aarch64; investigators obtained a runnable binary with patches and temporary stand-ins. That setup explains why the later measurements belong to an investigation binary. The same thread describes manifest filtering, excessive stamper threads and an expensive trivial run, while older reports explain warm-start and live-edit failures in implementations that subsequently changed.
| Reported problem | What the thread says happened | Practical reading |
|---|---|---|
| Rebuild workspace checking stopped in four crates | Investigators applied #2209 plus temporary lifetime and toolchain changes | Reproducing their binary includes those changes |
| Manifest discovery filtered out source paths | 03dae87a6 fixed one discovery defect; explicit paths outside recognized folders were still refused at the reported head | Include unusual manifest paths in a compatibility check |
| Repeat checks started excess stamper threads | #2210 changed stampers to start when first sent work | The reported hello repeat changed from 152.6 MB and 128 threads to 30.6 MB and four threads |
| Trivial run checked unnecessary library bodies | At 4685c8b5b, a trivial run consumed 39.6 seconds and 22.77 GB | Investigators localized the cost to the ladder's run_program path |
| Warm startup discarded reusable functions | #360 retained copied checkout functions; #803 addressed allocator-shim calls | These repairs belong to the earlier implementation |
The warm-start report, issue #216, initially describes 1,615 functions that were not kept and 24,769 entries recompiled because they called them. Its later repair history reports ripgrep startup compilation falling from 7,605 functions to one, with refused entries falling from 6,796 to zero. The thread subsequently moved broader warm-start work to ledger T6/D9. This history explains a concrete cache failure rather than making warm-cache behavior a single property shared by every version.
The rox report adds another failed path: attempted inline workarounds pushed the worker to approximately 27 GB RSS and swap thrashing on a 32 GB host. Investigators identified generic trait callees without usable bodies or symbols and standard-library statics that patches could not share. Later architecture changes and a std-static repair changed those paths. The original session's 67 refusals remain the reported application outcome.
Shared caches can break concurrent agent checks
Issue #2204 reports concurrent checks sharing one HOME failing or hanging because processes collided on temporary filenames. The supplied investigation identifies two processes making the same edit and opening the same temporary file and inode. It traces the filename collision to a per-process tag counter following the same sequence in both processes. This supports a specific shared-store failure mechanism without assigning unsupported byte counts to either write.
The concurrent-check investigation reports improved reruns with #2213: 10 to 11 of 18 concurrent groups failing became zero of 90 over five rounds. It also reports zero of 64 at 64-wide edits on all three projects. Those are attributed patched-rerun results. They make overlapping commands relevant to an agent-worktree evaluation, because separate checkout directories can still use the same HOME and shared store.
Correctness matters before a speed multiplier
Andrew Gazelka reports in issue #84 that Blaze accepted a Ruff/ty edit that rustc rejected. The harness added a parameter to SearchPath::is_standard_library and updated its method-call sites, while other sites passed the function to is_some_and. Rustc rejected the resulting function-arity mismatch. Blaze built the edited code in the reported run, so the tools returned different acceptance decisions for the same source change.
The correctness discrepancy in issue #84 concerns more than an inconvenient fallback or a slow edit. Its final status moves remaining acceptance differences to #1522, ledger C6, after removal of Cargo fallback paths. The README's recommendation to keep Cargo or CI as the final authority fits this evidence. A useful comparison therefore includes deliberate invalid edits as well as successful builds, with diagnostics checked before timing becomes the deciding factor.
Blaze vs Cargo and sccache
Cargo compiles Rust projects, sccache caches compiler results, and Blaze documents function-level rebuilding with its own compiler and daemon. Cargo downloads Rust dependencies and compiles projects. sccache is a compiler wrapper that caches compilation results locally or in cloud storage. These mechanisms give readers a concrete choice: retain the existing compilation workflow, add caching around it, or evaluate a different local rebuild mechanism beside it.
| Workload and source | Blaze or earlier ra-jit | Cargo | Decision supported by the report |
|---|---|---|---|
| Rebuild hello cold check, #2204 | 4.84 seconds, 713 MB, exit 3 | 0.04 seconds, 159 MB, exit 0 | The failed check cannot count as a speed win |
| Earlier ripgrep build, #86 | Empty store and remote: 16.8-17.4 seconds; warm store: 3.98-3.99 seconds | Cold: 5.53-5.76 seconds | Cache state changes the timing comparison |
| Biome leaf edit with #303, #242 | 0.50 seconds, spliced | 11.8 seconds | A specific edit benefited |
| Biome signature edit with #303, #242 | 145.1 seconds, then Cargo | 9.55 seconds | The historical fallback made this edit worse |
The sources are the rebuild scoreboard, standard-library measurements and Biome edit matrix. Biome's initial report also recorded a signature edit taking 111 seconds and 24 GB before going to Cargo, against Cargo's 8.1 seconds. Its warm start took 223 seconds plus 18 seconds to ready. Those initial results and the later #303 matrix describe different measurements; the fallback architecture was subsequently removed.
Cargo's README supports its role as the dependency and compilation baseline. sccache's README documents Rust support and integration through Cargo's rustc-wrapper setting or RUSTC_WRAPPER. Choose between mechanisms using the workload you need to improve. The supplied historical results show that a warm store, a leaf edit and a signature edit can produce different answers even within one project's evaluation.
Identify the Rust project and scope its speed claims
This review covers indexable-inc/blaze, the Rust build tool, rather than Blaze AI or Meteor Blaze. The supplied Blaze AI page describes a marketing product, and the Meteor tutorial describes reactive HTML templates. Those are different entities. Using the repository name keeps their capabilities out of the Rust comparison and gives readers a precise identity to search for.
Orhundev's supplied X search result circulates a claim of up to 92x faster builds than Cargo plus rustc. It supplies a claim, not a workload-specific comparison in this evidence. The issue results above show both gains and failed or slower outcomes, so the useful question is which version, cache condition and edit produced a successful result. A general multiplier would lose those distinctions.
Release activity does not guarantee a usable fix
GitHub metadata records a November 18, 2026 push, while the supplied release record names v0.20261027.0, dated October 28, 2026. Recent repository activity and a published artifact are separate facts. The issue evidence makes that distinction practical: a repair can exist on main while the release intended to deliver it fails, and a toolchain update can remain blocked despite continuing development elsewhere.
The toolchain-bump issue, #1485, records merge conflicts and vendored solver patches that stopped applying. The release-train issue, #631, lists failures across platform jobs, project builds and harnesses. In the rox release correction, a maintainer corrected an initial association between #857 and v0.20261028.1 because that release failed before publication: the fix was on main, but not yet in a published release.
Security: the recorded audit used pip-audit
Our harness recorded zero known vulnerabilities from pip-audit and 34 scanned packages, matching the 34 reported packages in that environment. The audit tool and package coverage give that number its meaning. The repository scan separately found 26 CI workflow files and no Dockerfile or tests directory. File-discovery signals describe what the scan detected; they do not turn skipped tests into a passing test suite.
The Blaze README documents a shell installer fetched over HTTPS and links a security-reporting policy. Reviewing that installer before running it is a practical setup step. Teams considering shared stores should also decide which credentials and artifacts the workflow can access. Those decisions concern operating a build tool, while the pip-audit result remains an observation about the recorded Python environment.
FAQ
Issue #227 reports historical affected-test selection reducing a ripgrep edit run to 12.8 seconds, compared with 78.3 seconds for Cargo running all tests. Its initial implementation used an explicit opt-in. The questions below come from the supplied issue synthesis and cover that test workflow, Linux setup, concurrency, compiler correctness and version identity. Each answer points to the report that supports the stated behavior.
Can Blaze run only the tests affected by an edit, and does it offer watch mode?
Issue #227 documents an initial RA_JIT_TESTS=affected opt-in for affected-test selection in the earlier ra-jit implementation. Its reported ripgrep edit ran 491 tests and skipped 677; helix-core ran 40 and skipped 116. Watch mode appears as a requested workflow in the supplied issue text. The affected-test report therefore supports historical selection behavior and distinguishes it from running every test after each edit.
Why is the Blaze toolchain bump blocked?
Issue #1485 records merge conflicts and vendored solver patches that no longer apply to newer upstream code. The logs call for resolving conflicts and porting affected patches. Blaze's README identifies its own toolchain as blaze-2026-10-27, independent of a project's pin. Changing the application's Rust setting is consequently a different operation from repairing the compiler maintenance failures in the toolchain-bump records.
Does the rebuilt Blaze compile and run on Linux aarch64?
Issue #2204 reports a runnable investigation binary after #2209 and temporary stand-ins were applied; unmodified workspace checking stopped in four crates. The patched binary let investigators collect timings and diagnostics at the reported snapshots. The Linux rebuild investigation describes both the failed workspace check and the changed setup that made subsequent measurements possible, rather than one uninterrupted successful installation.
Can multiple agents run Blaze checks concurrently in worktrees sharing one HOME?
Issue #2204 reports successful concurrent reruns with #2213 after shared-HOME checks failed or hung through temporary-file collisions. Its displayed result changed to zero failures across 90 concurrent groups over five rounds. The concurrency report concerns overlapping commands and a shared store. Sequential builds in separate worktrees exercise a different arrangement, even when the source checkouts and project edits otherwise match.
Why can a warm Blaze start still recompile thousands of functions?
Issue #216 traces historical recompilation to unusable cached callees and later allocator-shim calls. Maintainers report repairs through #360 and #803, followed by moving broader warm-start work to ledger T6/D9. The warm-start investigation gives an implementation-specific chain of causes and changes. It explains why a populated store alone did not guarantee that the loader could reuse every cached function needed by its callers.
Why did every source edit in the rox chat shell fail to splice?
Hexuria's report identifies generic trait callees without usable bodies or symbols and standard-library statics that patches could not share. The session recorded 67 refused patches and zero successful splices. Maintainers later removed the rustc-base architecture and repaired a returning std-static defect, while reduced trait examples stopped reproducing the problem. The rox diagnosis keeps those later changes separate from the original application's measured failures.
How do I install the earlier ra-jit package when cargo install --git fails?
Issue #242 reports a checkout-and-path workaround for the earlier ra-jit workspace error, followed by #293 excluding the vendored workspace and a reporter confirmation of successful installation. That repair concerns the historical package layout. The workspace installation report answers that specific error, while the current README documents a shell installer for Blaze. These are distinct installation routes rather than interchangeable instructions for every artifact.
Does Blaze reject the same invalid Rust programs as rustc?
Issue #84 reports a Ruff/ty edit accepted by Blaze and rejected by rustc because of a function-arity mismatch. Its closing status moves remaining differences to #1522, ledger C6, after removing fallback paths. The reported correctness discrepancy is a concrete reason to keep the existing acceptance workflow. A successful local build and agreement with rustc are separate outcomes in that report.
Does Blaze compile its own standard library, and where does its source come from?
Issue #86's closing comment says Blaze compiles std from the repository's library directory since #932. Earlier comments describe the ra-jit standard-library unit and rust-src from its private toolchain. The standard-library history records a source-location change between those stages. Reading the closing milestone separately from the earlier implementation avoids assigning one source layout to every version discussed in the thread.
Do the published live-edit benchmarks describe v1 or v2?
The README labels its displayed speed figures as v1 measurements, and issue #155 assigns its live-edit baselines to v1. That tracker includes a reported Bevy burst p50 increase from 42.7 ms to 5,192 ms before moving live-edit latency work to ledger T1. The live-edit benchmark history preserves the regression and its version identity. The README also assigns live editing to v1 rather than v2.
What we have not tested yet
Our c54fc99 sandbox covered a Python-classified recipe, not a reproduced Rust compiler workload. The configured image label does not identify actual runtime or operating-system versions; those require raw logs. We have not compared Blaze with Cargo or sccache on our own Rust application, checked diagnostic equivalence, applied live edits, exercised shared-HOME concurrency or run production CI with the rebuilt compiler. No corrected command or example on this page was executed for this revision.
The separate archived package attempt has a contradictory summary and failed installation log. Its records contain no application questions, screenshots, successful Rust task outcomes or Rust-installer step. The issue extracts leave merge confirmation for #2210 and #2213, a completed repair for the costly trivial run, a fresh Biome warm-start measurement and a full rox retest by its reporter unresolved. The supplied release and toolchain records contain no successful completion superseding their reported failures.
The issue evidence mainly consists of maintainer and investigator reports, sometimes using patched binaries. It supplies no confirmed production deployment of the current rebuild. Unrelated Reddit and video results provide no Rust-project user testimony, and autocomplete supplies no measured search demand. No prior published page or related-page URL was supplied for a duplication check. Rendered layout, related links, recommendation modules and template content also fall outside this text correction.
The Python audit does not cover Rust dependencies, compiler correctness, remote-cache trust, installer safety, artifact provenance or source-code confidentiality. Product-score dimensions remain unassessed for the gaps described in their notes. The next useful evaluation would pin an available artifact, record its toolchain and patches, and compare successful output and diagnostics on a representative Rust project before timing the edit loop. That would answer a different question from whether the recorded Python recipe completed.


