# Lexical review: Meta's editor framework, and what it asks of you
*Source: https://www.editorstack.cc/libraries/lexical — last updated 2026-08-20. Licensed CC BY 4.0 with attribution to EditorStack.*
## Summary
- Lexical is Meta's MIT-licensed editor framework, built around an immutable, transactional editor state, with plugins rather than a supplied interface.
- We measured @lexical/react 0.50.0 with the core at 104.9 kB gzip; in our time-to-editor benchmark (0.49.0) it reached a rendered editor in 25 lines of application code and a median of 159 ms.
- The npm package name carries a 2014 creation date from an unrelated earlier package; Meta's Lexical begins at version 0.1.0 in January 2022, which is the date we record.
## Quick facts
| Fact | Value |
| --- | --- |
| Type | library |
| Licence | MIT |
| First release | 2022-01 |
| Language | TypeScript |
| Frameworks | Any (framework-agnostic) |
| SSR support | partial |
| Bundle (min+gzip) | 104.9 kB gzip |
| Pricing | Free (open source) |
| npm weekly downloads | 4,577,452 |
| GitHub stars | 23,866 |
| Latest version | 0.51.0 |
| Last verified | 2026-08-20 |
| Drag & drop canvas | Partial |
| Responsive breakpoints | No |
| Visual style manager | No |
| Custom components | Yes |
| Data binding | No |
| E-commerce blocks | No |
| Email HTML export | No |
| AI generation | No |
| Editor i18n | Partial |
| White label | Yes |
| Self-hosted | Yes |
## What Lexical is, and who it is for
Lexical is a text editor framework built by Meta for the editing surfaces inside its own products,
and its design shows exactly that origin: an immutable editor state, transactional updates, a strict
reconciliation model, and no opinion whatsoever about what an editor should look like.
It suits teams whose editor is a serious, long-lived part of their product and who care about
behaviour on very large documents. It does not suit a team that needs a rich-text field working this
sprint, because it asks for more assembly than anything else in this dataset before an editor exists
on screen.
Like [Tiptap](/libraries/tiptap), [Plate](/libraries/plate) and [Editor.js](/libraries/editorjs), it
is a document editor. It has no canvas, no layout model and no styling for end users, so it is not an
alternative to [GrapesJS](/libraries/grapesjs) or [Puck](/libraries/puck) regardless of how the
category is described.
## A note on its first release date
Our dataset records Lexical's first release as January 2022, not the 2014 date the npm registry
reports as the package's creation. The name `lexical` was used by an unrelated package that published
0.0.1 in June 2014 and 0.0.2 three days later; Meta's Lexical begins at 0.1.0 on 10 January 2022,
which matches the first publish of `@lexical/react`.
We mention it because it is a clean illustration of our
[methodology](/methodology): reading a registry field is verification only if you also read what the
field means. A comparison site that scraped `time.created` would tell you Lexical is a decade older
than it is.
## Architecture: state first, everything else after
The editor state is immutable and every change is a transaction. Updates run inside `editor.update()`,
node transforms normalise the document, and listeners observe changes. Nothing mutates in place, which
is what makes the model predictable under collaboration and undo.
Plugins are React components that register commands, listeners and nodes against the composer. That
is why the minimal application is longer than Tiptap's: a usable editor needs the composer, a rich
text plugin, a content-editable element, an error boundary and a history plugin, all wired
explicitly. Nothing is bundled for you, and nothing is hidden from you.
The trade is stated honestly by the project itself: it is a framework for building editors, not an
editor.
## Getting started
From our benchmark, unedited. Twenty-five lines — the most of the eight applications we measured, and
every line is doing something the other frameworks decided for you.
```jsx
import { createRoot } from 'react-dom/client';
import { LexicalComposer } from '@lexical/react/LexicalComposer';
import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
import { ContentEditable } from '@lexical/react/LexicalContentEditable';
import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
const config = {
namespace: 'benchmark',
onError(error) {
throw error;
},
};
function App() {
return (
}
placeholder={Hello editor
}
ErrorBoundary={LexicalErrorBoundary}
/>
);
}
createRoot(document.getElementById('app')).render();
```
*Lexical 0.49.0 from the code above. Twenty-five lines of setup produce an editing surface and nothing else — which is the honest picture of what this framework hands you.*
Median 159 ms to a rendered editor, marginally faster than [Tiptap](/libraries/tiptap) at 171 ms.
Within this group those numbers are noise; the twenty-five lines against eleven are not.
## Strengths
**A genuinely well-designed state model.** Immutable, transactional, and easy to reason about. Teams
who have fought a mutable editor model will recognise immediately why this matters.
**Small core, strong performance.** 104.9 kB gzip with the rich-text and history plugins, and the
architecture is built for large documents rather than demos.
**Production credibility.** Meta runs it at a scale nobody else in this category can claim, which is
a meaningful signal for a dependency you intend to keep for years.
**MIT, with no commercial tier.** Nothing is gated behind a paid plan — a real difference from
[Tiptap](/compare/tiptap-vs-lexical), where collaboration and AI are products.
**Deliberately unopinionated.** If your editing surface is unusual — not a document, not a page — this
is the framework least likely to fight you.
## Limitations
**The most assembly required in this dataset.** Twenty-five lines for an editor with no toolbar.
Everything visible is yours to build, and the gap between "it renders" and "a person would use this"
is wide.
**Pre-1.0 API.** Version 0.50.0 at the time of writing. The project is stable in practice and the
version line still signals that public API changes are permitted.
**Documentation has a middle gap.** Concepts are explained well and the playground is a real
reference implementation, but recipes for the features every product needs — mentions, uploads,
toolbars — usually mean reading playground source rather than a guide.
**Smaller third-party ecosystem** than Tiptap's, and packages break more often against a moving
pre-1.0 core.
**Not a page builder**, and not a rich-text drop-in either: budget for the interface work before
comparing it with anything that ships one.
## Pricing
Free under MIT, no paid tier, no hosted service. The cost is entirely engineering time, and for this
framework that cost is higher than for its neighbours — which is the trade you are making for the
state model and the performance.
See [Tiptap vs Lexical](/compare/tiptap-vs-lexical) for the direct comparison, and
[Editor.js vs Lexical](/compare/editorjs-vs-lexical) if the requirement is structured blocks rather
than free-form rich text.
## Who it fits, and who it does not
**Good fit**
- Text editing at scale where predictable performance on very large documents is the deciding requirement
- Teams that want a framework maintained by the company running it in production at the largest scale in the industry
- Products willing to build the entire editor interface in exchange for a small, fast core
**Poor fit**
- Page building of any kind, since there is no canvas, no layout and no styling model
- Teams that need an editor working this week, because every visible control is code you write
- Products that need a stable public API today, given the pre-1.0 version line
## Lexical against its nearest neighbours
| Product | Type | Licence | Frameworks | Bundle (min+gzip) | Price from | Self-hosted | White label | Score |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [Lexical](https://www.editorstack.cc/libraries/lexical) | library | MIT | Any (framework-agnostic) | 104.9 kB gzip | Free (open source) | Yes | Yes | 7.4 |
| [BlockNote](https://www.editorstack.cc/libraries/blocknote) | library | MPL-2.0 | React, Vue | 386.1 kB gzip | from $195/mo | Yes | Yes | not scored |
| [Plate](https://www.editorstack.cc/libraries/plate) | library | MIT | React | 150.8 kB gzip | Free (open source) | Yes | Yes | 8 |
| [Tiptap](https://www.editorstack.cc/libraries/tiptap) | library | MIT | Any (framework-agnostic) | 123.3 kB gzip | Free tier, paid plans undisclosed | Yes | Yes | 8.3 |
## Our scores
- **developer experience: 7.5/10.** The editor state model is genuinely well designed — immutable, transactional, and easy to reason about once it clicks. Getting there takes longer than with Tiptap, because the concepts are lower level and the React composer requires assembling several plugins before anything appears on screen.
- **extensibility: 9/10.** Nodes, commands, transforms and listeners compose cleanly, and the architecture is deliberately unopinionated about rendering. Anything can be replaced, which is why teams building unusual editing surfaces choose it over frameworks that assume a document shape.
- **documentation: 7/10.** Concepts are documented carefully and the playground is a genuine reference implementation. What is thinner is the middle ground: recipes for the features every product needs — mentions, uploads, toolbars — usually mean reading the playground source rather than a guide.
- **ecosystem: 7/10.** Meta's production use gives it credibility and a steady release cadence, and the plugin set covers the common node types. Third-party supply is smaller than Tiptap's, and the pre-1.0 version line means community packages break more often than in a settled ecosystem.
- **time to production: 6.5/10.** The framework asks for the most assembly of any text editor in this dataset before you have something a user would recognise as an editor. That is a deliberate trade for control and performance, and it is the wrong trade for a team whose editor is a feature rather than a differentiator.
## Alternatives
- [Lexical vs Editor.js](https://www.editorstack.cc/compare/editorjs-vs-lexical)
- [Lexical vs Quill](https://www.editorstack.cc/compare/lexical-vs-quill)
- [Lexical vs Plate](https://www.editorstack.cc/compare/plate-vs-lexical)
- [Lexical vs Tiptap](https://www.editorstack.cc/compare/tiptap-vs-lexical)
## Frequently asked questions
### Is Lexical free?
Yes. Lexical is MIT licensed with no commercial tier and no hosted service, which distinguishes it from Tiptap, whose collaboration and AI features are paid products.
### When was Lexical first released?
Meta's Lexical was first published to npm as 0.1.0 on 10 January 2022. The npm package's creation date reads 2014 because an unrelated package occupied the name first — a good example of why a registry field should be read rather than trusted at face value.
### Lexical or Tiptap?
Lexical has the smaller core and a stricter state model; Tiptap is faster to something usable and has a larger extension catalogue. In our benchmark Tiptap needed 11 lines against Lexical's 25 for an equivalent editor.
### Is Lexical production-ready?
Meta runs it in production at very large scale, which is the strongest possible signal for the core. The version line is still pre-1.0, so treat the public API as one that can move between releases.
### Does Lexical work outside React?
The core is framework-agnostic and the React binding is first-party; other framework bindings are community-maintained, so in practice most Lexical work happens in React.
## Sources
1. [npm registry metadata for lexical (MIT licence, version timeline showing 0.1.0 in January 2022)](https://registry.npmjs.org/lexical) — accessed 2026-08-20
2. [npm registry metadata for @lexical/react (first publish date, latest version)](https://registry.npmjs.org/@lexical/react) — accessed 2026-08-20
3. [Lexical documentation](https://lexical.dev/docs/intro) — accessed 2026-08-20