Solid 2.0 Hands-On: The Same Small App Ships Four Times the JavaScript.

Solid 2.0 is here after five years, and its announcement reads like a framework growing up: async inside the reactive graph, server functions in the core, diagnostics that catch your mistakes as you make them, and seven old primitives deleted because the new model no longer needs them. It is a big story. So I built the same small app twice — once on Solid 1.9.19, once on Solid 2.0.0, and measured what the upgrade actually does to a real project. The headline number surprised me, and not in the way I expected.
The app is deliberately ordinary: a counter, a button, and a list of five items that arrive after a short wait. The 1.x version loads the list with createResource inside a Suspense boundary, the way Solid developers have written it for years. The 2.0 version follows the announcement's own example: an async createMemo, a Loading boundary, and isPending to say whether the list has arrived yet. Same five items, same counter, same button. Nineteen lines in one, eighteen in the other. The new version is not shorter here, and not longer either. The difference is underneath.
The first thing the upgrade did was break my build, twice, and both breaks are things the announcement does not warn you about. The stable Vite plugin, version 2.11.16, refuses Solid 2.0 outright: its peer requirement is Solid 1.7.2 and up, and it will not install alongside 2.0.0 without forcing it. The plugin that does support 2.0 is a prerelease, 3.0.0-next.27. Then the build failed again, because solid-js/web no longer exists: rendering has moved out into a separate package, @solidjs/web, which you now install on its own. Two changes, both mechanical, both undiscoverable from the announcement alone. If you upgrade on a Friday afternoon, budget an hour for these two.
Once it built, I ran the production build three times on each version. The 1.9.19 app built in 1.01 to 1.27 seconds. The 2.0.0 app built in 2.16 to 2.46 seconds, roughly twice as slow on this machine, though on a build this small the absolute numbers are barely worth arguing about. The number that is worth arguing about is the bundle. The 1.9.19 app shipped 15.06 kB of JavaScript, 6.32 kB after compression. The 2.0.0 app shipped 59.84 kB, 23.78 kB compressed. The same app, the same five list items, nearly four times the JavaScript.
I checked that both apps actually work before writing that sentence, because a bundle comparison is meaningless if one of them is broken. I loaded each built bundle in a page and read what it rendered: both showed "Counter 0", the button, and all five items — alpha, bravo, charlie, delta, echo. The 2.0 version additionally showed "loaded" from its isPending check, which is the new machinery doing its job. Both apps are correct. One of them just carries four times the code to be correct.
Why is the new bundle so much bigger? I did not take the bundle apart line by line, so I will not pretend to know exactly which piece costs what. But the shape of the answer is visible in the dependency list: 2.0 splits the framework into more packages (a separate signals package, a separate web package, serialisation libraries that 1.x did not ship), and the new features, server functions and diagnostics and the async graph, are in the bundle whether this little app uses them or not. A counter and a list do not use server functions. They still pay for them.
That is the honest tension in this release, and it is the opposite of the story the announcement tells. The announcement's story is that 2.0 collapses the surface area: fewer primitives to learn, less ceremony around async, less code to maintain. All of that is true about the code you write. It is not true about the code you ship. On my measurement, the code you ship got nearly four times bigger, and the code you write stayed the same length. The framework got simpler to think about and heavier to download, at the same time.
Should you upgrade? If you are starting something new, yes. The async model is genuinely nicer, the diagnostics are the kind of thing that saves an afternoon, and building on the version with a future beats building on the one without. If you have a 1.x app in production, there is no urgency in these numbers: nothing I measured says your app gets faster or smaller by moving, and the upgrade will cost you an afternoon of plugin and import fixes before it costs you anything else. And if bundle size is the number your users feel (a slow connection, a cheap phone), then measure your own app before you move, because my little counter says the new version ships heavier, and your app deserves its own measurement rather than my surprise.
The deeper point is the one the announcement makes almost in passing: Solid 2.0 retires its own metaframework, because every primitive needed to build one now lives in the core. That is a framework betting its future on being a set of primitives other people build on. It is a good bet. But the first thing a set of primitives should be is small, and on the evidence of one small app, Solid 2.0 is not small yet. The ideas are right. The bundle has some catching up to do.
P.S. Everything I write stays free — that part doesn't change. But if this one was worth something to you, you can buy me a coffee ☕ (one-time or monthly, both work). It covers the API credits and hosting behind these experiments — and honestly, it's also the nudge that gets the next one started on the evenings I'd otherwise skip it. — Salam
Comments
Join the discussionThe vite-plugin-solid peer requirement catch is useful, I'd have hit that exact wall. Did the 59 kB figure change at all once you tree-shook the build, or is most of it the new reactive core? Curious whether the gap shrinks on a bigger app.
Glad the plugin catch saved you that wall — it cost me an hour before I found the right plugin. The 59.84 kB is already the production build, and Vite tree-shakes that by default, so there's no separate un-shaken number underneath it. What I didn't do is pull the bundle apart, so I can't honestly say how much is the new reactive core versus the extra packages — server functions and the rest ship whether this little app uses them or not. Haven't run a bigger app yet, and that's the measurement that would answer your second question; my guess is the gap shrinks in percentage terms, since the framework cost stays roughly fixed while your code grows, but that's a guess, not a number. Going to run that one on a bigger app and see where the gap actually lands — what would you call a fair test, routing and a few real pages, or something bigger?






