PHP 8.5 JIT in the Real World: Benchmarking WordPress, Laravel & Symfony (2026)

Introduction

In our second benchmark, we saw a staggering PHP 8.5 JIT performance improvement of 110% on a pure CPU‑intensive script. But how does that translate to real‑world frameworks like WordPress, Laravel, and Symfony?

This question is critical for developers deciding whether to enable JIT in production. In this benchmark, we test PHP 8.5.2 with JIT on vs off across three scenarios:

• WordPress homepage – I/O‑bound (database queries, template rendering)
• Laravel CPU route – fibonacci(30) calculation
• Symfony CPU route – same CPU‑intensive task

All tests use the same server, same configuration, and follow industry best practices (warm-up, multiple runs, OPcache enabled).

Test Environment

Methodology

1. Configure JIT disabled (opcache.jit = disable), restart PHP-FPM
2. Run all tests (3 runs per scenario) – record Requests per second and Time per request
3. Configure JIT enabled (tracing + 256M), restart PHP-FPM
4. Wait 30 seconds for JIT warm-up
5. Run all tests again (3 runs per scenario)
6. Average results directly (runs were stable within ±2%)
7. Verify all Failed requests = 0 in every run

Results

Table 1: WordPress Homepage (I/O‑bound)

WordPress homepage is I/O‑bound – JIT offers minimal improvement.

Table 2: Laravel CPU Route (Compute‑intensive)

These Laravel JIT benchmark results show JIT nearly doubles throughput on compute‑intensive Laravel tasks.

Table 3: Symfony CPU Route (Compute‑intensive)

When comparing Symfony vs Laravel JIT gains, Symfony shows equally dramatic results, with throughput nearly doubling.

Key Findings

• PHP 8.5 JIT performance improvement: Up to 95% gain in compute‑intensive scenarios
• Laravel JIT benchmark results: 82% throughput increase (21.22 → 38.60 req/s)
• Symfony vs Laravel JIT gains: Both frameworks show 80-95% improvements, with Symfony slightly ahead at 95%

Analysis

The results clearly demonstrate where JIT matters and where it doesn’t:

WordPress Homepage (I/O‑bound): JIT offers minimal improvement (0.6%). WordPress spends most of its time waiting for database queries and file operations. The bottleneck is not PHP execution.

Laravel & Symfony CPU Routes (Compute‑intensive): This is where JIT shines. Our Laravel JIT benchmark results show an 82% gain, while Symfony vs Laravel JIT gains are comparable, with Symfony achieving 95%. Together, they confirm the substantial PHP 8.5 JIT performance improvement for CPU‑heavy tasks. Response times are cut by nearly half.

The takeaway is clear: JIT is not a magic switch for every application. Its value depends entirely on your workload:

• I/O‑bound apps (most WordPress sites) → JIT offers little (<5% gain)
• CPU‑bound apps (APIs with heavy computation, data processing) → JIT delivers 80-95% gains

Should You Enable JIT?

Yes, always – but with realistic expectations.

Why enable JIT even for WordPress?

• It rarely hurts performance
• Helps with background tasks (cron jobs, queue workers)
• Future-proofing – as WordPress evolves, it may leverage more CPU

JIT Configuration Best Practices

To get the most out of JIT:

php.ini

; Enable JIT with tracing mode
opcache.jit = tracing
; Allocate enough buffer – 256M recommended
opcache.jit_buffer_size = 256M
; Ensure OPcache is enabled
opcache.enable = 1

After configuration:

1. Restart PHP-FPM
2. Verify with phpinfo() – search for opcache.jit
3. Run warm-up requests (500+) to let JIT identify hot paths

Frequently Asked Questions

Test Scripts (for Reproducibility)

Important: Run these commands only on your own isolated test server.

bash

# WordPress homepage
ab -n 1000 -c 1 https://phpbenchlab.com/:8084/
# Laravel CPU route
ab -n 1000 -c 1 https://phpbenchlab.com/:8085/cpu-test
# Symfony CPU route
ab -n 1000 -c 1 https://phpbenchlab.com/:8086/cpu-test
# Verify JIT status
curl https://phpbenchlab.com/:8084/info.php 2>/dev/null | grep opcache.jit

Laravel Test Route (routes/web.php)

php

<?php
use Illuminate\Support\Facades\Route;
Route::get('/', function () {
    return view('welcome');
});
Route::get('/cpu-test', function () {
    function fibonacci($n) {
        if ($n <= 1) return $n;
        return fibonacci($n-1) + fibonacci($n-2);
    }
    
    $result = fibonacci(30);
    return response('OK');
});

Symfony Controller (src/Controller/BenchmarkController.php)

php

<?php
namespace App\Controller;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
class BenchmarkController
{
    #[Route('/cpu-test', name: 'cpu_test')]
    public function cpuTest(): Response
    {
        function fibonacci($n) {
            if ($n <= 1) return $n;
            return fibonacci($n-1) + fibonacci($n-2);
        }
        
        $result = fibonacci(30);
        return new Response('OK');
    }
}

Conclusion

This benchmark confirms that JIT’s impact is highly workload‑dependent:

While JIT shines in CPU-heavy Laravel routes, it’s a different story under I/O load. See our JIT performance under I/O latency test for a complete four-environment comparison with slow databases.

• For I/O‑bound applications like WordPress frontend, JIT offers minimal gains (<5%)
• For compute‑intensive tasks in frameworks like Laravel and Symfony, our Laravel JIT benchmark results and Symfony vs Laravel JIT gains confirm that JIT delivers 80-95% performance improvements – effectively doubling throughput. This represents a significant PHP 8.5 JIT performance improvement over JIT‑disabled configurations.

Final recommendation:

1. Enable JIT on all PHP 8.5 servers – it’s safe and helps in many scenarios
2. Configure correctly – 256M buffer, tracing mode
3. For CPU‑heavy applications, JIT is non‑negotiable – you’re leaving massive performance on the table if it’s disabled

The days of PHP being “slow” are over. With PHP 8.5 and JIT, the language competes with compiled runtimes on CPU‑intensive tasks while maintaining its legendary ease of development.

All raw data and methodology are provided. Reproduce this benchmark on your own hardware to validate results.