PHP:TheWebItself
From a 1994 human-resume hit counter to 2026's 75% of all server-side web. After being mocked as a "fractal of bad design," PHP 7 rewrote Zend, PHP 8 added a JIT, 8.1 brought enums and Fibers, 8.4 landed property hooks — every specific complaint in the 2010 critique has been fixed. The "PHP is dead" meme will keep going for another thirty years.
Rasmus Lerdorf
share in 2026
runs on PHP
next: 8.5 · 2026-11
What is PHP
PHP is a server-side scripting language started in 1994 by Rasmus Lerdorf, now maintained by the PHP Foundation and Zend. The original goal was tiny: track resume page hits. Thirty years later it is the most-deployed backend language on the internet — WordPress, Wikipedia, Drupal, Magento, early Facebook are all its descendants.
Unlike Python or Ruby, a PHP file is HTML by default; you enter code with <?php. "The template is the code, the code is the template" — the most consequential design choice PHP made in 1994.
Each request boots fresh and dies on completion. Sounds wasteful — actually makes horizontal scaling trivial: no leaks, no shared state, no warm-up. php-fpm polishes this model to its limit.
1995 = "form handling"; 2004 PHP 5 = real OOP; 2015 PHP 7 = perf doubled; 2020 PHP 8 = JIT + modern syntax. Few languages walk through three eras of computing without dying.
400k+ packages, modern dependency management since 2012. Laravel, Symfony, Doctrine, PHPUnit, Pest are quality-comparable to top-tier npm / Maven libraries.
<?php
// the old style — global, untyped, fragile
function find_user($id) {
global $db;
$res = mysql_query(
"SELECT * FROM users WHERE id=" . $id);
return mysql_fetch_assoc($res);
}
$u = find_user($_GET['id']);
echo "Hello, " . $u['name'];
// globals + string-built SQL + array return
// SQL injection: wide open<?php
declare(strict_types=1);
final class UserRepository {
public function __construct(
private readonly PDO $db,
) {}
public function find(int $id): ?User
{
$stmt = $this->db->prepare(
'SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => $id]);
return $stmt->fetchObject(User::class) ?: null;
}
}
// types + readonly + prepared + named paramsHistory : Timeline
PHP is one of the few languages that survived 30 years and stayed mainstream. 1994 personal project, 1997 student rewrite, 1999 commercial engine, 2004 real OOP, 2012 (Composer + Laravel + the "fractal" essay all in one year), 2015 PHP 7's comeback, 2020 PHP 8's JIT + modernisation, 2024 property hooks. One big leap every decade — an unusually steady curve.
- 1994
Rasmus Lerdorf writes "Personal Home Page Tools"
Rasmus Lerdorf, in Canada, builds a set of CGI binaries in C as a replacement for a stack of Perl scripts. The only goal: count how many times his online resume gets viewed. The first name is
PHP/FI— Personal Home Page / Forms Interpreter. Nobody, including the author, imagines this turning into industrial infrastructure. - 1995·06·08
First public release — PHP Tools 1.0
June 8: Lerdorf posts the source to
comp.infosystems.www.authoring.cgi. The feature set is tiny — form variables, a guestbook, SQL embedded in HTML. This is the day PHP officially exists; June 8 is the language's birthday. - 1997·夏
Zeev Suraski + Andi Gutmans rewrite the parser → PHP 3
Two Technion (Israeli Institute of Technology) students, working on an e-commerce class project, decide PHP/FI 2's parser is unextensible and rewrite it from scratch. Lerdorf agrees to ship their rewrite as PHP 3. From this point on "PHP" is officially a recursive acronym:
PHP: Hypertext Preprocessor. - 1999
Zend Engine ships → PHP 4
Suraski and Gutmans found Zend (Ze + nd), commercialising the PHP engine. PHP 4 introduces a two-phase compile-to-bytecode plus ZE1 interpreter model; performance leaps. From this point PHP can actually carry the load of the LAMP era.
- 2004·07·13
PHP 5 — real OOP arrives
Brings Zend Engine 2 (ZE2), a proper object model (reference semantics, no longer value-copy),
try/catchexceptions, and the PDO database abstraction. PHP finally looks like a "modern" language. WordPress 1.0 also ships this year — the two destinies become intertwined from here. - 2011·06
Laravel 1.0 — Taylor Otwell appears
26-year-old Taylor Otwell redoes everything he disliked about CodeIgniter, names the result Laravel. Eloquent ORM + Blade templates + the Artisan CLI together make "Rails-style PHP" usable for the first time. It eats Symfony's lunch within five years and becomes the default full-stack framework for PHP.
- 2012·04·01
Eevee writes "PHP: a fractal of bad design"
April 1: programmer Eevee publishes the most-cited language critique on the internet. It catalogues PHP's inconsistent function names (
strlenvsstr_replace), erratic parameter order, implicit conversion pitfalls, and counter-intuitive==behaviour. The post's force is that it isn't wrong — every single thing it lists is something PHP would spend the next decade actually fixing. - 2012·03
Composer goes public
Nils Adermann and Jordi Boggiano ship Composer, paired with the Packagist registry. For the first time PHP has npm-style dependency management:
composer.json,require, autoload. The shape of every PHP project changes — from a pile of include files into proper packaged engineering. - 2013·03
Facebook open-sources HHVM + Hack
Facebook releases HHVM (HipHop VM), a JIT for PHP that runs 2-9× faster than official PHP 5. Alongside it, their modified dialect Hack — strong typing, async/await, generics. For the first time the PHP team feels an external threat: if PHP doesn't get fast, Facebook will fork.
- 2015·12·03
PHP 7 ships — the performance rocket
Russian compiler engineer Dmitry Stogov drives the internal
phpngbranch, redesigning Zend Engine's memory representation — values become compact zvals, refcount and GC interlock, virtually every hot path is rewritten. Result: 2× WordPress throughput, and PHP overtakes HHVM. PHP 6 was skipped entirely after its Unicode overhaul failed — the version number jumps straight from 5 to 7. - 2017
Facebook walks away from PHP — Hack splits off
Facebook announces HHVM will no longer maintain PHP compatibility; Hack becomes a fully separate language. On the surface PHP "lost"; in reality PHP 7 is fast enough that Facebook no longer needs to do the two-way compatibility work. The PHP camp actually exhales: with Facebook's gravity gone, the language team is free to design without that constraint.
- 2020·11·26
PHP 8.0 — JIT plus a modern-syntax explosion
The version that genuinely makes PHP modern. JIT compiler lands in Zend Engine (Stogov again leading); named arguments; the
matchexpression; attributes (PHP-flavoured annotations,#[...]); constructor property promotion; the nullsafe?->operator; union types. One release drags PHP fully into the 2020s. - 2021·11
The PHP Foundation is founded
Nikita Popov (8 years as a core PHP contributor and feature lead) announces he's leaving for Rust work, triggering a "who funds the maintainers" crisis. JetBrains, Automattic, Laravel, Symfony and others jointly stand up the PHP Foundation, raising USD 600k in year one to pay full-time contributors. For the first time PHP has a real financial backbone.
- 2021·11·25
PHP 8.1 — enums / readonly / fibers
Real enums (no more faking with consts); readonly properties; first-class callable syntax
strlen(...); Fibers (cooperative concurrency — a real primitive for amphp / ReactPHP); pure intersection types. - 2023·11·23
PHP 8.3 — typed class constants
Class constants finally get types:
const string VERSION = '1.0'.json_validate()enters stdlib — no more hand-rolledjson_decode + last_errorchecks. The#[\\Override]attribute makes method-override intent explicit. - 2024·11·21
PHP 8.4 — property hooks + asymmetric visibility
The biggest syntax change in a decade: property hooks (C#-style get/set attached directly to a property — no more getter/setter pairs) and asymmetric visibility (
public private(set) string $name). PHP finally reads like C# — a sentence no one would have dared write ten years ago. - 2026
"PHP is dead" — year 30
2026 state: W3Techs server-side share around 75%, still the most-deployed backend language on the internet. WordPress runs 40%+ of all websites; Wikipedia's billions of daily requests go through MediaWiki/PHP; Slack, Etsy, Shopify and Wikipedia all grew up on PHP. Laravel is the default full-stack framework. "PHP is dead" is the language's own forever-meme — repeated for thirty years while market share doesn't budge.
Language Essentials : PhpAlphabet
The eight cards below are the spine of modern PHP: HTML embedding, the $ sigil, optional types, constructor property promotion, match, enums, #[Attributes], property hooks. Card nine deals with the "fractal of bad design" essay and how PHP fixed it, item by item.
Open / close tags — <?php ?>
PHP is designed to embed inside HTML: anything outside <?php is HTML, anything inside is code. This is why PHP templating feels effortless — and also why PHP doesn't read like a "proper" scripting language.
<!DOCTYPE html>
<h1>Hello, <?= $user->name ?></h1>
<?php
foreach ($posts as $p) {
echo $p->title;
}The $ sigil
Every variable starts with $. Why: a Perl inheritance — it distinguishes variables from bare words when interpolating into HTML / SQL. Nobody particularly loves it, but 30 years later it's untouchable.
$name = "world";
echo "Hello, $name!"; // interpolation
echo "Hello, {$user->name}!";Type declarations — modern PHP
From PHP 7+ optional static types: parameters, returns, and properties can be typed. 8.0 added unions, 8.1 intersections, 8.3 typed class constants. With types and strict mode on, PHP isn't that far from TS.
declare(strict_types=1);
function total(array $items): int
{
return array_sum($items);
}Constructor property promotion
Syntactic sugar added in PHP 8.0 — declare properties directly in the constructor signature. Code that used to be 30 lines of getter/setter boilerplate becomes one line.
class Point {
public function __construct(
public readonly float $x,
public readonly float $y,
) {}
}
$p = new Point(x: 1.0, y: 2.0);The match expression
PHP 8.0 added a real expression-based branch: no fall-through, strict comparison (===), returns a value. Effectively retires the legacy switch with all its pitfalls.
$status = match($code) {
200, 201 => 'ok',
301, 302 => 'redirect',
404 => 'not found',
default => 'error',
};Enums — real ones
Before PHP 8.1 you faked enums with consts. 8.1 brought backed enums (with a scalar value) and pure enums; both can carry methods and implement interfaces. The 30-year wait.
enum Status: string {
case Draft = 'draft';
case Published = 'published';
public function label(): string
{ return ucfirst($this->value); }
}Attributes — #[...] annotations
PHP 8.0 upgraded doc-block annotations (a de facto Symfony / Doctrine convention for years) into native syntax. Readable at runtime via reflection — the unified mechanism behind Symfony routing, Doctrine mapping, and Laravel 12 configuration.
#[Route('/users/{id}', methods: ['GET'])]
public function show(int $id): Response
{
return $this->render($this->repo->find($id));
}Property hooks (PHP 8.4)
The biggest single syntax change in November 2024's 8.4: properties carry their own get/set hooks; no more matched getter/setter pair. Equivalent to C# properties or Kotlin getters — this is the release where PHP finally drops Java-era boilerplate.
class User {
public string $fullName {
get => $this->first . ' ' . $this->last;
set(string $v) {
[$this->first, $this->last] = explode(' ', $v, 2);
}
}
}"A fractal of bad design" — what happened next?
Eevee's 2012 essay listed dozens of PHP defects and became the standard ammunition for 2010s PHP-bashing. Looking back, most of the concrete items it called out — inconsistent function names, parameter order, == behaviour, missing types — have been fixed in PHP 7/8: type declarations, strict mode, match, enums, attributes, property hooks. One of the few languages that took a devastating critique and actually responded.
"The fractal essay was true in 2012, and it was the best thing that ever happened to PHP — because it gave the language a checklist."
Why PHP : WhyPHP
PHP's value in 2026 is not novelty. It is "driving the cost and complexity of backend web work to the floor": zero-friction deploy, shared-nothing horizontal scaling, self-sufficient Composer ecosystem, PHP 8.x is fast enough for mainstream workloads, Laravel pulls DX up to Rails / Next.js parity.
Near-zero deploy friction
PHP was polished by the shared-hosting era into the easiest backend on Earth to deploy: FTP a .php file up, Apache / nginx / php-fpm serves it immediately. No process to start, no port conflicts, no build step. "Upload it = it's live" is a moat nobody has replicated in 30 years.
# scp index.php user@host:/var/www/
# done. no daemon. no port. no build.Shared-nothing architecture
Every PHP request boots from a clean slate and dies when it ends. Sounds wasteful — it's actually what makes horizontal scaling trivial: add a machine, add throughput. Node and Go's long-process models invite memory leaks and state corruption; PHP doesn't. Every request is a tiny program.
// request → fpm worker boots
// → script runs → returns
// → worker resets → next requestComposer + Packagist
Since 2012 PHP has had genuinely modern package management: composer require plus 400k+ packages on Packagist. Laravel, Symfony, Doctrine, PHPUnit, Pest, Carbon, Guzzle — the top-tier libraries are quality-comparable to anything in the npm or Maven worlds.
# composer require guzzlehttp/guzzle
# vendor/ + autoload — done.The real speed of PHP 7+
PHP 5 was genuinely slow; PHP 7 onwards is fast enough for business backends: running WordPress / Laravel, PHP 8.x with JIT lands in the same band as Node and Python for typical web loads, behind Go and Java but by less than people remember. "PHP is slow" was a fact in 2012; in 2026 it's a meme.
// WordPress · req/s · PHP 5.6 → 8.3
// 5.6 : ~100 → 8.0 : ~280
// 8.3 : ~340 (JIT on)The WordPress / Wikipedia / Drupal root
WordPress runs 40%+ of all websites, Wikipedia rides MediaWiki/PHP, Drupal still dominates enterprise portals. It isn't "these projects happen to run on PHP" — it's "these projects are PHP's soul." Their existence is why PHP cannot die.
// W3Techs (2026):
// PHP · 75% server-side
// Node · 4%
// Python · 1.6%Laravel — PHP's redemption in the 2010s
Without Laravel, PHP would have lost the "modern web framework" battle convincingly. Taylor Otwell alone (later joined by Mohamed Said and Nuno Maduro and others) dragged PHP back onto the same stage as Rails and Django. In 2026 Laravel is the de facto PHP full-stack default; Symfony has retreated to being "the skeleton library."
// Route::get('/users', UsersController::class);
// Eloquent: User::where('active', true)->get();
// php artisan migrateWho's Using : WebRunsOnPhp
PHP's user list is a sizeable slice of the internet itself. WordPress (40%+ of sites), Wikipedia (top-10 traffic globally), Drupal (government / enterprise CMS), Magento (e-commerce), Slack's origin, Facebook's origin, Etsy, early Shopify… this isn't "some sites use PHP" — it's "a meaningful portion of the internet was written in PHP".
Web Share & Perf : The Numbers
This section is the hard numbers against the "PHP is dead" narrative: W3Techs server-side language share, plus the PHP 5 → 7 → 8 performance curve. The two curves respectively say "it still dominates" and "it's fast enough now."
"I never imagined that what I wrote that weekend in 1994 would be used by this many people. PHP was an accident — at the start it wasn't even a language, just some C programs. It survived not because it was well-designed, but because it solved the problem people actually had at that moment: making HTML come alive.
W3Techs in 2026: among sites whose server-side language is detectable, PHP holds about 75%. Number two is Node.js around 4%, then ASP.NET / Ruby / Python / Java in low single digits. WordPress alone contributes the bulk — but even subtracting it, PHP remains the de facto server-side leader.
PHP 7 in 2015 delivered around 2× the WordPress req/s of PHP 5.6 on the same benchmark. Dmitry Stogov's phpng branch redesigned Zend Engine's memory model — compact zvals, refcount and GC interlocked. This rewrite overtook HHVM and led Facebook to drop PHP-compatibility from Hack's roadmap.
1995 → 2025: a clean 30 years. Among Perl / Ruby / PHP / Python / JS, PHP is the most-deployed and the only one still cranking out new language versions with conviction. November releases on the RFC clock, 5-year deprecation cycle — a cadence boring enough to be evidence of maturity.
PHP 5 → 7 → 8: the performance rocket
WordPress req/s, relative to PHP 5.6 = 1.0×; reflects Zend Engine's redesign and the introduction of JIT. The arc: Facebook's HHVM pressure → Stogov's phpng → PHP 7 → JIT.
Laravel
In 2011 a 26-year-old Taylor Otwell didn't like CodeIgniter, wrote his own. Fifteen years later, Laravel is PHP's default full-stack framework: Eloquent ORM, Blade templates, Artisan CLI, queues, broadcasting, scheduling, mail, file storage, cache — all batteries included. Same generation as Rails, but still gaining mindshare in 2026.
- Eloquent ORM — ActiveRecord-flavoured, Rails-derived
- Blade — templates + cached compilation
- Artisan — CLI · make / migrate / serve
- Livewire — SPA without React
- Filament — instant admin panels (huge in Laravel 11+)
- Forge / Vapor — official deploy platforms
vs Symfony: Symfony is a "skeleton library" — built for framework authors; Laravel is a product — built for application authors. Drupal 8+ runs Symfony components internally, and Laravel itself reuses a subset. The two coexist, they don't compete.
// routes/web.php
Route::get('/posts/{post}',
[PostController::class, 'show'])->name('posts.show');
// app/Http/Controllers/PostController.php
final class PostController {
public function show(Post $post): View
{
return view('posts.show', [
'post' => $post,
'comments' => $post->comments()->latest()->get(),
]);
}
}
// app/Models/Post.php
class Post extends Model {
public function comments(): HasMany
{
return $this->hasMany(Comment::class);
}
}2026 PHP toolchain / libs / ecosystem
After HHVM: how PHP 7 survived
In 2013 Facebook open-sourced HHVM — 2× faster than PHP 5.6 — and the Hack dialect alongside. The PHP team genuinely panicked internally: if Hack became the new standard, PHP risked being reduced to "HHVM's legacy compatibility layer".
The response was the phpng branch: Dmitry Stogov + Nikita Popov + Anatol Belski rewrote zval, compacted object layouts, interlocked refcount and GC, and revisited every hot path. PHP 7 shipped in 2015 at 2× PHP 5's throughput and pushed back past HHVM.
In 2017 Facebook announced Hack would no longer maintain PHP compatibility — a tacit admission that PHP could carry itself. One of the rare cases in open-source history of a language being forked by a megacorp and then winning the trunk back. Lattner's Swift didn't manage this (ObjC was still displaced).
// PHP 5.6 (2014)
// zval = 56 bytes · refcount per value
// hashmap heavy · GC slow
// phpng redesign → PHP 7 (2015)
// zval = 16 bytes · compact union
// refcount moves to the object
// hashmap rewritten · cache-friendly
// — Dmitry Stogov
// Result: WordPress req/s ≈ 2.0×
// HHVM: leads → falls behind → drops PHP compatIn one line: PHP isn't chasing fashion and doesn't need to. It is the most-deployed backend language on the internet, fast enough, ecosystem self-sufficient, syntax modernised, maintained by a funded foundation. "Dead" for thirty years — the numbers refuse to budge.
vs Python / JS / Ruby : PHP vs the Web peers
Versus JavaScript (/code/javascript): the same-generation web peer — one in the browser, one on the server, coexisting for 30 years. Versus Python (/code/python): same-era scripting language, very different paths — Python went into data and AI, PHP stayed on the web. Versus Ruby: same-era web language, Rails and Laravel are the same idea in different implementations.
| PHP | JavaScript / Node | Ruby (Rails) | |
|---|---|---|---|
| Origin | Lerdorf · 1994 | Eich · 1995 | Matsumoto · 1995 |
| Original goal | Embed in HTML, run as CGI | Browser interactivity | Programmer happiness |
| Runtime model | Shared-nothing · process-per-request | Single process · event loop | Puma / Unicorn · multi-process |
| Deploy friction | Near-zero · FTP a file | Medium · node + pm2 / docker | Medium · ruby + bundler + puma |
| Performance (web backend) | PHP 8 JIT · same band as Node | V8 · same band as PHP | A touch slower · YJIT closing gap |
| Type system | Optional · since PHP 7 · modern in 8.x | None (TS is a different language) | Sorbet · RBS · bolted on |
| Main framework | Laravel · Symfony | Express · NestJS · Next.js | Rails (dominant) |
| Package manager | Composer (2012) · Packagist | npm / pnpm / yarn | Bundler · RubyGems |
| Web share (W3Techs 2026) | ~75% | ~4% (server) · 100% (browser) | ~5% |
| Flagship projects | WordPress · Wikipedia · Drupal | React · server: Vercel / Netlify | GitHub · Shopify · Basecamp |
| Concurrency model | None (but Fibers 8.1+ · amphp / ReactPHP) | Native async / Promise | Fibers · Ractor · Async |
| Community vibe | Practical engineering · low hype | Fast-moving · framework churn | DHH · Rails-unified |
Outlook : TheBoringFuture
PHP's "outlook" doesn't depend on a next big move the way new languages do. It is a language in mature steady-state: a new minor every November, a 5-year lifecycle, JIT slowly deepening, Laravel slowly expanding, Fibers / Roadrunner / FrankenPHP giving "long-running PHP" a respectable path. No drama — and that is its strength.
"Mature, boring, profitable" — PHP's current resting position
PHP in 2026 in one sentence: the language has fully modernised (8.x = match / enum / readonly / property hooks), the ecosystem is self-sufficient (Laravel + Composer), deployment is still the easiest, and market share holds steady around 75%. It no longer chases fashion and is no longer attacked — the critique pieces stopped around 2015 because every specific complaint has been fixed.
For a language, this is the strongest possible position: a steady profit curve that doesn't depend on hype. WordPress, Laravel, and the enormous legacy of enterprise portals deliver continuous payroll; the hiring market always has PHP roles; new releases ship every November via the PHP RFC process. The "PHP is dead" meme will run another thirty years while the W3Techs number refuses to move.
Deeper JIT optimisation
PHP 8.0's JIT helped CPU-bound math markedly, but web workloads (mostly I/O) saw little change. Subsequent releases keep pushing type inference and method inlining; from 8.4 onwards Laravel apps see measurable latency drops. Not going to become V8 — but it will approach LuaJIT's trajectory.
Laravel keeps eating share
By 2026 Laravel powers 80%+ of new PHP full-stack projects (Symfony's remaining role: skeleton library + Drupal's core). Inertia.js and Livewire deliver the SPA experience without writing React; Filament turns admin panels into one command. Laravel isn't just a framework — it's quietly becoming "PHP's combined Rails and Next.js".
Fibers + Roadrunner / FrankenPHP
PHP 8.1's Fibers gave amphp / ReactPHP a real primitive; together with Roadrunner (a Go-built resident PHP server) and FrankenPHP (Caddy with embedded PHP), "long-running PHP" is finally Node-like in usability. Not replacing fpm — but giving WebSocket / SSE / long-poll scenarios a real option.