# Plate: a Slate-based rich-text editor framework with AI and shadcn/ui components

> Plate is a TypeScript editor framework built on slate-react, shipped as a plugin core, unstyled primitives and shadcn/ui components. It suits React teams that want to own the UI, and it is a poor fit if you want a finished editor out of the box.

**udecode/plate** — Rich-text editor with AI and shadcn/ui

- Repository: https://github.com/udecode/plate
- Website: https://platejs.org
- Stars: 16,625 · Forks: 996
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/udecode-plate

## What Plate solves, and who ends up using it

Building a rich-text editor in React usually means stitching together a content model, keyboard handling, serialization and a toolbar. Plate takes the position that the content model and the plugin plumbing should be a framework, while the visual layer should belong to you. The README describes four parts: a core plugin system for slate-react, a set of plugin packages covering behavior, hooks, serialization and normalization, unstyled accessible primitives built on Radix UI, and components generated with the Plate CLI and shadcn/ui.

That split tells you who it is for. If your team already uses shadcn/ui, the component layer is not a foreign dependency; it is the same copy-into-your-repo model. If your team wants a headless editor where you control every pixel and every keyboard shortcut, the primitives are the interesting part. Teams that want an editor with a finished toolbar and no interest in owning component source will find the framework orientation works against them.

## The plugin core, the CLI, and where your components live

The mechanism visible in the repository is a plugin system layered on slate-react. The core handles the editor instance and plugin registration; plugin packages add behavior, hooks, serialization and normalization on top. Primitives are unstyled and accessible, built on Radix UI. Components are not shipped as a locked library you import and forget. According to the README, they are created with the Plate CLI and shadcn/ui, which means the source lands in your project and you edit it there.

That is the central design trade-off. You get full control over markup and styling, and in exchange you inherit the maintenance of whatever the CLI writes into your repository. Upgrading Plate will not silently restyle your editor, but it also will not fix your components for you. The repository layout backs this up: there is a packages/ directory, a templates/ directory, and a tooling/ directory, alongside workspace configuration in pnpm-workspace.yaml and turbo.json. This is a monorepo that publishes many packages rather than one bundle, so your dependency surface is whatever you choose to install.

## Installing Plate and getting a first editor on screen

The README does not walk through an install command for a blank project. What it does provide is a template table. The Plate minimal template is listed with Plate only, no plugins and no AI. The Plate playground template adds plugins and AI but no backend. The Notion-like template is the only one marked with all four columns: Plate, plugins, AI and backend.

The practical first step is to start from one of those templates rather than assembling the core by hand. The repository is a pnpm workspace, so if you clone it, the workspace tooling applies:

```bash
pnpm install
pnpm build
```

If you would rather pull the core package directly into an existing React app, the README links the npm package page for the core under the @platejs scope. The exact peer setup is not spelled out in the README, so check the package page before assuming a version. Once an editor renders, the first real thing to verify is that your plugin list and your component list agree: a plugin that normalizes marks without a corresponding component will accept input you cannot see, which is a confusing first bug.

## Where Plate is the wrong choice

Plate is a framework, and frameworks charge rent. The README's own framing is that components are a starting point for your own component library, not a finished product. If you need an editor you can drop into a form and forget, the CLI-plus-shadcn model adds a code ownership burden you did not ask for.

The second limitation is documentation depth in the README itself. It points to platejs.org/docs for real learning, and the README does not document rollback, migration between major versions, or what happens to components you generated under an older CLI. The repository does carry a .changeset/ directory and recent releases in the v53.3.x line, so versioning is active, but the README alone will not tell you how to move a generated component set forward. Budget for reading the docs site and the changesets, not just the repository front page.

## Plate versus a batteries-included editor

The alternative most teams weigh is a batteries-included editor that ships its own UI, toolbar and theme, so you configure rather than assemble. The difference in approach is ownership of the render layer. A batteries-included editor gives you a working surface quickly and constrains how far you can restyle it without fighting the library. Plate gives you unstyled primitives and generated components, so the render layer is yours from the start.

That also changes the failure mode. With a batteries-included editor, an upgrade can change how your editor looks. With Plate, an upgrade can change what your generated components need to do, and the fix is a diff you apply yourself. Neither is strictly better; they fail in different places. Pick based on whether your design system or the library's design system is the source of truth.

## Maintenance, releases and the licence question

The repository was last pushed on 2026-09-10 and is not archived. Recent releases run through the v53.3.x line, with v53.3.12 published on 2026-09-06, v53.3.11 on 2026-09-04 and v53.3.10 on 2026-09-04. The presence of a .changeset/ directory indicates a changeset-driven release process, which usually means published packages carry their own changelogs.

On licensing, the signals conflict and you should resolve them before shipping. The README displays an MIT badge, and the repository package.json declares "license": "MIT". The repository metadata, however, reports NOASSERTION, which is what automated licence detection returns when it cannot confidently classify the terms. The README also points to a pro.platejs.org domain for the Notion-like template, which suggests some offerings sit outside the open repository. This is not legal advice; it is a flag that the open packages and the hosted template may not share one licence, and that a build which pulls the template is not the same as a build which pulls the core.

## Upgrade cost when the CLI generates your components

Because components are generated into your repository rather than imported, the upgrade path has two halves. The package half moves when you bump your dependencies. The component half moves only when you re-run the CLI or apply changes by hand. The README does not describe a re-generation or migration command, so treat that gap as real work.

The repository does include benchmarks/ with a set of bench:editor:* scripts in the root package.json, including bench:editor:bench and bench:editor:full. Those exist for maintainers measuring the editor itself; they are not a migration tool. If you adopt Plate, pin your versions, keep the generated components in a directory you can diff, and read the changesets for the packages you actually install before bumping.

## Conclusion

Adopt Plate if you are building a React product where the editor is part of your own design system and you can afford to assemble plugins, primitives and components yourself. Do not adopt it if you need a drop-in editor with a fixed toolbar and no component ownership, because the repository ships templates and plugin packages rather than a finished product. Before committing, verify the licence situation first: the README badge says MIT, the repository package.json declares MIT, but the repository metadata reports NOASSERTION, so confirm which packages your build actually pulls and under what terms. Then check that the template you pick matches your backend needs, since only the Notion-like template lists a backend.

## FAQ

### How do I install Plate?

The README does not give a single install command. It points to three templates: the Notion-like template, the Plate playground template and the Plate minimal template. The minimal template lists Plate only, the playground template adds plugins and AI, and the Notion-like template is the only one that also lists a backend.

### How do I use Plate in a React project?

Plate's core is a plugin system for slate-react, and the README says components are created with the Plate CLI and shadcn/ui, so the component source lands in your project. The README directs readers to platejs.org/docs for the actual usage documentation.

### What is Plate?

Plate is a rich-text editor framework written in TypeScript, built as a plugin system on top of slate-react. The README describes four parts: the core, plugin packages for behavior, hooks, serialization and normalization, unstyled accessible primitives on Radix UI, and shadcn/ui components.

### What are the parts of Plate?

The README lists four: the core plugin system for slate-react, plugin packages for behavior, hooks, serialization and normalization, unstyled accessible primitives built on Radix UI, and components created with the Plate CLI and shadcn/ui.

## Sources

- [Issues](https://github.com/udecode/plate/issues)
- [Project website](https://platejs.org)
- [README](https://github.com/udecode/plate/blob/main/README.md)
- [Releases](https://github.com/udecode/plate/releases)
- [udecode/plate on GitHub](https://github.com/udecode/plate)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/udecode-plate