aberdeen VS million

We've had great results from our custom built non-pure reactive system (which predates React by a couple of years).

The idea is to have an Observable object that can store arbitrary trees of data (each itself an Observable). UI drawing is generally split into a function call for each DOM element that has children. These functions are executed such that they track the use of observables and will be rerun when they change.

I've more recently, after having suffered React and friends, started creating an Open Source implementation of the pattern we used. Currently, it's mostly still lacking in documentation and marketing, and that's unlikely to change if I'm honest. But this should give you an impression if you're interested:

https://github.com/vanviegen/aberdeen/blob/master/examples/t...

Curious to know your thoughts about this being an effective non-pure reactive system.

Yes, that's possible and works really well.

I've written this library [1] as a clean reimplementation of a more complex beast we created for a (now dead) startup. Although the reimplementation has only seen very light use, we've used the concept extensively, and it's a joy to use. Take a look at the examples [2].

[1] https://github.com/vanviegen/aberdeen

Hey HN! Founder of Million – We’re building a tool to that helps fix slow React code. Here is a quick demo: https://youtu.be/k-5jWgpRqlQ

Fixing web performance issues is hard. Every developer knows this experience: we insert console.log everywhere, catch some promising leads, but nothing happens before "time runs out." Eventually, the slow/buggy code never gets fixed, problems pile up on a backlog, and our end users are hurt.

We started Million to fix this. A VSCode extension that identifies slow code and suggests fixes (like ESLint, for performance!) The website is here: https://million.dev/blog/lint

I realized this was a problem when I tried to write an optimizing compiler for React in high school (src: https://github.com/aidenybai/million). It garnered a lot of interest (14K+ stars) and usage, but it didn't solve all user problems.

Traditionally, devtools either hinge on full static analysis OR runtime profiling. We found success in a mixture of the two with dynamic analysis. During compilation, we inject instrumentation where it's necessary. Here is an example:

  function App({ start }) {

To be honest, it fills me with great joy to finally be able to witness the launch of the 3.0.0 major release of Million.js; this is something that has been talked about since maybe July 2023, but, Aiden Bai finally assembled a team to get it out there and just last week on the day 2 February as at 8:00 am PST (Pacific Standard Time) Million v3 was released!!

>> React is not traditionally used for making games, but that's part of the fun and the challenge. R

> MS Flight Simulator cockpits are built with MSFS Avionics Framework which is React-like and MIT licensed:

https://github.com/microsoft/msfs-avionics-mirror/tree/main/...

preactjs may or may not be faster: https://preactjs.com/

Million.js is faster than preact, and lists a number of references under Acknowledgements: https://github.com/aidenybai/million#acknowledgments

https://million.dev/docs :

> We use a novel approach to the virtual DOM called the block virtual DOM. You can read more on what the block virtual DOM is with Virtual DOM: Back in Block and how we make it happen in React with Behind the block().*

React API reference > Components > Profiler:

Consider replacing the default virtual DOM with an alternative solution. For instance, Million.js

@aidenybai 's Millionjs

In brief: I'm Aiden, 18, and have spent the past 2 years of high school working on Million.js, an open source React alternative with 11K stars on GitHub and hundreds of thousands of npm downloads.

Recently, I released automatic mode, which detects slow React components and automatically optimizes the reconciliation phase. It's still in beta but chugging along. It's around 70% faster than React on the JS Framework Benchmark and you can see how I did it here: https://million.dev/blog/virtual-dom

Interested? Check it out here: https://million.dev

Either that or add signals to the library itself. I don't get why it isn't in there when a ton of React's competitors are either using signal-like behavior or forgoing the clearly-obsolete way React handles its VDOM. When a high schooler can create something to make the library faster, you know that the core team is either prioritizing the wrong things or someone managing React is too prideful to admit that a lot of what worked a decade ago doesn't work today.

Reference: https://million.dev/