PHP 8.6.0 Is Out: New Features, Changes and Release Date

PHP 8.6.0 reached general availability on November 19, 2026, adding partial function application, Time\Duration, Io\Poll, clamp(), SortDirection and more.

The official PHP project logo
Image: PHP.

PHP 8.6.0 is officially out. The PHP development team announced the "immediate availability" of PHP 8.6.0 on November 19, 2026, marking the newest major yearly release of the language that still powers the majority of server-side websites. The release ships partial function application, a new Time\Duration class, a stream-monitoring Io\Poll API, a clamp() helper function, a SortDirection enum, and default values for readonly properties, alongside a long list of smaller additions, deprecations and several security fixes.

Here's what changed, what breaks, and what to check before you upgrade a production app.

PHP 8.6.0 release date and availability

According to the official PHP 8.6.0 release announcement, the PHP team released version 8.6.0 on November 19, 2026. The PHP 8 changelog lists the same date for the stable build. PHP 8.6 is a standard annual minor-version release under PHP's existing versioning scheme, following PHP 8.5 and continuing the project's usual two-years-of-active-support, one-year-of-security-only-support lifecycle. Source packages and Windows binaries are available now from php.net, and distro and container maintainers typically follow within days to weeks.

Quick facts
  • Version: PHP 8.6.0 (stable/GA)
  • Release date: November 19, 2026
  • Type: Annual minor version release
  • Headline additions: partial function application, Time\Duration, Io\Poll, clamp(), SortDirection, readonly property defaults
  • Also included: multiple security fixes, several deprecations, and backward-incompatible behavior changes

The headline new features in PHP 8.6

PHP.net's own release notes point to six features as the marquee additions in 8.6. The migration guide's New Features page documents each in detail; the table below summarizes them.

FeatureWhat it does
Partial function applicationLets you create a Closure from an existing function call by replacing one or more arguments with ?, or the remaining arguments with ...
Time\DurationA new class representing a fixed length of elapsed time (nanosecond precision), distinct from the calendar-aware DateInterval
Io\Poll APIA new polling API (Io\Poll\Context, Io\Poll\Watcher, Io\Poll\Backend, Io\Poll\Event, Io\Poll\Handle, StreamPollHandle) for monitoring multiple streams for readiness
clamp()A new built-in function that restricts a number to a given minimum/maximum range
SortDirection enumA new enum for expressing ascending/descending sort order in standard library sorting calls
Readonly property defaultsReadonly properties, including on readonly classes, may now declare a default value; the default counts as the property's one allowed write

Partial function application, explained

The biggest syntax-level change in PHP 8.6 is partial function application. Per the migration guide, "a call in which one or more arguments are replaced by the ? placeholder, or the remaining arguments by the ... placeholder, creates a Closure that accepts the missing arguments." In practice:

function add(int $a, int $b, int $c = 0): int {
    return $a + $b + $c;
}

$addOne = add(1, ?);
var_dump($addOne(5)); // int(6)

$addToOne = add(1, ...);
var_dump($addToOne(2, 3)); // int(6)

$stripSpaces = str_replace(' ', '', ?);
var_dump($stripSpaces('a b c')); // string(3) "abc"

It works on user-defined functions, built-ins, and methods alike, and the Core changelog notes that array_map() is now compiled into a plain foreach() loop when its callback is a partial-application closure, which is a performance optimization specific to that pattern.

Time\Duration and the new Io\Poll API

Time\Duration is aimed at code that needs to represent timeouts or elapsed intervals without calendar ambiguity. As the migration guide puts it, unlike DateInterval it "has no calendar units such as days or months, so its length is unambiguous." It ships factory methods (fromSeconds(), fromMilliseconds(), fromIso8601DurationString()), arithmetic (add(), sub(), multiplyBy(), divideBy()), sign operations (negate(), absolute()) and comparison, and throws a new Time\TimeException for out-of-range or malformed values.

$timeout = \Time\Duration::fromSeconds(2)->add(\Time\Duration::fromMilliseconds(500));
printf("%d.%09d seconds\n", $timeout->seconds, $timeout->nanoseconds);
// 2.500000000 seconds

The new Io\Poll namespace adds a polling API for watching multiple streams at once for I/O readiness, built around Io\Poll\Context and Io\Poll\Watcher classes plus Backend/Event enums and a StreamPollHandle. It's squarely aimed at async and event-loop style PHP code — the kind of workload that frameworks and runtimes built around non-blocking I/O rely on.

