Skip to main content
Root.js · The Web Platform

Build. Edit. Ship.

Root.js pairs a fast web framework with a CMS your whole team will actually enjoy:
live previews, AI, localization, and publishing workflows, all built in.

pnpm create @blinkk/root
The Root CMS doc editor, with the fields for a garden market landing page on the left and a live desktop and mobile preview of the page on the right.
One platform

One system for code and content

Most teams end up wiring together a separate framework, headless CMS, translation tool, and deploy pipeline. Root.js ships them together so they share the same schemas, routes, and previews.
Build

A TypeScript framework built on Vite

Write server-rendered TSX with file-based routing and web component islands, backed by Vite.
  • Zero client JavaScript by default
  • i18n routing and sitemaps built in
  • Deploy to Firebase or App Engine
Read the guides
Manage

A CMS backed by your own Firestore

Edit fields alongside a live preview, coordinate launches with releases, and manage translations and comments in one UI.
  • Content models defined in code
  • Schedule launches with releases
  • Roles, publishing locks, and version history
Explore the CMS
Automate

AI that works with your schemas

Use Root AI in the browser or connect external agents through the CLI to draft, translate, and update content under your team’s review.
  • Chat with docs and releases in the CMS
  • Bring your own model provider
  • Review agent edits before they land
See Root AI
Root AI

Built-in AI that understands your schemas

Ask Root AI to search, draft, translate, or reorganize content across your site. Because it uses the same CMS actions your editors do, every edit lands as a draft you can review before publishing.

  • Reads and edits docs, schemas, and releases
  • Read-only, approve-each-step, or auto modes
  • Anthropic, OpenAI, Google, or any compatible model provider
Root AI chat in the CMS: a request to localize a page and add it to a release, with the tool calls Root AI ran to do it.
Content as code

Your content model lives in your repo

Define schemas in TypeScript to generate typed props automatically, then render them directly in your TSX components.
1templates/TemplateHero/TemplateHero.schema.ts
Define the fields editors fill in.
import {schema} from '@blinkk/root-cms';

export default schema.define({
  name: 'TemplateHero',
  fields: [
    schema.string({id: 'title', translate: true}),
    schema.richtext({id: 'body'}),
    schema.image({id: 'image'}),
  ],
});
2templates/TemplateHero/TemplateHero.tsx
Render with generated TypeScript types.
import {RichText} from '@blinkk/root-cms/richtext';
import {TemplateHeroFields} from '@/root-cms.js';

// Props are typed from your schema.
export function TemplateHero(
  props: TemplateHeroFields
) {
  return (
    <section>
      <h1>{props.title}</h1>
      <RichText data={props.body} />
      <Image {...props.image} />
    </section>
  );
}
3routes/[[...page]].tsx
Map a collection to a route.
import {cmsRoute} from '@/utils/cms-route.js';
import {Page} from '@/components/Page.js';

export default Page;

// Drafts for editors, published for everyone.
export const {handle} = cmsRoute({
  collection: 'Pages',
  slugParam: 'page',
});
Publishing

Drafts, releases, and pre-publish checks

Edit in drafts, then publish immediately, schedule a launch time, or group multiple docs into a single release. Custom checks run before anything goes live so broken links or missing fields don’t slip through.

  • Field-by-field diffs and publish notes
  • Group multiple docs into scheduled releases
  • Custom checks for missing translations, accessibility, and broken links
The publish dialog in Root CMS, showing a scheduled publish time, an AI-written change summary and passing publishing checks.
Localization

Localization from schema to URL

Mark fields as translatable in your schema and Root.js tracks every string across your site. Edit translations in the CMS, generate drafts with AI, or send them to a vendor, with localized URLs, fallbacks, and hreflang tags handled automatically.

  • Per-page translation editor with missing-string alerts
  • Import and export CSV, Google Sheets, and ARB
  • Connect third-party translation providers like Crowdin
The Root CMS translations editor for a page, with source strings alongside German, French and Japanese translations and an AI translate action.
Collaboration

Edit together and comment on any field

See who else has a doc open, get their edits in real time, and leave comment threads directly on individual fields with @mentions.

  • Live presence and real-time updates
  • Field-level comment threads with @mentions
  • Email and custom notification settings
A comment thread pinned to a field in the Root CMS editor, with teammates discussing a headline and an @mention.
The framework

Static or server-rendered, built on Vite

Use the same setup for marketing pages, docs, and blogs, built directly on TypeScript, TSX, and Vite.
  • Server-rendered TSX

    Render on the server or pre-build static HTML, sending zero client JavaScript unless a page needs it.
  • Web component islands

    Add interactivity with standard custom elements. Only the components used on a page load their scripts.
  • File-based routing

    Map files in routes/ directly to URLs, with support for dynamic params, catch-alls, and custom handlers.
  • Built-in i18n

    Localized URLs, locale fallbacks, and hreflang sitemaps are wired into the router.
  • Plugins & pods

    Extend the server, build, or CMS with plugins, or package routes and schemas as reusable pods.
  • Deploy anywhere

    Deploy to Firebase, App Engine, or any Node host, with secrets synced from Google Secret Manager.
Inside the CMS

More tools built into the CMS

  • Version history

    Compare past versions side by side, restore an earlier draft, or copy fields from history.
  • Publishing checks

    Run required or advisory checks before publishing to validate links, metadata, or translations.
  • Agent-ready CLI

    Script content updates from CI or AI agents, with change proposals your team reviews in the CMS.
  • Asset library

    Organize images and files in folders, sync them from Figma or Google Drive, and serve resized variants.
  • Data sources

    Sync data from Google Sheets or external APIs and publish snapshots alongside your pages.
  • Roles & locks

    Control access with project roles, collection permission groups, and document publish locks.
  • Customizable UI

    Add custom sidebar tools, themes, and notification hooks, or embed the editor in your own app.
  • Global search

    Jump to any doc, field, or translated string from anywhere in the CMS with ⌘K.
Contact us

Meet the team behind Root.js

Root.js was handcrafted by the team at Blinkk. We offer custom solutions and forward deployments, including full integration and maintenance of Root.js sites on infrastructure that you own.

1
2
3
4
5
6
7
8
9
10
11
12
Breakpoint: