Introducing Thorn: A Modern Starter Theme for WordPress Built on Simplicity and Power

The Backstory

If you’ve been building WordPress themes professionally for any amount of time, chances are you’ve run into the Sage starter theme from the folks over at Roots. For years, Sage has been a staple in the developer’s toolkit—bringing sanity, structure, and modern tooling to an otherwise chaotic and repetitive WordPress theming landscape.

But as Sage evolved (and rightfully so) into a more sophisticated and framework-like structure, it also became increasingly reliant on newer tools like Blade templating, Laravel-inspired architecture, and additional build layers. For many, this was a dream come true. But for others—especially those who loved the simplicity of Sage 8 and 8.5.1—the new direction introduced a level of complexity that didn’t always match project scopes or client budgets.

So we built something familiar, lean, and refreshingly modern: Thorn.

Why Thorn?

Thorn is what happens when you want the clean build system of Sage, but without the overhead of Blade, Laravel-style service containers, or rigid folder structures.

We built Thorn for devs like us:

• Freelancers who just need to spin up a theme fast
• Agencies with teams that don’t want a deep Laravel learning curve
• WordPress developers who loved Sage 8 but want Webpack 5, Yarn, and Composer

It’s a respectful nod to the old Roots stack, rebuilt from scratch to be easier to extend, scale, and maintain—while keeping it human.

What We Built

At its core, Thorn is a fusion of modern tooling and good ol’ fashioned WordPress theming.

You still get your functions.php, index.php, header.php, footer.php, etc. — but under the hood, you get a modern development stack that works how you want it to.

Let’s break it down:

🔧 Key Features

1. Webpack 5 Setup (Finally)

We built the Webpack config from the ground up to give you:

• Multiple entry points (for SCSS and JS)
• Minified and hashed production assets in /dist/
• CSS/JS source maps in development
• BrowserSync integration
• publicPath support for assets
• Full Babel support via @babel/preset-env
• Terser and CSS minimizer built-in

2. Modular Sass with Custom Bootstrap Integration

Forget bloated CSS or conflicting styles. We organize styles based on ITCSS:

assets/
  styles/
    abstracts/      // Variables, functions, mixins
    base/           // Reset, typography
    layout/         // Structural layout (header, footer, grid)
    components/     // Buttons, cards, navs, etc.
    pages/          // Page-specific styles
    wordpress/      // WP-specific overrides
    utilities/      // Helpers, print, accessibility

You define your variables before importing Bootstrap, so everything can be customized using the standard SCSS override method.

No more fighting the framework—just make it yours.

3. Font Awesome + Bootstrap Built-In

Font Awesome and Bootstrap are integrated out of the box:

• Bootstrap is injected via SCSS, not bloated CSS bundles
• Font Awesome fonts are copied into both dist/webfonts and assets/fonts for compatibility
• Bootstrap variable overrides work as expected

This lets you use utility-first classes and build a scalable design system from day one.

4. Modular JavaScript Routing

We brought back the Sage 8 DOM-based routing and cleaned it up:

const Thorn = {
  common: {
    init() {
      // Fires on all pages
    },
    finalize() {
      // Fires after page-specific init
    }
  },
  home: {
    init() {
      // Home page scripts
    }
  }
}

Body classes map directly to JS routes. Clean. Easy to extend. No bloat.

5. Modern PHP Theme Structure

We’ve kept the traditional PHP theme flow with some helpful organization:

• lib/assets.php – Manages asset paths (like Sage’s manifest helper)
• lib/setup.php – Registers menus, theme support, sidebars
• lib/wrapper.php – Replicates Sage’s layout wrapper system
• lib/extras.php – Useful WP filters and helpers
• lib/titles.php – Clean, contextual title logic

No Blade. No dependency on controller files. Just familiar, flexible structure with logic where it helps.

6. Composer Support (Yes, Really)

We’ve baked in Composer support from the start.

Here’s the current composer.json:

{
  "require": {
    "guzzlehttp/guzzle": "^7.9",
    "phpmailer/phpmailer": "^6.9"
  },
  "config": {
    "platform-check": false
  }
}

Why disable platform-check?

Great question.

When running composer install, Guzzle was throwing compatibility warnings depending on your local PHP version (especially on environments like Laravel Valet or MAMP). To prevent Composer from blocking installation, we disabled platform-checking so you can install dependencies regardless of your local setup.

You can still control PHP compatibility via .nvmrc, .tool-versions, or custom tooling.

Getting Started

1. Clone the repo:

git clone https://github.com/synmekthorn/thorn_wp.git

2. Install dependencies:

cd thorn_wp
composer install
yarn install

3. Run the dev server:

yarn dev

4. Build for production:

yarn build

That’s it. You’re now building themes like it’s 2025, not 2015.

BrowserSync Config

Out of the box, BrowserSync is pre-configured to hot-reload your PHP, JS, and SCSS files. Just edit the local dev URL in the webpack.config.js file if needed:

new BrowserSyncPlugin({
  proxy: 'https://your-local-url.test',
  files: ['dist/**/*', '**/*.php'],
});

Folder Structure

thorn_wp/
├── assets/
│   ├── styles/
│   ├── scripts/
│   ├── images/
│   └── fonts/
├── dist/
├── lib/
│   ├── assets.php
│   ├── setup.php
│   ├── wrapper.php
│   └── ...
├── templates/
├── index.php
├── functions.php
├── package.json
├── composer.json
└── screenshot.png

GitHub Repo

All code is open-source and MIT-licensed.

🔗 https://github.com/synmekthorn/thorn_wp

You can fork it, clone it, or install via Composer (coming soon to Packagist).

Future Features (That We’re Thinking About)

• Optional support for Alpine.js or Stimulus
• Theme options via ACF or native Customizer
• FSE (Full Site Editing) optional compatibility
• Packagist support for composer create-project

A Thank You to Roots

We wouldn’t be here without Roots. Their work on Sage, Bedrock, and Trellis changed how we build WordPress sites forever.

To @benword, @retlehs, and the rest of the Roots team: thank you. We’ve used and loved Sage for years—and we hope Thorn honors the legacy you started.

Open to Feedback

This is just the beginning. We built Thorn to solve problems we personally felt—but we know other devs might want different things.

Raise issues. Submit PRs. Or just say hi and tell us how you use it.

Final Thoughts

If you’ve ever said:

“I love Sage 8, but I just want to use Webpack and Composer without all the extra Blade stuff.”

Then Thorn was built for you.

Familiar folder structure. Modern stack. No opinionated templating engines. Just clean, scalable, performance-ready WordPress themes with tools that feel great to use.

🛠 Built by Synmek
📬 Got questions or ideas? Open an issue

Welcome to Thorn. Let’s build something awesome.