Skip to content

Radicle: The Complete Guide to the All-in-One Roots.io Starter Template

Emnes
Illustration of Radicle combining Bedrock Sage and Acorn into one starter template

Every Roots-based WordPress project eventually arrives at the same assembly question: Bedrock for the project structure, Sage for the theme, Acorn for Laravel features, Trellis for deploys, a set of curated mu-plugins for the common stuff every site needs. Gluing these together takes time — hours for an experienced developer on a new project, days for someone still learning the stack. That’s the gap Radicle fills.

Radicle is Roots.io’s opinionated, all-in-one WordPress starter. It combines Bedrock, Sage, Acorn, and a set of pre-wired mu-plugins into a single Laravel-style project structure. It’s the one paid Roots product — a one-time purchase that skips you past the gluing step and lands you directly in “write your application code” mode. The current version as of April 2026 is Radicle 2.6.0.

This guide covers what Radicle is, what’s in the box, what you give up by choosing Radicle over composing the stack yourself, and whether it’s worth the purchase for your team.

What Radicle Is

Radicle is a project template — a Composer-installable starting point that gives you a fully-assembled Roots stack on day one. Unlike Bedrock (an unopinionated boilerplate) or Sage (just a theme), Radicle takes opinions about:

  • How project code is organized (Laravel-style app/, config/, resources/, storage/).
  • Which mu-plugins are installed by default (Extended CPTs, Allow SVG, Query Monitor, Acorn Prettify, Acorn Mail, Blade Icons).
  • Where Blade templates live (resources/views/ at the project root, not inside a theme).
  • How to structure REST API endpoints (Laravel-style routing).
  • How to handle database migrations (Acorn migrations by default).
  • Testing setup (Pest with PHPUnit).

If you agree with the opinions, Radicle saves you days of setup. If you disagree, it’s the wrong starting point — go back to composing Bedrock + Sage + Acorn yourself.

The Radicle Directory Structure

A fresh Radicle project:

my-project/
├── app/ # PHP classes (controllers, providers, models)
│ ├── Http/
│ ├── Providers/
│ └── Models/
├── bootstrap/
├── config/ # Laravel-style config + WordPress + Acorn
├── database/
│ └── migrations/ # Acorn migrations
├── public/ # web root
│ ├── content/ # wp-content replacement
│ │ ├── mu-plugins/
│ │ ├── plugins/
│ │ ├── themes/
│ │ └── uploads/
│ └── wp/ # WordPress core (Composer-managed)
├── resources/
│ └── views/ # Blade templates at project root
├── routes/ # Laravel-style routing
├── storage/
├── tests/ # Pest test scaffolding
├── .env.example
├── composer.json
└── package.json

The standout features:

  • Blade views at the project root, not inside a theme folder. Your templates are a first-class part of the application.
  • Acorn at the project level, not just inside Sage. Service providers, migrations, console commands, and Laravel features are all top-level.
  • Standard Laravel directory names — app/, bootstrap/, config/, resources/, storage/ — so Laravel developers feel immediately at home.
  • Routes directory for defining custom REST endpoints using Laravel’s routing syntax, independent of WordPress’s REST API.

The theme in public/content/themes/ is stripped down — most of what would go in a Sage theme lives at the project root instead. The theme is almost incidental in Radicle.

What’s in the Box (mu-plugins)

Radicle ships with a curated set of must-use plugins, each chosen because it’s useful on almost every WordPress project:

  • Extended CPTs — the library Acorn Post Types wraps, for less-boilerplate CPT registration.
  • Allow SVG — safely allows SVG uploads in the media library.
  • Query Monitor — the essential debugging toolbar for WordPress development.
  • Acorn Prettify — removes WordPress’s default clutter (emoji scripts, jQuery Migrate, default feeds).
  • Acorn Mail — Laravel’s mailer with Blade-templated emails.
  • Blade Icons — <x-icon name="heroicons.arrow-right" /> for icons in templates.

None of these are unique to Radicle — you can install them on any Roots-based project. But Radicle’s default install has them already wired up, configured, and ready to use.

Laravel-Style REST APIs

One of Radicle’s underrated features is the routes/ directory, where you define REST endpoints using Laravel’s routing syntax:

// routes/api.php
use App\Http\Controllers\EventController;

Route::get('/events/upcoming', [EventController::class, 'upcoming']);
Route::get('/events/{id}', [EventController::class, 'show']);

And the controller:

namespace App\Http\Controllers;

use App\Models\Event;
use Illuminate\Http\Request;

class EventController {
  public function upcoming(Request $request) {
    return Event::upcoming()->limit(10)->get();
  }

  public function show(int $id) {
    return Event::findOrFail($id);
  }
}

Contrast this with WordPress’s REST API, which requires register_rest_route() calls, manual argument validation, manual authentication, and lots of boilerplate. The Radicle approach is substantially cleaner for complex APIs.

You can still use WordPress’s REST API alongside Radicle’s Laravel routes — they coexist without conflict. Pick whichever fits each endpoint.

Built-in Testing with Pest

