Laravel + WordPress

Modern PHP,
zero compromise.

Build WordPress sites with Laravel's elegance. PHP 8 attributes, Blade templates, auto-discovery, and a full ecosystem of packages.

Book.php
use Pollora\Attributes\PostType;
use Pollora\Attributes\ShowInRest;

#[PostType('book')]
#[HasArchive]
#[Supports(['title', 'editor', 'thumbnail'])]
#[ShowInRest]
class Book {}

// That's it. Auto-discovered, registered, ready.

Up and running in one command

Install the CLI, scaffold a project, start building. WordPress + Laravel, ready in under two minutes.

~ Terminal
$ composer global require pollora/cli
$ pollora new my-site --ddev
✓ Project created successfully.
✓ DDEV environment configured.
✓ WordPress installed.
Ready at https://my-site.ddev.site

Built for the modern PHP developer

Everything you need to build WordPress sites with the tooling you already know and love.

PHP 8 Attributes

Declare, don't register

Post types, taxonomies, hooks, REST endpoints, schedules — all defined with PHP 8 attributes. No more register_post_type() calls.

#[PostType('product')]
#[HasArchive]
#[ShowInRest]
class Product {}
Auto-Discovery

Write it, it works

No manual registration. Pollora scans your codebase and registers everything automatically. Convention over configuration.

Blade Templates

WordPress data, Laravel syntax

Replace PHP template files with Blade. Use directives like @posts, @title, @content for clean, readable templates.

Hybrid Routing

Laravel routes + WordPress fallback

Route::wp() maps WordPress conditions to controllers. Custom routes take priority; the template hierarchy handles the rest.

Route::wp('single', [PostController::class, 'show']);
Route::wp('page', 'contact', [ContactController::class, 'index']);
Vite + Tailwind

Modern asset pipeline

Vite with HMR, Tailwind CSS v4, and the Asset facade for script and style registration. No more enqueue headaches.

Type Safety

PHPStan, types everywhere

Constructor property promotion, explicit return types, type-hinted parameters. PHPStan level 5 enforced across the framework.

The difference is visible

Register a custom post type. Left: WordPress traditional. Right: Pollora.

WordPress — 25+ lines
function register_book_post_type() {
    register_post_type('book', [
        'labels' => [
            'name'          => 'Books',
            'singular_name' => 'Book',
            'add_new'       => 'Add New Book',
            'edit_item'     => 'Edit Book',
            'view_item'     => 'View Book',
        ],
        'public'       => true,
        'has_archive'  => true,
        'show_in_rest' => true,
        'supports'     => ['title', 'editor', 'thumbnail'],
    ]);
}
add_action('init', 'register_book_post_type');
Pollora — 6 lines
use Pollora\Attributes\PostType;
use Pollora\Attributes\ShowInRest;

#[PostType('book')]
#[HasArchive]
#[Supports(['title', 'editor', 'thumbnail'])]
#[ShowInRest]
class Book {}

// Auto-discovered. Auto-registered.
// Labels generated from the class name.
WordPress — scattered across files
// functions.php — action
add_action('init', 'setup_custom_rewrites', 20);

function setup_custom_rewrites() {
    add_rewrite_rule(/* ... */);
}

// functions.php — filter
add_filter('the_content', 'add_cta_to_posts');

function add_cta_to_posts($content) {
    if (is_single()) {
        $content .= '<div class="cta">...</div>';
    }
    return $content;
}
Pollora — one class, typed methods
use Pollora\Attributes\Action;
use Pollora\Attributes\Filter;

class ContentHooks
{
    #[Action('init', priority: 20)]
    public function setupRewrites(): void
    {
        // Auto-discovered, auto-registered
    }

    #[Filter('the_content')]
    public function addCta(string $content): string
    {
        return $content . '<div class="cta">...</div>';
    }
}
WordPress — 30+ lines, fragile
// 1. Register custom 6h interval
add_filter('cron_schedules', function($s) {
    $s['every_6h'] = [
        'interval' => 21600,
        'display'  => 'Every 6 hours',
    ];
    return $s;
});

// 2. Schedule daily cleanup
if (!wp_next_scheduled('daily_cleanup')) {
    wp_schedule_event(time(), 'daily', 'daily_cleanup');
}
add_action('daily_cleanup', 'do_daily_cleanup');

function do_daily_cleanup() {
    // Clean up old data
}

// 3. Schedule feed check every 6h
if (!wp_next_scheduled('check_feeds')) {
    wp_schedule_event(time(), 'every_6h', 'check_feeds');
}
add_action('check_feeds', 'do_check_feeds');

function do_check_feeds() {
    // Check RSS feeds
}
Pollora — one attribute, done
use Pollora\Attributes\Schedule;
use Pollora\Schedule\Every;
use Pollora\Schedule\Interval;

class Maintenance
{
    #[Schedule(Every::DAY)]
    public function dailyCleanup(): void
    {
        // Runs daily. Auto-registered.
    }

    #[Schedule(new Interval(hours: 6))]
    public function checkFeeds(): void
    {
        // Custom interval. No cron_schedules filter.
    }
}

Two themes, two purposes

Start with a clean default or a conversion-ready WooCommerce storefront. Both use Blade, Vite, and Tailwind CSS.

pollora:make-theme starter

Clean, minimal, ready to customize

Default Theme

Blade templates, Vite with HMR, Tailwind CSS v4, theme-specific service providers and configuration. The right starting point for any project.

--template=apiary

WooCommerce, conversion-optimized

Apiary WooCommerce

Sticky add-to-cart, search autocomplete, Alpine.js interactivity, responsive product grids, and full checkout override. Built for conversion.

pollora/nectar

AI-native development

Nectar gives AI coding agents deep context about your Pollora project. Built on Laravel Boost, it provides live introspection via MCP and domain-specific skills for every framework feature.

10

MCP tools for live introspection of WordPress, routes, hooks, and components

8

Agent skills for post types, theming, hooks, blocks, REST API, and more

Compatible with
Claude Code
Cursor
Windsurf
Any MCP-compatible agent
php artisan nectar:mcp
Pollora documentation mascot

Documentation

Everything you need, explained

From installation to advanced plugin development — comprehensive guides, API references, and real code examples. Searchable, versioned, and AI-ready with llms.txt.

Start building with Pollora

One command to install. Laravel conventions from day one. WordPress power underneath.