Dante: React block editor on TipTap and ProseMirror, with 6 built-in block types

A React block editor built on TipTap and ProseMirror, not a direct Medium clone

Dante's GitHub description reads 'Just another Medium wysiwyg editor clone', but the README describes it as 'a block editor and renderer built on top of TipTap and ProseMirror'. TipTap is itself a headless editor framework that wraps ProseMirror, so Dante adds a block-oriented React surface on top of 2 abstraction layers. This is a deliberate design, not just an implementation detail.

The distinction matters for anyone evaluating it. A Medium clone means a specific visual interface with floating toolbars and inline formatting, which describes the original Dante concept. Building on TipTap instead means the editor inherits TipTap's extension model, ProseMirror's document schema, and a larger maintenance surface. Any team already familiar with TipTap will find Dante's abstractions familiar; teams that have never used either library will need to learn both to extend or debug Dante at depth.

It is MIT-licensed per the README, and the last push was on 2026-08-23.

npm install dante3 and a DanteEditor component as the starting point

Adding dante3 to a React project takes one command:

npm install dante3

The README's basic usage example is a single component:

import DanteEditor from "dante3";

export default function Example() {
  return <DanteEditor bodyPlaceholder="Write the next section" />;
}

Dropping DanteEditor into a page gives a block editor with a text area and a placeholder string. The bodyPlaceholder prop is the only option shown in the README example, but the README names configurable blocks, tooltips, and themes as capabilities but provides no code examples showing how to configure them.

To run the local demo and documentation site from the repository, the README gives 2 commands:

npm install
npm run dev

That starts the Next.js demo site at http://localhost:8080. This is the workspace root's dev server, not a way to install the editor. A developer who runs these commands gets the demo site, not a development copy of dante3 itself.

6 built-in block types: images, files, embeds, GIFs, dictation, and recorders

Images, files, embeds, GIFs, dictation, and recorders ship as built-in block types in dante3. Each addresses a content type beyond plain text, and each comes packaged as part of the editor. The README does not describe how to configure individual block types, how to disable unused ones, or how to add a custom block outside the built-in set.

GIF support and dictation are the 2 most unusual inclusions. GIF embedding is expected in a blog-style editor, but dictation as a built-in audio feature is uncommon; most editors treat microphone-based input as a platform concern rather than an editor concern. Recorders is a separate entry from dictation, with no additional description in the README. Whether 'recorders' means screen recording, audio recording, or something else is not defined by the README text.

TipTap extensions are the mechanism Dante uses to implement each block type, since TipTap's architecture is extension-based. The README does not describe Dante's extension API or how the built-in blocks connect to it.

JSON and HTML as parallel output formats with renderer and parser helpers

Content saved by dante3 comes in 2 formats: JSON or HTML. dante3 includes utilities for rendering content outside the editor, so a display page can parse stored output without mounting the full DanteEditor component. This is the standard block-editor pattern where editor state is serialized at save time and deserialized at display time.

JSON is the natural format for ProseMirror-based editors, since ProseMirror stores its document as a structured JSON node tree. HTML is the secondary output, produced from that structure. The README does not document the JSON schema, the HTML output format, or how the renderer and parser map between them. For a team that needs to store editor content in a database and render it in multiple contexts, understanding the actual data format is a prerequisite for adoption, and the README points to documentation at dante-editor.dev rather than describing the format inline.

The documentation in the repository is backed by MDX files in packages/dante3/docs, according to the README. One link in that sentence uses a local absolute path (/Users/michelson/Documents/node-apps/Dante/packages/dante3/docs) rather than a relative path, so following it from GitHub returns an error rather than the documentation page. The content exists in the repository but the link in the README will not resolve in a browser.

Workspace root versus the dante3 package: two separate npm workflows

The repository uses Yarn workspaces, with packages/ as the workspace directory. The root package.json has the name dante-next-tiptap, version 0.1.0, and the flag private: true. That root is the Next.js demo site, not the published editor package. The editor lives in packages/dante3 as a separate workspace member.

Building the editor package uses a distinct workspace command:

npm run dante3:build

Publishing uses npm run dante3:publish, which runs release inside the dante3 workspace. A developer who clones the repository and runs npm install at the root installs the demo site's dependencies, not dante3's dependencies. These are 2 separate operations, and the README covers both without clearly separating when each applies.

The root dependencies in package.json include Next.js 13.3.0, React 18.2.0, and TypeScript 5.0.4. These are demo site dependencies. The actual dante3 package dependencies are in packages/dante3/package.json, which is not shown in the available repository information, so the peer requirements for using dante3 in a project other than the demo site are not documented here.

Where TipTap directly is the right choice instead of Dante's block layer

Dante is a wrapper around TipTap, and that wrapper adds a cost: it constrains how the document schema is structured and how blocks are configured. For a team that needs a highly customized editor, working with TipTap directly gives access to the full extension API, custom node types, custom mark types, and full control over serialization. Dante's pre-built blocks and React surface are a trade-off: faster start for standard block types, less control for anything outside that set.

For teams that do not need a visual block editor at all, ProseMirror is the lower layer. ProseMirror itself is not a React component; it is a view-agnostic document editing library with a complete transaction and schema system. Dante and TipTap both exist to reduce the work of building a React editor on top of it.

The practical decision point is whether the 6 built-in block types cover the use case. If they do, Dante shortens development time. If they do not, adding new block types requires understanding Dante's wrapping layer as well as TipTap's extension API, which doubles the learning surface.

Collaborative editing in the repository topics but not in the README or any example

The repository topics list collaborative-editing alongside wysiwyg-editor and medium-clone. Nothing in the README mentions collaboration, real-time sync, conflict resolution, or any backend protocol for shared editing. The topic is present but the feature has no documentation in the README.

Dante's README does not name any backend protocol or real-time sync mechanism. Whether the collaborative-editing topic was added in anticipation of a feature or describes something already present in the packages/dante3/ source is not stated in the README or at dante-editor.dev based on what is available here.

For any team that needs collaborative editing as a stated requirement, the README cannot confirm that Dante supports it. Checking the dante-editor.dev documentation site and the packages/dante3/ source directly is the only way to determine whether this feature is actually implemented.

Editorial conclusion

Dante suits React teams wanting a block editor with pre-built blocks for images, embeds, GIFs, and dictation, with JSON and HTML as parallel output formats. Skip it if you need collaborative editing (the topic appears in the repository but not the README), or a documented upgrade path beyond the private workspace at 0.1.0. Before adopting, install via npm install dante3, confirm that packages/dante3/ builds from the workspace root, and check the documentation links in the README, since the docs link points to a local filesystem path rather than a relative one.

Frequently asked questions

Official sources

1. Issues
2. michelson/Dante on GitHub
3. Project website
4. README
5. Releases