PHP 8.5: New Features, Deprecations, and Everything You Need to Know

The PHP community is gearing up for the release of PHP 8.5, scheduled for November 20, 2025, a version that continues to push the language forward with more innovative tools, cleaner syntax, and a focus on developer efficiency.

Building upon the solid foundation of PHP 8.x, this latest update emphasizes performance improvements, enhanced debugging capabilities, and better configuration control. From introducing new features like the IntlListFormatter class and the max_memory_limit directive to refining the CLI and deprecating legacy code, PHP 8.5 reflects a strong commitment to modernization and long-term stability.

For developers, PHP 8.5 means writing more expressive, reliable, and efficient code with less hassle. For businesses, it ensures smoother upgrades, improved performance, and a more secure environment to power modern web applications.

PHP 8.5 is currently in its Release Candidate (RC) phase, with the final stable release planned for November 20, 2025. This marks another significant milestone in the ongoing evolution of the PHP 8.x series, which has consistently focused on improving performance, developer productivity, and code maintainability.

Version Status

Latest release: PHP 8.5.0 RC3
Final release date: November 20, 2025
Status: Upcoming stable release

Compatibility and Upgrade Notes

Upgrading to PHP 8.5 is expected to be relatively smooth for projects already running on PHP 8.2 – 8.4, as it maintains backward compatibility with most features. However, developers should be aware of the new deprecations introduced in this version, such as:

• Deprecated MHASH_* constants
• Non-canonical scalar type casts like (integer) or (double)
• Returning non-string or emitting output from user output handlers

To ensure a seamless transition, it's recommended to test existing applications in a staging environment using PHP 8.5 RC builds and resolve any deprecation warnings early.

How PHP 8.5 Fits into the PHP 8.x Roadmap

PHP 8.5 continues the modernization journey started with PHP 8.0’s JIT compiler and PHP 8.1’s enums and fibers. It focuses more on refinement and stability rather than revolutionary changes. The goal is to make PHP cleaner, more consistent, and future-proof — setting the stage for PHP 9.0, which is expected to remove many deprecated features and introduce stricter typing rules.

The latest PHP 8.5 update brings a fresh wave of innovation and performance improvements to the world of web development. Designed to make coding faster, cleaner, and more efficient, PHP 8.5 introduces several exciting features such as the new pipe operator, enhanced error handling, and improved array functions. These updates not only simplify development but also boost application performance and maintainability. In this article, we’ll explore the top new features in PHP 8.5 that every developer should know to stay ahead in 2025.

One of the most anticipated additions in PHP 8.5 is the pipe operator (|>), a new syntax that simplifies writing chained function calls and data transformations.

This operator allows developers to write cleaner, more readable, and functional-style code by passing the result of one expression directly into the following function without needing nested parentheses.

What Is the Pipe Operator?

The pipe operator (|>) takes the result of the expression on its left-hand side and passes it as the first argument to the function or expression on its right-hand side.

It's inspired by functional programming languages such as Elixir, Hack, and JavaScript (in the proposal stage) and aims to make PHP code more fluent and expressive.

Before vs After Example

Without Pipe Operator (PHP ≤ 8.4)

$result = strtoupper(trim(htmlspecialchars($input)));

With Pipe Operator (PHP 8.5+)

$result = $input
    |> htmlspecialchars
    |> trim
    |> strtoupper;

In the second example, each transformation is applied in sequence, improving readability and maintainability.

How It Works

The pipe operator supports:

• Function calls (|> trim)
• Static methods (|> MyClass::process)
• Object methods (|> $obj->handle)
• Anonymous functions or closures

Example:

$result = $data
    |> array_map(fn($x) => $x * 2, $$)
    |> array_filter(fn($x) => $x > 10, $$);

Why It Matters

The |> operator makes code cleaner, more linear, and easier to maintain, especially for complex data transformations, stream processing, or functional pipelines. This small but mighty addition enhances developer productivity and code clarity, continuing PHP's evolution toward modern, expressive syntax.

The IntlListFormatter is one of the key new additions in PHP 8.5's Intl extension, providing developers with a convenient way to format lists in a locale-aware manner. This means lists like "A, B, and C" can automatically adapt to the grammar and punctuation rules of the target language or region.

What Is IntlListFormatter?

The IntlListFormatter class leverages the ICU (International Components for Unicode) library to create human-readable lists that respect the linguistic and cultural norms of different locales.

It supports three main types of list formatting:

• And-lists (e.g., "A, B, and C")
• Or-lists (e.g., "A, B, or C")
• Unit-lists (e.g., "4 hours, 30 minutes")

This is particularly useful for multilingual applications, international e-commerce platforms, or localized reporting systems where user interfaces need to respect users' language preferences.

Example Usage

English (en-US)

$formatter = new IntlListFormatter('en-US');
echo $formatter->format(['Zurich', 'Berlin', 'Amsterdam']);
// Output: Zurich, Berlin, and Amsterdam

Dutch (nl-NL)

$formatter = new IntlListFormatter('nl-NL');
echo $formatter->format(['Zurich', 'Berlin', 'Amsterdam']);
// Output: Zurich, Berlin en Amsterdam

Japanese (ja-JP)

$formatter = new IntlListFormatter('ja-JP');
echo $formatter->format(['水', '火', '木']);
// Output: 水、火、木

As shown above, PHP automatically formats the list according to the grammar rules of the specified locale — no manual string manipulation required.

Configuration Options

The IntlListFormatter class provides options for both type and width, giving developers control over how the list is displayed:

Type Options

• TYPE_AND – For "and"-style lists.
• TYPE_OR – For "or"-style lists.
• TYPE_UNITS – For unit-style lists (e.g., measurements or time).

Width Options

• WIDTH_WIDE – Standard, full-length formatting (default).
• WIDTH_SHORT – Shorter forms using symbols or abbreviations (e.g., "A, B & C").
• WIDTH_NARROW – Compact form that removes connectors when possible.

Why It Matters

Before PHP 8.5, developers had to manually implement locale-based list formatting logic, which was time-consuming and error-prone. With the introduction of IntlListFormatter, PHP now offers native, standardized, and consistent internationalization support that aligns with global standards such as ICU and CLDR.

This feature significantly enhances PHP's capabilities for globalized web applications, improving both developer efficiency and user experience across multiple languages.

PHP 8.5 introduces a new max_memory_limit INI directive that provides finer control over memory usage in PHP scripts. While memory_limit has long been used to limit the memory a single PHP process can consume, the new max_memory_limit setting acts as a ceiling, defining the maximum value memory_limit can be set to.

This addition helps system administrators and hosting providers enforce a global upper limit on memory usage, even if developers attempt to increase the memory_limit from within scripts.

How It Works

• memory_limit: Controls how much memory a PHP request can use.
• max_memory_limit: Defines the highest possible value that memory_limit can be set to.

If max_memory_limit is set, any attempt to raise the memory_limit beyond that value will automatically fail and generate a PHP warning. By default, max_memory_limit is set to -1, meaning no ceiling is enforced.

Example Configuration

; php.ini
max_memory_limit = 256M
memory_limit = 128M

In the example above:

• The maximum allowed memory usage (max_memory_limit) is 256 MB.
• The current memory limit for scripts is 128 MB.
• You can still lower the memory_limit at runtime, but cannot exceed the ceiling.

Runtime Behavior

echo ini_get('max_memory_limit');  // 256M
echo ini_get('memory_limit');      // 128M

ini_set('memory_limit', '156M');   // Allowed
ini_set('memory_limit', '300M');   // Not allowed

If you attempt to exceed the defined ceiling, PHP automatically resets the memory_limit to the maximum and issues a warning:

Warning: Failed to set memory_limit to 300M.
Setting to max_memory_limit instead (currently: 256M) ...

Setting memory_limit = -1 (unlimited memory) will also be blocked if max_memory_limit is set to a finite value.

Why It Matters

This directive improves server stability and security by preventing runaway scripts or misconfigured applications from consuming excessive memory. It's beneficial in:

• Shared hosting environments where multiple applications run on the same server.
• Enterprise systems where administrators want strict memory control.
• Production servers to avoid unexpected out-of-memory crashes.

Backward Compatibility

max_memory_limit is new in PHP 8.5 and is disabled by default (-1). Older PHP versions simply ignore this directive without any warnings, ensuring smooth backward compatibility.