Radicle ships with Pest — a more expressive PHPUnit wrapper — configured and ready to go. Example test:

// tests/Feature/HomepageTest.php
it('displays the homepage', function () {
  $response = $this->get('/');

  $response->assertOk();
  $response->assertSee('Welcome');
});

Run tests with ./vendor/bin/pest. Compared to bolting tests onto a vanilla WordPress theme, having the scaffolding present from day one is a significant accelerator.

Database Migrations

Radicle’s database/migrations/ directory is wired for Acorn migrations out of the box. Generate a migration:

wp acorn make:migration create_events_table

And run it with wp acorn migrate. See our Laravel-style migrations guide for the full workflow.

Installing Radicle

Radicle is a paid product — purchase a license on the Roots website. After purchase, you get a Composer repository URL and credentials.

Create a new project:

composer create-project roots/radicle my-project

With the Radicle credentials configured, this pulls the Radicle template, scaffolds the directory structure, and installs all default dependencies. Total setup: about 5 minutes including Composer downloads.

Copy .env.example to .env, fill in database credentials, and run the WordPress installer at your project URL. You’re ready to start building.

When Radicle Is Worth It

Radicle makes sense when:

  • You’re committed to the Roots way. Radicle’s opinions are Roots’s opinions — if you’re already using Bedrock + Sage + Acorn, Radicle is the natural next step.
  • You value time over the license cost. A few hours saved on each new project adds up quickly for agencies.
  • You have Laravel-experienced developers who’ll appreciate the familiar directory structure.
  • You’re building application-heavy projects — subscriptions, workflows, complex APIs — where the Laravel-style organization pays off.
  • You want Laravel-style migrations and routing as a first-class feature.
  • You want the curated mu-plugin defaults. Saves research time across many projects.

When Radicle Isn’t the Right Fit

  • You want to pick every piece yourself. Radicle’s opinions are not subtle — if you’d prefer a different theme framework, different mu-plugins, or a different directory structure, compose Bedrock + your choices manually.
  • You’re building a simple site that doesn’t need Laravel features. Radicle’s overhead isn’t warranted for a brochure site.
  • You don’t want to pay for Composer templates. The open-source alternative (Bedrock + Sage + Acorn assembled manually) is always available.
  • Your team doesn’t have Laravel experience and doesn’t want to learn it. The Radicle structure is Laravel-idiomatic; adopting it without Laravel familiarity slows teams down.
  • You’re handing sites off to non-technical clients who need a classic WordPress admin-UI experience. Radicle is developer-facing.

Radicle vs Building It Yourself

Everything Radicle does, you can build yourself:

  • Start with Bedrock.
  • Install Sage as a theme.
  • Promote Acorn to the project root.
  • Install the curated mu-plugins.
  • Set up routes, migrations, Pest testing.
  • Configure the Laravel-style directory structure.

Realistic effort: 4–8 hours for an experienced Roots developer, 1–2 days for someone still learning. Radicle compresses that to 5 minutes. Whether the compression is worth the license fee depends on how often you start new projects and how experienced your team already is.

Our detailed comparison lives in the next post in this series: Bedrock + Sage + Acorn vs Radicle — which Roots starting point to choose.

Frequently Asked Questions

Is Radicle a one-time purchase or subscription?

One-time purchase per developer (or per team license, depending on tier). Check roots.io/radicle for current pricing.

Can I use Radicle on an unlimited number of projects?

Generally yes, subject to the license terms. Check the specific license you purchased.

Does Radicle include Trellis?

Trellis is separate and remains open-source. You can use Radicle with Trellis (recommended) or any other deploy tool. Trellis-CLI’s trellis new can scaffold a Radicle + Trellis project in one step.

Can I migrate an existing Bedrock + Sage project to Radicle?

Technically yes, but it’s a significant restructuring — the directory layout changes, Blade templates move from the theme to the project root, and much configuration shifts. For existing projects, it’s usually easier to keep the composed stack; for new projects, start on Radicle.

Is Radicle actively maintained?

Yes. Radicle v2.6.0 shipped in April 2026 with Acorn v6 and updated mu-plugin defaults. Roots treats Radicle as an actively-developed flagship product.

Does Radicle work with WP Engine or Kinsta?

Kinsta officially supports Radicle deployments. WP Engine works with some configuration (similar to Sage’s post-deploy requirements). Pantheon is trickier.

The Fastest Path to a Roots-Style WordPress Project

Radicle isn’t the only way to work with the Roots stack. But it’s the fastest way to start a new Roots-style project without spending hours on setup. For teams that ship Roots-based WordPress sites regularly, the time savings pay for the license in the first week.

At Emnes, we use Radicle for new application-heavy projects and vanilla Bedrock + Sage for simpler content sites. The split reflects Radicle’s sweet spot: when you’re building something that’s genuinely more like a Laravel app than a WordPress theme, Radicle’s structure removes friction at every step.

Related reading: Acorn explained, Laravel-style migrations, upcoming comparison of Bedrock + Sage + Acorn vs Radicle, and the Sage 11 deep dive.