PHP 8.5 Is Here: Smarter, Faster, and Built for the Future

On November 20, 2025, the PHP community officially released PHP 8.5, a major milestone that continues PHP’s evolution into a safer, more expressive, and more modern programming language. PHP 8.5 is not just about incremental improvements; it introduces long-requested language features, new core extensions, and developer-experience enhancements that significantly reduce boilerplate, improve correctness, and boost performance.

Let’s dive into what makes PHP 8.5 a release worth upgrading to.

A Clear Focus: Developer Productivity and Safety

PHP 8.5 continues the trend started in PHP 8.x:

• Less magic, more clarity

• Better defaults

• Stronger tooling for correctness

• Language features that encourage good design

This release focuses on three big themes:

1. Modern syntax and expressiveness

2. Built-in, standards-compliant tooling

3. Improved runtime safety and performance

Built-In URI Extension (Finally!)

One of the standout features of PHP 8.5 is the new URI extension, which provides a first-class, always-available API for parsing and manipulating URIs and URLs.

Why this matters

Historically, PHP developers relied on:

• parse_url() (limited and error-prone)

• Userland libraries for proper URL handling

PHP 8.5 fixes this by shipping a standards-compliant solution out of the box.

What you get

• RFC 3986–compliant URIs

• WHATWG URL support (browser-compatible)

• Safe parsing, normalization, and modification

• Powered by uriparser and Lexbor

use Uri\Rfc3986\Uri;

$uri = new Uri('https://php.net/releases/8.5/en.php');
echo $uri->getHost(); // php.net

This is a huge win for security-sensitive applications and framework authors.

Pipe Operator (|>): Read Code Left-to-Right

The new pipe operator introduces a cleaner way to compose functions without nested calls or temporary variables.

Before PHP 8.5

$slug = strtolower(
    str_replace('.', '',
        str_replace(' ', '-',
            trim($title)
        )
    )
);

With PHP 8.5

$slug = $title
    |> trim(...)
    |> (fn($s) => str_replace(' ', '-', $s))
    |> (fn($s) => str_replace('.', '', $s))
    |> strtolower(...);

Why it’s great

• Improves readability

• Encourages functional composition

• Eliminates deeply nested calls

• Makes data flow explicit

This feature alone will dramatically improve the clarity of everyday PHP code.

Clone With: Immutable Objects Made Easy

PHP 8.5 introduces the ability to modify properties during cloning, enabling a clean and elegant “with-er” pattern, especially for readonly classes.

The problem

Creating immutable objects often required verbose constructors or array unpacking.

The solution

return clone($this, [
    'alpha' => $alpha,
]);

Why it matters

• Encourages immutability

• Cleaner domain models

• Less boilerplate

• Perfect for value objects and DTOs

This feature aligns PHP with modern object-oriented best practices.

#[\NoDiscard]: Catch Bugs Before They Happen

The new #[\NoDiscard] attribute helps prevent subtle bugs caused by ignored return values.

#[\NoDiscard]
function getPhpVersion(): string {
    return 'PHP 8.5';
}

getPhpVersion(); // Warning emitted

Why is this important?

• Improves API correctness

• Prevents accidental misuse

• Encourages intentional code

If a return value truly doesn’t matter, developers can explicitly discard it using (void) — making intent crystal clear.

Closures in Constant Expressions

PHP 8.5 allows static closures and first-class callables in constant expressions, including:

• Attribute arguments

• Default property values

• Constants

This unlocks far more expressive attribute-driven APIs, especially in frameworks and libraries.

#[AccessControl(static function (Request $r, Post $p): bool {
    return $r->user === $p->getAuthor();
})]

This change makes attributes more powerful and reduces the need for awkward expression wrappers.

Persistent cURL Share Handles

PHP 8.5 introduces persistent cURL share handles, allowing DNS and connection data to survive across requests.

$sh = curl_share_init_persistent([
    CURL_LOCK_DATA_DNS,
    CURL_LOCK_DATA_CONNECT,
]);

Benefits

• Faster HTTP requests

• Reduced connection overhead

• Better performance for API-heavy apps

This is especially impactful for long-running SAPIs and high-traffic services.

array_first() and array_last()

A small change with a big impact on code clarity:

$lastEvent = array_last($events);

No more manual key checks or ternary expressions. These functions return null for empty arrays, making them easy to compose with ??.

Additional Improvements Worth Noting

PHP 8.5 also brings a long list of refinements:

• Fatal errors now include stack traces

• Attributes can target constants

• #[\Override] now works on properties

• Static properties support asymmetric visibility

• Properties can be marked final

• New DOM methods for modern HTML manipulation

• New grapheme_levenshtein() function

• Improved error and exception handler access

• Better warnings for unsafe casts and destructuring

Each of these changes improves correctness, debuggability, or performance.

Deprecations and BC Breaks

As expected with a major release, PHP 8.5 cleans up legacy behaviors:

• Backtick operator (`) deprecated

• Non-canonical cast names deprecated

• __sleep() and __wakeup() soft-deprecated

• Using null as an array offset deprecated

• Several syntax edge cases now emit warnings

While most modern codebases will be unaffected, reviewing the migration guide is strongly recommended.

Should You Upgrade?

If you’re on PHP 8.1–8.4, yes — PHP 8.5 is a compelling upgrade:

• Cleaner syntax

• Safer APIs

• Better performance

• Stronger tooling

• A language that keeps moving forward

Frameworks and libraries will quickly adopt these features, and early adopters will benefit the most.

Conclusion

PHP 8.5 is a confident, forward-looking release that proves PHP is not just keeping up, it’s setting its own pace. With features like the pipe operator, built-in URI handling, safer APIs, and modern object patterns, PHP 8.5 empowers developers to write cleaner, faster, and more reliable code. If PHP powers your business or your passion projects, PHP 8.5 is a release worth celebrating and upgrading to.