Key Takeaways
- Laravel 13 launches in Q1 2026 with a mandatory PHP 8.3+ requirement.
- Includes the Reverb database driver for horizontal scaling, granular
maxExceptionsfor queues, andCache::touch(). - Bug fixes run until Q3 2027, with security patches supported through Q1 2028.
- Plan your upgrade now to leverage “free” performance gains from PHP 8.3 and modern dependency security.
Laravel 13 might feel like a “maintenance release” compared to previous overhauls, and that’s exactly why it matters.
While flashy new features grab headlines, this release focuses on something more valuable for production applications: stability, type safety, and a modernized foundation built on PHP 8.3+. For teams running enterprise applications, this is the upgrade that sets you up for long-term success. In this guide, we’ll go beyond the changelog.
You’ll learn why upgrading makes business sense, see real-world code examples for the new features, and walk away with a battle-tested upgrade strategy that won’t give you headaches.
-
- Laravel 13 Support Policy and Release Schedule
- Why Upgrade? The Business Case
- Deep Dive: New Features with Real-World Code
- Laravel 13 Performance Benchmarks
- The Zero-Headache Upgrade Strategy
- How to Install and Upgrade on Cloudways
- Future Outlook: Laravel in the AI Era
- Conclusion
- Frequently Asked Questions
Laravel 13 Support Policy and Release Schedule
Laravel follows a predictable annual release cycle, typically dropping major versions in Q1. Here’s what the support timeline looks like:
| Version | Release Date | Bug Fixes Until | Security Fixes Until |
|---|---|---|---|
| Laravel 11 | March 2024 | September 2025 | March 2026 |
| Laravel 12 | February 2025 | August 2026 | February 2027 |
| Laravel 13 | Q1 2026 | Q3 2027 | Q1 2028 |
The key takeaway is that you’re not being forced to upgrade immediately. Laravel 12 remains fully supported until early 2027, giving you plenty of runway to plan and test. That said, starting a new project? Laravel 13 should be your default choice from day one.
Laravel 13 Is Ready. Is Your Hosting?
Cloudways supports PHP 8.3 out of the box, so you can deploy Laravel 13 without wrestling with your server. Move your Laravel app to Cloudways for free and let experts handle the migration while you focus on the upgrade.
Why Upgrade? The Business Case
Most Laravel upgrade guides skip the “why.” Here’s the ROI you can expect from moving to Laravel 13:
Performance: Free speed from PHP 8.3+
By mandating PHP 8.3 as the minimum runtime, Laravel 13 inherits all of PHP’s recent optimizations without any code changes on your part. Benchmarks show Laravel applications on PHP 8.3 handling around 445 requests per second on API endpoints—a modest but meaningful improvement over PHP 8.2.
The real gains come from JIT compilation refinements and reduced memory overhead in long-running processes. For applications with heavy compute workloads or high-traffic APIs, expect a 5–10% throughput improvement simply by upgrading your runtime.
Security: A cleaner dependency tree
Laravel 13 removes deprecated polyfills and backward-compatibility layers that have accumulated over the years. This isn’t just housekeeping—fewer dependencies mean a smaller attack surface. The framework also aligns with Symfony 7.4 and 8.0 components, ensuring you’re building on actively maintained, security-audited foundations.
Developer efficiency: Better tooling saves hours
PHP 8.3’s typed class constants and the #[Override] attribute catch bugs at development time rather than production. Combined with Laravel’s enhanced Artisan commands, your team spends less time debugging and more time shipping features.
Deep Dive: New Features with Real-World Code
Let’s move beyond feature lists and see how Laravel 13’s additions solve actual problems.
Feature A: PHP 8.3 native support
Context: Laravel 13 drops support for PHP 8.2 and earlier. While this might seem restrictive, it unlocks PHP 8.3’s full feature set—most notably typed class constants and the json_validate() function.
class OrderController extends Controller
{
// No type safety on constants
const STATUS_PENDING = ‘pending’;
const STATUS_SHIPPED = ‘shipped’;public function store(Request $request)
{
// Manual JSON validation
$data = json_decode($request->input(‘payload’));
if (json_last_error() !== JSON_ERROR_NONE) {
return response()->json([‘error’ => ‘Invalid JSON’], 400);
}
}
}// After (PHP 8.3 with Laravel 13)
class OrderController extends Controller
{
// Typed constants – compiler enforced
public const string STATUS_PENDING = ‘pending’;
public const string STATUS_SHIPPED = ‘shipped’;public function store(Request $request)
{
// Clean JSON validation
$payload = $request->input(‘payload’);
if (!json_validate($payload)) {
return response()->json([‘error’ => ‘Invalid JSON’], 400);
}
$data = json_decode($payload);
}
}
The json_validate() function is more efficient than json_decode() for validation alone since it doesn’t build the entire data structure in memory.
Feature B: The Reverb database driver
Context: Laravel Reverb is the framework’s first-party WebSocket server for real-time applications. Previously, horizontal scaling required a Redis setup for channel/connection state. Laravel 13 introduces a database driver that simplifies this for smaller deployments.
Value: For apps that don’t need Redis’s extreme throughput, the database driver removes a dependency from your stack. Chat apps, live notifications, and collaborative tools can now scale horizontally without the infrastructure overhead.
BROADCAST_CONNECTION=reverb
REVERB_APP_ID=your_app_id
REVERB_APP_KEY=your_app_key
REVERB_APP_SECRET=your_app_secret
REVERB_HOST=“localhost”
REVERB_PORT=8080
REVERB_SCHEME=http
Reverb supports private channels, presence channels, and integrates directly with Laravel Echo on the frontend. A single server can handle thousands of concurrent WebSocket connections.
Feature C: Granular job queue control with maxExceptions
Context: Previously, Laravel’s job retry logic was tied to the tries property. If a job threw exceptions on each attempt, it would fail after exhausting all tries. The new maxExceptions property gives you independent control over how many exceptions are tolerable.
Use case: Imagine a job that calls a third-party payment API. The API sometimes returns temporary 503 errors. You want the job to retry on transient failures but fail fast if there’s a persistent problem—like a validation error that will never succeed.
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;// Allow up to 10 retry attempts
public $tries = 10;// But fail if more than 3 exceptions occur
public $maxExceptions = 3;public function handle(): void
{
$response =
Http::post(‘https://api.payment.com/charge’, [
‘amount’ =>
$this->order->total,
]);if ($response->failed()) {
throw new PaymentFailedException($response->body());
}
}
}
This approach prevents one consistently failing job from clogging your entire queue worker while still allowing transient failures to retry.
Feature D: Cache::touch() and subdomain routing improvements
Cache::touch() lets you extend a cache entry’s TTL without fetching and re-storing its value. This is particularly useful for session-like data where you want to keep items “warm” based on activity.
Cache::touch(‘user:123:preferences’, now()->addHours(2));
Subdomain routing has also been refined. Routes targeting specific subdomains now take priority over generic routes, which makes multi-tenant applications easier to manage without routing conflicts.
Laravel 13 Performance Benchmarks
Based on early testing with the Laravel 13 development branch, here are indicative performance numbers comparing Laravel 12 (PHP 8.2) to Laravel 13 (PHP 8.3):
| Endpoint type | Laravel 12 / PHP 8.2 | Laravel 13 / PHP 8.3 |
|---|---|---|
| Simple HTML (Welcome page) | ~730 req/s | ~710 req/s |
| API endpoint with DB query | ~437 req/s | ~445 req/s |
| Complex API with Eloquent relations | ~380 req/s | ~400 req/s |
The Zero-Headache Upgrade Strategy
Forget generic advice. Here’s a battle-tested upgrade plan that addresses the real pain points.
Step 1: The pre-flight check
Third-party packages are the number one blocker for Laravel upgrades. Run this audit before anything else:
composer outdated –direct# Check PHP 8.3 compatibility
composer why-not php 8.3
Create a list of packages that don’t yet support PHP 8.3 or Laravel 13. For critical packages, check their GitHub issues or find alternatives before proceeding.
Step 2: The Rector shortcut
Rector is a PHP tool that automates code upgrades. Combined with the Laravel-specific ruleset, it can handle 80% of breaking changes automatically:
composer require rector/rector –dev
composer require driftingly/rector-laravel –dev# Create rector.php config
vendor/bin/rector init
Configure Rector with Laravel-specific rules:
use Rector\Config\RectorConfig;
use RectorLaravel\Set\LaravelSetProvider;return RectorConfig::configure()
->withSetProviders(LaravelSetProvider::class)
->withComposerBased(laravel: true);
Run Rector in dry-run mode first to preview changes, then apply them:
vendor/bin/rector process –dry-run# Apply changes
vendor/bin/rector process
For teams that prefer a managed service, Laravel Shift automates the entire upgrade process and opens a pull request with atomic commits for review.
Step 3: The testing pyramid
Not all tests are created equal. Here’s the priority order for catching Laravel 13 regressions:
- Unit tests first: These run fastest and catch issues in isolated logic. If you have typed properties or constants, these tests will fail immediately on PHP 8.3 type mismatches.
- Feature tests second: These verify your HTTP endpoints, authentication, and database interactions. Run your full feature suite before deploying.
- Browser tests last: Dusk tests are slowest but catch frontend integration issues that API tests miss.
php artisan test –testsuite=Unit
php artisan test –testsuite=Feature
php artisan dusk
How to Install and Upgrade on Cloudways
Cloudways makes Laravel deployment straightforward, but there’s one critical step many developers miss when upgrading to Laravel 13.
Server prep: Upgrade PHP before deploying
Laravel 13 requires PHP 8.3 or higher. Deploy your code before upgrading PHP, and Composer will fail. Here’s how to upgrade:
- Log into your Cloudways Platform.
- Navigate to Server Management > Settings & Packages > Packages.
- Click Modify next to the PHP version.
- Select PHP 8.3 (or 8.4 if available).
- Confirm the upgrade and wait a few minutes for completion.
Important: Take a server backup before upgrading PHP. While Cloudways supports downgrading from 8.3 to 8.2, having a backup ensures you can restore quickly if your application has compatibility issues.
Fresh Laravel 13 installation
For new projects, SSH into your server and run:
composer create-project laravel/laravel . “13.*”
Upgrading existing projects
For existing Laravel 12 projects:
“require”: {
“php”: “^8.3”,
“laravel/framework”: “^13.0”
}# Run the update
composer update# Clear caches
php artisan config:clear
php artisan cache:clear
php artisan view:clear
Future Outlook: Laravel in the AI Era
Laravel 13’s stability-focused release isn’t just about the present—it’s laying groundwork for what’s coming next. The Laravel ecosystem is actively exploring AI integrations, with community projects leveraging the Model Context Protocol (MCP) for AI-powered development workflows.
By modernizing the codebase and requiring PHP 8.3+, Laravel 13 ensures your applications are positioned to adopt these emerging capabilities without technical debt holding you back. Teams that upgrade now will have an easier path to Laravel 14 and beyond.
Conclusion
Laravel 13 might not have the headline-grabbing features of previous releases, but its focus on modernization, stability, and developer experience makes it one of the most important upgrades for production applications. The PHP 8.3 requirement alone delivers performance and security improvements that compound over time.
Don’t wait for security warnings to force your hand. Start planning your upgrade roadmap today:
- Audit your third-party packages for PHP 8.3 compatibility.
- Set up a staging environment with Laravel 13’s development branch.
- Run your test suite and fix any deprecations.
- Plan the production upgrade for Q1 2026.
Your future self (and your application’s users) will thank you.
Deploy Laravel 13 on Managed Cloud Hosting
Get the best performance for your Laravel applications with Cloudways. 1-Click scaling, PHP 8.3 support, and optimized stacks.
Frequently Asked Questions
Will Laravel 13 break my existing Livewire or Inertia apps?
A) Both Livewire and Inertia.js are expected to support Laravel 13 from launch. However, you should update these packages to their latest versions before upgrading and test thoroughly in a staging environment. Any breaking changes will be documented in the official Laravel 13 upgrade guide.
Is Laravel 13 an LTS (Long-Term Support) release?
A) No. Laravel hasn’t had an LTS release since version 6. The current support policy provides 18 months of bug fixes and two years of security fixes for all major versions—which is generous enough for most upgrade cycles.
Can I skip Laravel 12 and upgrade directly from Laravel 11 to 13?
A) While possible, it’s not recommended. Each major version builds on the previous one, and skipping versions increases the risk of subtle breaking changes. Tools like Rector and Laravel Shift can handle incremental upgrades efficiently.
What if my hosting provider doesn’t support PHP 8.3?
A) You’ll need to either stay on Laravel 12 (supported until February 2027) or switch to a hosting provider that supports modern PHP versions. Cloudways currently supports PHP 7.4 through 8.4, making Laravel 13 deployment straightforward.
How long will my Laravel 12 application remain safe?
A) Laravel 12 receives bug fixes until August 2026 and security fixes until February 2027. You have well over a year from Laravel 13’s release to plan and execute your upgrade without security concerns.
Do I need Redis for Laravel Reverb?
A) Not anymore. Laravel 13 introduces a database driver for Reverb that allows horizontal scaling without Redis. This is ideal for smaller applications or teams that want to minimize infrastructure complexity. For high-throughput applications with thousands of concurrent WebSocket connections, Redis remains the recommended option.
Zain Imran
Zain is an electronics engineer and an MBA who loves to delve deep into technologies to communicate the value they create for businesses. Interested in system architectures, optimizations, and technical documentation, he strives to offer unique insights to readers. Zain is a sports fan and loves indulging in app development as a hobby.
