mrkeyoor.comAsk

indexable-inc/blazetested 18 Nov 2026commit c54fc99

blaze review

Use Blaze for a pinned evaluation of Rust edit loops beside Cargo, especially when affected-test selection or function-level rebuilding matches your workload.

  • Build 2 s
12 sto install
  • 34 packages
Dev Toolsevaluationupdated 18 Nov 2026
+23 / 3dstars / 7d

Blaze, indexable-inc/blaze, is a Rust build tool whose daemon keeps compiled work in memory and rebuilds changed functions. Its README separates v1 speed measurements from v2 and recommends keeping Cargo or CI as the final authority.

Verdict

Use Blaze for a pinned evaluation of Rust edit loops beside Cargo, especially when affected-test selection or function-level rebuilding matches your workload. Teams needing rustc-equivalent acceptance as their only gate should not replace that workflow with Blaze: issue #84 reports an invalid program it accepted. Our install and build completed in 12 and 2 seconds, but those are Python-classified recipe results, with tests skipped.

Blaze infographic: keeps compiled work in memory and rebuilds changed functions, plus our test result and who it suits
Tested 18 November 2026: uv pip install blaze-scripts failed after 1 s. Before that: source install 12 s, build 2 s.

We ran it

Lab card: what happened when we ran blaze
Lab card from our sandbox run
Screenshot of blaze (ix.dev/blaze)
ix.dev/blaze
Install✓ · 12s34 packages · 39 MB
Build✓ · 2s
Testsn/ano test script
Known vulns0(pip-audit)
Repo12660 files~3,236,332 lines of source · 184.3 MB · 26 CI workflows

Answers from our run

Does blaze build from source?

Dependencies installed in 12 seconds (34 packages), and the build succeeded in 2 seconds. We cloned commit c54fc99 into a clean Debian container with 3 CPUs and no project-specific setup.

Does blaze have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does blaze have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use blaze?

Teams replacing rustc as their sole acceptance gate: issue #84 reports Blaze accepting an invalid Ruff/ty edit.

What are the alternatives to blaze?

Cargo, sccache. Use Blaze for a pinned evaluation of Rust edit loops beside Cargo, especially when affected-test selection or function-level rebuilding matches your workload.

Setup2/5In our 2026-11-18 run “uv pip install blaze-scripts” failed with “╰─▶ Because blaze-scripts was not found in the package registry and y…”, though our source checkout installed in 12 s and built in 2 s.Editor’s note: The Rust installer was not exercised: the successful harness used a Python-classified recipe, and the separate archived package attempt failed.
Docs4/5The README has an install section (“Install”) and a usage section (“Try it”); we did not run its quickstart ourselves.Editor’s note: The supplied README documents installation and version distinctions, but its linked workflow was not executed end to end.
Community4/5Last push on 2026-11-18, 2,410 stars, maintainers answered or closed 7 of the 10 most-discussed issues we sampled and 462 open issues and pull requests is a heavy backlog for its size.Editor’s note: Sampled maintainer and investigator threads supply no representative adoption or support-response measurement.
Maturity2/5Latest release v0.20261027.0 on 2026-10-28 and repository created 2026-10-19.Editor’s note: The records span historical implementations and patched rebuild snapshots; our sandbox reproduced no current production Rust workload.

How we score

Discussed on

  1. hnBlaze: Incremental Rust builds up to 92x faster than cargo/rustc4 points

Who it’s for

Rust tooling developers evaluating a pinned Blaze artifact beside Cargo.
Engineers investigating function-level rebuilding or affected-test selection on a representative project.
Teams comparing successful output and diagnostics alongside elapsed time.

Who it’s NOT for

Teams replacing rustc as their sole acceptance gate: issue #84 reports Blaze accepting an invalid Ruff/ty edit.
Developers expecting v1 live editing in v2: the README assigns live edits to v1.
Windows users needing the documented installer: the README lists macOS on Apple silicon and Linux.

Setup reality

Our November 18, 2026 run at c54fc99 recorded a successful install in 12 seconds and build in 2 seconds, with 34 dependencies and 39 MB on disk. Tests were skipped because the recipe found no test script or target. pip-audit reported zero known vulnerabilities. The harness classified the ecosystem as Python.

The configured sandbox had 3 CPUs, 8 GB RAM and image ghcr.io/astral-sh/uv:python3.12-bookworm. A separate archived quickstart-lib attempt at c54fc993e6f2 recorded a failed blaze-scripts package installation. These are separate attempts, not consecutive steps in one successful Rust setup.

The README documents a shell installer for macOS on Apple silicon and Linux, with stable and canary channels. It says Blaze uses its own Rust toolchain, blaze-2026-10-27, regardless of the project's pin.

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.

Alternatives

ProjectWhat it isPick it when
Cargo gh↗Rust's dependency and compilation tool, and the baseline in the supplied issue comparisons.Choose Cargo for the existing Rust compilation workflow and retain it or CI as the final authority, as Blaze's README recommends.
sccacheA compiler wrapper that caches compilation results locally or in cloud storage, including Rust compilations.Evaluate sccache when you want compiler-result caching around the existing compiler workflow.

What people are saying

  1. [velocity-scout] indexable-inc/blaze

Sources

  1. Blaze README
  2. Rebuild measurements
  3. Affected-test selection
  4. Compiler correctness discrepancy
  5. Biome edit results
  6. Rox live-edit report
  7. Cargo README
  8. sccache README

More dev tools reviews