In previous versions of PHP, when a fatal error occurred such as running out of memory or encountering another unrecoverable condition PHP simply displayed the error message and stopped execution. While this message included the file name and line number, developers often struggled to identify how the error occurred because no stack trace was provided.

With PHP 8.5, this changes dramatically. Fatal errors now include a full stack trace, offering valuable insight into the exact sequence of function calls that led to the error. This improvement brings fatal error reporting closer to modern exception handling, significantly simplifying debugging.

Before PHP 8.5

ini_set('memory_limit', '2M');

function myFunction() {
    $data = str_repeat('A', 1024 * 1024 * 5);
}

myFunction();

Output (PHP ≤ 8.4):

Fatal error: Allowed memory size of 2097152 bytes exhausted (tried to allocate 5242880 bytes)
in /var/www/test.php on line 5

In older versions, you only received the file and line number — no information about the call stack or execution path.

In PHP 8.5

The same code now produces a much more detailed error message:

Fatal error: Allowed memory size of 2097152 bytes exhausted (tried to allocate 5242880 bytes)
in /var/www/test.php on line 5
Stack trace:
#0 /var/www/test.php(5): str_repeat('A', 5242880)
#1 /var/www/test.php(8): myFunction()
#2 {main}

Now you can see the entire function call chain, helping pinpoint the root cause of the problem instantly.

Configuration Control

A new INI directive, fatal_error_backtraces, controls this feature. It is enabled by default but can be turned off if needed.

; php.ini
fatal_error_backtraces = Off

Turning it off reverts to the old behavior without stack traces.

Compatibility with Other Error Settings

• Works seamlessly with display_errors: if error display is disabled, the backtrace won’t be shown on screen.
• Respects Zend.exception_ignore_args: when enabled, argument values won't appear in the stack trace.
• Parameters marked with #[\SensitiveParameter] remain hidden to protect sensitive data.

Why It Matters

This feature makes fatal errors much easier to diagnose and far more developer-friendly. Instead of guessing where an error originated, developers can now:

• Trace the full call stack leading to the crash.
• Debug complex applications more efficiently.
• Identify performance bottlenecks or logic errors faster.

In short, PHP 8.5 bridges the gap between recoverable exceptions and fatal errors, making error visibility more transparent and debugging more efficient than ever before.

PHP 8.5 introduces several new helper functions to simplify everyday coding tasks, improve readability, and provide better control over localization and error handling. Let's take a look at each of them.

1. array_first() and array_last()

Working with arrays in PHP often requires manually fetching the first or last element using functions like reset() or end(). These approaches can be verbose or modify the array's internal pointer, leading to unexpected behavior.

PHP 8.5 simplifies this with two new functions:

$array = ['apple', 'banana', 'cherry'];

echo array_first($array); // apple
echo array_last($array);  // cherry

Both functions are non-destructive — they do not change the internal pointer of the array and work consistently with both numeric and associative arrays.

$fruits = ['a' => 'apple', 'b' => 'banana'];
echo array_first($fruits); // apple
echo array_last($fruits);  // banana

These are particularly useful for functional or data-driven code that chains or applies array operations dynamically.

2. locale_is_right_to_left()

For developers building multilingual applications, text direction is an important consideration. PHP 8.5 adds a new function, locale_is_right_to_left(), along with its object-oriented counterpart Locale::isRightToLeft().

This function determines whether a given locale uses a right-to-left (RTL) writing direction, which is helpful for dynamically adjusting layouts, aligning text, or applying styles.

var_dump(locale_is_right_to_left('en_US')); // bool(false)
var_dump(locale_is_right_to_left('ar_EG')); // bool(true)

It enhances PHP's internationalization (Intl) capabilities, especially in applications that support both LTR and RTL languages.

3. get_exception_handler() and get_error_handler()

PHP has long provided set_exception_handler() and set_error_handler() to customize how exceptions and errors are handled. However, there was no built-in way to retrieve the currently active handlers — until now.

PHP 8.5 introduces get_exception_handler() and get_error_handler(), giving developers visibility and control over their current error/exception handling setup.

set_error_handler('customErrorHandler');
set_exception_handler('customExceptionHandler');

