Laravel 13: Complete Guide to New Features, Release Date & What's Coming in 2026

# Minimum Requirements for Laravel 13
PHP >= 8.3
BCMath PHP Extension
Ctype PHP Extension
cURL PHP Extension
DOM PHP Extension
Fileinfo PHP Extension
Filter PHP Extension
Hash PHP Extension
Mbstring PHP Extension
OpenSSL PHP Extension
PCRE PHP Extension
PDO PHP Extension
Session PHP Extension
Tokenizer PHP Extension
XML PHP Extension

# Recommended for Production
OPcache PHP Extension (for performance)
Redis PHP Extension (for caching/queues)
Memcached PHP Extension (alternative caching)
GD or Imagick PHP Extension (image processing)

<?php

// Laravel 12 - Old way (inefficient)
$data = Cache::get('user_session_123');
Cache::put('user_session_123', $data, now()->addHours(2)); // Wasteful

// Laravel 13 - New way (efficient)
Cache::touch('user_session_123', now()->addHours(2)); // Just extends TTL

// Practical example: Extending user sessions
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', function () {
        // Touch the user's session cache to extend activity
        Cache::touch('user_activity_' . auth()->id(), now()->addMinutes(30));
        
        return view('dashboard');
    });
});

// Multiple keys at once
Cache::touch(['session_1', 'session_2', 'session_3'], now()->addHour());

// Store-specific usage
Cache::store('redis')->touch('api_rate_limit_user_456', now()->addMinutes(60));

<?php

// routes/web.php

// Laravel 12 - Could cause conflicts
Route::get('/dashboard', function () {
    return 'Main app dashboard'; // This might catch first
});

Route::domain('{tenant}.myapp.com')->group(function () {
    Route::get('/dashboard', function ($tenant) {
        return "Dashboard for {$tenant}"; // Might not work as expected
    });
});

// Laravel 13 - Subdomain routes get priority automatically
Route::domain('{tenant}.myapp.com')->group(function () {
    Route::get('/dashboard', function ($tenant) {
        return "Dashboard for {$tenant}"; // ✅ Matches first now!
    });
});

Route::get('/dashboard', function () {
    return 'Main app dashboard'; // ✅ Only matches when no subdomain
});

// Multi-tenant application example
Route::domain('{account}.app.com')->group(function () {
    Route::get('/', [TenantHomeController::class, 'index']);
    Route::get('/settings', [TenantSettingsController::class, 'show']);
});

// API subdomain
Route::domain('api.app.com')->group(function () {
    Route::get('/v1/users', [ApiUserController::class, 'index']);
});

// Default domain (lowest priority)
Route::get('/', [PublicHomeController::class, 'index']);

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected static function boot()
    {
        parent::boot();
        
        // ❌ Laravel 13 will throw an exception
        // Creating models during boot causes side effects
        $admin = Admin::first(); // FORBIDDEN
        
        // ✅ Instead, use events or model observers
        static::creating(function ($user) {
            // You can access models in event callbacks
            $defaultRole = Role::where('name', 'user')->first();
            $user->role_id = $defaultRole->id;
        });
        
        // ✅ Register observers instead
        static::observe(UserObserver::class);
    }
}

// The correct way - using observers
namespace App\Observers;

class UserObserver
{
    public function creating(User $user)
    {
        // ✅ Safe to query models here
        if (!$user->role_id) {
            $user->role_id = Role::where('name', 'user')->first()->id;
        }
    }
}

// Register in AppServiceProvider
public function boot()
{
    User::observe(UserObserver::class);
}

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Carbon;

// Laravel 12 - No native typing
class User extends Model
{
    protected $casts = [
        'email_verified_at' => 'datetime',
        'is_active' => 'boolean',
    ];
}

// Laravel 13 - Native typed properties
class User extends Model
{
    public int $id;
    public string $name;
    public string $email;
    public ?string $phone;
    public bool $is_active;
    public Carbon $created_at;
    public Carbon $updated_at;
    public ?Carbon $email_verified_at;
    
    // Your IDE now knows exact types!
    // Type hints work perfectly
    // Static analysis tools (PHPStan, Psalm) can verify correctness
}

// Practical example with type safety
Route::get('/user/{user}', function (User $user) {
    // ✅ IDE knows these are the correct types
    $name = $user->name; // string
    $isActive = $user->is_active; // bool
    $verifiedAt = $user->email_verified_at; // Carbon|null
    
    // ✅ Type errors caught before runtime
    // $user->is_active = "yes"; // Static analyzer error!
});

# 1. Verify PHP 8.3+ is installed
php -v
# Should show: PHP 8.3.x or higher

