The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Bytes issue #186, published May 11, 2023, revisited the virtual DOM through Million.js, a proposed way to reduce React rendering work without abandoning React’s declarative style. The issue reported Million.js’s claim of being “up to 70% faster,” but that figure was not an independently verified benchmark. Its central point was narrower: block-based updates might help components with mostly static content, not every React interface.
What Bytes #186 covered
The issue’s subtitle set out three threads: “One man’s Remix struggle, OSS Marketing 101, and every developer conference in the world happening at the same time.” Its main feature, however, asked whether the virtual DOM needed to be discarded, using Million.js as a case study. Bytes #186
The issue’s other brief items ranged from a critique of Remix and a Retool webinar to Google I/O, conference livestreams, lazy-loaded Web Components, and releases including Vue 3.3, Prisma 4.14, Redwood v5, Dart 3, and Expo Router v2/Expo 49. These were side notes, not the feature’s argument about rendering.
Is the virtual DOM slow?
Not by definition. A virtual DOM is a programming approach: a framework represents the UI in JavaScript, creates a new representation when state changes, compares it with the prior one, and applies the resulting changes to the browser’s real DOM. That lets developers describe the UI declaratively rather than manually tracking every transition.
The approach has costs. The comparison takes computation, and rendering components can also allocate virtual elements and perform other work on each update. Those costs may matter in a particular workload, but the existence of a virtual DOM alone does not show that an application is slow or that a different framework will be faster.
In a 2018 article, Svelte author Rich Harris argued that virtual DOM provides state-driven UI programming with performance that is “generally good enough.” He also argued that a compiler can use build-time knowledge to generate targeted updates and avoid some runtime work. That is Harris’s analysis of the trade-offs, not a neutral benchmark of every framework or application. Rich Harris, “Virtual DOM is pure overhead,” December 27, 2018
Rank #2
What Million.js proposed
Bytes described Million.js, created by Aiden Bai, as a React-oriented alternative intended to retain React’s declarative programming model while reducing rendering work. Rather than treating every DOM element independently, its described approach groups static content into blocks and identifies dynamic content for updates. Developers could wrap React components in block(); static analysis and dirty checking would then help determine what to update.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The reported “up to 70% faster” figure was Million.js’s claim as relayed by Bytes in 2023—not a result established by a comparable independent benchmark in the available evidence. It should not be read as a guaranteed improvement, a result for every application, or a current performance measurement.
Where block-based updates might fit
The feature’s key qualification was workload shape. A component with substantial static content and infrequent changes was presented as a more promising fit: if much of the rendered structure stays the same, a strategy that identifies dynamic regions may avoid some unnecessary work. As content becomes more dynamic, the potential advantage narrows. The issue relayed the creator’s recommendation to use Million.js selectively rather than as a universal replacement.
That distinction matters more than a headline speed claim. Rendering performance depends on what the interface does, how often it updates, and the work performed by the application around those updates. A useful comparison would test the same representative components and interactions, rather than treating one library-wide percentage as decisive.
How to interpret the 2023 comparison
| Approach | Update strategy described in the sources | What the sources establish |
|---|---|---|
| Conventional virtual-DOM approach | Create a new virtual representation, compare it with the prior one, and apply changes to the real DOM. | Harris’s 2018 article explains the runtime work involved and argues that the approach can still offer generally good-enough performance. |
| Million.js as described by Bytes | Group static content into blocks, identify dynamic content, and use static analysis and dirty checking; React components could be wrapped in block(). |
Bytes’ May 2023 feature describes the proposal and reports its performance claim. Current API, compatibility, maintenance, and comparable benchmark results are not established by these sources. |
| Svelte’s compiler-oriented approach | Use build-time knowledge to generate targeted updates, according to Harris’s explanation. | The 2018 article presents the rationale, but the cited material does not provide a current, workload-matched benchmark against Million.js. |
The comparison is therefore about different strategies, not a verdict that one is universally best. Deciding whether Million.js is appropriate now would require current project documentation and tests against the application’s own React version, component patterns, and update workload; the 2023 feature cannot establish those present-day details.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →The JavaScript quiz: why the result is undefined and {}
The issue’s pop quiz assigns a property using Symbol('key'), then reads it using a second Symbol('key') and stringifies the object. The read returns undefined because each call to Symbol() creates a distinct symbol, even when the descriptions match. The JSON result is {} because JSON serialization omits symbol-keyed properties. MDN: Symbol MDN: JSON.stringify()
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