var_dump(get_error_handler());      // string(19) "customErrorHandler"
var_dump(get_exception_handler());  // string(23) "customExceptionHandler"

These functions are handy for frameworks, libraries, and debugging tools that need to inspect or temporarily override global handlers safely.

Why These Matter

Together, these helper functions make PHP 8.5 code cleaner, more intuitive, and more powerful:

• Simpler array handling with array_first() and array_last().
• Smarter localization with locale_is_right_to_left().
• Improved debugging and flexibility with get_error_handler() and get_exception_handler().

They may seem small individually, but collectively, they enhance developer productivity and make modern PHP code more expressive.

Managing and debugging PHP configurations across environments (like local, staging, and production) has always been a challenge — especially when multiple php.ini files or additional .ini files are involved.

PHP 8.5 introduces a new and developer-friendly CLI improvement: the php --ini=diff command.

This enhancement allows developers to compare configuration differences directly from the command line — making it much easier to identify what changed between two PHP setups.

What It Does

The php --ini=diff option compares the active configuration files against another configuration snapshot or environment and shows the differences in INI settings.

This is particularly useful when:

• Migrating between PHP versions.
• Debugging inconsistent behavior across servers.
• Ensuring local and production environments are aligned.

Example Usage

Suppose you have two different PHP configurations — one from your local machine and one from a staging server. You can quickly generate a diff like this:

php --ini=diff /path/to/local/php.ini /path/to/staging/php.ini

The output will show only the lines that differ between the two configurations:

< memory_limit = 128M
> memory_limit = 256M
< display_errors = On
> display_errors = Off

This makes it fast and straightforward to pinpoint precisely what has changed — without manually combing through hundreds of lines in multiple configuration files.

Why It Matters

Before PHP 8.5, developers typically had to use external tools (like diff, vimdiff, or custom scripts) to compare configuration files. Now, this functionality is built directly into the PHP CLI, ensuring consistency and improving productivity.

Key benefits include:

• Faster debugging of environment-related issues.
• Easier configuration audits and version upgrades.
• Reduced dependency on external tools.

The addition of php --ini=diff in PHP 8.5 is a small but powerful quality-of-life improvement for system administrators and developers alike. It strengthens PHP's CLI ecosystem and simplifies one of the most common operational pain points: safely and efficiently comparing PHP configuration files.

PHP 8.5 enhances the cURL extension with a brand-new function: curl_multi_get_handles(). This addition improves visibility and management when working with multiple concurrent cURL handles — a feature often used in high-performance or asynchronous HTTP request scenarios.

What It Does

The curl_multi_get_handles() function allows developers to retrieve all cURL handles currently attached to a multi cURL handle. Previously, once you added several handles to a multi-handle (using curl_multi_add_handle()), there was no straightforward way to retrieve the list of all added handles, making debugging and request management cumbersome.

With PHP 8.5, this new function provides direct access to all those handles, enabling developers to:

• Inspect, manage, or remove specific requests.
• Debug multi-handle sessions more effectively.
• Monitor concurrent HTTP operations.

Example Usage

Here's how the new function can be used:

$mh = curl_multi_init();

$ch1 = curl_init('https://example.com/api/user');
$ch2 = curl_init('https://example.com/api/orders');

curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);

// Retrieve all handles added to the multi-handle
$handles = curl_multi_get_handles($mh);

foreach ($handles as $handle) {
    var_dump(curl_getinfo($handle, CURLINFO_EFFECTIVE_URL));
}

curl_multi_close($mh);

Output:

string(31) "https://example.com/api/user"
string(33) "https://example.com/api/orders"

This example demonstrates how developers can now easily inspect or manage each cURL handle in a multi-handle context.

Why It Matters

When working with parallel HTTP requests — such as fetching data from multiple APIs simultaneously — developers often use cURL multi handles to improve performance. Until PHP 8.5, it wasn't easy to query or debug which handles were part of the multi-session once they were added.

With curl_multi_get_handles(), PHP provides a cleaner and more transparent way to handle concurrent network operations.

The introduction of curl_multi_get_handles() in PHP 8.5 makes it much easier to inspect, monitor, and debug multiple cURL requests. This enhancement is especially beneficial for developers building scalable, API-driven applications that rely on parallel network operations.

