The CMS for Astro and Next.js

For designers and developers. Your clients compose and edit pages inside the rails you set, from the design system you built. The design stays on brand.

Get launch updatesSee the editor ↓
npx create-smoodly-app
Editor features
Performance

Lightning fast delivery, with a cache that keeps itself fresh

The API answers from Cloudflare's edge, over 300 cities worldwide and 50 in Europe. Caching is on autopilot: every page is cached near the visitor and expired by tag the moment you publish.

25 ms
median time to first byte from the cache
0 KB
CMS JavaScript on the page
< 5 s
from Publish to the live page, only the pages that changed
Visitor
Site cache
~25 msTTFB

Smoodly tags every page it renders and expires exactly the changed ones on publish, so the cache is always current for nearly every visitor.

Smoodly API
15–30 msper call

The first visitor after a publish. One call to Cloudflare's edge, answered from the nearest of 300 cities, and the page is cached again.

Measured from Helsinki in October 2026 on the Astro starter on Vercel, with its function in Stockholm. The first number is your host's CDN; the second is Smoodly's.

Out of the box

The features we always missed on client projects

  • Composable pages and globals

    Editors compose pages from the sections you wrote, inside the zones you allow, right on the page. Header, footer and other globals are edited once and shown everywhere.

  • Localization

    Languages are built in, not bolted on. Every locale shares one page structure, with its own slugs and hreflang, so layouts never drift and nothing goes live half-translated.

  • Routing and page tree

    Every page in one tree, and the tree is the URL. Drag to reorder or nest, with a path per language, and query the tree for your navigation.

  • Collections, related and sorted

    Articles, people, products: typed fields and references between them, one source of truth. Order a list by any field, or drag entries into place.

  • Video, images and files

    Hosted and delivered from the edge. Images optimized to AVIF and WebP, cropped per use around one focus point; video and files served as uploaded.

  • Caching on autopilot

    Every page is tagged by what it reads, and a publish expires exactly those pages the moment it happens. Nothing to configure, no build to wait for.

How it works

Absolute freedom in design and architecture

Smoodly lives inside your Next.js or Astro site. It dictates neither your design nor your hosting, and nothing about how you build.

  1. Workflow

    Build the site with the tools you already use. Smoodly is an add-on.

  2. src/components/sections/Hero.schema.ts
    export const heroSchema = smoodly.schema.section({
      name: "hero",
      title: "Hero",
      fields: {
        heading: f.text(),
        text: f.text().max(240),
        image: f.image({ crops: { desktop: "16:9", mobile: "4:5" } }),
      },
    });
    src/sections/hero.astro
    ---
    type Props = SmoodlyProps<typeof heroSchema>;
    const { heading, text, image, styles } = Astro.props;
    const m = smoodly.marks(heroSchema);
    ---
    
    <Section styles={styles} class="hero">
      <h1 {...m.field("heading")}>{heading}</h1>
      <p {...m.field("text")}>{text}</p>
      <Image image={image} media={{ mobile: "(max-width: 767px)" }} />
    </Section>
    components/sections/Hero.schema.ts
    export const heroSchema = smoodly.schema.section({
      name: "hero",
      title: "Hero",
      fields: {
        heading: f.text(),
        text: f.text().max(240),
        image: f.image({ crops: { desktop: "16:9", mobile: "4:5" } }),
      },
    });
    components/sections/Hero.tsx
    const m = smoodly.marks(heroSchema);
    
    type HeroProps = Props<typeof heroSchema>;
    
    function HeroView({ heading, text, image, styles }: HeroProps) {
      return (
        <smoodly.Section styles={styles} className="hero">
          <h1 {...m.field("heading")}>{heading}</h1>
          <p {...m.field("text")}>{text}</p>
          <SmoodlyImage image={image} media={{ mobile: "(max-width: 767px)" }} />
        </smoodly.Section>
      );
    }

    Content modelling

    The schema lives in the component. No studio to configure.

  3. src/page-types/author.astro
    const { entries: articles = [] } = await getLiveCollection("articles", {
      locale,
      where: { author: author.id },
      order: { by: "date", direction: "desc" },
      limit: 3,
    });
    
    const { entries: nav = [] } = await getLiveCollection("pageTree", { locale });
    app/(site)/[[...path]]/page.tsx
    const articles = await q().getEntries("articles", {
      locale,
      where: { author: author.id },
      order: { by: "date", direction: "desc" },
      limit: 3,
    });
    
    const nav = await q().getPageTree({ locale });

    Queries

    Simple queries, typed by your schema. A list, an entry or the page tree in one call.

  4. src/sections/reel.astro
    ---
    import { Image, Section, Video } from "smoodly/astro/components";
    ---
    
    <Section styles={styles} class="reel">
      <Image image={poster} sizes="40vw" />
      <Video video={video} controls muted />
    </Section>
    src/layouts/Layout.astro
    <Head of={head} fallback="Lorem Co." />
    components/sections/Reel.tsx
    import { SmoodlyImage, SmoodlyVideo } from "smoodly/image";
    
    <smoodly.Section styles={styles} className="reel">
      <SmoodlyImage image={poster} sizes="40vw" />
      <SmoodlyVideo video={video} controls muted />
    </smoodly.Section>
    app/(site)/[[...path]]/page.tsx
    export async function generateMetadata({ params }: { params: Params }) {
      const { path = [] } = await params;
      return smoodlyMetadata(path, { locale });
    }

    Built-in components

    Image, Video, Section and Head come built in. Nothing to write twice.

  5. my-site/
    ├── astro.config.ts       smoodly() serves the pages, the admin, the preview
    ├── src/
    │   ├── page-types/       page types: which zones, what may go in them
    │   ├── sections/         name.astro, beside its schema
    │   ├── elements/         what richtext may embed
    │   ├── components/       the schemas: Name.schema.ts
    │   ├── smoodly/          the setup
    │   └── live.config.ts    the content as live collections
    └── .env                  the space's keys
    my-site/
    ├── app/
    │   ├── (site)/[[...path]]/page.tsx   every CMS URL, one file
    │   ├── (smoodly)/admin/              the admin
    │   └── api/preview/route.ts
    ├── components/
    │   ├── pages/        page types: which zones, what may go in them
    │   ├── sections/     Name.schema.ts + Name.tsx
    │   └── elements/     what richtext may embed
    ├── smoodly/          the setup
    └── .env.local        the space's keys

    Project structure

    Smoodly is one folder and its routes. Grow the app however you like.

