Laravel in Mid-2026: Volt, Reverb, Pulse, Pennant, and the New Starter-Kit Story

Laravel in mid-2026 is denser than ever — and somehow easier to start a new project on. Laravel 12 is the production floor, the starter-kit story finally consolidated around Breeze + Inertia 2 + Volt, Pulse and Pennant are first-class, Reverb has replaced the WebSocket-server question, and Folio gives you file-based routing that finally feels Next.js-grade. If you stopped reading Laravel release notes around Laravel 10, the framework has quietly become a different stack underneath you.

This is a tour of the trends — what we are shipping at Techglock, what we have decommissioned, and what's worth the migration effort right now.

Laravel 12 Is the Floor; Laravel 13 Is Coming

Laravel 12 shipped in February 2025 with a streamlined application skeleton, Inertia 2 support, and the consolidated starter-kit model. It is the version we accept as the floor on any maintenance engagement in 2026. Laravel 13 is in the late stages of development as of mid-2026 — the team's annual February cadence has been reliable for years and there's no reason to expect 13 to slip.

What changed across 11 and 12:

• Slimmer application skeleton — fewer files in app/, fewer middleware registered by default, configuration consolidated.
• Per-second rate limiting — finer granularity than the previous per-minute model.
• Inertia 2 as the default for the React / Vue starter kits.
• Single starter-kit story — Jetstream is in extended maintenance only. Breeze is the recommended starting point, with React, Vue, and Livewire variants.
• Eloquent improvements — eager loading enhancements, better tap-and-chain methods on collections, native casts for typed enums.
• Pulse, Reverb, Pennant, Folio, Volt all reached production maturity and are the recommended primitives in their domains.

The Starter-Kit Story Finally Makes Sense

For years, the question "which starter kit should I use for a new Laravel project?" had three answers: Jetstream (heavy, opinionated), Breeze (light, flexible), or roll-your-own. By mid-2026, the question has narrowed:

• Breeze + Inertia 2 + React or Vue — for SPA-style products. This is our default for client work that needs rich UI.
• Breeze + Livewire 3 + Volt — for products where the team is PHP-first and doesn't want a JavaScript build pipeline. This stack is much more capable than it was in 2022.
• Breeze + Blade — for content sites, marketing sites, and admin panels where you don't need SPA behaviour.

What we have removed from new projects: Jetstream. The team-management, two-factor, and API token features that Jetstream provided are now either in Breeze or in standalone packages (Sanctum for tokens, packages for teams). The starter kit doesn't need to ship them by default.

Livewire 3 + Volt Is the Real Surprise

If you stopped following Livewire around v2, you missed the most impactful change in the Laravel ecosystem of the last two years. Livewire 3 is materially faster, has a much smaller client payload, and the Volt component-style syntax makes single-file components feel like Svelte.

<?php

use function Livewire\Volt\{state, computed};

state(['search' => '']);

$results = computed(fn () =>
    Product::where('name', 'like', "%{$this->search}%")
            ->take(10)
            ->get()
);

?>

<div>
    <input wire:model.live="search" placeholder="Search...">
    @foreach ($this->results as $product)
        <p>{{ $product->name }}</p>
    @endforeach
</div>

That whole component — state, computed properties, view — lives in one file. There's no JavaScript build. There's no API endpoint. The reactive updates happen via Livewire's wire protocol over WebSocket (if Reverb is enabled) or polling fallback.

For internal tools, admin dashboards, customer portals, and many B2B SaaS interfaces, Livewire + Volt is the fastest way to ship interactive UI we have measured. It's not the right call for marketplaces or consumer products that need true SPA fluidity — Inertia is better for those — but the productivity gap on internal-facing work is real.

Reverb Solved the WebSocket Question

Before Reverb, the answer to "how do I add real-time features to a Laravel app?" was Pusher (expensive), Soketi (self-hosted but unmaintained), or a custom Node server (operational burden). Reverb shipped in 2024 as a first-party Laravel WebSocket server and by mid-2026 is the unambiguous default.

What Reverb gives you:

• Pusher-protocol-compatible — drop-in replacement for clients already using Pusher.
• Horizontally scalable via Redis pub/sub.
• Production-ready performance — tens of thousands of concurrent connections per instance.
• Integrates with Echo on the frontend and with Laravel broadcasting on the backend.

For real-time notifications, presence channels, live dashboards, and chat features in our client products, Reverb has replaced every other option. The deployment story is small (one extra process behind your existing load balancer), and the cost savings versus Pusher at scale are meaningful.

Pulse Is the Best Application Monitor Most Teams Aren't Using

Pulse is Laravel's first-party application monitoring dashboard. By mid-2026 it has matured to the point where for most internal monitoring (slow queries, high-throughput jobs, cache hit rates, slow requests, exception trends), we install Pulse before installing DataDog or Sentry.

What it gives you out of the box:

• Slow database query tracking with a percentile distribution.
• Slow request tracking by route.
• Cache hit/miss rates.
• Queue depth and job duration.
• Usage tracking — which users / IPs are driving load.
• Customisable cards — add your own metrics.

