With the AI SDK, you can build provider-agnostic AI features while keeping a consistent, Laravel-native developer experience.

For example, a basic agent can be prompted with a single call:

use App\Ai\Agents\SalesCoach;

$response = SalesCoach::make()->prompt('Analyze this sales transcript...');

return (string) $response;

The Laravel AI SDK can also generate images, audio, and embeddings:

For visual generation use cases, the SDK offers a clean API for creating images from plain-language prompts:

use Laravel\Ai\Image;

$image = Image::of('A donut sitting on the kitchen counter')->generate();

$rawContent = (string) $image;

For voice experiences, you can synthesize natural-sounding audio from text for assistants, narrations, and accessibility features:

use Laravel\Ai\Audio;

$audio = Audio::of('I love coding with Laravel.')->generate();

$rawContent = (string) $audio;

And for semantic search and retrieval workflows, you can generate embeddings directly from strings:

use Illuminate\Support\Str;

$embeddings = Str::of('Napa Valley has great wine.')->toEmbeddings();

JSON:API resources handle resource object serialization, relationship inclusion, sparse fieldsets, links, and JSON:API-compliant response headers.

Queue::route(ProcessPodcast::class, connection: 'redis', queue: 'podcasts');

Notable additions include controller and authorization attributes like #[Middleware] and #[Authorize], as well as queue-oriented job controls like #[Tries], #[Backoff], #[Timeout], and #[FailOnTimeout].

For example, controller middleware and policy checks can now be declared directly on classes and methods:

<?php

namespace App\Http\Controllers;

use App\Models\Comment;
use App\Models\Post;
use Illuminate\Routing\Attributes\Controllers\Authorize;
use Illuminate\Routing\Attributes\Controllers\Middleware;

#[Middleware('auth')]
class CommentController
{
    #[Middleware('subscribed')]
    #[Authorize('create', [Comment::class, 'post'])]
    public function store(Post $post)
    {
        // ...
    }
}

Additional attributes have also been introduced across Eloquent, events, notifications, validation, testing, and resource serialization APIs, giving you a consistent attribute-first option in more areas of the framework.

These features make it straightforward to build AI-powered search experiences using PostgreSQL + pgvector, including similarity search against embeddings generated directly from strings.

For example, you may run semantic similarity searches directly from the query builder:

$documents = DB::table('documents')
    ->whereVectorSimilarTo('embedding', 'Best wineries in Napa Valley')
    ->limit(10)
    ->get();

Inertia v3 is here — a ground-up rethink of the developer experience with a focus on zero-config setup, smaller bundles, and powerful new primitives for building modern apps. Axios and qs have been replaced with a built-in XHR client, SSR works automatically during development without a separate Node process, and a new Vite plugin eliminates nearly all boilerplate. On top of that, v3 introduces optimistic updates, instant visits, standalone HTTP requests via useHttp, layout props, and fine-grained exception handling — all designed to make Inertia apps feel faster to build and faster to use. Here's what's new:

Read the upgrade guide: https://inertiajs.com/docs/v3/getting-started/upgrade-guide

Our first-party starter kits have all been upgraded to use Laravel 13 and Inertia v3 from day one. Spin up a fresh app with the latest stack today!

When a provider runs out of credits or hits a quota limit, Laravel AI now automatically fails over to your next configured provider instead of throwing an exception. Billing errors from Anthropic, OpenAI, OpenRouter, and DeepSeek are all detected and routed through the standard failover mechanism - no code changes required.

Agents can now pass provider-specific options - like OpenAI's reasoning.effort - by implementing the new HasProviderOptions interface. This is especially useful for reasoning models where the default effort level may burn unnecessary tokens for simple tasks:

use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasProviderOptions;

class MyAgent implements Agent, HasProviderOptions
{
    use Promptable;

    public function providerOptions(): array
    {
        return [
            'reasoning' => ['effort' => 'low'],
        ];
    }
}

A new built-in skill covering 125+ best practices across 21 categories, from database performance and security to caching, testing, and deployment. Your AI agent now has a comprehensive reference for writing idiomatic Laravel code.

When you install a third-party skill, Boost now runs a non-blocking security audit via partner services. Results appear as a color-coded table so you can make an informed decision before proceeding. Skip it anytime with --skip-audit:

php artisan boost:add-skill owner/repo --all
php artisan boost:add-skill owner/repo --all --skip-audit

A new MCP prompt that walks your AI assistant through upgrading from Laravel 12.x to 13.0. It auto-registers for apps running Laravel 12 and disappears once the upgrade is complete.

Similar to the Laravel 13 upgrade prompt, this one provides step-by-step guidance for moving from Inertia v2 to v3. It detects your frontend framework (React, Vue, or Svelte) and renders only the relevant migration steps.

Boost's log reading tools now auto-detect JSON-formatted logs and parse them correctly. If you're using Monolog's JsonFormatter, LogstashFormatter, or LogglyFormatter, the LastError and ReadLogEntries tools handle them seamlessly alongside standard PSR-3 logs.

Running php artisan boost:update --discover now detects new guideline packages and skills that have been published since your last update, prompting you to select which ones to add.

Amp is now a supported AI agent in Boost. Running boost:install will detect and configure the MCP server for Amp automatically, bringing it to parity with Claude Code, Cursor, Windsurf, and others.

The DatabaseSchema tool now accepts a summary parameter that returns only table names and column types - roughly 83% fewer tokens. AI agents can call summary first for an overview, then drill down with filter on specific tables when they need the full picture.

Stories can now reference other stories, making it easy to compose complex deployment workflows from reusable building blocks:

@story('deploy')
    build
    migrate
@endstory

@story('full-deploy')
    deploy
    clear-caches
    notify-team
@endstory

The Livewire starter kit now ships with Caleb Porzio's Blaze compiler, resulting in up to 97% reduction in compilation overhead.

MCP tools can now return images and audio natively. A new Response::fromStorage() method auto-detects content type from your Laravel filesystem and handles the base64 encoding for you:

// From raw binary data
Response::image($rawBytes, 'image/png');
Response::audio($rawBytes, 'audio/wav');

// From any Laravel disk with automatic MIME detection
Response::fromStorage('photos/avatar.jpg');
Response::fromStorage('recordings/clip.mp3', disk: 's3');

A new TokenCan attribute lets you declare required token scopes directly on controller methods:

class PhotoController
{
    #[TokenCan('read')]
    public function index() { /* ... */ }

    #[TokenCan('write')]
    public function store() { /* ... */ }
}

You can now add custom middleware to Passport's registered routes via config - great for enforcing rules like UUID validation on client_id before it ever hits the database.

{
    "Pint/phpdoc_type_annotations_only": true
}

Before:

/**
 * Register any application services.
 */
public function register(): void

After:

public function register(): void

Type annotations like @var list<string> are preserved. The config directory is excluded by default. Best suited for new projects - enable with care on existing codebases.

