Satteri: A Rust Core for Markdown and MDX with JavaScript Plugins

What Satteri Actually Does Differently

Satteri is a high-performance Markdown and MDX processor for the JavaScript ecosystem, but its core is written in Rust. The README states that it 'parses and compiles in Rust, runs your plugins in JavaScript.' That split is the key design decision. Most JavaScript Markdown processors, like remark and rehype, do everything in JavaScript, which is flexible but slower for large files. Satteri moves the parsing and compilation into Rust, using a fork of pulldown-cmark for CommonMark parsing and a fork of mdxjs-rs for MDX compilation, both adapted to use the OXC JavaScript parser. The result is a pipeline where the heavy lifting is native code, while the plugin interface remains in JavaScript, so you do not have to write Rust to extend it. This is aimed at developers who want the speed of a native compiler without abandoning the JavaScript plugin ecosystem they already use.

The Monorepo and Its Packages

The project is a Rust and TypeScript monorepo with two sets of packages. On the Rust side, there are crates like satteri, which is the high-level API for the pipeline, satteri-ast for MDAST and HAST node types, and satteri-plugin-api for writing Rust plugins. There is also satteri-napi-binding, which exposes the Rust pipeline to JavaScript via NAPI, and two forks: satteri-pulldown-cmark and satteri-mdxjs-rs. On the npm side, there is the satteri package, which is the TypeScript layer with the plugin API and top-level functions, plus satteri-expressive-code, a HAST plugin for rendering code blocks with Expressive Code, and vite-plugin-satteri, which lets you import .md and .mdx files in Vite. The README lists these packages but does not give much detail on their APIs, so the documentation site at satteri.bruits.org is where you would find installation instructions and usage examples.

How the Pipeline Works

The pipeline is described as parse, convert, compile. The Rust crate satteri provides the high-level API for this pipeline. Parsing uses the forked pulldown-cmark, which is a CommonMark pull parser with MDX extension support. The MDX compilation is handled by satteri-mdxjs-rs, which is a fork of mdxjs-rs adapted for OXC. OXC is a Rust JavaScript parser and compiler, and it is used to handle the JavaScript parts of MDX, like embedded expressions and components. The AST types are defined in satteri-ast, which includes MDAST and HAST node types, codecs, tree operations, and conversion between them. The plugin API in Rust is a trait that allows you to write plugins in Rust, but the JavaScript layer also has a plugin API, so you can choose your language. The NAPI bindings are what let JavaScript call into the Rust code, and the TypeScript package satteri wraps that with a plugin API and top-level functions.

Getting Started with the Vite Plugin

The README points to the documentation for installation, and it specifically mentions the vite-plugin-satteri package for importing .md and .mdx files in Vite. The release history shows recent versions like v0.3.5, v0.3.4, and v0.3.3, all published on the same day, 2026-08-19, which suggests rapid iteration. To use it, you would install the plugin via npm, add it to your Vite config, and then you can import Markdown files as modules. The exact configuration keys are not in the README, so you have to check the documentation. The same goes for the satteri package, which provides the plugin API and top-level functions for programmatic use. There is also a playground at satteri.bruits.org where you can try it online without installing anything. That is useful for evaluating the output before committing to the setup.

The JavaScript Plugin API and Its Limits

A major selling point is that plugins run in JavaScript, but the README does not specify how that works in detail. It says the TypeScript layer has a plugin API, and the Rust crate has a Plugin trait for Rust plugins. The JavaScript API likely mirrors the unified ecosystem, given the acknowledgement of unifiedjs and remark/rehype, but that is an inference, not a stated fact. What is clear is that you can write plugins in either language, but the documentation is thin on the exact interface. A limitation is that the plugin API is not yet proven at scale. The project is young, with recent releases in 2026, and the README does not list any production users or benchmarks. If you rely on a large set of existing remark plugins, you will need to verify that they work through Satteri's JavaScript API, which may not be a drop-in replacement for unified's plugin system. The documentation site is the only place to confirm compatibility.

Expressive Code Integration and Other Extras

One concrete extra is satteri-expressive-code, a HAST plugin that renders code blocks with Expressive Code. Expressive Code is a syntax highlighter that produces styled output, and this plugin integrates it into the Satteri pipeline. This is a specific feature that could be a differentiator if you want polished code blocks in your Markdown output. The README lists it as an npm package, but again, no usage details are given. You would need to read its README or the main documentation. There is also a playground, which is a practical way to test the output without setting up a project. For a tool that is still in early versions, having a playground is a good sign for evaluation, but it does not replace reading the API reference.

Maintenance, Licensing, and the Road Ahead

The project is licensed under MIT, which is permissive and standard for open source. It is not archived, and the last push was on 2026-08-19, the same day as the latest release, indicating active development. The release cadence shows multiple releases in a single day, which could mean rapid bug fixing or a busy release process. The README acknowledges several upstream projects, including unifiedjs, pulldown-cmark, mdxjs-rs, OXC, and Lightning CSS. This is a fork-heavy architecture, which means you inherit the maintenance burden of those forks. If upstream pulldown-cmark or mdxjs-rs changes, Satteri must merge those changes into its forks. That is a real cost. The documentation is the primary resource, and it is hosted on a separate site, so you should expect to consult it frequently. The project is from Bruits, a Rust-focused collective, which suggests a strong Rust background but also a niche community. For a production system, you would want to monitor the issue tracker and release notes for breaking changes, but that is a general practice, not a specific recommendation.

Editorial conclusion

Adopt Satteri if you need fast Markdown and MDX processing in a Vite-based JavaScript project and you are comfortable with a young, actively developed tool that expects you to read its documentation. The Rust core promises performance, and the JavaScript plugin API keeps your existing plugin ecosystem intact, but the documentation is the only place to learn the actual API and configuration keys. Do not adopt it if you need a stable, battle-tested processor with a large community, or if you cannot afford to debug API changes across releases. Before adopting, verify the exact plugin configuration for your Vite version, test that your existing remark or rehype plugins work through the JavaScript API, and check the current release notes for any breaking changes. The project is not archived, and the recent release cadence suggests active maintenance, but that is a fact about activity, not a promise of stability.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes