How I built super fast JS framework

Mārcis Bergmanis
4 min readMar 7, 2018

*Updated performance tests (added React Fiber)

First of all I want to address elephant in the room that is one question you might be having: “Why the heck another JavaScript framework ?”. Well my answer is that I noticed a pattern in all of the frameworks I recently went through and all of them have the same problem. They are stuck in creating Virtual DOM and then running diffing algorithm over it, which led to diffing algorithm wars. And I thought that there is a better way of doing this (sneaking around this war), so I created a tiny JS Framework called Radi.js.

How does other frameworks operate ?

What if we didn't use Virtual DOM at all, instead work with real DOM instead ? To answer this, we first need to understand how most frameworks work, to better illustrate this I drew a small example.

How other frameworks operate on each change

Violet are DOM/VDOM nodes, Blue = state, Red = diffing, Green = patching. I should explain what happens in this picture. So most of frameworks that have state and DOM, act like this when something in state is modified. In this example, has changed. So now we iterate through all of the nodes (those 5 steps) and renders them. If something is changed, then patching happens where rendered stuff goes to actual DOM (green action). Ok, that's cool, but why do we need to iterate every single node (note that here comes those diffing algorithms that compete with each other and some does diffing differently) when only changes?!..

So back to my original question “Why do we need Virtual DOM ?”, answer is to iterate through all of DOM more quickly. Ok, so what if we didn't iterate ?

Utopia way of doing this

But I want to show you the way that in my head it should work without diffing nor iterating, nor Vnodes for that matter as well.

So in this utopia way we changed same and there is no iteration (so no need for Virtual DOM), only one render (that single red dot), only one single parameter/attribute/node modifies which is affected by changes. Much less unnecessary iteration, unnecessary memory usage for virtual nodes, much less rendering = much faster. This would be so cool right ? The thing is that this is how actually Radi.js work.

How does Radi.js work ?

Now that you know why I created another framework, we can talk how it works underneath. We have state and real DOM nodes, built with HyperScript or JSX. Rather than state being separate, I bind every state value to nodes/attributes that it affects. When something in state changes, it triggers event that re-renders corresponding nodes/attributes. And that is it, not much really going on here.

Performance tests

Finally we need to address my claim, that Radi.js is faster than React (stack). For this, let's use it's own performance test that recreates and animates Sierpinski triangle from DOM node.

There are 2 components 1 is Dot that has prop value as text and hoverable action (wraps number with stars and turns background yellow) with JavaScript not CSS, 2. component is triangle that contains 3 of those Dots. Each visible triangle is nested down in multiple DOM levels. Top component counts from 0 to 10 (on repeat) and feeds this number down to every single component. Also top level component is being constantly resized.

Here are tests for React, Stencil and Radi.js filmed on not that powerful machine.

*Note: In Fiber example I did remove “deferredUpdates” as it makes calculations not to lock view. (Just makes no sense testing against it, as Radi and Stack doesn't do that). Also Radi.js had option to enable this too, but it really had no performance gains as Radi performs so well without it.

React (Stack)~1.8 fps
React (Fiber) ~ 40 fps
Stencil ~41 fps
Radi.js ~58.9 fps

All tests are available live! Take a look yourself:

React (Stack) —
React (Fiber) —
Stencil.js —

The future of this

All the things considered, Radi.js is still in development and this means core, router, fetch, devtools and compiler are in progress of being finished. I am actually building 4 production ready projects with this framework already. So no escape for not finishing this project. But main goal in mind is to create very lightweight, super duper fast, memory efficient framework that is developer friendly (this means amazing debugging tools and ease of writing code and/or migrating from other framework).

Thanks for staying till the end and stay tuned for more of this next time.



Mārcis Bergmanis

Senior Front-end dev and overall JavaScript enthusiast