# "92x faster than cargo": a renamed Rust compiler, 18 days, 2000 stars · GitHub open-source project

> Source: https://stringers.io/en/github/gh_indexable-inc__blaze.html (Stringers / 什么值得做, generated 2026-11-08)
> Stringers answers one question every day: what small product can one or two people build in a few months and actually make money from. Numbers come from 15 databases we collect daily, each with source and date.
> For agents: these verdicts and the underlying databases (verified revenue, App Store / Google Play charts, ad libraries, GitHub, Product Hunt…) are queryable live over MCP — tools today / hot / products / directions / direction / data. Setup: https://github.com/komako-workshop/stringers (the user logs in at stringers.io → "配置 agent" to get a personal URL). Site index: https://stringers.io/llms.txt

> The author launched to their own X audience, with a headline comparing it to a famous project using an exaggerated number, "92x faster." After a rename to blaze, the second push hit #1 on the Rust language chart, and Spanish and Japanese dev accounts with big followings reshared it, adding 10-28 +1,084 in a single day. It also landed right on the "one person rewrites a compiler with AI" wave.

[GitHub open-source project](https://stringers.io/en/github/index.md) · written 11-6

indexable-inc/blaze · indexable-inc

# "92x faster than cargo": a renamed Rust compiler, 2000 stars in 18 days

**What it is** A Rust build tool meant to replace cargo. A background process keeps the compiled results in memory, so when you change one function it only recompiles that function. The makers claim rebuilds run 10 to 24 times faster.

**Why it blew up** The author had a built-in X audience for the launch, and the title leaned on a flashy number, "92x faster," compared against a well-known project. After the rename to blaze, the second push hit #1 on the Rust language chart, and big Spanish and Japanese dev accounts picked it up too: 10-28 gained 1,084 in a single day. It also landed right as the "one person rewrites a compiler with AI" wave was peaking.

**C** **How to ride it:** don't build another Rust compiler head-on. Copy how it launched (hard, reproducible numbers, benchmarks on well-known projects, a one-line install, a demo you can see working on the spot, and a rename-then-push if the name doesn't land), then aim the same playbook at slow ecosystems like Swift, Gradle, or C++ with a narrow, fast alternative, and go for #1 in its language chart first.

Grade C: a similar project, rustd, has only 204 stars. This one blazed because of its author's audience and the investment from a YC company, which followers don't get. The "AI rewrites the compiler" wave already has plenty of known players, and the Rust community is starting to push back. The launch playbook is worth learning, but going head-to-head isn't worth it. It's being talked about in small circles

Data (updated daily) · Repo created 2026-10-19 · 2,050 stars · 7 days +239

GitHub · stars

Data 2026-10-21 → 2026-11-08 (19 days, 19 observations). Points before 10-28 come from deeply / archive backfill, not every day has one

In 2026 Oct 20, former xAI engineer Andrew Gazelka posted on X a single line and one command, announcing that his new project makes Rust compile 24x faster. 18 days later, the repo, renamed blaze, had 2003 stars. The idea wasn't his: someone had done nearly the same thing more than a month earlier and got only 204 stars. Below: what blaze is, how the stars came, where the real difference lies, and what indie devs who want their open-source project to take off can take from it.

### One line, one command

Oct 20 noon (Beijing time), @andrewgazelka posted: "24x faster Rust compilation powered by rust-analyzer", followed by a line: `nix run github:indexable-inc/ra-jit`. The post got 926 likes and 57k views. The repo had only been created late the night before, under the name ra-jit, and gathered about 124 stars on day one.

He's no nobody: he wrote hyperion, a Minecraft server engine that can handle tens of thousands of players together, worked at xAI, and his current company, Indexable (ix.dev), is from YC's 2026 spring batch. Those first 100+ stars were bought by his name.

The same day he posted on Hacker News himself, scoring 13 points, and it was quickly marked dead. The top comment said: you imported rustd's code three hours ago, yet your README says "ra-jit already far surpasses rustd, stop using rustd". That's ugly. rustd isn't abandoned; it was updated 17 hours ago.

### What it is