Every major PHP release refines the language by removing outdated or inconsistent features. PHP 8.5 introduces several deprecations aimed at improving consistency, security, and developer experience. Developers should review these changes carefully to ensure smooth upgrades and future-proof their applications.

The legacy MHASH extension and its constants (such as MHASH_SHA1, MHASH_MD5, etc.) have been fully deprecated in PHP 8.5. These constants were remnants of older PHP versions and are now replaced by the more powerful hash() and hash_hmac() functions.

Example

// Deprecated
$hash = mhash(MHASH_SHA1, 'test');

// Recommended
$hash = hash('sha1', 'test', true);

Developers using mhash() functions should migrate to the modern hash APIs, which offer better performance, support more algorithms, and are actively maintained.

PHP 8.5 deprecates non-canonical type casts, which are legacy synonyms for standard scalar types. These alternate casts are now deprecated to improve consistency between type declarations and casting.

Deprecated vs Replacement

Example

// Deprecated
$val = (integer) $num;

// Correct
$val = (int) $num;

In PHP 9.0 and later, using the old forms will trigger errors rather than warnings.

Output buffering in PHP allows custom processing of output through ob_start() with a callback. Previously, these callbacks could return any type, which PHP silently coerced into a string. In PHP 8.5, returning anything other than a string now triggers a deprecation warning.

Example

// Deprecated
ob_start(function ($buffer) {
    return []; // Non-string return
});

// Correct
ob_start(function ($buffer) {
    return strtoupper($buffer);
});

To avoid deprecations, ensure your output buffer handlers always return a string or an empty string.

In addition to the change above, PHP 8.5 now warns when output (e.g., via echo or print) is produced inside a user-defined output buffer handler. This behavior was previously ignored but is now officially deprecated.

Example

// Deprecated
ob_start(function ($buffer) {
    echo "Debug info"; // Produces output - not allowed
    return $buffer;
});

Handlers should modify the buffer content directly rather than producing their own output.

Summary

These deprecations continue PHP’s move toward a cleaner, stricter, and more predictable language paving the way for PHP 9.0.

With PHP 8.5, the core team continues to refine the language while maintaining backward compatibility wherever possible. However, several deprecations and subtle behavioral changes introduced in this release may impact existing applications — especially those relying on older or less strict PHP practices.

Key Points to Consider

Deprecated Features Still Work — For Now

All deprecated features (such as MHASH_* constants, non-canonical casts, and lenient output buffer behaviors) still function in PHP 8.5, but they will trigger deprecation warnings during execution. These warnings serve as early indicators that the code will break in PHP 9.0, where deprecated behaviors will be removed entirely or converted into fatal errors.

Memory Limit Ceiling (max_memory_limit) May Affect Runtime Configuration

Applications or frameworks that dynamically modify memory_limit using ini_set() may encounter new restrictions if a system-level max_memory_limit is enforced. Review your hosting or server configuration to ensure compatibility.

Output Buffer Handlers Need Refactoring

Custom output buffer handlers that emit non-string values or print directly to output should be refactored. While the current behavior only triggers warnings, future versions will throw exceptions or errors.

CLI and Configuration Differences

The new php --ini=diff feature helps identify environment inconsistencies between development and production setups — use it to prevent configuration-related bugs after upgrading.

Recommended Actions for Developers

Run Tests in a Staging Environment

Before upgrading production servers, test your applications in a PHP 8.5 staging environment. This will help identify deprecation warnings and compatibility issues early.

Enable Error Reporting During Testing

Use the following configuration to catch deprecation notices during development:

error_reporting(E_ALL);
ini_set('display_errors', '1');

Review All Deprecated Features

Update your code to remove deprecated function calls, constants, and type casts. Replace them with their modern equivalents as outlined in previous sections.

Prepare for PHP 9.0

PHP 8.5 is the final step before PHP 9.0, which will permanently remove all deprecated features. Updating now ensures a smoother migration and prevents costly refactors later.

PHP 8.5 provides powerful new features while enforcing cleaner coding practices. By proactively adapting your codebase and testing against deprecation warnings, you can ensure your applications remain stable, secure, and forward-compatible as the language evolves toward PHP 9.0.

