Modernizing PHP Streams: Faster I/O, Safer Async, and TLS 1.3 Enhancements

Overview

Thanks to the Sovereign Tech Agency (STA), a German‑government‑backed organization supporting open‑source infrastructure, the PHP Foundation is modernising one of PHP’s oldest and most critical subsystems: Streams.

This article outlines the planned work and explains why these changes matter for the PHP ecosystem.

What Are PHP Streams?

PHP streams were introduced around 2001 to provide a unified API for file and network I/O, allowing data from files, sockets, or memory to be accessed with the same set of functions.

Over time the implementation has lagged behind modern use‑cases, performance expectations and system capabilities. The project aims to make streams faster, safer and easier to extend for modern PHP applications.

The work is divided into four sub‑areas.

Performance and Stability Improvements

This part targets faster and more consistent stream copying and seeking.

There is still room for performance gains in stream copying. For example, using Linux asynchronous I/O mechanisms such as io_uring can speed up large‑file copies or network transfers, while also avoiding crashes caused by memory‑mapped files. The goal is to gradually deprecate mmap usage and introduce a new copy API that leverages io_uring or other system facilities when available.

Seeking currently suffers from inconsistencies in filtered streams, limiting developers when rewinding or skipping data. The plan is to add a new seeking‑filter API that permits seeking where possible and forbids it where not, with a new internal API to support filters that can seek to arbitrary positions.

Error Handling and Monitoring Enhancements

This section introduces a new error‑reporting mechanism for streams and additional hooks. Existing low‑level I/O errors are reported inconsistently; the goal is to standardise error reporting and provide richer context for debugging.

Hooks will be useful for asynchronous code and may be exposed to user space if performance permits, allowing replacement of certain blocking operations, especially for file I/O.

Network and Socket Improvements

The work adds a new polling API, improves the stream_select function and fixes various socket handling issues.

Modern network applications rely on scalable event handling. The new polling API will bring mechanisms such as epoll and kqueue to PHP, enabling more efficient handling of multiple I/O streams. Currently only select is available in user space, which has known performance and scalability limits.

The primary purpose of this API is to build an internal foundation that can be used for many core tasks and serve as the basis for future asynchronous I/O APIs.

The use of stream_select will be expanded to better handle filtered streams and to provide an API for external objects that can supply additional data, sharing logic with the new polling API.

Additional socket‑specific improvements include new socket context options for better configurability and utilities for handling file descriptors.

Security and TLS Enhancements

A major focus is the OpenSSL extension that handles encrypted streams. The async handling will be refactored to remove current limitations and clarify the polling operations required in user space.

TLS 1.3 support will be improved with options for cipher‑suite selection, integration of TLS sessions, PSK (pre‑shared keys) and early data (0‑RTT).

A new TLS 1.3 test library for PHP is being built to allow custom protocol flows and to test TLS 1.3 features, including asynchronous behaviour.

Next Steps

These efforts will collectively modernise and harden PHP’s I/O layer to support the next decade of web and CLI development.

Work started in 2025 and will continue through 2026, with incremental progress shared via PHP Foundation updates, internal discussions and RFCs.

We thank the Sovereign Tech Agency for its foundational investment in PHP core.

Pseudocode

Simulated HTTP GET request.

Old Way

// Old way: procedural, complex configuration
$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'header' => "Accept: text/html
"
    ]
]);
$handle = fopen('https://example.com', 'r', false, $context);
$html = stream_get_contents($handle);
fclose($handle);
// Getting metadata is cumbersome
$meta = stream_get_meta_data($handle);
$headers = $meta['wrapper_data'];

New Way

// New way: object‑oriented, clear and intuitive
$factory = new StreamFactory();
$stream = $factory->createHttpRequest('https://example.com', 'GET', ['Accept' => 'text/html']);
// Synchronous read
$html = $stream->read();
// Asynchronous read (inside a Fiber)
$fiber = new Fiber(function () use ($stream) {
    $html = $stream->readAsync(); // non‑blocking
    echo "Received " . strlen($html) . " bytes.
";
});
$fiber->start();
// Getting metadata is very simple
$headers = $stream->getMetadata()->getHeaders();