# 2. Check Composer is up to date
composer --version
# Should be Composer 2.5+ recommended

# 3. Verify required extensions
php -m | grep -E 'pdo|curl|mbstring|xml|bcmath'

# If you need to install PHP 8.3 (Ubuntu/Debian)
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.3 php8.3-cli php8.3-common php8.3-curl \
  php8.3-mbstring php8.3-xml php8.3-bcmath php8.3-mysql

# Install/update Laravel installer globally
composer global require laravel/installer

# Create new Laravel 13 project with dev flag
laravel new my-laravel-13-app --dev

# Navigate to project
cd my-laravel-13-app

# Configure environment
cp .env.example .env
php artisan key:generate

# Set up database in .env, then run migrations
php artisan migrate

# Start development server
php artisan serve
# Visit: http://localhost:8000

# Create project using dev-master branch
composer create-project --prefer-dist laravel/laravel my-laravel-13-app dev-master

# Navigate to project
cd my-laravel-13-app

# Install dependencies
composer install

# Generate application key
php artisan key:generate

# Configure .env file for database
nano .env  # or use your preferred editor

# Run migrations
php artisan migrate

# Start server
php artisan serve

# Check Laravel version
php artisan --version
# Should show: Laravel Framework 13.x-dev

# Check PHP version
php -v

# Test new Cache::touch() method
php artisan tinker

>>> Cache::put('test_key', 'test_value', now()->addMinutes(10));
>>> Cache::touch('test_key', now()->addMinutes(30));
>>> Cache::get('test_key');
=> "test_value"

# Run tests to ensure everything works
php artisan test

# Pull latest changes from dev-master
cd my-laravel-13-app
git pull origin master

# Update dependencies
composer update

# Clear caches after updates
php artisan optimize:clear

# Run migrations for any new changes
php artisan migrate

# Subscribe to Laravel News for updates
# https://laravel-news.com

# Follow Laravel on GitHub
# https://github.com/laravel/framework

# 1. Backup everything
# Database
mysqldump -u username -p database_name > backup_$(date +%Y%m%d).sql

# Application files
tar -czf laravel_backup_$(date +%Y%m%d).tar.gz /path/to/laravel

# 2. Review current Laravel version
php artisan --version

# 3. Check PHP version and upgrade if needed
php -v
# Must be 8.3+ for Laravel 13

# 4. Update composer to latest version
composer self-update

# 5. Review all installed packages
composer show

# 6. Check for deprecated code in your application
php artisan route:list
grep -r "deprecated" vendor/laravel/framework/UPGRADE.md

# Step 1: Update composer.json
# Edit composer.json and change Laravel version
{
    "require": {
        "php": "^8.3",
        "laravel/framework": "^13.0"
    }
}

# Step 2: Update dependencies
composer update

# Step 3: Clear all caches
php artisan optimize:clear
php artisan config:clear
php artisan route:clear
php artisan view:clear

# Step 4: Update configuration files
# Compare config files with fresh Laravel 13 installation
php artisan vendor:publish --tag=laravel-config --force

# Step 5: Run migrations
php artisan migrate

# Step 6: Run comprehensive tests
php artisan test

# Step 7: Check for deprecations
php artisan route:list
php artisan config:show

<?php

// 1. Update Model Boot Methods
// ❌ Laravel 12 - This will break in Laravel 13
class User extends Model
{
    protected static function boot()
    {
        parent::boot();
        $admin = Admin::first(); // Forbidden in Laravel 13!
    }
}

// ✅ Laravel 13 - Use observers instead
class UserObserver
{
    public function creating(User $user)
    {
        // Safe to query models here
        $defaultRole = Role::where('name', 'user')->first();
    }
}

// 2. Update Cache Operations
// ❌ Laravel 12 - Inefficient pattern
$value = Cache::get('key');
Cache::put('key', $value, now()->addHours(2));

// ✅ Laravel 13 - Use touch() method
Cache::touch('key', now()->addHours(2));

// 3. Review Subdomain Routing
// Ensure subdomain routes are defined correctly
// They now take priority automatically

// 4. Add Type Hints to Models (optional but recommended)
class Product extends Model
{
    public int $id;
    public string $name;
    public float $price;
    public bool $in_stock;
    public Carbon $created_at;
}

# Run full test suite
php artisan test

# Test specific features
php artisan test --filter=CacheTest
php artisan test --filter=RoutingTest
php artisan test --filter=ModelTest

# Run static analysis (if using PHPStan)
./vendor/bin/phpstan analyse

# Check code style (if using PHP CS Fixer)
./vendor/bin/php-cs-fixer fix --dry-run --diff

# Performance testing
php artisan route:cache
php artisan config:cache
php artisan optimize

# Load test critical endpoints
# Use tools like Apache Bench or Laravel Dusk

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Carbon;

class Order extends Model
{
    // Define explicit types for better IDE support
    public int $id;
    public int $user_id;
    public string $order_number;
    public float $total_amount;
    public string $status;
    public ?string $tracking_number;
    public Carbon $created_at;
    public Carbon $updated_at;
    public ?Carbon $shipped_at;
    
    // Benefits:
    // - Perfect IDE autocomplete
    // - Static analysis catches type errors
    // - Self-documenting code
    // - Better refactoring support
    
    public function calculateTax(): float
    {
        // IDE knows total_amount is float
        return $this->total_amount * 0.08;
    }
}

<?php

// Efficient session management
Route::middleware('auth')->group(function () {
    Route::get('/api/{endpoint}', function () {
        $userId = auth()->id();
        $cacheKey = "user_session_{$userId}";
        
        // Extend session without retrieval
        Cache::touch($cacheKey, now()->addMinutes(30));
        
        // Continue with request handling
    });
});

// Rate limiting with touch()
class RateLimiter
{
    public function hit(string $key, int $decayMinutes = 1): void
    {
        $cacheKey = "rate_limit:{$key}";
        
        if (Cache::has($cacheKey)) {
            Cache::increment($cacheKey);
            Cache::touch($cacheKey, now()->addMinutes($decayMinutes));
        } else {
            Cache::put($cacheKey, 1, now()->addMinutes($decayMinutes));
        }
    }
    
    public function tooManyAttempts(string $key, int $maxAttempts): bool
    {
        return Cache::get("rate_limit:{$key}", 0) >= $maxAttempts;
    }
}

<?php

// routes/web.php

// Define subdomain routes first (they get priority in Laravel 13)
Route::domain('{account}.myapp.com')->group(function () {
    Route::get('/', [TenantController::class, 'dashboard']);
    Route::get('/settings', [TenantController::class, 'settings']);
    Route::resource('projects', ProjectController::class);
});

// API subdomain
Route::domain('api.myapp.com')
    ->prefix('v1')
    ->group(function () {
        Route::apiResource('users', ApiUserController::class);
        Route::apiResource('posts', ApiPostController::class);
    });

// Admin subdomain
Route::domain('admin.myapp.com')
    ->middleware(['auth', 'admin'])
    ->group(function () {
        Route::get('/', [AdminController::class, 'index']);
        Route::resource('users', AdminUserController::class);
    });

// Main domain routes (lowest priority)
Route::get('/', [HomeController::class, 'index']);
Route::get('/pricing', [PricingController::class, 'index']);

<?php

namespace App\Observers;

use App\Models\User;
use App\Models\Role;
use Illuminate\Support\Str;

class UserObserver
{
    public function creating(User $user): void
    {
        // Assign default role
        if (!$user->role_id) {
            $user->role_id = Role::where('name', 'user')->first()->id;
        }
        
        // Generate UUID
        if (!$user->uuid) {
            $user->uuid = Str::uuid();
        }
    }
    
    public function created(User $user): void
    {
        // Send welcome email
        Mail::to($user->email)->send(new WelcomeEmail($user));
    }
    
    public function updating(User $user): void
    {
        // Log changes
        if ($user->isDirty('email')) {
            activity()
                ->causedBy($user)
                ->log('Email changed from ' . $user->getOriginal('email'));
        }
    }
}

// Register in AppServiceProvider
public function boot(): void
{
    User::observe(UserObserver::class);
}

# Production optimization commands
php artisan config:cache      # Cache configuration
php artisan route:cache        # Cache routes
php artisan view:cache         # Cache Blade templates
php artisan event:cache        # Cache events
php artisan optimize           # Run all optimizations

# Enable OPcache in php.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0  # Disable in production

# Use Redis for cache and sessions
CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

# Database query optimization
php artisan db:show            # Show database info
php artisan model:show User    # Show model details
php artisan query:count         # Count queries per page

# Development tools
composer require --dev barryvdh/laravel-debugbar
composer require --dev barryvdh/laravel-ide-helper
composer require --dev nunomaduro/phpinsights

# Testing
composer require --dev pestphp/pest
composer require --dev pestphp/pest-plugin-laravel

# Code quality
composer require --dev larastan/larastan
composer require --dev friendsofphp/php-cs-fixer

# Popular packages (verify Laravel 13 compatibility)
composer require spatie/laravel-permission
composer require spatie/laravel-query-builder
composer require spatie/laravel-activitylog