# Pollora vs Acorn, Sage, Radicle and Corcel

> How Pollora relates to Roots Acorn, Sage, Radicle and to Corcel: architecture, routing, templating, hooks, ORM and license, to pick the right tool.

Source: https://pollora.dev/compare/

**Short answer:** pick **Sage** for a modern theme on an ordinary WordPress site, **Acorn** to bring Laravel components into an existing WordPress install, **Radicle** for the Roots stack prepackaged as a ready-made project, and **Corcel** when a Laravel app only needs to read WordPress data. Pick **Pollora** for the opposite arrangement: a Laravel application that boots first and runs WordPress inside it, with hooks, post types and REST routes declared as PHP attributes.

## Built on what Roots started

Roots has shaped modern WordPress development for over a decade, and it is a real source of inspiration for Pollora. Bedrock showed that WordPress belongs in a Composer-managed project, Sage brought Blade and a modern build to themes, and Acorn proved that Laravel and WordPress can share a codebase. Pollora builds on that work directly:

- themes, blocks and plugins are built with **`@roots/vite-plugin`** (WordPress dependency extraction and `theme.json` generation);
- the framework uses **`roots/bedrock-autoloader`**, and the project follows a Bedrock-style layout;
- the Blade layer ships **Sage Directives** (`@posts`, `@title`, `@content`, from `log1x/sage-directives`).

Pollora's own WordPress models are built on **`pollora/colt`, a fork of Corcel**. The projects on this page are not rivals so much as different answers to the same question. This page says where each one fits.

## At a glance

