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