The 20x Rust Build Speedup That Turned Into a Debugging Marathon
Teams chasing 20x build speedups must budget for stricter parsers, unfamiliar error stacks, and plugin rewrites; a single two-day debugging session or one week rewriting a loader can wipe out months of saved wait time.
Rspack's migration delivered on paper: cold start dropped from 45 seconds to 2, HMR went from seconds to milliseconds, and the official benchmark claimed roughly 20x. Within a week the build failed on a missing space in an old `@media` rule. Lightning CSS, which replaced Webpack's tolerant minifier, rejected it as invalid syntax. A dynamic import silently broke when CommonJS `default` export resolution shifted under stricter interop rules. Webpack had held together years of 'historical dust'; Rust tools refuse to.
The trade-off goes beyond strictness. Rust tools speed up execution of existing compilation burden, but they don't remove any of it: duplicate polyfills, dead tree-shaking, conflicting plugins, and unused loaders still run, just faster. Error stacks are less friendly, and a custom loader that survived five years in Webpack may have no Rspack equivalent, forcing a rewrite. Vite 8's Rolldown upgrade shows the same pattern: `/@/` aliases fail in config loaders, `manualChunks` object syntax is dropped, and Rollup hooks go unsupported.
The decision rule is greenfield or computation-bound. If the build spends 80% of its time compiling a huge library in `node_modules`, Rust pays off. If the repo is full of configs that work without explanation or nobody understands the build chain, the migration bill will eat the speed gain. Rustification is irreversible, but migration cost is the wall between a faster tool and a better project.
The speedup measures execution time, not total engineering time; when debugging and plugin rewrites are added, a 20x build improvement can become net-negative for a team that doesn't understand its build chain.
The binary advice (switch for new or computation-bound projects, postpone for legacy) underestimates the common case where a project has both historical debt and heavy computation; cleaning debt first is the only way Rust speedups become real.
Webpack's tolerance for invalid syntax and quirky interop was a feature that let teams accumulate debt; Rust tools turn that debt into hard failures, which is why migration cost is proportional to a project's age and historical sloppiness.
One position takes the article's caution to heart: a faster tool does not make the project better, and silent failures that raise no error are the scariest failure mode of all. A countervailing firsthand report describes a webpack-to-rspack migration finished quickly with Claude Code, one UMD compilation pitfall aside, with a massive speed gain. The split turns on whether the legacy codebase has accumulated enough tolerated invalid syntax to make the move a marathon or a sprint.
"A faster tool doesn't mean a better project" — that hits the point dead on. The 20x speed looks great to watch, but the real bill for the migration comes due afterward. That silent-failure stretch made me break out in a cold sweat; the scariest thing is when it doesn't even raise an error.
I just finished migrating from webpack to rspack the day before yesterday. Got it done in a short while with Claude Code, only tripping over one UMD compilation pitfall. The speed is far too much better.