A Rust compilation tool meant to replace `cargo build`. The README's first line is "Rebuild Rust in milliseconds", the second "Type `blaze` wherever you'd type `cargo`", and the third plays on an old Rust community joke: "Blazingly fast Rust, literally."

The principle in one sentence: a resident background process keeps the whole project's compile results in memory. When you change one function, it recompiles only that function and relinks with its own linker. Underneath it uses rust-analyzer's analysis and the Cranelift code generator. v2 claims it no longer needs cargo or rustc at all.

The numbers in the README (all for v1; v2 hasn't been measured yet):

| Rebuild after changing one function (Linux x86-64) | cargo build | blaze build |
|---|---|---|
| ripgrep | 508 ms | 56 ms |
| nushell | 1.25 s | 236 ms |
| helix | 2.15 s | 116 ms |
| bun (1.25M lines of Rust) | 9.11 s | 451 ms |

On average it's 10 to 24x; the repo title's "up to 92x" is the best single case. On HN someone reran its 25 benchmarks: median 19x, lowest 3.7x.

The README also spells out the costs: a small project eats several GB of RAM; it compiles on a pinned nightly build of Rust; there's no Windows installer; and the borrow checker is newly written, with none at all in 0.1.0 and the current version catching about two-thirds of rustc's borrow errors. One HN commenter replied: "So now we have vibechecker."

### Nearly all the stars came in one week

| Date | star | What happened |
|---|---|---|
| 10-21 | 124 | After the first post |
| 10-25 | 192 | Second post "ra-jit can now build most large Rust projects" (417 likes, 27k views); on day 24 it was renamed to blaze |
| 10-26 | 367 | Rename post "blazingly fast rust compilation 🔥🔥"; hit #8 on GitHub Trending Rust |
| 10-27 | 514 | On the day (UTC)+889: #1 on Rust, #19 overall |
| 10-28 | 1,598 | Single day +1,084 |
| 11-06 | 2,003 | Then twenty to thirty a day |

(GitHub daily stars; Trending ranks from Trendshift)

In the last 7 days it grew only 269, while the first 7 days brought 1,547. This was a spike, not sustained growth.

The chain on the breakout day went roughly like this: the second post after the rename pushed it up the Rust language charts → 10-27 hit #1 on the Rust chart → developer accounts in various languages came to it on their own. Spanish-speaking dev @FaztTech posted an intro that day (275 likes, nearly 10k views); Japanese Rust-community account @TaKO8Ki reposted it (202 likes, 12k views); Chinese and Japanese accounts followed with write-ups.

HN didn't help. 10-27 another account posted "Incremental rust builds up to 92x faster than cargo/rustc", scoring 29 points, and it was again marked dead. The top comment said it was the same copied repo posted a second time and suspected the poster was paid (no evidence). 11-02 someone posted it again, scoring 4 points. On Reddit r/rust I found no substantive thread and no media coverage; only a few aggregator sites and YouTube Shorts reposts.

10-28, Charlie Marsh, author of uv and ruff, posted that this kind of "agent-driven Rust fork" using "how long a rebuild takes after an edit" as its metric is very misleading (122 likes, 20k views). Gazelka replied in defense. This pulled blaze into a bigger debate, but it didn't bring a second wave of stars.

### Why it was blaze and not rustd

It isn't the only "compile daemon + recompile only changed functions" project:

| Project | Launched | Scale | How blaze differs |
|---|---|---|---|
| DioxusLabs/rustd | 2026-09 | 204 star | The origin of blaze, same rust-analyzer + Cranelift, "up to 25x"; dependencies still compiled by rustc |
| CapSoftware/cinder | 2026-08 | 99 star | Also called a "drop-in Cargo replacement"; didn't take off |
| t3dotgg/lust-lang | 2026-10 | 101 star | Theo's Rust-subset compiler, serving only his own projects |
| rustc_codegen_cranelift | 2018 | 2,169 star | The official fast backend, still running the full rustc pipeline |
| mold / wild | 2020 / 2024 | 17.7k / 4,100 stars | Only speeds up the linking step |
| sccache | 2016 | 7,900 star | Per-compilation-unit caching; changing one function helps little |
| hot-lib-reloader-rs, subsecond, cargo-hot | From ¥2022 | 87–762 star | Runtime hot patching; doesn't replace the compiler |

(GitHub,11-06)

Compared with rustd, blaze's scope is indeed more aggressive: it builds the whole project itself, supports test and bench, and uses cargo, zed, servo, bun, and OpenAI's Codex CLI as projects it must build before each release, with benchmark curves published on every merge. Bigger scope, bigger numbers in the title (92x vs 25x).

But the same idea, rustd, had only 204 stars a month earlier. That shows **the decisive factor wasn't the technical approach but the author's distribution and packaging** : a pain point every Rust developer complains about, an exaggerated number that makes you want to click, comparisons with well-known projects, a one-line `curl | sh` install, a Game-of-Life demo whose rules you can edit while it runs, and a name that invites memes.

There's also timing. In the fall of 2026, everyone was watching whether "one person plus AI" could write a compiler, and blaze was the most aggressive sample: 19 days, 1,015 PRs merged, the author's account committed 4,600+ times, and of about 689 issues, 588 were opened by the author himself. The 469 still-open issues look more like an AI to-do list than user bug reports from 469 people (GitHub, 11-06; inferred). The author himself said on X that "we have an internal agent chatroom".

On the plagiarism controversy: the README's acknowledgments now include "rustd (DioxusLabs), whose code blaze includes" (11-06 repo page).

### How many people know about it

Very little. Spread stayed within the Rust developer circles on X and a few tech bloggers in several languages. Neither HN post reached the front page, and there was no major media. How many people use it daily can't be seen from outside. The company, though, is already moving toward business: the ix.dev homepage shows "blaze closed beta: Fast Rust CI", and the README's ending is looking for teams "fed up with waiting on Rust compiles".

### If it were you

**Verdict** : C. This cold-start playbook is worth learning, but building another "faster Rust compiler" like blaze isn't worth it. The same-idea rustd has only 204 stars; blaze's gap comes from the author's built-in audience and the YC company's full-time investment. The "AI rewrites a compiler" wave already has Theo, Cap, and Charlie Marsh in it, so newcomers will struggle to be seen.

**Who it suits** : someone who already has a few thousand developers following them on X and holds a performance project that one number can explain; or someone who knows an ecosystem with slow compiles or builds (Swift, Kotlin, C++, Scala) and is willing to iterate hard with AI for several weeks.

**Who it doesn't suit** : anyone without an audience who wants to head-on build a "blaze but better" Rust compiler. It's engineering that involves borrow checking, linkers, and compatibility with dozens of large projects, and blaze is backed by a company. Rust's community has also clearly soured on "AI-written forks"; HN marked it dead twice.

**How to do it** , ranked by how worthwhile:

1. **Copy the launch, not the category** : put an extreme but reproducible number in the title; in the first screen of the README, show a before-and-after against a project everyone knows; one-line install; a demo you can see working on the spot. After launch, watch the reaction, and if the name is hard to remember, rename it and push again. blaze's second round was far bigger than its first.

2. **Switch ecosystems and build a fast replacement for a slow tool** : pick a step developers wait on every day and the community complains about constantly (Swift compilation, Gradle builds, C++ incremental linking, or some other slow step outside Python type checking), use AI to quickly build a narrow, fast replacement, and promise to do only one thing right. Aim first for #1 on that language's GitHub Trending sub-chart, where the bar is far lower than site-wide. Once you're on the chart, reposting accounts in other languages will come on their own.

3. **The part blaze didn't do well** : Windows support, integration with Bazel (some people on HN asked for it), and a neutral "Rust incremental compile benchmark" repo that compares cargo, mold, wild, sccache, and blaze on the same set of projects. The last one doesn't require betting on technology and ties right into Charlie Marsh's debate about misleading metrics.

**How to get users** : mainly X, with the author launching it personally and a 10-to-15-second before-and-after screen recording. Once you're on a language chart, proactively send the post to a few non-English tech bloggers. HN can be tried, but put the source and acknowledgments in the README's first screen beforehand. Forking someone else and saying theirs is worse will get you marked dead on HN every time.

**When to get in** : the #2 move needs to land before the novelty of "one person writes tool X with AI" wears off, probably Q1 of 2027 (inferred). After that, similar titles will be so common that no one clicks.

**What would prove me wrong** : (1) A month from now, blaze is still gaining hundreds of stars a day, or the official Rust project and big projects start recommending it. That would mean the product has real pull beyond a launch spike, and the room for a Rust build-tool play is bigger than I estimated here. (2) Someone with a known name uses the same playbook on another language and gets a project past 1,000 stars. That would mean the playbook itself drives traffic, and item 2 should have been acted on sooner. (3) The reverse: if the next "N times faster" AI rewrite can't even reach the language trending charts, the narrative is worn out, and the value of copying the playbook drops with it.

### Data and sources

GitHub: indexable-inc/blaze repo page, README, daily stars (10-21 to 11-06), contributor and issue stats (11-06); stars of similar repos (11-06). Trendshift: blaze's daily additions and Rust chart rank. X: @andrewgazelka posts 10-20, 10-25, 10-26; @FaztTech, @TaKO8Ki posts 10-27; @charliermarsh post 10-28. Hacker News: items 50168220, 50254300 and comments. Where it says "inferred" or "no evidence", it's inference or unverified.

[GitHub repo ↗](https://github.com/indexable-inc/blaze)

**Research notes: competitor table, acquisition evidence, full research report**

Competitors

| Name | Where | Launched | Scale | How it differs from this one |
|---|---|---|---|---|
| DioxusLabs/rustd | Open source | 2026-09-12 | 204 star | blaze was forked from it; rustd still needs rustc to compile dependencies, has no test, 25x; blaze claims not to use cargo/rustc, has a bigger scope, and much stronger packaging and distribution |
| Cargo's built-in incremental compilation | Big-company features | 2016 | All Rust users | Baseline; blaze recompiles only changed functions and ships its own linker, but its borrow checking is incomplete and it uses several GB of memory |
| rustc_codegen_cranelift | Open source | 2018 | 2169 star | Official fast backend, still runs the full rustc pipeline; blaze uses Cranelift but builds its own frontend and incrementality |
| mold / wild linkers | Open source | 2020 / 2024 | 17.7k / 4.1k star | Speed up only the linking stage; blaze replaces the whole compile chain |
| sccache | Open source | 2016 | 7.9k star | Compilation-unit-level caching; little incremental help when changing one function |
| Dioxus subsecond / hecrj/cargo-hot | Open source | 2025 | cargo-hot 87 star | Runtime hot patching; doesn't replace the compiler; blaze's live edit is a similar capability |
| rksm/hot-lib-reloader-rs | Open source | 2022 | 762 star | Requires splitting code into dynamic libraries; blaze directly replaces the cargo command |
| CapSoftware/cinder | Open source | 2026-08-14 | 99 star | Same positioning as drop-in cargo replacement, but no traction |
| t3dotgg/lust-lang | Open source | 2026-10-15 | 101 star | Only supports a Rust subset, built for ts-rust |

Where users come from

- **Verified** **Founder's X posts** : 10-20 @andrewgazelka 'ra-jit 24x faster' ❤926 👁57k; 10-25 ❤417 👁27k; 10-26 rename post ❤158

- **Verified** **GitHub Trending (Rust chart)** : Trendshift: 10-25/26 #8,10-27 on the Rust chart, #1 on the Rust chart, #19 overall, +889 stars that day

- **Verified** **Multilingual dev accounts reposting** : 10-27 @FaztTech (Spanish) ❤275 👁9.8k; @TaKO8Ki (Japan) ❤202 👁12k

- **Verified** **Hacker News** : 10-20 self-posted by the author (13 pts), 10-27 0x1997 posted (29 pts), both flagged to dead; comments accuse it of copying rustd. 11-02 reposted again with 4 pts. Only aggregator reposts brought a little traffic

- **Verified** **Rename + community meme** : 10-24 ra-jit renamed to blaze, 'Blazingly fast Rust, literally'. The second wave after the rename was far bigger than the first

- **Verified** **Aggregators / short-video reposts** : faun.dev, news.lavx.hu, isvworld, YouTube Shorts, Facebook Daily Finds Dev

## indexable-inc/blaze: why it got 18 stars in 2000 days

> Research date 2026-11-06. Sources: our github DB / hackernews DB / x DB (agent-im server), GitHub API, HN official Firebase API, Trendshift, Jina search/page reader.

### One line

blaze is a Rust compiler/build tool from Indexable, a YC Spring 2026 batch company (founder Andrew Gazelka, ex-xAI engineer, author of hyperion, the engine behind a 10,000-player Minecraft server). It's a resident daemon that keeps the whole project's compile state in memory. Edit one function and it recompiles only that function, then relinks with its own linker. It claims 10–24x faster incremental builds than `cargo build` (the headline says "up to 92x"). Almost all the stars came in the 10-20–10-28 week, from **the founder's own X post + a striking numeric headline + GitHub Trending Rust chart #1 + Spanish/Japanese dev accounts reposting** . It was the loudest entry in the 2026 fall wave of "let AI agents rewrite the compiler."

### 1. Basic data

- Repo created 2026-10-19 23:31 UTC (originally called **ra-jit** ; 10-24 renamed to blaze, same repo). Apache-2.0, homepage ix.dev/blaze.

- 2026-11-06:2003 stars (GitHub API at the time: 2030), 70 forks, open issues 469 (data card).

- Daily stars (our github DB repo_day, by snapshot date): 10-21 124 → 10-25 192 → 10-26 367 → 10-27 514 → **10-28 1598 (single day +1084)** → 11-01 1811 → 11-06 2003. Last 7 days +269, the 7 days before that +1547; clearly fading.

- Trendshift by UTC calendar day: 10-20 +39, 10-24 +50, 10-25 +167, 10-26 +195, **10-27 +889** , 10-28 +192, then 20–50 per day. On 10-25 and 10-26 it hit #8 on the Trendshift Rust chart, **#10-27 on the Rust chart and #1 overall on 19** , #10-28 in Rust on 22; it dropped off the charts afterward (https://trendshift.io/repositories/312802).

- How it was built: 19 days, 1015 PRs merged (Trendshift). Contributor andrewgazelka has 4608 commits; second place is the github-actions bot with 115; everyone else is single digits to twenty-something (GitHub contributors API). Of about 689 issues, 588 were opened by the author himself (GitHub search `author:andrewgazelka`), essentially work tickets the agent created for itself. **The 469 open issues don't mean 469 users are reporting bugs; they're the to-do list of the agent development process** . The author said on X, "we have an internal agent chatroom" (2026-10-27).

### 2. Competitors (doing the same thing: making Rust rebuilds faster after code changes)

| Name | Form | Launched | Scale | How blaze differs |
|---|---|---|---|---|
| DioxusLabs/rustd | Open source | 2026-09-12 | 204 stars (github library) | **blaze's predecessor** : a compile daemon also built on rust-analyzer + Cranelift, "up to 25x faster," self-described as mostly AI-written. It still needs rustc to compile dependencies and a pinned Rust 1.99. ra-jit was forked from it; blaze v2 went further, claiming "no cargo, no rustc." rustd's name recognition, packaging, and distribution were far behind blaze. |
| Dioxus subsecond / dx hot patching, hecrj/cargo-hot | Open source | From ¥2025 | cargo-hot 87 star | Hot-patches functions at runtime without replacing the compiler; blaze's "live edit ~20ms" is the same kind of capability |
| rksm/hot-lib-reloader-rs | Open source | 2022 | 762 star | Hot-reloads code by splitting it into dynamic libraries; requires restructuring the project |
| rustc_codegen_cranelift | Official, open source | 2018 | 2169 star | Official fast code-generation backend, still going through the full rustc pipeline |
| mold / wild linkers | Open source | 2020 / 2024 | 17.7k / 4.1k star | Only speeds up the linking step |
| sccache | Open source | 2016 | 7.9k star | Caches whole compilation units; little help for the "change one function" incremental case |
| Cargo's built-in incremental compilation | Official feature | From ¥2016 | All Rust users | Baseline; all of blaze's numbers are "faster than warm incremental cargo" |
| CapSoftware/cinder | Open source | 2026-08-14 | 99 star | Also called itself a "drop-in Cargo replacement… dramatically faster," barely took off |
| t3dotgg/lust-lang | Open source | 2026-10-15 | 101 star | A Rust-subset compiler + incremental daemon by Theo, serving only his own ts-rust |
| Bazel rules_rust | Open source | 2016 | 854 star | A large monorepo build system; on HN someone said Bazel builds Rust better than cargo |

Takeaway: **"compile daemon + recompile only the changed functions" was not blaze's idea** . rustd got there more than a month earlier with nearly the same approach and only collected 204 stars. blaze succeeded because of distribution, not a unique idea.

### 3. Growth: where the stars came from

Timeline (Beijing time; X data from the x DB / live queries):

1. **10-20 12:58 创始人首发** :@andrewgazelka "24x faster Rust compilation powered by rust-analyzer. nix run github:indexable-inc/ra-jit" ❤926 🔁52 👁5.7 万。当天 star 到 ~124。同日他本人在 HN 发帖(item 50168220,13 分),被指"3 小时前刚 import 了 rustd,README 却写'已经超越 rustd,用 ra-jit 别用 rustd',很不厚道",帖子被 flag 成 dead(HN Firebase:dead=true)。

2. **10-25 00:31 second post** : "ra-jit now compiles most large rust projects" ❤417 👁27k. Trendshift 10-25 hit #8 on the Rust chart.

3. **10-24 renamed to blaze** ; 10-26 23:32 the author quoted @rustaceans_rs "ra-jit got renamed to Blaze!" and posted "blazingly fast rust compilation 🔥🔥" ❤158 👁13k. The name itself played on the Rust community's "Blazingly fast" meme.

4. **10-27 breakout day (UTC +889)** :
    - 11:09 An HN post, "Incremental rust builds up to 92x faster than cargo/rustc" (item 50254300, by user 0 with 1997,29 points), was flagged dead again. The top comment said this is "the second time they've posted this copied library under a new name... last time from a personal account, this time from a bought account?" (the accusation is unverified). Betterhn20 and other HN mirror accounts still reposted it.
    - 11:49 Spanish-language dev account @FaztTech introduced blaze ❤275 👁9.8k; 23:51 Japanese Rust figure @TaKO8Ki reposted it ❤202 👁12k; Chinese and Japanese small accounts followed with explainers.
    - GitHub Trending: Trendshift recorded it at #1 on the Rust chart and #19 overall that day.

5. Since 10-28, only a long tail: Charlie Marsh (author of uv/ruff) posted 10-28 that "using rebuild time as a metric for these agent-driven Rust forks is misleading"❤122 👁20k, and the author replied to defend it. That pulled blaze into a bigger discussion, but it didn't bring a second wave. Since then, aggregators like faun.dev, news.lavx.hu, and isvworld, plus a few YouTube Shorts and Facebook reposts, have covered it sporadically. 11-02 jakubadamw posted it to HN again (4 points).

6. 11-05 The author open-sourced blaze's harness (a native app based on Flecs) ❤100, but it didn't drive more stars.

Channel read: HN flagged both posts dead, so **the main traffic didn't come from HN. It came from a positive loop: founder's X post → star gains put it on GitHub Trending Rust #1 → multilingual dev accounts reposting** . I found no ads, no big r/rust thread (Jina search turned up nothing), and no unsolicited media coverage.

### 4. Why it took off

1. **A pain every Rust developer knows + an extreme number** : slow Rust compile times are the community's top complaint. "92x faster," "rebuild in milliseconds," "type blaze wherever you'd type cargo". One line and you get it, and you want to try it. The README benchmarks against well-known projects like ripgrep 508ms→56ms and bun 9.11s→451ms, which adds a lot of credibility.

2. **The founder had an existing X audience and tech credibility** : hyperion (10,000-player Minecraft server engine), ex-xAI, YC P26. The first post got 57k views and 926 likes, which secured the first 100+ stars right at launch.

3. **Rename + second launch + community meme** : the name ra-jit meant nothing to anyone. Renaming it to blaze ("Blazingly fast Rust, literally") and pushing again put the stars onto GitHub Trending Rust #1, and that Trending placement brought in the multilingual account reposts.

4. **Timing: the "let agents rewrite the compiler" wave** : at the same time there was Theo's ts-rust (1614 stars), lust-lang, Cap's Tov/cinder, and Charlie Marsh's critique of "agent-driven Rust forks." People were asking whether one person plus AI could write a compiler, and blaze was the most aggressive sample (19 days, 4600+ commits, its own frontend/borrow checker/linker, "no cargo, no rustc").

5. **Low-barrier trial** : `curl | sh`, and a live-editable Game of Life demo via `nix run …#life`, with each step mapping to a cargo command.

### 5. Differentiation

- Compared with rustd (its origin): rustd still needs rustc to compile dependencies, has no test, and is only a Linux/macOS prototype. blaze claims the whole project is self-compiled (v2 needs no cargo/rustc), supports build/check/run/test/bench, uses cargo, zed, servo, bun, and Codex CLI as release gates, and publishes per-commit benchmark curves. **The real difference is "a more aggressive scope + far stronger packaging and distribution"** , not the technical approach itself.

- Compared with hot-reload tools (subsecond, hot-lib-reloader): no project restructuring needed, it directly replaces cargo commands.

- Was it the hype that drove it? **Partly.** The broader scope makes the headline number bigger (92x vs rustd's 25x). But rustd, built on the same idea, has only 204 stars, which suggests the deciding factors were the founder's distribution and packaging, not any exclusive technology.

- Costs and risks (from HN comments and the README): the borrow checker is incomplete (0.1.0 has none; on main it catches only some of rustc's 2/3 borrow errors), it uses several GB of memory, it pins a bundled nightly toolchain, v2 speed is still unmeasured, and there's no Windows installer. It was accused of copying rustd and initially didn't credit it in the license. Charlie Marsh questioned the "rebuild time" metric itself.

### 6. How many people can see it

- It spread within niche circles: the Rust/X developer crowd (the founder's post peaked at 57k views, with reposts from FaztTech and TaKO8Ki), and a few aggregator sites covered it. Hacker News flagged it twice and it never reached the front page (not in our HN database, so the score didn't clear the threshold or it went dead). No major media coverage.

- No revenue involved yet, but the company has turned it into a business: the ix.dev homepage went from the YC profile's "agent sandbox infrastructure" to "blaze closed beta: Fast Rust CI," and the README is recruiting teams for "fast Rust CI and remote builds."

- Copycats: none seen copying blaze. Similar projects from the same period (rustd, lust-lang, cinder) are parallel efforts, and all have far fewer stars.

### 7. Takeaways

- The cold-start formula for developer tools: a quantified, extreme comparison number in the headline, a well-known project as the benchmark, a one-line install, and a visual demo. The founder launched it with an X post.

- If the name doesn't land, rename and run another round: the second wave after renaming ra-jit to blaze was much bigger than the first.

- Use GitHub Trending's language charts as an amplifier: reach #1 on a smaller language chart (the Rust chart) first, since the bar is far lower than site-wide. Once charted, repost accounts for each language pick it up on their own.

- Iterating fast with agents (1000+ PRs in 19 days) is itself a story and a trust signal (public benchmark curves, release gates).

- The downside: forking someone else's project while disparaging the original gets you flagged to death on HN. Credit the original formally in the README and the license.

### 8. Uncertain

- Real usage is unknown: stars don't equal use. Most issues were opened by the author or agents, and external user reports number in the roughly hundred range (not broken down further).

- The "92x" figure and v2's actual performance are unverified. The README itself says v2 is untested.

- Whether the second HN poster was a "bought" account is only a comment's accusation, unverified.

- Each channel's share of the 10-27 same-day stars (Trending, big X accounts, HN reposts) can't be separated.

- How the license and credit dispute with rustd plays out is unclear (the README currently credits rust-analyzer and Cranelift in its Credits section; I haven't checked whether rustd is listed).

This article was written by AI from public data and the data we collect daily. Numbers are sourced, and inferences are labeled.