Upgrading to PHP 8.5 isn't just about staying current; it's about improving performance, security, and developer productivity. This release builds on the solid foundation of PHP 8.x, bringing refinements that make modern PHP development faster, safer, and more consistent.

1. Enhanced Security and Stability

Every new PHP version includes essential security patches and engine-level improvements. PHP 8.5 introduces safeguards such as the max_memory_limit directive, which prevents uncontrolled memory usage, and stricter output buffering rules — both designed to make your applications more robust and predictable. By upgrading, you also ensure compatibility with the latest libraries, frameworks, and hosting environments, all of which will gradually drop support for older PHP versions.

2. Better Performance and Efficiency

PHP 8.5 continues to optimize the Zend Engine, improving execution speed and memory handling. Even minor core updates deliver noticeable performance gains, especially in large or framework-heavy applications such as Laravel, Symfony, or WordPress.

Features like stack trace support for fatal errors and CLI enhancements make debugging faster and troubleshooting smoother, saving both developer time and server resources.

3. Cleaner, More Predictable Code

With deprecations such as non-canonical type casts and legacy constants, PHP 8.5 encourages developers to use consistent, modern syntax. This reduces confusion and improves long-term code maintainability.

The addition of helper functions like array_first() and array_last() simplifies everyday coding tasks, while the new IntlListFormatter provides native locale-aware text formatting, making internationalization easier than ever.

4. Improved Developer Experience

From the pipe operator to enhanced error reporting and new CLI tools (php --ini=diff), PHP 8.5 introduces features that make the developer workflow smoother. You'll spend less time debugging configuration issues and more time focusing on building clean, performant code.

Upgrading to PHP 8.5 is straightforward for most modern applications, but preparation is key to ensuring a smooth, trouble-free transition. Before you roll out the update in production, take these essential steps:

1. Check PHP Version Requirements and Extensions

Before upgrading, confirm that your application stack supports PHP 8.5.

• Review your framework's compatibility (e.g., Laravel, Symfony, WordPress, or Drupal).
• Verify that all installed extensions and custom modules are compatible with PHP 8.5.
• If you compile PHP manually, ensure your build includes the correct flags and dependencies (e.g., ICU 57.1+ for Intl features).

You can check your current PHP environment using:

php -v
php -m

2. Test Code for Deprecated Features

PHP 8.5 introduces several deprecations — such as non-canonical scalar casts, MHASH_* constants, and stricter output buffering behavior. Run your application in a staging or development environment with error reporting enabled to identify and fix deprecated usage:

error_reporting(E_ALL);

Replace deprecated syntax and functions before moving to production. You can also use tools like PHPStan or Psalm to detect outdated patterns in your codebase.

3. Update Composer Dependencies

Run the following commands to update your dependencies and ensure your packages are compatible with PHP 8.5:

composer update
composer check-platform-reqs

Many libraries and frameworks specify a PHP version constraint in their composer.json. Adjust it if necessary:

"require": {
  "php": "^8.5"
}

This ensures your project is ready for the new version and avoids installation conflicts.

4. Review and Update CI/CD Pipelines

If you're using continuous integration (CI) or automated deployment pipelines, update your environment to use PHP 8.5 in test and build stages.

For example, in GitHub Actions or GitLab CI, update your workflow configuration:

php-version: '8.5'

Running tests and builds in PHP 8.5 before deployment helps detect compatibility issues early.

5. Test Thoroughly Before Production

Finally, test your application from start to finish. Focus on APIs, background jobs, and performance benchmarks. Use tools such as PHPUnit, Pest, or Codeception to verify stability.

PHP 8.5 is a big leap in its evolution. It aims to boost developer productivity, introduce modern features, and ensure safer, cleaner code. This release enhances both performance and developer experience. It introduces the Pipe Operator (|>) and new array helper functions, along with improved fatal error stack traces and CLI enhancements.

Deprecations like non-canonical type casts and unsafe output handling are paving the way for a more consistent and predictable PHP 9.0 ecosystem. With these updates, PHP Web Development continues to evolve into a modern, efficient, and developer-friendly language while maintaining backward compatibility for most existing applications.

Now is the time to prepare. Test your applications on PHP 8.5, check for deprecations, and start using the new features. These improvements simplify your codebase and make debugging faster and more intuitive.