Other Core language changes worth knowing

Alongside the headline features, the migration guide's new-features page documents several smaller Core changes that quietly remove long-standing annoyances:

  • Objects in constants can now be mutated. "Objects stored in constants or class constants can now be mutated directly via OBJ->prop = $val," so code like const CONFIG = new stdClass(); CONFIG->debug = true; now works instead of erroring.
  • Reference assignment on WeakMap no longer requires the key to already exist in the map.
  • __debugInfo() on enums is now allowed; previously it caused a fatal error.
  • #[\Override] now applies to class constants and enum cases, raising a compile-time error when no matching constant exists in a parent class or implemented interface.
  • Hard out-of-memory now calls abort() instead of exit(), and the Core changelog also notes a new stateless closure cache and first-class callable cache shared for the duration of a request, plus a new error_include_args INI option for more consistent function arguments in error output.

Streams, sockets and networking updates

Several extensions aimed at network-heavy PHP applications also got attention in this release. OpenSSL streams gain TLS session resumption, external pre-shared key (PSK) support, and TLS 1.3 early data (0-RTT), the last of which surfaces its outcome in stream_get_meta_data() as "accepted", "rejected" or "not_sent". The streams layer adds a batch of new socket context options, including so_reuseaddr, so_keepalive with its tcp_keepidle/tcp_keepintvl/tcp_keepcnt companions, and so_linger, so_rcvbuf and so_sndbuf. Filtered streams can now be cast to file descriptors for use with stream_select(), and cURL adds a CURLOPT_SEEKFUNCTION callback so libcurl can rewind and resend a streamed request body instead of failing outright.

Other notable additions

Beyond the six headline items, PHP 8.6 adds a number of smaller but widely usable changes across the standard library and extensions, per the 8.6.0 changelog:

  • Endianness modifiers (< and >) for pack()/unpack()
  • A new stream errors API (StreamError, StreamException, stream_last_errors(), stream_clear_errors())
  • TLS session resumption, external PSK support, and TLS 1.3 early data (0-RTT) for OpenSSL streams
  • gmp_powm_sec() and gmp_prevprime() in GMP
  • mysqli_quote_string() / mysqli::quote_string()
  • Objects stored in constants or class constants can now be mutated directly via CONST->prop = $val
  • #[\Override] now applies to class constants and enum cases

Backward-incompatible changes to test for

The backward incompatible changes page is the one every team running PHP in production should actually read before upgrading. A few changes are likely to bite real codebases:

ChangeWhy it matters
Form feed (\f) now trimmed by defaulttrim(), ltrim(), rtrim() now strip form-feed characters by default, which can alter output for legacy text processing
array_intersect() string conversion timingValues now convert to strings while scanning inputs rather than during sort comparisons, which can change __toString() call order and warnings
?? / empty() on magic propertiesNo longer call __get() when __isset() has already materialized the property
unpack() format stringsA < or > right after a format code is now read as an endianness modifier, not as the start of the element name
New ValueErrors for invalid argumentsFunctions including array_filter(), pathinfo(), scandir(), number_format(), sleep() and several file functions now throw instead of warning on bad input
DOM readonly propertiesProperties like DOMNode::$nodeType move from readonly to public private(set), changing the exact error raised on external writes
Session default changessession.use_strict_mode and session.cookie_httponly now default to 1, and session.cookie_samesite defaults to "Lax"

Teams that run automated test suites against the ValueError/TypeError-sensitive functions, or that rely on the older session cookie defaults for cross-site POST flows, should run a full regression pass in staging rather than upgrading production directly — the same discipline worth applying any time a core dependency ships a major version, as we noted when PostgreSQL 19 shipped breaking changes of its own.

Security fixes in this release

PHP 8.6.0 also bundles fixes for several vulnerabilities disclosed alongside the release, per the official changelog, including:

  • A session-handling remote code execution issue from partially overwritten session files (CVE-2026-126714)
  • A second session RCE from a session serializer mismatch (CVE-2026-115560)
  • A Phar OpenSSL signature bypass via algorithm downgrade (CVE-2026-128090)
  • A PHP-FPM local privilege escalation via an epoll use-after-free (CVE-2026-129291)
  • A PHP-FPM request-smuggling issue through an unread request body (CVE-2026-129289)
  • A Date extension remote code execution bug from a timezone cache use-after-free (CVE-2026-129496)
  • A SOAP information-disclosure issue through malformed array dimensions (CVE-2026-15353)

