Skip to content

Sage vs Underscores vs Block Themes: Choosing a WordPress Starter Theme in 2026

Emnes
Comparison illustration of Sage Underscores and Block Theme WordPress starter themes

If you’re starting a custom WordPress theme in 2026, you have three mainstream choices: Sage, Underscores (_s), or a native block theme built on full-site editing (FSE). Each reflects a fundamentally different philosophy about how WordPress themes should be built — and picking the wrong one means fighting the tool for the entire project lifecycle.

This post is an honest, opinionated comparison of the three. We’ll cover what each starter represents, when each is the right choice, where each falls short, and how to pick for a new project. The comparison is based on shipping real sites with all three approaches, not on marketing material.

If you already know you want Sage, skip to our Sage 11 deep dive. This post is for the “which should we pick?” decision that comes first.

The Three Starting Points

Sage

Maintained by: Roots.io
Templating: Blade (Laravel)
Asset pipeline: Vite with hot module replacement
Default styling: Tailwind CSS v4
PHP minimum: 8.3
Build required: yes (Node.js + Composer)
Block editor support: first-class, HMR inside the iframe

Sage is the Roots.io starter theme. It’s a developer-facing starting point that assumes you’ll use modern tooling (Composer, pnpm, Vite) and borrows heavily from Laravel conventions. The theme is a blank slate — you get Blade, a compile pipeline, and Tailwind set up, but no pre-built layouts. Everything is built by the developer.

Underscores (_s)

Maintained by: Automattic (the company behind WordPress.com)
Templating: plain PHP
Asset pipeline: none by default (add your own)
Default styling: bare-minimum CSS
PHP minimum: whatever WordPress supports
Build required: no
Block editor support: classic theme with partial block support

Underscores has been Automattic’s official starter theme since 2013. It’s deliberately minimal — no styling opinions, no build pipeline, just WordPress’s classic template hierarchy scaffolded out with every file you’d expect (header.php, footer.php, single.php, etc.). You add your own toolchain, your own styles, your own everything.

Block Themes (FSE)

Maintained by: WordPress core contributors (many options — Twenty Twenty-Five, Astra, GeneratePress, Kadence, etc.)
Templating: HTML templates with block markup
Asset pipeline: none needed (themes ship CSS directly)
Default styling: varies by theme
PHP minimum: whatever WordPress supports
Build required: no
Block editor support: native — the theme is block templates

Block themes are the newest option, enabled by WordPress’s full-site-editing feature (stable since WordPress 5.9 in 2022). Instead of PHP templates, the theme ships HTML files containing block markup. Site owners edit everything — header, footer, templates, styles — through the block editor’s Site Editor interface.

Philosophy Differences

The three starters reflect three different answers to the question “who builds the site?”

  • Sage: the developer builds the site. Everything is defined in code. Clients don’t edit layout, spacing, or components. They edit content. This is the classic “designed-and-developed theme” model.
  • Underscores: the developer builds the site, with less scaffolding. Similar philosophy to Sage but without opinionated tooling — you bring your own.
  • Block themes: the site owner builds the site. Developers ship a theme with patterns and templates; non-technical users customize via the Site Editor. The developer’s role shifts from “writes every template” to “sets up the design system and curates patterns.”

Neither philosophy is wrong. They fit different projects.

When to Pick Sage

Sage is the right choice when:

  • You have a custom design system — typography, spacing, color, components — that you want to codify tightly in the theme.
  • Your team is comfortable with modern PHP and JavaScript tooling (Composer, pnpm/npm, Vite, Tailwind).
  • The client doesn’t need to redesign the site themselves. Editors add content; structure comes from developers.
  • You’re already using Bedrock — Sage integrates cleanly into Bedrock’s web/app/themes/.
  • You value dev velocity — HMR, Blade components, and Tailwind make building custom UIs dramatically faster than raw PHP.
  • You have existing Laravel developers — Sage feels immediately familiar.

When to Pick Underscores

Underscores is the right choice when:

  • You want a minimal starting point with no opinions. You’ll assemble the stack yourself — or not at all.
  • You don’t want a build step. Hosting requirements are lighter (no Node.js on the server), deployment is simpler.
  • Your team is more comfortable with raw PHP than with Blade.
  • You’re targeting a very cheap host where Composer and Node aren’t available server-side.
  • You’re building a learning project and want maximum exposure to WordPress’s native template hierarchy.

The tradeoff: you’re responsible for everything Sage gives you for free — a sensible asset pipeline, a modern CSS framework, a component system, and the kind of build-time escaping/compilation that Blade provides automatically.

When to Pick a Block Theme

Block themes are the right choice when:

  • The site owner wants to redesign visually without involving a developer. Non-technical editing of layout and style is the whole point of FSE.
  • You’re building a pattern library that other sites will consume.
  • The site is content-heavy and the editor’s drag-and-drop experience is valuable.
  • You’re okay with less programmatic control over markup, at least in the default FSE workflow.
  • You want to align with WordPress’s stated direction. Gutenberg + FSE is where WordPress core is investing.

