The PHP Foundation: How It's Shaping the Future of PHP

Open-source languages have a sustainability problem. For years, PHP’s continued evolution depended almost entirely on volunteers — developers who maintained the core engine in their spare time around demanding day jobs. When Nikita Popov, one of the most prolific PHP core contributors, stepped back from PHP development in 2021, the community realized it had been relying on a model that didn’t scale.

The PHP Foundation was the answer. Founded in November 2021 as a non-profit under the Open Source Collective umbrella, it was established with a single clear mission: to ensure the long-term sustainability of the PHP language by funding professional PHP core developers. Understanding what the Foundation does — and what it’s accomplished — matters for every developer who builds on PHP for a living.

The Problem It Solves

Before the Foundation, PHP’s development looked like this: a handful of passionate volunteers built and maintained one of the web’s most widely deployed runtime environments. Engine improvements, security patches, new language features, and the ongoing work of keeping PHP competitive with other modern languages all flowed through people doing this work on evenings and weekends.

This produced remarkable results — PHP 8.0’s JIT compiler, named arguments, match expressions, fibers in PHP 8.1, readonly properties, enum types — but it was fragile. Volunteer burnout is real. When key contributors have to choose between personal obligations and unpaid open-source work, the language loses. Companies that derive enormous value from PHP had no structured way to give back to its development.

The Foundation created that structure.

How It Works

The PHP Foundation raises money from corporate sponsors and individual contributors, then uses those funds to pay PHP core developers. This isn’t grant funding with strings attached — it’s straightforward employment for developers to work on PHP full-time.

The Foundation operates with radical transparency. Its annual reports detail exactly which developers were funded, how many hours were worked, and what they accomplished. There’s no mystery about where the money goes.

As of 2024, the Foundation had funded multiple developers working on PHP core. The sponsorship model attracts both large tech companies and smaller PHP-focused businesses, with tiered contribution levels. Past and current sponsors include JetBrains, Automattic, Laravel, Private Packagist, Symfony, Craft CMS, Tideways, and others — essentially a coalition of companies that depend on PHP’s continued health.

What Foundation-Funded Developers Actually Work On

Looking at the PHP Foundation’s public reports gives a clear picture of what professional core development produces:

Performance improvements: JIT compiler refinements, opcode optimizations, and memory allocation improvements that benefit every PHP application. PHP 8.x’s performance gains have been substantial — PHP 8 code runs significantly faster than equivalent PHP 7 code in most benchmarks.

New language features: Many of the features in PHP 8.2, 8.3, and 8.4 were implemented or driven by Foundation-funded developers. Fibers (async primitives), readonly classes, intersection types, disjunctive normal form types, new array functions — these features came from real developer hours.

Bug fixes and security patches: The unglamorous but critical work of triaging bug reports, writing regression tests, and shipping security fixes. This work has no end date and requires consistent, sustained attention.

PHP internals tooling: Improvements to the build system, documentation tooling, CI/CD pipelines, and the infrastructure that supports PHP’s development process.

RFC process participation: Core developers review, debate, and vote on PHP RFCs (Requests for Comments), the process by which new features enter the language. Having funded developers who can invest real time in RFC review improves the quality and consistency of language decisions.

PHP 8.4 and What’s Ahead

PHP 8.4, released in November 2024, was the first major release where Foundation-funded developers made substantial contributions. Some highlights from that release:

Property hooks — one of the most significant PHP features in years, allowing get/set logic to be defined directly in class property declarations:

class User
{
    public string $fullName {
        get => "{$this->firstName} {$this->lastName}";
    }

    private string $_email = '';
    public string $email {
        get => $this->_email;
        set {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new \ValueError("Invalid email: {$value}");
            }
            $this->_email = strtolower($value);
        }
    }
}

$user = new User('Eric', 'Smith');
echo $user->fullName; // Eric Smith (no method call needed)
$user->email = '[email protected]'; // validated and normalized automatically

Asymmetric visibility — allowing different access levels for reading vs. writing a property:

class Order
{
    public private(set) string $status = 'pending';

    public function approve(): void
    {
        $this->status = 'approved'; // Works: we're inside the class
    }
}

$order = new Order();
echo $order->status;      // Works: reading is public
$order->status = 'done'; // Fatal error: writing is private

array_find() and array_find_key() — filling a long-standing gap in PHP’s array functions:

$users = [
    ['id' => 1, 'role' => 'admin'],
    ['id' => 2, 'role' => 'editor'],
    ['id' => 3, 'role' => 'admin'],
];

$admin = array_find($users, fn($u) => $u['role'] === 'admin');
// ['id' => 1, 'role' => 'admin']

$key = array_find_key($users, fn($u) => $u['id'] === 2);
// 1

Why This Matters for Working PHP Developers

If you earn your living writing PHP, the Foundation’s work directly affects your career. A well-maintained, continuously improving PHP means your skills stay relevant. Modern PHP features — property hooks, fibers, match expressions, first-class callables — mean you can write cleaner, safer code without reaching for other languages.

The alternative — a PHP that stagnates because maintainers burn out — is a language that starts losing ground to ecosystems that do invest in developer relations and sustainable maintenance. The PHP Foundation is the mechanism that prevents that outcome.

How to Support It

Individual developers can support the Foundation through Open Collective. Even a small monthly contribution from a significant portion of the PHP developer community would meaningfully expand what the Foundation can fund.

For companies, the sponsorship model is a straightforward way to give back proportionally to the value you extract from PHP. A company running PHP in production at scale, with teams of PHP developers, is deriving enormous economic value from the work the Foundation funds. Sponsorship is a reasonable and direct way to acknowledge that.

If financial contribution isn’t viable, the Foundation’s work is also advanced by community participation: contributing to RFCs on the internals mailing list, reporting bugs with reproducible test cases, and improving documentation all support the ecosystem.

The Bigger Picture

The PHP Foundation’s existence is a sign of a maturing ecosystem. Languages that want to remain relevant into the 2030s and beyond can’t rely on volunteer heroics. Rust has the Rust Foundation. Python has the PSF. JavaScript has the OpenJS Foundation. PHP now has its own organization doing this work.

For the PHP developer community, the right response is to treat the Foundation not as a curiosity but as infrastructure — the kind of unglamorous, essential work that makes everything else possible. The features you use today in your Laravel or Symfony applications exist in PHP’s core because someone professional was paid to design, implement, and maintain them.

That’s worth understanding, and worth supporting.

Sources:

The PHP Foundation — Official Site
PHP Foundation Annual Report 2024 — PHP Foundation Blog
PHP 8.4 Migration Guide — PHP.net
PHP Foundation on Open Collective — Open Collective