Compare

Why we built Smoodly

We loved working with Sanity, Payload, Storyblok and Prismic. But for a marketing site, they all felt clumsy. Smoodly is the content platform we always wished we had.

SmoodlySanityPayloadStoryblokPrismic
Multi-language built inLocales on every field and URL, no pluginOfficial translation plugins; localized URLs are up to youField-level translation on higher plans; localized URLs need an appPer page, not per field; 2 locales on Free, 8 on Platinum
Page treeNested pages, the tree is the URLDocuments can be nested, but the URL is up to youThe official nested-docs plugin builds URLs from parents; no tree viewA flat page list; nested URLs through a parent link, two levels
Image libraryHosted, optimized, delivered from a CDN
Video libraryUpload, poster frame and delivery, no add-onVideo is an add-on on certain Enterprise plansUploads and serves video files; no poster frameVideo files in the asset library, as uploadedVideo files up to 100 MB, no poster frame; embeds advised
Visual editingEdit with a live preview of the real pageA form with live slice thumbnails; the full preview opens in a tab
Modular visual editingAdd and arrange your sections on the live pageSections reorder on the preview; you add them in the StudioBlocks are edited in a form beside the live previewSlices are added and dragged in a sidebar, not on the live page
Global componentsShared header, footer and other site-wide blocksA documented singleton pattern, not built inA documented pattern with references, not built inHeader and footer as single custom types, without slices
Schema in the component fileTypes, form, editor block and AI schema, beside the componentSchemas live in the Studio config, apart from the componentSchemas live in the Payload config, apart from the componentBlocks are defined in Storyblok's web appA model.json beside each slice; types in one shared file
Lives inside your appNo separate studio app to deploy and keep in syncThe Studio can be embedded; the content is hosted by SanityEditing happens in Storyblok's own appEditing happens in Prismic's own app; models sync by CLI
Freedom dial per zoneLocked, curated or free areas, set by the developerPer-field and per-array limits, no zonesPer-field and per-block limits, no zonesAllowed blocks per field, no zonesAllowed slices per page type, no zones

Based on core features and official plugins, without third-party plugins, October 2026. Hover or tap a mark for the details.

Agents welcome

Your agent should edit Smoodly, not the source code.

Changing a headline is not a coding task. Point your agent at Smoodly instead: content stays structured, searchable and related, and the agent works inside the same rails as your editors.

MCPMCP server for Claude, Cursor and any MCP client. Read and write content with the schema as the contract.
RESTREST API for automations and custom agents. Same permissions, same validation, same history.
Agent edits source codeAgent edits Smoodly
Content changes become code changes.Content changes stay content, inside limits the developer set.
Every change risks breaking the build.Every change is validated, versioned and reversible.
Tokens burned reading the codebase for a two-word fix.One API call. The schema tells the agent exactly what to change.
Content in files is not searchable or indexable.Content in a database is queryable, filterable, searchable.
Relations don't exist.Courses link to instructors, spots to courses. Change once, updated everywhere.