None of these are exotic edge cases for a typical web stack — session handling, PHP-FPM, and Phar are all in the default path for most hosted PHP applications. As with any release that patches remote-code-execution bugs, operators should prioritize this update the way security teams are already being told to prioritize other high-severity, actively-tracked flaws, such as the recently CISA-flagged Synology DSM vulnerability.

What's deprecated in PHP 8.6

PHP 8.6 also deprecates a batch of legacy functions and patterns, which won't break anything yet but signal what to stop relying on:

  • is_double(), is_long(), is_integer(), doubleval(), strcoll(), metaphone() and the SORT_LOCALE_STRING constant
  • spl_object_hash() (use spl_object_id()) and spl_classes()
  • return inside finally blocks
  • Returning values from __construct() or __destruct()
  • Using let or is as identifier names, and _ as a constant name
  • Passing a third argument to define()

Should you upgrade now?

For new projects, PHP 8.6 is the obvious baseline going forward. For existing production applications, the usual minor-version advice applies: read the backward-incompatible changes and deprecations pages in full, run your test suite against 8.6 in a staging environment, and pay particular attention to session configuration, any code parsing pack()/unpack() binary formats, and DOM manipulation if you rely on exact exception types. Given that this release also closes several remote-code-execution and privilege-escalation holes, security-conscious teams shouldn't leave the upgrade indefinitely on the backlog — the security fixes alone are a reason to schedule the move even before you've audited every new language feature. PHP applications sitting on managed backends, including those built against services like Supabase's Postgres-backed API, should still confirm their database drivers and ORMs declare 8.6 compatibility before flipping the switch.

What's next for PHP 8.6

PHP 8.6.0 is the first release in its series; expect a steady cadence of 8.6.x point releases over the coming weeks fixing any regressions found in the wild, following the project's usual pattern of near-monthly bugfix and security updates for each actively supported branch. PHP 8.6 will receive active support alongside 8.5 and 8.4 under PHP's standard supported-versions policy, with full details tracked on the project's own release pages. Framework and extension maintainers (Laravel, Symfony, WordPress plugin authors, PECL extension developers) will spend the coming weeks validating compatibility, and distro packagers will start rolling 8.6 builds into their repositories on their own schedules.

For the complete, unabridged list of every change, the PHP 8.6 migration guide remains the canonical reference, alongside the original release announcement itself.

Frequently asked questions

When was PHP 8.6.0 released?

PHP 8.6.0 reached general availability on November 19, 2026, according to the official PHP release announcement and the PHP 8 changelog.

What is partial function application in PHP 8.6?

It is a new syntax that lets you create a Closure from an existing function call by replacing one or more arguments with a ? placeholder, or the remaining arguments with ..., so you can build reusable partially-applied versions of any function or method.

What is the new Time\Duration class for?

Time\Duration represents a fixed length of elapsed time, such as a timeout, with nanosecond precision. Unlike DateInterval, it has no calendar units like days or months, so its length is unambiguous.

Does PHP 8.6 break backward compatibility?

Yes, in several smaller ways. Notable changes include trim() now stripping form feed characters by default, array_intersect() converting values to strings earlier, unpack() reading endianness modifiers differently, and several functions now throwing ValueError instead of warning on bad input. The official migration guide lists the full set.

Does PHP 8.6.0 fix security vulnerabilities?

Yes. The release notes list fixes for multiple CVEs, including two session-handling remote code execution issues, a Phar signature-bypass bug, a PHP-FPM privilege escalation flaw, a PHP-FPM request-smuggling issue, a Date extension use-after-free RCE, and a SOAP information-disclosure bug.

Should I upgrade to PHP 8.6 immediately?

New projects should target 8.6 as their baseline. Existing production applications should first test against the documented backward-incompatible changes and deprecations in staging, though the bundled security fixes are a good reason not to delay the upgrade indefinitely.

Sources

More on PHP →PHPPHP 8.6Web DevelopmentProgramming LanguagesSoftware Release
Felix Moreau
Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Software & Guides

See all