PHP 8.5 released on November 20, 2025. It stays in active support until the end of 2027, with security fixes through 2029. It is not a headline release like 8.0's union types or 8.1's enums, but several additions remove real friction from day-to-day backend code, especially if you write Laravel or Symfony.

The pipe operator: |>

The pipe operator chains callables left to right without intermediary variables or nested calls. It reads like a data pipeline instead of a stack of parentheses, and it composes with the first-class callable syntax (trim(...)). The left side is any expression; the right side is anything callable with one argument.

// Before: nested calls, read from the inside out
$result = strtoupper(trim(str_replace('_', ' ', $rawInput)));

// PHP 8.5: pipe operator, read left to right
$result = $rawInput
    |> fn ($s) => str_replace('_', ' ', $s)
    |> trim(...)
    |> strtoupper(...);

Native URI parsing

PHP now ships a built-in URI extension, so you stop reaching for parse_url() and hand-rolling normalization. It offers two parsers: Uri\Rfc3986\Uri for strict RFC 3986, and Uri\WhatWg\Url for the browser-compatible WHATWG rules. Using a real parser instead of string work also closes a class of security bugs around host and scheme confusion in redirect and SSRF checks.

use Uri\Rfc3986\Uri;

$uri = Uri::parse('https://api.example.com/v1/users?page=2');

echo $uri->getHost();  // api.example.com
echo $uri->getPath();  // /v1/users
$uri->getQuery()->get('page'); // "2"

clone() with property modification

Readonly classes and value objects used to need a hand-written "with" method for every immutable update: withStatus(), withEmail(), and so on. The new clone() syntax clones an object and overrides specific properties in one expression, so a chain of updates stays readable without the boilerplate.

final readonly class Money
{
    public function __construct(
        public int $amount,
        public string $currency,
    ) {}
}

$price = new Money(1000, 'EUR');

// Before: a hand-written withAmount() method on every value object
// PHP 8.5:
$discounted = clone($price, ['amount' => 800]);

The #[\NoDiscard] attribute

Marking a method with #[\NoDiscard] makes PHP warn when its return value is ignored. It catches a common bug: calling a method that returns a new instance, as immutable value objects do, without using the result and assuming it mutated in place.

final readonly class Money
{
    #[\NoDiscard]
    public function add(Money $other): self
    {
        return new self($this->amount + $other->amount, $this->currency);
    }
}

$price->add($fee);          // warning: return value discarded
$price = $price->add($fee); // correct usage

Smaller wins

• ✓array_first() and array_last() return the first and last element without reset() or end() and their pointer side effects.
• ✓Fatal errors now include a full backtrace, so a crash in a production log tells you the call chain instead of just the final line.
• ✓get_error_handler() and get_exception_handler() let you inspect the currently registered handlers, useful in tests and framework code.
• ✓Closures are allowed in constant expressions, so you can define a default callable on a property or a constant.
• ✓Attributes can be applied to constants, which frameworks use for metadata on enum-like constant sets.

What to adopt now

Upgrading

PHP 8.5 has no breaking changes for typical application code, so the upgrade is low risk. Run your test suite, check the deprecations list for anything your dependencies still use, and update your CI matrix. Laravel and Symfony both support it, so the framework side is a version bump.

PHP keeps proving that a mature language can improve ergonomics release after release without breaking backward compatibility. None of these features force a rewrite; they are tools you reach for the next time you touch the code.