The tradeoff: less control over exact markup, a harder time enforcing a tight design system (editors can override styles in ways developers didn’t plan for), and less mature tooling compared to Sage’s Blade-based workflow.

Head-to-Head Comparisons

Developer Experience

  • Sage wins on velocity. HMR in the block editor, Blade components, Tailwind utilities — you ship UI fast.
  • Underscores wins on simplicity of setup. No build step, no Node, no Composer config to tune.
  • Block themes win on WYSIWYG editing. The editor previews exactly what users see.

Editor Experience (Content Editors)

  • Block themes win. Editors can change layout, colors, spacing — all without developer involvement. For sites where content editors are the primary users, this is a big deal.
  • Sage is second. Editor gets the full block editor, with custom blocks developers build. But layout is locked in PHP templates.
  • Underscores is last. Classic theme with the block editor bolted on; the editor experience is the least polished of the three.

Performance

  • Sage, with care, is fastest. Tailwind + Vite + cached Blade produce very small HTML and CSS.
  • Underscores is fastest by default (since there’s nothing extra), but matches Sage only with significant developer effort.
  • Block themes vary. Well-built block themes (Kadence, GeneratePress) are fast; bloated ones are very slow.

Maintenance

  • Block themes win at client-level maintenance. Clients can update patterns themselves.
  • Sage wins at developer-level maintenance. Component-based architecture, strict design system, compile-time errors when something breaks.
  • Underscores is somewhere in between — stable by virtue of being simple, but harder to evolve as requirements change.

Hiring Pool

  • Underscores has the widest hiring pool — any WordPress developer can pick it up.
  • Block themes require block-editor expertise, which is becoming more common but is still a specialty.
  • Sage requires Laravel/modern-PHP experience. Smaller pool, but overlaps heavily with Laravel devs.

The Hybrid Approach

Most real sites in 2026 aren’t purely one philosophy:

  • Sage + custom blocks. Structural templates live in Blade; content-level flexibility comes from custom blocks editors can place.
  • Block theme + custom blocks with developer-defined markup. Use a block theme’s structure but constrain what blocks are available and how they render.
  • Sage + FSE (Acorn 4.1+). Blade templates take precedence where they exist; FSE handles areas without a Blade counterpart. Community fork strarsis/sage10-fse takes this further.

The best answer for many projects is “Sage for structure, block editor for content” — which is effectively what every site in our Bedrock + Sage monorepo uses.

A Decision Tree

Work top-to-bottom:

  • Will non-technical users need to change layout and design post-launch?
    • If yes → Block theme. The WYSIWYG site editing is the whole value proposition.
    • If no → continue.
  • Do you have Composer and a build pipeline in your stack?
    • If no and won’t add them → Underscores. The minimal build-less workflow fits.
    • If yes → continue.
  • Is the design system tight enough to codify in components?
    • If yes → Sage. Blade components + Tailwind + Vite is the most productive setup.
    • If no (content-first, loose design) → Block theme — and let editors configure it.

Frequently Asked Questions

Is Sage still maintained?

Yes. Sage 11.2.0 shipped in March 2025 and the project is actively developed. Roots.io treats Sage as a flagship project.

Is Underscores deprecated?

Not officially, but it hasn’t received significant updates since ~2021 as Automattic’s focus moved to block themes. It still works on current WordPress versions, but don’t expect new features.

Which approach does WordPress core recommend?

Block themes. WordPress’s official documentation and the bundled default theme (Twenty Twenty-Five) are block themes. That said, classic themes (both Underscores-style and Sage-style) are still fully supported and will be for the foreseeable future.

Can I migrate from one to another?

Partially. Content migrates freely (posts, pages, users, media). Theme-specific things — templates, widgets, menus — often need to be rebuilt. Plan a theme migration as a new theme build, not as a mechanical conversion.

Is there a performance penalty to Sage?

Negligible. Blade compiles to plain PHP and caches the result. Production Sage sites are typically among the fastest on any given host.

Can a block theme enforce a design system like Sage can?

Partially. theme.json enforces colors, fonts, and spacing tokens, and you can disable custom values (no free-form color picker, no free-form font). Block patterns constrain what editors can place. But an editor who really wants to override a style usually can. If tight enforcement is critical, Sage with carefully-designed custom blocks gives you more control.

Pick Once, Commit

The worst outcome is picking a theme architecture and then fighting it for two years because the team’s working style doesn’t match the theme’s assumptions. Take an afternoon to evaluate your team’s comfort with tooling, your client’s editing expectations, and your design system’s maturity — then commit to the right one for the project.

At Emnes, the overwhelming majority of our work is Sage, because our projects tend to be design-heavy agency builds with strict component systems. When we work on content-first sites for clients who want to customize layout themselves, we pick block themes. The philosophy matters more than the starter.

Related reading: Sage 11 deep dive, building a production Sage theme, and the full Roots.io stack overview.