| | Pollora | Acorn | Sage | Radicle |
|---|---|---|---|---|
| **What it is** | A framework: a Laravel application that runs WordPress | A package that brings Laravel components into WordPress | A WordPress starter theme | A WordPress starter combining the Roots stack (Acorn, Bedrock, Sage, optional Trellis) |
| **Architecture** | Laravel boots first; WordPress (admin, database, plugins, REST API) runs inside the Laravel app | WordPress boots first; Acorn is booted from a theme's `functions.php` or a plugin | A theme loaded by WordPress, using Acorn | WordPress first, with Acorn, in a Bedrock layout |
| **Routing** | Laravel routes, `Route::wp()` on WordPress conditional tags, then the template hierarchy as fallback | Laravel routes alongside WordPress | WordPress template hierarchy, rendered with Blade | Laravel routes, through Acorn |
| **Templating** | Blade themes with Sage Directives, Vite and Tailwind CSS; block themes also supported | Blade | Blade, Tailwind CSS, Vite | Blade, through Sage |
| **Post types and hooks** | PHP 8 attributes (`#[PostType]`, `#[Taxonomy]`, `#[Action]`, `#[Filter]`, `#[WpRestRoute]`, `#[Schedule]`…), auto-discovered | Your theme or plugin code | Your theme code | Post types and taxonomies in `config/post-types.php` |
| **Blocks** | `pollora:make:block`, rendered with Blade | Your build | Your build | `make:block`, server-side rendering |
| **Media and image sizes** | Any Laravel disk (S3, R2, MinIO…) with two settings; sizes declared in PHP with `ImageSize`, made on demand | WordPress's own uploads and image sizes | WordPress's own uploads and image sizes | WordPress's own uploads and image sizes |
| **Testing** | Laravel's testing tools | Laravel's testing tools | Your setup | Pest, Playwright, linting in GitHub Actions |
| **AI tooling** | [Nectar](https://pollora.dev/nectar/overview/): guidelines, 12 agent skills and 11 MCP tools, on Laravel Boost | | | |
| **License and price** | MIT, free | MIT, free | MIT, free | One-time purchase: $80 for one site, $240 for unlimited sites |
| **Maturity** (November 2026) | v13.40.2 stable, a young project | v6.3.0, about 2.8M Packagist installs | v11.2.1, about 13.3k GitHub stars | Commercial product from Roots |

Sources: each project's GitHub repository, Packagist and product page (roots.io/acorn, roots.io/radicle), checked on 6 November 2026.

Corcel is not in this table: it is a library of database models, not a way to build a WordPress site, so most rows would not apply. It has [its own section](#corcel-a-different-job) below.

## Pollora and Acorn

**Choose Acorn if** you already have a WordPress site, theme or plugin and want Laravel's container, Blade, Eloquent, queues, migrations and commands without changing how the site is structured. Acorn is installed with `composer require roots/acorn` and booted from your theme or plugin, so WordPress stays in charge of the request. It is mature, maintained by the Roots team, widely used, and its WP-CLI integration (`wp acorn`) fits existing WordPress workflows.

**Pollora takes the inverse route.** The project *is* a Laravel application: `public/index.php` is Laravel's front controller, `routes/web.php` is checked first, and WordPress is loaded inside it to serve the admin, the database and the plugins. Registration code becomes attributes that are [discovered automatically](https://pollora.dev/core-concepts/auto-discovery/): a class with `#[PostType]` becomes a post type, a method with `#[Action('init')]` becomes an action. `Route::wp()` lets a Laravel route match a WordPress conditional tag such as `is_singular` (see [WordPress Routes](https://pollora.dev/routing/wordpress-routes/)).

Acorn slots into any WordPress site; Pollora is a project layout you start from. The [full Pollora and Acorn comparison](https://pollora.dev/compare/pollora-vs-acorn/) goes further: the same task written both ways, adoption figures and when Acorn is the better choice.

## Pollora and Sage

**Choose Sage if** you are building a theme for a standard WordPress install and want Blade, Tailwind CSS and a Vite build with hot reloading. Sage is the most popular project on this page and the reference for modern WordPress themes.

**Pollora is an application framework rather than a theme.** Pollora themes use the same ingredients, Blade, Vite, Tailwind CSS and Sage Directives (see [Theme Structure](https://pollora.dev/theming/theme-structure/)), but they sit inside a Laravel app that also owns routing, controllers, middleware, queues, and the post types, hooks and REST routes declared as attributes.

If you only need a theme, Sage is the simpler choice.

## Pollora and Radicle

Radicle is the closest project to Pollora: a complete, Laravel-powered WordPress starter from the Roots team.

**Choose Radicle if** you want the Roots stack prepackaged, with Bedrock's structure, Acorn, Sage, optional Trellis for servers, and the tooling already wired: Pest, Playwright end-to-end tests, linting in GitHub Actions, and block scaffolding with `make:block`. It is a one-off purchase that also supports the Roots team's work.

**Pollora covers the same ground and goes further in a few places:**

- **Laravel first.** WordPress runs inside the Laravel application instead of Laravel running inside WordPress, so routing, middleware and the request lifecycle are Laravel's.
- **Attributes and auto-discovery** for post types, taxonomies, hooks, REST routes, WP-CLI commands, schedules, AJAX handlers and abilities, where Radicle registers post types and taxonomies in a configuration file.
- **Media on any disk, image sizes in PHP.** The [media library](https://pollora.dev/advanced/media/) moves to S3, R2 or any Laravel disk with `MEDIA_DISK` and `MEDIA_URL`, and `ImageSize` declares the sizes your design uses, instead of the sizes WordPress registers for every image.
- **`Route::wp()`**: Laravel routes matched on WordPress conditional tags, with the template hierarchy as a fallback.
- **AI tooling**: [Nectar](https://pollora.dev/nectar/overview/) gives coding agents guidelines, skills and MCP tools for the project.
- **Free and MIT-licensed.**

The [full Pollora and Radicle comparison](https://pollora.dev/compare/pollora-vs-radicle/) sets them side by side, including where Radicle is ahead.

Both use a Bedrock-style layout (in Pollora, WordPress core in `public/cms` and `wp-content` in `public/content`; see [Server Configuration](https://pollora.dev/getting-started/server-configuration/)) and install WordPress core and plugins with Composer.

## Corcel: a different job

Corcel is not a framework and does not build WordPress sites. It is a set of Eloquent models over the WordPress tables, for a Laravel (or other PHP) application that needs to read WordPress data. WordPress itself is never booted: no hooks, no plugins, no theme.

**Choose Corcel if** your main application is a Laravel app and WordPress is only a back office where editors write content. Your app reads posts, pages, terms, users and meta through Corcel and renders them its own way. It is MIT-licensed, at v9.0.0, with about 4.8k GitHub stars (October 2026).

**Choose Pollora if** the site itself is WordPress: you want its admin, its plugins and its editors, with Laravel routes, controllers and Blade on the front end. Hooks fire, plugins load, and the REST API and the template hierarchy keep working.

The two are related rather than rivals. Pollora's WordPress models (`Pollora\Models\Post`, `Page`, `Attachment`, `Term`, `User`, `Menu`…) are built on `pollora/colt`, a fork of Corcel, so Corcel-style queries remain available inside a Pollora app.

## Coming from Sage or Acorn

There is no dedicated migration guide yet. What carries over directly:

- **Blade templates**, including Sage Directives such as `@posts`, `@title` and `@content`.
- **Tailwind CSS and Vite**, with `@roots/vite-plugin` generating `theme.json` from your `@theme` design tokens (see [Theme Structure](https://pollora.dev/theming/theme-structure/)).
- **A Bedrock-style, Composer-managed project**: WordPress core and plugins are Composer dependencies.
- **ACF-style inner blocks**: Pollora's `<InnerBlocks />` tag follows ACF's, only the default wrapper class differs (see [Gutenberg Blocks](https://pollora.dev/blocks/gutenberg-blocks/)).

What changes: hooks and post types move from function calls or configuration to attribute classes, and the project becomes a Laravel application with WordPress inside it.

## Next steps

- [Install Pollora](https://pollora.dev/getting-started/installation/) with `pollora new example-app`.
- Read [Why Pollora](https://pollora.dev/why/) for the reasoning and the trade-offs.
- New to the question? See [six ways to integrate Laravel with WordPress](https://pollora.dev/guides/laravel-and-wordpress-approaches/), of which Pollora is one.
- Looking at Timber? Not a Laravel project, but a common alternative for cleaner templates: [Pollora vs Timber](https://pollora.dev/compare/pollora-vs-timber/).
- Check the [FAQ](https://pollora.dev/faq/) for requirements, hosting and plugins.
