Blog

Root AI has been rewritten from the ground up with a new streaming API (improving token response times), reasoning and logic (with planning and execution modes), and tool calling (which allows Root AI to read and write directly to the CMS).

Configuration has graduated from "experimental" and moves to a new top-level ai plugin option, and you can register one or many models across different providers. For example:

cmsPlugin({
  ai: {
    models: [
      {
        id: 'claude-opus-4-7',
        label: 'Claude Opus 4.7',
        provider: 'anthropic',
        apiKey: process.env.ANTHROPIC_API_KEY,
        capabilities: {tools: true, reasoning: true, attachments: true},
      },
      {
        id: 'gpt-5.5',
        label: 'GPT-5.5',
        provider: 'openai',
        apiKey: process.env.OPENAI_API_KEY,
      },
      {
        id: 'gemini-3.1-pro',
        label: 'Gemini 3.1 Pro',
        provider: 'gemini',
        apiKey: process.env.GEMINI_API_KEY,
      },
    ],
    defaultModel: 'claude-opus-4-7',
  },
});

The Root CMS UI received a style refresh. We plan to add support for customized themes soon — stay tuned!

You can now search for items in the CMS using the new global search tool, which can be triggered by the Cmd+k hotkey.

Searchable items in the CMS are automatically indexed via the Root cron job every 5 minutes. Users can also manually trigger re-indexing via the settings page.

Root v3.0 allows greater access granularity and organization through permission groups.

Within a permission group, you can assign a role to all users in the group, and optionally restrict their access to one or more collections. This makes it easy to give, say, a blog editorial team EDITOR access on just their collections without granting them the run of the project.

Within the CMS, there is a new "picker" variant that presents content editors with a more visual way of selecting content to add to their site, including support for "presets" that autofill templated data with commonly used field values.

Developers can use the component picker by adding {variant: 'picker'} to schema.oneOf() fields. For example:

schema.oneOf({
  id: 'block',
  variant: 'picker',
  types: [HeroSchema, GallerySchema],
});

// Hero.schema.ts
export default schema.define({
  name: 'Hero',
  image: '/cms/previews/hero.png',
  presets: [
    schema.preset<HeroFields>({
      id: 'big',
      label: 'Big hero',
      data: {title: 'Welcome', layout: 'wide'},
    }),
  ],
  fields: [...],
});

For projects where the "picker" variant is preferred as the default, set defaultOneOfVariant:

cmsPlugin({
  defaultOneOfVariant: 'picker',
});

We're experimenting with a new task manager built right into the CMS to provide better project management capabilities directly in the UI.

In the future, we envision the task manager to be used as an entrypoint for coordinating tasks and reviews with Root AI and humans alike, so we're very excited to continue to develop and refine this feature.

To opt-in to the experiment:

cmsPlugin({
  experiments: {taskManager: true},
});

Under the hood, we've updated Root's 3rd party dependencies to the latest verions. The biggest change is the update to Vite 8, which switches its bundler from rollup to rolldown.

As far as we know, the update to Vite 8 should be backwards compatible other than deprecation warnings to rename the config from "rollupOptions" to "rolldownOptions".

Learn more about Vite 8 at: https://vite.dev/blog/announcing-vite8

Root now ships with its own JSX renderer (@blinkk/root/jsx). It exposes a Preact-compatible API so existing components, contexts, and islands keep working without changes. The difference is what happens at render time: Root walks the VNode tree itself, with first-class understanding of custom-element tag formatting, script/style ordering, and Root's own context propagation.

In practice, this means cleaner HTML output, a much smaller server-side dependency footprint, and a renderer that we can keep evolving alongside the rest of Root.

Opt in by adding jsxRenderer to root.config.ts:

export default defineConfig({
  jsxRenderer: {
    mode: 'pretty',
    blockElements: ['my-card', 'my-section'],
  },
});

Pods are a new way for plugins to bundle a chunk of a Root project — routes, elements, bundles, collections, translations, even custom Vite plugins — and reuse it across sites. Drop a pod into a project's root.config.ts and its routes are mounted, its elements and bundles are auto-registered, and (for CMS projects) its collections show up in the CMS sidebar.

Pods make it dramatically easier to share design systems, marketing-page templates, and reusable CMS schemas across teams.

import blogPod from '@third-party/blog-pod';

export default defineConfig({
  plugins: [
    blogPod(),
  ],
});

Plugins can now hook into Root's notifications service to provide users with timely updates as actions occur throughout the system, such as subscribing to email and Slack notifications when changes are published.

cmsPlugin({
  notifications: [
    {
      id: 'team-notifier',
      label: 'Team notifier',
      onAction: async (ctx, action) => {
        if (action.action === 'doc.publish') {
          // ...send a notification.
        }
      },
    },
  ],
});

Root v3.0 is available now on npm and is installable using the package manager of your choice.

pnpm add @blinkk/root@latest @blinkk/root-cms@latest

A v2 → v3 migration is mostly a package install and a config tweak. The pieces to be aware of:

• Vite 8: Rename build.rollupOptions to build.rolldownOptions in any custom Vite config.

• JSX renderer: Optional. To opt in, add jsxRenderer: {mode: 'pretty'} to root.config.ts. The renderer is API-compatible, so no component changes are required.

• Root AI config: Move from experiments.ai: {endpoint, model, ...} to the top-level ai: {models: [...]} shape.

The full breakdown is in packages/root/CHANGELOG.md and packages/root-cms/CHANGELOG.md.

Huge thank you to all the Root users who tested the alpha/beta builds and filed bugs and feature requests. Root is continually improving and we have so many more big features planned ahead.

Issues, ideas, and PRs are always welcome at github.com/blinkk/rootjs.