+ use Database\Factories\UserFactory;

  class User extends Authenticatable
  {
-     /** @use HasFactory<\Database\Factories\UserFactory> */
+     /** @use HasFactory<UserFactory> */
      use HasFactory, Notifiable;

This applies automatically when you update Pint.

Precognition v2 ships with a built-in fetch-based HTTP client, dropping Axios as a hard dependency and reducing bundle size by up to 50%. The new client handles XSRF tokens, FormData conversion, and AbortController support out of the box. If you still need Axios for interceptors or other features, an adapter is provided:

import { client, axiosAdapter } from "laravel-precognition";

client.useHttpClient(axiosAdapter());

A brand new prompt for browsing, searching, and selecting from tabular data. Navigate with arrow keys, press / to search across all columns, or pass a filter closure for custom logic:

$selected = datatable(
    label: 'Select a team member',
    headers: ['Name', 'Twitter', 'Role'],
    rows: [
        'taylor' => ['Taylor Otwell', '@taylorotwell', 'CEO'],
        'jess'   => ['Jess Archer', '@jessarchercodes', 'Developer'],
    ],
);

Set and update the terminal window title at any point during execution:

title('Deploying to Cloud...');
// ... work happens ...
title('Deployed!');

Stream text to the terminal with automatic word wrapping and a pleasant fade-in effect - perfect for displaying AI responses in real time:

$stream = stream();

foreach ($events as $event) {
    $stream->append($event->delta);
}

$stream->close();

Display output from a running task with a spinner, real-time label updates, and scrollable log lines. Handles ANSI escape sequences and supports partial-line output for streaming.

task('Installing dependencies', function (Logger $log) {
    Process::run(
        'composer install',
        fn ($type, $output) => $log->line($output)
    );
});

A new prompt that suggests matching values as the user types while still allowing free-form text input. Accepts a static list or a closure for dynamic suggestions.

$key = autocomplete(
    label: 'New config key',
    options: collect(Arr::dot(config()->all()))->keys()->all(),
    placeholder: 'e.g. app.name, mail.from, database.default',
    required: true,
);

Select, multiselect, and search prompts now support a secondary info panel. Pass a string or closure to the new info parameter to show context about the currently highlighted item.

Send native desktop notifications straight from your CLI commands. Supports macOS (via osascript) and Linux (via notify-send):

notify('Build complete', 'Deployed to production');

// With macOS-specific options
notify(
    title: 'Build complete',
    body: 'Deployed to production',
    sound: 'Glass',
);

Reverb now supports per-application rate limiting, using Laravel's built-in rate limiter under the hood. Configure limits per app to protect your WebSocket server from abuse.

Scout's query builder now accepts operators in where() clauses, making range queries straightforward without dropping into engine-specific callbacks:

User::search('taylor')
    ->where('created_at', '>', now()->subMonth()->timestamp)
    ->get();

Routes registered with Route::livewire() now link directly to the Livewire component. Clicking a route name navigates to the component file, and hovering shows the full component hover card.

Intermediate translation keys like __('validation.attributes') now produce clickable links and hover info without false diagnostics. Previously only the deepest leaf keys were recognized.

You can now generate temporary upload URLs even when you're using the local driver, making it much easier to build consistent upload flows across local, staging, and production environments.

use Illuminate\Support\Facades\Storage;

$url = Storage::disk('local')->temporaryUploadUrl(
    'uploads/incoming/video.mp4',
    now()->addMinutes(10),
    ['Content-Type' => 'video/mp4']
);

makeMany() gives you a clean, expressive way to generate multiple in-memory model instances without persisting anything. It's ideal for tests, previews, and shaping data before a write.

$users = User::factory()->makeMany(3);

$payload = $users->map->only(['name', 'email']);

You can now lazily compute attribute values only when a record is actually being created. That means fewer unnecessary queries and less wasted work when the model already exists.

$location = Location::firstOrCreate(
    ['address' => $address],
    fn () => ['coordinates' => Geocoder::resolve($address)],
);

afterSending() lets you hook into the lifecycle after a notification is dispatched, which is perfect for audit logging, metrics, or cleanup work without cluttering your notification channels.

class BookingNotification extends Notification
{
    public function __construct(
		public Booking $booking;
	) {
        //
	}

	public function via()
	{
		return ['mail'];
	}

	public function toMail()
	{
		// ...
	}

	public function afterSending($notifiable, $channel, $response)
	{
		$this->booking->update(['notified_at' => now()]);
	}
}

These helpers are particularly useful when you use the validator to validate data outside the request cycle where the error would not get picked up automatically by the HTTP handler.

Validator::make(
    ['file' => $file],
    ['file' => 'required|image|dimensions:min_width=100,min_height=200']
)->whenFails(function () {
    throw new InvalidArgumentException('Provided file is invalid');
});

Removing headers is now straightforward with withoutHeader(), which is handy when you need to strip inherited headers (like caching or debug headers) before returning a response.

return response($content)->withoutHeader('X-Debug');

Console and non-browser contexts no longer receive the decorative ASCII SVG payload, keeping error output cleaner in logs, CI, agent, and API responses. Furthermore...

The exception page ASCII SVG is now generated on the fly with JavaScript, keeping output leaner and better suited to different rendering contexts.

Typed cache getters reduce repetitive casting and make intent obvious when reading cached values, helping you avoid subtle bugs from unexpected types.

$count = Cache::integer('downloads.count', 0);
$enabled = Cache::boolean('features.new_checkout', false);

A clamp() method has been added to the InteractsWithData trait, giving you a tidy way to bound numeric input values, which is great for pagination, limits, sliders, and any user-controlled numbers.

// Instead of:
/** @var int<PHP_INT_MIN, PHP_INT_MAX> $perPage */
$perPage = request()->integer('per_page', 50);

// You can now do:
/** @var int<1, 100> $perPage */
$perPage = request()->clamp('per_page', 1, 100, 50);

The default models used for text, images, audio, transcription, and embeddings may are now configurable in your application's config/ai.php file. This gives you granular control over the exact models you'd like to use if you don't want to rely on the package defaults.

return [
    'models' => [
        'text' => [
            'default' => 'claude-sonnet-4-6',
            'cheapest' => 'claude-haiku-4-5-20251001',
            'smartest' => 'claude-opus-4-6',
        ],
    ],
],

Transcription now supports timeouts, giving you better control in production workloads and preventing long-running requests from tying up workers.

$transcript = Transcription::fromPath('./podcast.mp3')->timeout(240)->generate(Lab::ElevenLabs);

Pull request by @imYashGupta

Mistral AI

Pull request by @jackbayliss

Voyage AI

Pull request by @jackbayliss

DeepSeek

Pull request by @ihxnnxs

Guidelines and skills can now be loaded directly from vendor packages, ensuring that guidelines always match the package version you are using and will never go stale.

Nightwatch MCP support improves the integration story for observability-driven workflows, so you can connect monitoring context to your tools more seamlessly.

The database schema tool now exposes richer column metadata, which improves the quality of schema-aware tooling and reduces incorrect assumptions (types, defaults, nullability).

This is particularly helpful when generating code, validating migrations, or building assistants that reason about your database structure.

JSON responses are now compact by default, trimming payload size and making tool-to-tool communication faster and less noisy in logs.

A new number prompt makes it easy to collect numeric input with validation baked in, perfect for CLI setup flows and interactive tooling. Features automatic clamping of the min/max values and adjusting the value via the up and down arrows.

$retries = number('How many retries?', default: 3, min: 0, max: 10);

The new @laravel/stream-svelte package makes it trivial to consume streaming output from your server in your Svelte app. If you're shipping real-time UI, this helps you move from prototype to production faster.

Pull request by @joetannenbaum

The new Svelte starter kit gets you up and running with Inertia, Svelte, and Laravel conventions quickly, so you can spend time on product code instead of scaffolding.

Integrating with VS Code's built-in test runner makes it easier to run and iterate on your suite from within your IDE, shortening the edit-test loop and helping you stay in flow.

New support for hovering over Livewire 3 and 4 props means that you can see the relevant type and docblock information directly from the PHP class, reducing context switching in your Livewire and Blade components.

When you need to reuse a partial without accidentally leaking variables in (or out), @includeIsolated gives you a clean, predictable boundary - great for shared UI components and emails where "mystery data" can be costly to debug.

{{-- Only receives what you pass explicitly --}}
@includeIsolated("partials.alert", ["type" => "success", "message" => $message])

This adds a tidy, expressive wrapper around cache locks, so you can prevent overlapping work with less boilerplate. Perfect for cron jobs, report generation, and any "only one at a time" tasks.

Cache::withoutOverlapping('reports:daily')
    ->block(10, function () {
        // This work will not run concurrently.
        GenerateDailyReport::run();
    });

This work moves Laravel's "vector" capabilities forward, helping set the stage for richer integrations and smoother workflows when dealing with embeddings and similarity search. If you're exploring AI-powered features, this one's for you.

A new containsManyItems method was added to complement the existing containsOneItem, enabling you to do a quick check to see if a collection contains two or more items.

match (true) {
    $collection->isEmpty() => '...',
    $collection->containsOneItem() => '...',
    $collection->containsManyItems() => '...',
};

This introduces JSON:API resource support, making it easier to ship standards-compliant APIs with consistent structure across teams and services. If you're standardizing responses (or integrating with clients that expect JSON:API), this helps reduce custom formatting and makes your API surface more predictable.

You can now use backed enums as session keys, which keeps key names centralized and typo-proof, especially helpful in larger apps where session keys tend to spread over time.

enum CheckoutSession: string
{
    case Cart = 'checkout.cart';
    case ShippingAddress = 'checkout.shipping_address';
    case PaymentMethod = 'checkout.payment_method';
}

session()->put(CheckoutSession::Cart, $items);
session()->get(CheckoutSession::Cart);

Same productivity boost, now for cache: backed enums can be used as cache keys, helping you standardize key naming and avoid subtle collisions. Great fit for teams that want a single source of truth for cache identifiers.

enum CacheKey: string
{
    case Settings = 'settings.global';
}

Cache::put(CacheKey::Settings, $settings, now()->addHour());

$settings = Cache::get(CacheKey::Settings);

A practical quality-of-life improvement: --readable makes encrypted env output easier to audit by keeping key names visible, which helps during reviews and incident response while still protecting secret values. If you're hardening deployments, this pairs nicely with Laravel's environment encryption workflow.

php artisan env:encrypt --readable

Replacing the deprecated router.cancel(), you can now get the same functionality with router.cancelAll({ async: false }). Giving you more control over request cancellation means smoother UX under heavy navigation or rapid input.

The new useFormContext hook allows child components to know about parent component forms without having to do a bunch of unnecessary prop drilling.

<!-- Parent.vue -->
<template>
    <Form action="/users" method="post">
        <Input name="name" />
    </Form>
</template>

<!-- Input.vue -->
<script setup>
import { useFormContext } from "@inertiajs/vue3";

defineProps({
    name: {
        type: String,
        required: true,
    },
});

const form = useFormContext();
</script>

<template>
    <input type="text" :name="name" />

    <div v-if="form.errors[name]">
        {{ form.errors[name] }}
    </div>
</template>

This gives you a straightforward way to opt out of Inertia's form remembering behavior when it's not desired. This is handy for sensitive forms or one-time flows where you don't want old values sticking around (e.g., password resets, invite flows).

We made a slew of updates to all of our Starter Kits this month! Amongst the various tune-ups:

Safer defaults in the AppServiceProvider reduce the "oops" factor on new projects, helping you start with a more secure, production-friendly baseline while keeping the kit lightweight and easy to customize.

- Enforcing immutable dates with CarbonImmutable
- Not allowing destructive commands in production
- Requiring safer passwords by default in production

The Livewire starter kits are now ready for Livewire 4, so you can begin new builds on the latest Livewire foundation without spending time on upgrade plumbing. If you're planning a fresh app, this keeps your starting line modern.

Out-of-the-box linting makes teams faster: consistent formatting, fewer style nits in code review, and easier onboarding. The included Pint config plus utility scripts make "format everything" a one-command habit.

This update transitions many package guidelines into agent skills, enabling significantly better context management. By loading package-specific knowledge only when it is relevant, agents produce more accurate, higher-quality Laravel code with far less context noise. This is a must-have upgrade for getting the best results from AI agents when building Laravel applications.

As a result, existing guidelines are now roughly ~ 40 percent leaner, making agent responses more focused and much higher quality.

A dedicated "code simplifier" prompt helps you quickly turn verbose or repetitive Laravel code into clean, idiomatic patterns, great for polishing PRs and accelerating refactors when you're moving fast.

Upgrading is easier when you have a focused guide. This prompt helps you identify the key changes for Livewire 4 and work through them systematically, reducing upgrade risk and cutting down on "why did this break?" time.

This improves hook reliability and performance by addressing stale closure issues, meaning fewer head-scratching realtime UI bugs and smoother rendering under heavy event traffic. If you're building reactive dashboards or chat experiences, this makes your client-side behavior more dependable.

A connection status hook is a big UX unlock: you can clearly reflect "connected / reconnecting / offline" states and handle them gracefully in your UI. Great for realtime-heavy apps where user trust depends on knowing whether updates are truly live.

Event overloading expands how you can map and handle events, making advanced realtime patterns easier to express without workaround code. Useful when you're consolidating many event types into a cleaner, more maintainable client-side layer.

Introducing a new horizon:listen command that watches for file changes and automatically restarts Horizon during development. This new command mirrors Laravel's built-in queue:listen command behavior.

A new --format agent flag was added that gets automatically used when Pint is executed within OpenCode or Claude Code.

The default Pint output is designed for humans: colorful, with progress dots and formatted summaries. AI agents need something different: structured JSON they can reliably parse, unambiguous status values like "status":"pass" instead of inferring from formatted text, minimal output that saves context window and reduces token cost, and deterministic results without ANSI colors or formatting noise.

The new grid component in Prompts allows developers to easily create responsive grid-based layouts and present data clearly.

Pulse is ready for Livewire 4, keeping your application observability UI compatible as you move forward. That means fewer blockers when modernizing your stack.

First-class Livewire 4 support in the extension helps you stay in flow with better editor understanding as you build components: less context switching, more shipping.

Improved Docker support makes Laravel development inside containers feel more natural in VS Code, helping teams standardize environments and reduce "works on my machine" friction.

Hover links turn query scopes into a navigable experience, jumping from usage to implementation faster, which is especially valuable in large codebases with lots of shared scopes.

Better attribute support helps the editor understand modern Laravel patterns, improving navigation and reducing false positives. If your project leans on PHP attributes, this makes day-to-day editing noticeably smoother.

Generate files where you're already working: integrating artisan make:* into the explorer and context menu cuts down on terminal hopping and keeps scaffolding close to your project structure.

Smarter autocomplete for FormRequest validation rules means fewer typos and faster validation authoring, which is particularly helpful when you're juggling complex rule sets.

Docblocks and repository hints that include scope parameters improve autocomplete accuracy and make "discoverability" better for teammates, so using existing scopes becomes as easy as reading the method signature.

A new afterResponse method was added to the HTTP Client, which allows the user to inspect and mutate the response returned from an HTTP call:

Http::acceptJson()
    ->withHeader('X-Shopify-Access-Token', $credentials->token)
    ->baseUrl("https://{$credentials->shop_domain}.myshopify.com/admin/api/2025-10/")
    ->afterResponse(
        // Report any deprecation notices that were in the header
        function (Response $response) use ($credentials) {
            if ($header = $response->header('X-Shopify-API-Deprecated-Reason')) {
                event(new ShopifyDeprecationNotice($credentials->shop, $header));
            }
        })
    ->afterResponse(
        // Map the response into our own custom response class
        fn (Response $response) => new ShopifyResponse($response->toPsrResponse()),
    )
    ->afterResponse(
        // Report the cost of the query
        static fn (ShopifyResponse $response) => QueryCostResponse::report(
            $response->getQueryCost(),
            $credentials->shop
        ),
    );

Userland chaining in Http::pool is now possible with the introduction of FluentPromise. Previously, the chain would return the original response, limiting flexibility. With this change, users can access the underlying array and return whatever they wish:

$response = Http::pool(function (Pool $pool) {
    $pool->as('cosmatech')
        ->get('https://cosmastech.com')
        ->then(
            fn ($response) => strlen($response->body())
        );
    $pool->as('laravel')
        ->get('https://laravel.com')
        ->then(
            fn ($response) => strlen($response->body())
        );
});

/*
array:2 [
  "cosmatech" => 9095
  "laravel" => 1422023
]
*/

Two new helpers, lazy and proxy, were added to make PHP's new lazy objects more ergonomic to use.

<?php

use Illuminate\Support\Facades\Http;
use Vendor\Facades\ResultFactory;
use Vendor\Result;
use function Illuminate\Support\lazy;
use function Illuminate\Support\proxy;

$response = Http::get(...);

$instance = lazy(Result::class, fn () => [$response->json()]);
$instance = proxy(Result::class, fn (): Result => ResultFactory::make($response->json()));

A new php artisan reload command was introduced, allowing service providers to add their own commands for reloading. This makes it easier for services to specify one command to include in their deployment steps after the deployment is completed.

The applicable reload commands have already been added to Laravel Horizon, Pulse, Reverb, and Octane.

public function boot()
{
    $this->reloads('reverb:restart');
}

The default Laravel email template was cleaned up and modernized, giving it a fresh coat of paint and an elevated, professional appearance.

The next version of Wayfinder entered public beta.

This version generates far more TypeScript from your Laravel app than the previous version, including routes and controller actions, named routes, form requests, Eloquent models, PHP enums, Inertia.js page props, Inertia shared data, broadcast channels, broadcast events, environment variables, and more.

Two new packages used by Wayfinder were also introduced into public beta:

use Laravel\Surveyor\Analyzer\Analyzer;

$analyzer = app(Analyzer::class);

// Analyze a file by path
$result = $analyzer->analyze('/path/to/your/File.php');

// Access the analyzed scope
$scope = $result->analyzed();

// Access the class result
$classResult = $result->result();

It uses Surveyor under the hood and extracts the results into detailed data transport objects for straightforward consumption.

use Laravel\Ranger\Ranger;
use Laravel\Ranger\Components;
use Illuminate\Support\Collection;

$ranger = app(Ranger::class);

// Register callbacks for individual items
$ranger->onRoute(function (Components\Route $route) {
    echo $route->uri();
});

$ranger->onModel(function (Components\Model $model) {
    foreach ($model->getAttributes() as $name => $type) {
        //
    }
});

$ranger->onEnum(function (Components\Enum $enum) {
    //
});

$ranger->onBroadcastEvent(function (Components\BroadcastEvent $event) {
    //
});

// Or register callbacks for entire collections
$ranger->onRoutes(function (Collection $routes) {
    // Called once all of the routes have been discovered and processed
});

$ranger->onModels(function (Collection $models) {
    // Called once all of the models have been discovered and processed
});

// Walk through the application and trigger all callbacks
$ranger->walk();

Unlike regular props, Flash Data isn't persisted in the browser's history state, making it ideal for one-time notifications like toasts. On the frontend, Flash Data is available on page.flash. You can also listen for Flash Data using the global flash event or the onFlash callback.

<template>
    <div v-if="page.flash.toast" class="toast">
        {{ page.flash.toast.message }}
    </div>
</template>

router.on("flash", (event) => {
    if (event.detail.flash.toast) {
        showToast(event.detail.flash.toast);
    }
});

router.post("/users", data, {
    onFlash: ({ newUserId }) => {
        // ...
    },
});

Laravel Precognition is now baked directly into the useForm hook and the Form component; there is no need to install additional libraries. Live validation has never been easier.

<template>
    <Form action="/users" method="post" #default="{ errors, invalid, validate, validating }">
        <div>
            <input name="name" @change="validate('name')" />
            <p v-if="invalid('name')">{{ errors.name }}</p>
        </div>

        <div>
            <input name="email" @change="validate('email')" />
            <p v-if="invalid('email')">{{ errors.email }}</p>
        </div>

        <p v-if="validating">Validating...</p>
    </Form>
</template>

Opt-in support was added for loading the initial Inertia page data from a <script type="application/json"> element instead of the body tag. This results in a greatly reduced initial page data size, faster parsing, and makes the initial page data a breeze to inspect with your browser's dev tools.

You can opt in to this behavior as follows:

createInertiaApp({
    // ...
    defaults: {
        future: {
            useScriptElementForInitialPage: true,
        },
    },
});

Some data rarely changes, is expensive to compute, or is simply large. Rather than including this data in every response, once props are remembered by the client and reused on subsequent pages that include the same prop.

return Inertia::render('Billing', [
    'plans' => Inertia::once(fn () => Plan::all()),
]);

Previously, all third-party package guidelines needed to be added to the global context, which could grow unbounded as more packages were integrated.

Boost is now reducing global context bloat by adding guidelines for only actively used packages that are loaded, thereby improving token efficiency and leaving room for more application-specific information.

Event payloads are now automatically inferred from the broadcast event if the user provides a module override file, resulting in a cleaner useEcho experience and less type management for the user.

import { App } from "./types";

declare module "@laravel/echo-react" {
    interface Events {
        ".App.Events.UserCreated": {
            user: App.Models.User;
        };
        ".App.Events.OrderShipped": {
            order: App.Models.Order;
            user: App.Models.User;
        };
    }
}

Support was added for the MCP completion utility, allowing servers to provide IDE-like autocompletion suggestions for prompt arguments and resource template variables.

Three annotation types are now available for use with Resource classes: audience, priority, and lastModified. This adheres to the MCP specs and allows the server to provide hints to clients about how to use or display the resource.

Support for output schemas and structured content was added to the MCP package, enabling better integration with ChatGPT Apps and AI clients that need parseable tool results.

Model scope parameters now appear in model helper docblocks, making it clear to the user which parameters are required by the query scopes they are using.

A new "Generate Namespace" command was added to the extension, allowing the user to quickly generate the correct namespace for a class.

Previously, there wasn't a way to schedule tasks on multiple arbitrary days of the month (e.g., 1st, 10th). A daysOfMonth() method was added that allows scheduling tasks to run on multiple specific days of the month with a clean, intuitive API.

$schedule->command('process-payroll')
    ->daysOfMonth(1, 15) // 1st and 15th of each month
    ->timezone('America/New_York');

A new encoding validation rule was added that checks the contents of a file or string matches a specific encoding using mb_check_encoding(), ensuring that uploaded files are encoded as expected before processing.

Validator::validate($input, [
    'attachment' => [
        'required',
        File::types(['csv'])->encoding('utf-8'),
    ],
]);

New interval helper functions were added for fluently getting the current time with adjustments:

use Illuminate\Support\{ now, minutes }

Cache::put('name', 'Taylor', minutes(5));

Invitation::create([
    'expires_at' => now()->plus(hours: 6),
]);

Sometimes you may need to temporarily prevent a queue worker from processing new jobs without stopping the worker entirely. Now you can with newly added artisan commands:

php artisan queue:pause database:default
php artisan queue:continue database:default

The new @hasStack directive can be used to wrap @stack directives for conditional output depending on if the stack is empty or not. This is useful if you want some markup to wrap the stack only if it is not empty.

@hasStack("list")
<ul>
    @stack("list")
</ul>
@endif

A --middleware option was added to the route:list command to filter output by middleware. This can be a single middleware class name or a middleware group name, allowing you to easily see routes with the specified middleware applied.

php artisan route:list --middleware=api
php artisan route:list --middleware=ThrottleRequests

A new testing trait called WithCachedRoutes was introduced. This testing trait stores the routes as a static property within a Testing\CachedState object during test setup, ensuring subsequent tests do not need to read from disk.

The insert() method was added to Eloquent Factories, allowing you to perform a mass insert of models. This increases performance during testing with numerous of database records.

A ucwords method was added to Stringable, allowing fluent uppercasing of the first letter of a string. Note that this differs from title in that the rest of the string remains untouched.

// Taylor Otwell, Creator Of Laravel
$name = $this->string('taylor otwell, creator of laravel')->ucwords();

A number of packages were updated to ensure they maintained compatibility with the newly released PHP 8.5, including:

• Laravel Framework
• Dusk
• Folio
• Fortify
• Helpers
• Horizon
• Installer
• Jetstream
• Pail
• Pennant
• Pulse
• Reverb
• Sanctum
• Scout
• Socialite
• Telescope
• Tinker

The Inertia website and docs got a major glow up!

Inertia finally has the website it deserves, showing off all of its power and flexibility as the best way to create a SPA with the backend and frontend of your choice.

Furthermore, the docs are now hosted on Mintlify and received a complete refresh that supercharges them with cleaner formatting, an AI chat, and a more comprehensive search. Both users and LLMs should be very satisfied with this update.

Google's Gemini has been added to Boost. This addition marks the completion of our support for all major code environments, further empowering developers with enhanced Laravel capabilities.

User guidelines now take precedence over the Boost presets while maintaining the overrides strategy, giving developers more control over how instructions are interpreted by agents.

Sail now has first-class support across all guidelines. When a project installs Boost with Sail enabled, agent instructions now automatically switch to Sail-specific commands rather than native CLI commands.

With the new third-party guidelines feature, these guidelines can now live within the Filament package and automatically stay full up to date with any new Filament features introduced.

Developers now have seamless integration of OpenCode in their workflows, with the ability to take advantage of its power just like any other agent.

The MCP package now fully supports the _meta field as documented in the MCP specification. Users can now attach metadata at three different levels: on tools/resources/prompts (in listings), on the result envelope (for execution metadata), and on individual content items.

public function handle(Request $request): Response
{
    return Response::text('The content generated by the tool.')
        ->withMeta('x', 'y');
}

Previously, Http::batch results were sorted in the order that the responses came back, rather than the order that the requests were defined:

dump(Http::batch(fn (Batch $batch) => [
    $batch->get('https://httpbin.org/delay/3'),
    $batch->get('https://httpbin.org/delay/2'),
    $batch->get('https://httpbin.org/delay/1'),
])->send());

array:3 [
  2 => Illuminate\Http\Client\Response {#419}
  1 => Illuminate\Http\Client\Response {#374}
  0 => Illuminate\Http\Client\Response {#328}
]

The results are now sorted before they are returned, respecting any requests named with the as method. Learn more about request batching.

Several PRs introduced new config values for app.editor, allowing dumps to link correctly for several new IDEs: neovim, zed, kiro, fleet, and windsurf.

The recently introduced new exception page now includes a new file reference and line number that opens the file directly in your IDE of choice.

Instead of using the onGroup() method at the time of dispatch, you can now define a messageGroup() directly method on the job class, removing an inconsistency where event listeners supported the messageGroup() method on the class, but all the other job types required calling onGroup().

Using deferred synchronous dispatching, you can dispatch a job to be processed during the current process, but after the HTTP response has been sent to the user. This allows you to process "queued" jobs synchronously without slowing down your user's application experience. To defer the execution of a synchronous job, dispatch the job to the deferred connection:

RecordDelivery::dispatch($order)->onConnection('deferred');

The failover cache driver provides automatic failover functionality when interacting with the cache. If the primary cache store fails for any reason, Laravel will automatically attempt to use the next configured store in the list. This is particularly useful for ensuring high availability in production environments where cache reliability is critical.

'failover' => [
    'driver' => 'failover',
    'stores' => [
        'database',
        'array',
    ],
],

PostgreSQL 18 was recently released, along with it support for virtual generated columns. The virtualAs column modifier now has backwards compatible support this new PostgreSQL feature.

The failover queue driver provides automatic failover functionality when pushing jobs to the queue. If the primary queue connection fails for any reason, Laravel will automatically attempt to push the job to the next configured connection in the list. This is particularly useful for ensuring high availability in production environments where queue reliability is critical.

'failover' => [
    'driver' => 'failover',
    'connections' => [
        'redis',
        'database',
        'sync',
    ],
],

When the new defer method is invoked on Http::batch, the batch of requests is not executed immediately. Instead, Laravel will execute the batch after the current application request's HTTP response has been sent to the user, keeping your application feeling fast and responsive:

use Illuminate\Http\Client\Batch;
use Illuminate\Support\Facades\Http;

$responses = Http::batch(fn (Batch $batch) => [
    $batch->get('http://localhost/first'),
    $batch->get('http://localhost/second'),
    $batch->get('http://localhost/third'),
])->then(function (Batch $batch, array $results) {
    // All requests completed successfully...
})->defer();

Inertia now supports setting app-wide defaults, with the ability to update values at runtime. You can pass a default config object to the createInertiaApp() method:

createInertiaApp({
    // resolve, setup, etc.
    defaults: {
        form: {
            recentlySuccessfulDuration: 5_000,
        },
        prefetch: {
            cacheFor: 60_000,
        },
        visitOptions: (href: string, options: VisitOptions) => {
            return { headers: { ...options.headers, "X-Foo": "Bar" } };
        },
    },
});

Each adapter now also exports a config instance to update any values at runtime:

import { config } from "@inertiajs/vue3";

config.set("form.recentlySuccessfulDuration", 1000);

usePage() now supports a global type definition file, allowing you to type-hint shared page props:

// resources/js/types/globals.d.ts

declare module "@inertiajs/core" {
    export interface InertiaConfig {
        sharedPageProps: {
            auth: { user: { id: number; name: string } | null };
            flash: { success?: string; error?: string };
        };
    }
}

Shared page props are now automatically type-hinted throughout the app when you use usePage():

const page = usePage();
const successMessage = page.props.flash.success;

Boost now detects which NPM package manager should be used to run any given script (npm, pnpm, yarn and bun). This assists the AI in using the correct CLI tools when running npm commands based on the project's existing dependencies.

You can now create custom code environments (IDEs and AI agents) for Boost. Previously, Boost only supported a hardcoded list of environments, which made it difficult to add support for new IDEs or agents directly within the official Boost repository.

use Laravel\Boost\Contracts\Agent;
use Laravel\Boost\Contracts\McpClient;
use Laravel\Boost\Install\CodeEnvironment\CodeEnvironment;

class MyCustomIDE extends CodeEnvironment implements Agent, McpClient
{
    // Implementation
}

Registering your custom code environment:

use Laravel\Boost\Boost;

Boost::registerCodeEnvironment('myide', MyCustomIDE::class);

AI guidelines were added which can be used by Laravel Boost's Third-Party Package AI Guidelines. This is completely opt-in for each user, they can choose if they want additional intelligence around Fortify's usage with their Laravel application.

When you have several Horizon instances running in different regions, all within a single application, it can be difficult to determine with instance of Horizon a notification is originating from. You can now specify a name for each instance, making identification straightforward.

Before:

Long Wait Detected
[Nightwatch] The "{queue}" queue on the "{connection}" connection has a wait time of {seconds} seconds.

After:

Long Wait Detected
[eu-central-1] The "{queue}" queue on the "{connection}" connection has a wait time of {seconds} seconds.

When running laravel new, there are now additional flags you can pass to specify which Node package manager you'd like to use: --npm, --pnpm, --bun, or --yarn. Passing one of these flags will also update any composer script that references a Node command to reflect the correct command specific to the selected package manager.

All starter kits now use Fortify for login, registration, password reset, and email verification. Fortify is a battle-tested solution, removing code from your codebase that is rarely changed, keeping your application code streamlined and maintainable.

Several improvements to full-text support were added when using the database engine. First up, you can now pass multiple columns to orWhereFullText in a single call. Secondly, when using Postgres and no other developer-provided ordering has been defined, Scout automatically adds relevance-based ordering by default to match MySQL's built-in ordering behavior.

use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Symfony\Component\HttpFoundation\Response;

/*
 * Ensure a user can only hit ten 404 responses in a minute before they are
 * rate limited to ensure user's cannot enumerate resource IDs.
 */
RateLimiter::for('resource-not-found', function (Request $request) {
    return Limit::perMinute(10)
        ->by("user:{$request->user()->id}")

        // The new `after` hook...
        ->after(function (Response $response) {
            return $response->getStatusCode() === 404;
        });
});

The new RateLimiter::after hook lets you apply rate limiting based on the response as well as the request.

$responses = Http::batch(fn (Batch $batch) => [
    $batch->get('http://localhost/first'),
    $batch->get('http://localhost/second'),
    $batch->get('http://localhost/third'),
])->before(function (Batch $batch) {
    // This runs before the first HTTP request is executed.
})->progress(function (Batch $batch, int|string $key, Response $response) {
    // This runs after each successful HTTP request from the Batch.
})->catch(function (Batch $batch, int|string $key, Response|RequestException $response) {
    // This runs after each failed HTTP request from the Batch.
})->then(function (Batch $batch, array $results) {
    // This runs ONLY IF all the HTTP requests from the Batch are successful and the batch is not cancelled.
})->finally(function (Batch $batch, array $results) {
    // This runs after all the HTTP requests from the Batch finish and the batch is not cancelled.
})->send();

The new Http::batch method allows you to hook into the lifecycle of each HTTP call when making multiple requests in parallel.

use Closure;
use Illuminate\Support\Benchmark;
use Illuminate\Support\Facades\Log;

Benchmark::macro('log', fn (Closure $callback) =>
    Log::debug(Benchmark::measure($callback))
);

Benchmark::log(fn () => sleep(1));

Benchmark is now updated with the Macroable trait to allow arbitrary macro registration.

You can now pass a --whisper option to the schedule:work command. The option is passed through to the schedule:run command, which hides the "No scheduled commands are ready to run" message from the output, producing cleaner logs and terminal output and reducing noise for monitoring tools.

$discount = $request->session()->cache()->get('discount');

$request->session()->cache()->put(
    'discount', 10, now()->addMinutes(5)
);

The new session cache provides a convenient way to cache data that is scoped to an individual user session. Unlike the global application cache, session cache data is automatically isolated per session and is cleaned up when the session expires or is destroyed.

use App\Http\Resources\MyCustomNameResource;
use App\Http\Resources\MyCustomNameCollectionResource;

#[UseResource(MyCustomNameResource::class)]
#[UseResourceCollection(MyCustomNameCollectionResource::class)]
class MyModel extends Model {
    //
}

// Now you can call:
$model->toResource();
$collection->toResourceCollection();

You can now define resources classes directly on your Eloquent models using PHP attributes.

[
    {
        "expression": "0 0 15 * *",
        "repeat_seconds": null,
        "command": "php artisan backup:run",
        "description": "Run daily backup process",
        "next_due_date": "2025-09-15 00:00:00 +00:00",
        "next_due_date_human": "5 days from now",
        "timezone": "UTC",
        "has_mutex": false
    }
]

The schedule:list command now accepts a --json flag to allow programmatic consumption of scheduled task data for monitoring and integration purposes.

{{-- Instead of: --}}
We had {{ number_format($attendees->count()) . ' ' . Str::plural('attendee', $attendees->count()) }} at Laracon 2025.

{{-- Now we can: --}}
We had {{ Str::plural('attendee', $attendees->count(), prependCount: true) }} at Laracon 2025.

The Str::plural helper now accepts a new argument, prependCount, that will prepend the count to the string automatically.

SQS fair queues are now supported.

The exception page was given a refresh, making local errors clearer and more actionable.

This month, we switched all of our NPM packages over to Trusted Publishing. Now you'll know where the latest release originated and you can verify that it came from us.

<template>
    <InfiniteScroll data="users">
        <div v-for="user in users.data" :key="user.id">{{ user.name }}</div>
    </InfiniteScroll>
</template>

A new <InfiniteScroll> component was introduced for React, Vue, and Svelte that allows you to easily create infinite scroll interfaces by wrapping your items in the new component.

A new middle ground was added between Inertia::merge() and Inertia::deepMerge() so you can have fine-grained control over what should be merged.

The front-end will replace the entire object, except the data array. The new items will be appended to the existing items:

Inertia::merge(User::paginate())->append('data');

There's also prepend(), and you can also combine multiple calls:

Inertia::merge($complexObject)
    ->append('users', matchOn: 'username')
    ->prepend('messages.data');

Then there's a new Inertia::scroll() function which you can pass paginated resources:

Inertia::scroll(User::paginate());

import { progress } from "@inertiajs/vue3";

progress.start(); // Begin progress animation
progress.set(0.25); // Set to 25% complete
progress.finish(); // Complete and fade out
progress.reset(); // Reset to start
progress.remove(); // Complete and remove from DOM
progress.hide(); // Hide progress bar
progress.reveal(); // Show progress bar

progress.isStarted(); // Returns boolean
progress.getStatus(); // Returns current percentage or null

The internal methods used to drive the Progress indicator are now exposed publicly, giving developers control over the progress bar.

Boost can now self-update with the new boost:update command. In addition, third-party packages can now auto-register their own guidelines by including a resources/boost/guidelines/core.blade.php file in their package.

Users can now override guideline files, specifying that Boost should use their guidelines in specific instances instead of the default guidelines that come with Boost.

const callback = (notification) => {
    console.log(notification.type);
};

// Start listening...
Echo.private(`App.Models.User.${userId}`).notification(callback);

// Stop listening (callback must be the same)...
Echo.private(`App.Models.User.${userId}`).stopListeningForNotification(
    callback
);

A new stopListeningForNotification method was added to stop listening for notifications without leaving the channel.

The session and session and CSRF token are now regenerated on user registration.

The installer now checks if there are updates available on Packagist to ensure you are using the latest version when running laravel new.

The installer now detects lock files for the PNPM and Yarn package managers, falling back to NPM if neither are found.

laravel new --using https://gitub.com/user/project

You can specify a git repo as a custom starter kit when running laravel new.

Laravel MCP allows you to rapidly build MCP servers for your Laravel applications. MCP servers allow AI clients to interact with your Laravel application through the Model Context Protocol.

The display of the progress bar when using a large number of steps is improved by adding thousands separators and extra spacing.

You can specify connection limits for those users who wish to limit the number of active connections to a given application as supported by the Pusher protocol.

Commands are now available that refactor the selected or all class attributes to the @class directive.

Commands are now available that wrap the selected text with a helper, such as dd, collect, dump, and str.

Commands are now available to "Run Pint", "Run Pint on Dirty Files", and "Run Pint on Current File". There is also now an optiont to run Pint on save for the current file.

$collection
    ->withHeartbeat(CarbonInterval::minutes(5), function () {
        // ...
    })
    ->each(function ($item) {
        // ...
    });

The new withHeartbeart method allows you to run a callback at regular time intervals while the collection is being lazily enumerated, particularly useful for long-running processes.

$collection = collect([1,2,3]);

// Instead of this:
$collection->toJson(JSON_PRETTY_PRINT);

// You can now do this:
$collection->toPrettyJson();

Http::allowStrayRequests([
    'http://127.0.0.1:13714/*',
]);

The Http::allowStrayRequests method now accepts an argument that allows you to specify URLs that tests are allowed to send requests to when using Http::preventStrayRequests.

There is now a "Copy as Markdown" button on the Laravel exception page. When clicking this button, a markdown representation of the exception is copied to the users clipboard, which can then be used for AI agents/LLMs.

protected function initializeTwoFactorAuthentication(): void
{
    $this->mergeHidden([
        'app_authentication_secret',
        'app_authentication_recovery_codes',
    ]);

    $this->mergeCasts([
        'app_authentication_secret' => 'encrypted',
        'app_authentication_recovery_codes' => 'encrypted:array',
    ]);
}

Additional attribute helper methods added to Eloquent models for merging visibility-related arrays, bringing them in line with existing helpers like mergeCasts, mergeFillable, and mergeGuarded.

if ($this->hasChanges($data)) {
    Arr::push($result, 'pending.changes', $data);
}

A new Arr method that allows you to push something to an array if the array exists, or initialize it to an empty array and then push to it if it doesn't.

<script setup>
import { Form } from "@inertiajs/vue3";
</script>

<template>
    <Form action="/users" method="post">
        <input type="text" name="name" />
        <input type="email" name="email" />
        <button type="submit">Create User</button>
    </Form>
</template>

A new <Form> component that behaves much like a classic HTML form and simply allows Inertia to intercept the network call on form submission. This new component greatly reduces the boilerplate needed to create a form with Inertia.

import UserController from "@/actions/App/Http/Controllers/UserController";

// Regular visits
router.visit(UserController.store());

// Prefetching
router.prefetch(UserController.index());
router.getPrefetching(UserController.index());
router.getCached(UserController.index());
router.flush(UserController.index());

Adds support for passing Wayfinder-like objects into router methods instead of specifying the URL and method manually.

// Specify cache tags via the Link component
<Link href="/users/1" prefetch="hover" :tags="['user', 'profile']">
    View Profile
</Link>

// Or via prefetch method on the route
router.prefetch(
  '/users',
  { method: 'get', data: { page: 2 } },
  { cacheFor: '1m', tags: ['users'] }
)

// Flushes all cache entries tagged with 'user'
router.flushByTags(['user'])

// Flushes entries tagged with 'user' OR 'product'
router.flushByTags(['user', 'product'])

// Flush via visit
router.visit('/users', {
  invalidate: ['user']
})

// Flush via useForm helper
form.post('/users', { invalidate: ['users'] })

Introduces tag-based cache invalidation for prefetch requests. This enables better control over the prefetch cache without having to flush everything.

<Link as={CustomButton} method="post" href="/user" data={{ test: "data" }}>
    Custom Component with Data
</Link>

The Inertia Link component now supports custom components instead of just HTML tags such as a or button.

Laravel Boost was released this month! Not only was it just released, it is already aware and up-to-date with the just-released Pest 4 and Filament 4.

Adds a config('boost.enabled') option to allows users to specifically enable/disable Boost in certain scenarios outside of environment constraints.

Updates Boost guidelines to prefer the usage of Pint with the --dirty flag for cleaner diffs and PRs.

import { Form } from "@inertiajs/react";

export default function Login() {
    return (
        <Form action="/login" method="post">
            {/* Form fields */}
        </Form>
    );
}

Reduces the boilerplate for all forms in the starter kits by replacing useForm with the new Inertia Form component.

import AuthenticatedSessionController from "@/actions/App/Http/Controllers/Auth/AuthenticatedSessionController";
import { Form } from "@inertiajs/react";

export default function Login() {
    return (
        <Form {...AuthenticatedSessionController.store.form()}>
            {/* Form fields */}
        </Form>
    );
}

Removes Ziggy from the starter kits and replaces it with the current version of Laravel Wayfinder, bringing end-to-end type safety to your routes.

Adds the missing feature tests so that fresh projects start with 100% test coverage.

Docker configuration updates to allow you to run Pest 4 browser tests in Sail.

Adds proper support for DDEV, Docker-based PHP environments.

The extension now recognizes custom registered view extensions such as .blade.sh or .blade.ts and will now autocomplete and link correctly to these files.

The extension now supports configs in nested subfolders (e.g. config/foo/bar/baz.php), providing better autocomplete and linking.

Now, when the extension warns you about an invalid value, such as a config key, the warning will directly link you to the file where you can fix the issue.

Full autocomplete and linking support for the Route::is and routeIs methods.

import type { RouteDefinition } from "@/wayfinder";

const sendRequest = (route: RouteDefinition<"post">) => {
    //
};

sendRequest(StorePostController());

Utility types are now exported, making them easier to consume if your app requires them.

  setup({ el, App, props }) {
    const root = createRoot(el);

    setUrlDefaults({
      workspace: props.initialPage.props.workspace.slug
    });

    root.render(<App {...props} />);
  },

In instances where Wayfinder is unable to determine the proper default URL params as defined by the server, you can now specify them on the client side using setUrlDefaults.

php artisan queue:work --verbose
// App\Jobs\UrgentAction 85 high
// App\Jobs\NormalAction 84 default

With --verbose, you’ll now see queue names alongside each job and job ID, making multi-queue debugging straightforward and saving you time when tracing issues.

echo json_encode(new Uri('/path?x=1'));
// "http://localhost:8000/path?x=1"

This release fixes a serialization bug, properly converting the URI to a string when serializing a larger JSON object that contains the URI as a value.

str('apple')->doesntStartWith('b'); // true
str('apple')->doesntEndWith('e'); // false

The inverse of startsWith/endsWith, these new methods allow you to fluently test for starting and ending characters in your string.

$users->pluck(fn($u) => $u->email, fn($u) => strtoupper($u->name));

You can now dynamically generate keys and values via callbacks. Instead of mapping then plucking, you get a single, flexible method that reduces steps and keeps intent clear.

./vendor/bin/pint --parallel

By leveraging PHP CS Fixer’s parallel runner, Pint now formats files concurrently. On large codebases that once took minutes, you’ll see results in seconds, speeding up both local workflows and CI pipelines for a clear quality of life win.

Telescope’s frontend now uses Vite instead of Mix. Asset builds finish faster, hot-reloads are more reliable, and you benefit from a modern toolchain without changing your workflow.

Octane now relies on FrankenPHP’s native file watcher for reloading the server on file changes. This removes the NodeJS dependency and eases the local development process significantly.

const form = useForm({ name: "", email: "" });

// Instead of:
form.reset();
form.clearErrors();

// You can now:
form.resetAndClearErrors();

You can now concisely reset all fields and errors in one go, bringing your form back to square one.

Inertia no longer distributes minified builds, aligning it with the strategy of other popular libraries. This makes debugging more straightforward and allows for local patching if the need arises.

You can now chain encrypt() and decrypt() directly on a Str instance, so instead of piping your string through separate encryption calls, you can write:

$value = Str::of('secret')->encrypt()->prepend('Encrypted: ');
$original = Str::of($value)->decrypt();

This keeps your string-manipulation chains concise (no need to write separate, extra code to handle encryption) and you don’t have to manually wrap a value in encryption calls each time.

Learn more about encrypt and decrypt

You now have two methods for conditional broadcasting in a single call:

broadcast_if($order->isPaid(), new OrderShipped($order));
broadcast_unless($user->isActive(), new InactiveUserAlert($user));

This replaces multi-line conditionals around broadcast() and makes your event logic more readable, improving the overall developer experience.

Read the docs about event broadcasting in Laravel

The php artisan make:job command now accepts a --batched option:

php artisan make:job ProcessPodcast --batched

This command scaffolds the job with the Batchable trait already applied, so you don’t have to add it manually. It saves you a manual step and ensures consistency.

Learn more about defining batchable jobs

We fixed a memory-leak issue in the extension’s background processes, reducing its long-term footprint and preventing slowdowns during extended coding sessions.

Initialization with the VS Code extension now completes in under one second (down from 5–7 seconds) by deferring heavy setup until it’s actually needed. You’ll notice the extension loads almost instantly so you can start building faster.

Get started with the Laravel VS Code extension

When implementing infinite scrolling with Inertia or other paginated data merges, you can now specify a key (matchOn) to do a deep merge, matching items by ID and replacing or appending as appropriate. This provides greater flexibility, prevents duplicated entries, and keeps your client-side data consistent.

Inertia::render('Users/Index', [
    'users' => Inertia::deepMerge($users)->matchOn('data.id'),
]);

Learn more in the Inertia docs

We fixed a React-specific issue in <StrictMode> where the initial Inertia page would render twice. Now you get a single, clean first render without flicker, improving perceived performance.

Get started with the Laravel + React Starter Kit