When should you NOT use Ahead-of-Time vs Just-in-Time Compilation?

Do not enable PHP JIT for typical CRUD web apps — the warm-up cost and memory overhead outweigh gains for I/O-bound code. Avoid JIT in short-lived PHP scripts (CLI one-shots) where the compilation cost exceeds total runtime. Do not assume JIT improves all code paths equally — profile first; unoptimised JIT can regress some patterns.

When is Ahead-of-Time vs Just-in-Time Compilation the right choice?

Prefer AOT (Go, Rust, C) for CLI tools, containers, and serverless where cold-start time and binary portability matter. Use JIT (PHP 8+ opcache.jit, JVM) for long-running CPU-bound workloads where runtime profiling improves hot-path throughput. Enable PHP JIT specifically for number-crunching, image processing, or ML inference — not for typical I/O-bound web requests.

← Back to glossary

Ahead-of-Time vs Just-in-Time Compilation

compiler Intermediate

Also Known As

AOT compilation JIT compilation PHP JIT compile time

TL;DR

AOT compiles all code before execution (C, Go, Rust — fast startup, predictable performance). JIT compiles hot paths at runtime (PHP 8+, JVM — adapts to actual usage patterns).

Explanation

AOT (Ahead-of-Time): the entire program is compiled to machine code before running. Advantages: fast startup, predictable performance, no runtime compilation overhead. Languages: C, C++, Go, Rust. Disadvantage: cannot optimise based on runtime data. JIT (Just-in-Time): compiles frequently executed code paths to machine code while running. Advantages: can use runtime profiling to optimise hot paths, supports dynamic languages. Disadvantages: warm-up time (startup slower), runtime overhead for compilation. PHP 8's JIT uses Opcache as the foundation — compiles hot opcodes to native code. Impact on PHP: significant for CPU-bound code (image processing, cryptography), negligible for typical I/O-bound web requests.

Common Misconception

✗ PHP 8's JIT always makes PHP faster — PHP's JIT primarily benefits CPU-bound code. Typical web applications spend 90% of time in I/O (database, network) — the JIT has minimal impact on these and can even add slight overhead.

Why It Matters

Enabling PHP's JIT for a typical web application and expecting 2x speedup is a common misunderstanding — profiling first identifies whether the bottleneck is CPU or I/O before enabling JIT.

Common Mistakes

Enabling PHP JIT expecting speedup for I/O-bound web apps — measure first.
Not understanding JIT warmup — first requests are slower while code is being profiled and compiled.
Comparing PHP JIT to Go/Rust AOT — AOT languages have no warmup and generally faster peak performance.
Not testing JIT stability — JIT is complex; some code paths may have JIT bugs.

Avoid When

Do not enable PHP JIT for typical CRUD web apps — the warm-up cost and memory overhead outweigh gains for I/O-bound code.
Avoid JIT in short-lived PHP scripts (CLI one-shots) where the compilation cost exceeds total runtime.
Do not assume JIT improves all code paths equally — profile first; unoptimised JIT can regress some patterns.

When To Use

Prefer AOT (Go, Rust, C) for CLI tools, containers, and serverless where cold-start time and binary portability matter.
Use JIT (PHP 8+ opcache.jit, JVM) for long-running CPU-bound workloads where runtime profiling improves hot-path throughput.
Enable PHP JIT specifically for number-crunching, image processing, or ML inference — not for typical I/O-bound web requests.

Code Examples

💡 NoteThe bad config enables tracing JIT globally without measurement; the good example profiles first, confirms a CPU bottleneck, then targets JIT at the specific slow path.

✗ Vulnerable

; Enabling JIT everywhere without measuring:
; php.ini:
opcache.jit_buffer_size = 100M
opcache.jit = tracing
; Benchmark result: 0% improvement for DB-heavy Laravel app
; JIT overhead: 50MB memory, slower startup
; Wrong tool for the problem

✓ Fixed

; First: profile to confirm CPU-bound bottleneck
; $ php -d xdebug.mode=profile script.php
; Result: 80% time in image resize — CPU bound!

; Now enable JIT for targeted benefit:
opcache.jit_buffer_size = 64M
opcache.jit = tracing  ; Best for loops
; Benchmark: 40% faster image processing
; Web endpoints: 2% faster (within noise)
; Worth it for image service, not general app

References

↗ https://www.php.net/manual/en/opcache.configuration.php#ini.opcache.jit

Tags

compiler performance php

Added 16 Mar 2026

Edited 31 Mar 2026

Curated in Warsaw under one editorial standard. 1,444 terms, single voice. About this reference →

Rate this term

No ratings yet

🤖 AI Guestbook educational data only

| |

Last 30 days

Agents 1

No pings yesterday

Perplexity 12 Amazonbot 12 Unknown AI 4 Google 4 SEMrush 3 Ahrefs 2 ChatGPT 1

Also referenced

Profiling & Benchmarking 41 JIT Compilation 34 PHP Compilation Pipeline 27 Bytecode VMs 21

How they use it

crawler 34 crawler_json 3 pre-tracking 1

Related categories

performance 1.6k compiler 364

⚡ DEV INTEL Tools & Severity

🔵 Info ⚙ Fix effort: Low

⚡ Quick Fix

PHP uses JIT (compile hot paths at runtime) not AOT (compile everything upfront) — JIT benefits CPU-bound long-running workers, not typical I/O-bound web requests

📦 Applies To

any web cli

🔗 Prerequisites

PHP JIT — When It Helps (and When It Doesn't) PHP Compilation Pipeline Bytecode VMs

🔍 Detection Hints

Enabling PHP JIT expecting web request speedup; not enabling JIT for CPU-intensive CLI image processing scripts

Auto-detectable: ✗ No blackfire opcache-gui

⚠ Related Problems

PHP JIT — When It Helps (and When It Doesn't) PHP Compilation Pipeline performance degradation

🤖 AI Agent

Confidence: Low False Positives: High ✗ Manual fix Fix: Medium Context: File