It's not a replacement for Sentry (you still want error tracking and source-maps for the frontend) or DataDog (if you have multi-language infra). But for Laravel-only stacks, Pulse covers the core monitoring needs without adding a vendor relationship.

Pennant Made Feature Flags Boring (in a Good Way)

Before Pennant, feature flags in Laravel meant either a third-party SaaS (LaunchDarkly, Statsig) or a homemade table-and-helpers pattern that drifted across projects. Pennant ships a feature-flag primitive that handles the common patterns — per-user flags, percentage rollouts, group targeting, definition in code — and stores state in the database, in Redis, or in a custom driver.

use Laravel\Pennant\Feature;

Feature::define('new-checkout', fn (User $user) =>
    $user->is_beta_tester || lottery(0.1)
);

if (Feature::active('new-checkout')) {
    return view('checkout-v2');
}

For SaaS feature gating, gradual rollouts, kill switches, and per-tenant experiments, Pennant is sufficient. We still recommend LaunchDarkly for organisations that need an external dashboard for non-engineers — but for engineer-driven feature flagging inside a Laravel app, Pennant has replaced our previous third-party recommendations.

Folio Is File-Based Routing for the Blade World

Folio adds Next.js-style file-based routing to Laravel. Drop a Blade file in resources/views/pages/ and it becomes a route. The naming convention handles dynamic segments and nested layouts. For documentation sites, marketing pages, and content-heavy areas inside a Laravel app, this removes the routes/web.php ceremony entirely.

resources/views/pages/
├── index.blade.php          // GET /
├── pricing.blade.php        // GET /pricing
├── blog/
│   ├── index.blade.php      // GET /blog
│   └── [slug].blade.php     // GET /blog/{slug}

We have used Folio on every content-heavy section of the last few Laravel projects we shipped. It coexists fine with traditional controller-based routes — you don't have to commit to one model.

Inertia 2 Closed the Gap with Next.js

Inertia 2 shipped in 2024 with async props, deferred loading, server-driven preloading, and form helper improvements. The developer experience is finally close enough to Next.js's App Router that we recommend Inertia + Laravel for product teams who would otherwise reach for a Next + tRPC stack. The advantages: one runtime, one auth model, one type system (if you adopt Inertia's TypeScript story), one deploy pipeline.

The remaining gap with Next.js is server components — Inertia is a server-rendered, client-hydrated model, not a server-component model. For most SaaS dashboards and internal tools, that's fine. For content-heavy sites with sub-second LCP requirements, Next.js still has the edge.

Eloquent Quietly Got Better

Several small Eloquent improvements added up across Laravel 11 and 12:

• Native enum casts with backing-type validation.
• Better lazy loading guards — preventLazyLoading is the right default for new projects.
• Eager-load constraints with cleaner syntax.
• Attribute accessors and mutators using closures (since 9, mature now).
• JSON column casts with native PHP arrays — no more ->cast = 'array' on every JSON field by default.

The net effect: less Eloquent ceremony in models, more behaviour discoverable from the attribute definitions themselves.

The Things We Have Stopped Using

Kill list for new Laravel projects in 2026:

• Jetstream — too opinionated for most teams. Breeze is enough.
• Pusher (as a paid service) — replaced by Reverb.
• Soketi (self-hosted WebSocket alternative) — replaced by Reverb.
• Sanctum-only auth for new SaaS — combine with Fortify or Breeze depending on the product shape.
• Sail for production-like local dev — Herd has replaced it on macOS for most of our team.
• StyleCI / PHP-CS-Fixer config copies — Pint is the default now and ships with sensible config.
• Laravel Mix — Vite is the default and has been for years.

The Migration Order If You're Catching Up

For teams that froze around Laravel 9 or 10, the rollout we recommend:

1. Upgrade to Laravel 11 first, then to 12. Don't skip 11. The breaking changes are small but worth absorbing in two steps.
2. Replace Pusher with Reverb. The cost savings alone make this worth doing in week one.
3. Install Pulse on staging, then production. Look at the slow-query and slow-request data before deciding what to optimise.
4. Adopt Pennant for any new feature flag. Migrate existing homemade flag tables when you next touch them.
5. If you have a Livewire 2 codebase, upgrade to Livewire 3 with the official upgrade kit. The performance win is real.
6. Migrate from Laravel Mix to Vite if you haven't already. This is overdue.
7. Adopt Folio for the documentation or marketing area of your app first. Get a feel for the routing model on low-risk pages.

What's Coming Next

Three things to watch through the back half of 2026:

• Laravel 13 — expect more first-party AI primitives, deeper Reverb integration, and continued slimming of the default app skeleton.
• Native server components for Blade. The framework team has hinted at it; it would be a significant shift in how Blade and Livewire interact.
• Tighter Pulse + Reverb + Pennant integration. A unified observability + experimentation story is the obvious next product surface.

If you only do one thing after reading this: install Pulse on your staging environment and look at the slow-query dashboard. You will find at least three optimisations you didn't know you needed, and you'll understand why Laravel's first-party tooling has become genuinely difficult to compete with.