lexical VS million

Lexical (https://lexical.dev/) is really nice to use and doesn't use Prosemirror or CKEditor.

I've tried to get to grips with Lexical but found the docs pretty hard to follow. It definitely seems to offer pretty heaps of power, just unlocking that seemed tricky. We're hoping to use it for customer facing collaborative list product that allows for richer media (video, code blocks etc.)

Yes, it uses the Lexical framework internally, so markdown gets converted to an AST, then the AST gets serialized back.

Rich text editing doesn't imply pagination. Contenteditable is not abandoned. Lexical[1], Meta's framework for text editing relies on contenteditables.

[1]: https://lexical.dev/

lexical is a framework for building web based text-editors ... so yea it can do formatting but if you are using it to just do formatting you are very much using the wrong tool.

Haven't tried it out myself, but it's probably Lexical.

Svelte just got a lot more interesting! Dominic who is the creator of LexicalJs and InfernoJs (which is known to be insanely fast) has joined the svelte core team and is now working at Vercel full time! Here is the announcement on Twitter!

Finally there's Slate and Lexical which are super powerful in terms of customizability and extensibility. They're great options for when the editing experience plays a major role in the product.

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/