Under discussion; not accepted. The RFC page (version 0.1, dated 2026-10-25, author Ayoub Ezzini; edited
2026-10-26 at 14:35 UTC and 2026-10-27 at 10:31 and 16:22 UTC without a version change) lists its status as Under Discussion and proposes it for the next minor version (PHP 8.7).
The official RFC index lists it under discussion from 2026-10-25. The author opened the
[RFC] discussion thread at about 13:38 UTC on 25 October, after an earlier
karma-request thread that shaped the design. The voting thread is "tbd" and no
vote date is named. The implementation is php-src PR #24568.
Proposal
ext/standard would gain array_partition(array $array, callable $callback): array. The callback runs once per element,
in array order, and receives ($value, $key) like array_find(), array_find_key(), array_any() and array_all().
The result is always a list of two arrays: index 0 holds the elements for which the callback returned a truthy value,
index 1 holds the rest. Keys and relative order are preserved and the input is not modified, so
[$matching, $rest] = array_partition($array, $callback) always destructures.
The RFC defines index 0 as identical to array_filter($array, $callback, ARRAY_FILTER_USE_BOTH) and index 1 as the
array_diff_key() of the input and index 0. An empty input returns [[], []]. If the callback throws, the exception
propagates and no partial result is returned. Because the callback always gets two arguments, passing an internal
function with a fixed arity, such as 'is_string', throws ArgumentCountError. The RFC gives is_string(...) as a
form that also fails and an arrow-function wrapper as one that works. Since the 27 October edit it also lists
is_string(?) as working, labelled "partial function application (PHP 8.6+)"; the status of that feature was not
checked here.
Since the same edit the proposal section defines the behavior by a userland foreach implementation. The RFC says the
only observable difference is that the native function keeps by-reference elements of the input as references, like
array_filter(), and the loop does not.
Design decisions recorded in the RFC
No $mode parameter; it was removed after review in favor of the array_find() callback signature.
Matching elements come first, as in the cited Laravel, Ruby, Kotlin, Rust and Haskell functions. A result keyed by
true/false was rejected because PHP casts boolean keys to integers, which would put the non-matching elements
at index 0.
The parameter stays $callback rather than $predicate, so the callback: named argument matches the other
array functions.
It is a two-way split, not a general grouping function. The RFC calls the 2023 array_group draft (never voted)
complementary.
Compatibility and limitations
The RFC's only listed backward-incompatible change is the global name: code that declares its own array_partition()
without a function_exists() guard would fail with "Cannot redeclare function". It notes earlier userland functions of
that name that split an array into N chunks. In old versions of a WordPress plugin the declaration was guarded, so a
call such as array_partition($posts, 3) would reach the native function and throw a TypeError. php-src issue
#14582 asked for the N-chunks meaning and was closed by its author in favor of array_chunk(). Only arrays are accepted; iterables are future scope. The RFC's benchmark puts the function on par with
array_filter() plus array_diff_key() and slightly slower than a hand-written loop. It was run on one machine by
the author and has not been reproduced here.
Discussion
The first reply came on 26 October at about 12:26 UTC (132928):
mickmackusa suggested folding the behavior into a general array_group() with an optional third parameter that seeds
empty groups in a chosen order, rather than adding array_partition() and later array_group(). The author
replied at about 14:34 UTC that seeded keys solve missing buckets
but not boolean-key casting: list destructuring matches by key, so seeding [true, false] still yields keys 1 and
0 and swaps the buckets, while string labels require the callback, the seed list and the destructuring keys to
agree (a typo silently creates an extra group). They kept the two-way function, citing array_find()/array_any()
alongside array_filter(), and said a future array_group() is not ruled out. The 14:35 UTC page edit adds this
argument to the "Why not a general grouping function?" section.
Tim Düsterhus reviewed the RFC at about 22:37 UTC and said he is in
favor. His points were editorial: a wiki-markup rendering error in the "An empty input" bullet; noting that a partial
function application placeholder such as is_string(?) should work in the arity example; linking the
destructuring coalesce RFC (declined, per his message) in the
grouping section; that the BC section's first paragraph understates the impact on function_exists()-guarded userland versions, whose behavior may
differ (though new symbols are not a BC break under policy); and extending the stub to a full userland polyfill, as the
array_find() RFC did. The author replied at about 10:36 UTC on 27 October that the
10:31 UTC page edit addresses all five points: the rendering fix, is_string(?) in the arity example (verified against
the implementation, per the author), links to the declined Destructuring Coalesce RFC, a rewritten first BC paragraph
(with or without a function_exists() guard, an existing userland array_partition() must be checked against the native
semantics) and the userland implementation described above. No vote date has been named.
At about 16:00 UTC Tim Düsterhus asked for an example that shows the
reference behavior. He said he is not sure he likes a function whose behavior cannot be replicated in userland, noted
that array_find() (he believes) drops references, and asked for more opinions. The author
replied at about 16:24 UTC. The 16:22 UTC edit adds a "By-reference
elements" example: writing through the result changes the input and vice versa, and a reference that is no longer
shared is copied as a plain value. The author said the functions that return part of their input (array_filter(),
array_diff_key(), array_slice(), array_values(), array_chunk()) keep references while array_find() and
array_map() drop them, and that keeping them means replacing the array_filter() + array_diff_key() idiom does not
change behavior. Dropping references would be a one-line change; reference handling is now the RFC's open issue, to be
settled before a vote. That classification of the other functions is the author's and was not checked here.
The thread had no replies at about 17:05 UTC on 25 October. The PR's code and tests were not checked. Until a
release, use array_filter() with array_diff_key() or a loop.
Under discussion; not accepted. The RFC page (version 1.0, dated 2026-10-08) was created as
a Draft at 17:06 UTC on 8 October, the same day the author asked for RFC
karma and got it.
After an edit at 06:16 UTC on 9 October the status line reads Under Discussion. At 06:19 UTC the
author opened the discussion on internals, calling it
"an invitation for discussion, not a call for votes". The official RFC index
collected at 10:01 UTC on 9 October lists it as discussion. At 19:43 UTC on 9 October the author
published version 1.1 (dated 2026-10-09). Its changelog says it was updated after a review of the
implementation (see below). An edit at 11:30 UTC on 11 October made it version 1.2 (dated 2026-10-11),
still Under Discussion. The page's discussion and voting thread fields still read "tbd". The author is
Damian Jóźwiak. The proposed version is the "next minor PHP version (the release after PHP 8.6)",
recorded here as 8.7.
The proposal is based on Gina Peter Banyard's girgias/csv extension (BSD-3-Clause). The RFC
says Gina has not reviewed it and that it is not her endorsement. The announcement adds that parts
of the implementation were developed with LLM assistance and reviewed by the author.
Motivation given by the RFC
The RFC argues that the existing CSV functions (fgetcsv(), fputcsv(), str_getcsv() and the
SplFileObject CSV methods) cannot follow RFC 4180 without breaking compatibility. It names
the proprietary $escape mechanism, locale-dependent parsing, single-byte delimiters and
enclosures, empty lines parsing as [null], and the lack of an inverse of str_getcsv(). It
also says PHP 8.6 deprecated SplFileObject::fgetcsv(), fputcsv(), setCsvControl() and
getCsvControl() with no replacement. The
PHP 8.6 deprecations RFC does list "Deprecate
SplFileObject CSV methods", but the result of that vote was not checked here.
What is proposed
A new, always-enabled ext/csv with six functions and one class in the Csv\ namespace:
Csv\array_to_row() and Csv\row_to_array() format and parse one row.
Csv\collection_to_buffer(), Csv\buffer_to_collection() and
Csv\buffer_to_collection_lax() convert between a string and rows. The strict variants throw
ValueError when rows have different numbers of fields. The _lax variant allows it.
Csv\collection_to_file() writes any iterable of arrays through the streams layer one row at
a time.
final class Csv\LazyLaxCollection (IteratorAggregate) reads rows lazily, with
createFromBuffer() and createFromFile() factories. The RFC says memory use depends on the
longest row, not the file size, and that iteration can restart if the stream is seekable.
Every function takes $delimiter = ',', $enclosure = '"' and $eolSequence = "\r\n". All three
may be multibyte. Parsing is described as binary-safe and locale-independent, with no escape
character. Invalid dialects and malformed input throw ValueError, non-array rows throw
TypeError, I/O failures throw Error, and no function returns false.
Version 1.1 adds a "Strict parsing" section. Whatever the dialect, input that does not follow the
RFC 4180 record grammar throws ValueError instead of being guessed. This covers an enclosure inside
an unenclosed field (including whitespace or a BOM before the opening enclosure), data between a
closing enclosure and the next delimiter or line ending ("a" ,b), an enclosure that is never closed,
and CR or LF outside an enclosed field that is not part of the EOL sequence. As a result, an LF-only
file read with the default "\r\n" is an error, not one long row; it is read by passing "\n".
row_to_array() now accepts exactly one row, with an optional trailing EOL sequence.
Version 1.1 also describes stream handling in more detail. $file accepts anything the streams layer
accepts (paths, php://, compress.zlib://, user wrappers) and is opened with the default stream
context. A collection from createFromFile() owns its stream like SplFileObject does: fclose()
refuses to close it, and it is closed when the object is destroyed. Iteration state belongs to each
iterator, so nested loops over a buffer-backed collection are independent. A second concurrent loop over
a file-backed collection throws Error.
The RFC lists differences from the legacy functions: no escape character, no [null] for empty
lines, an enclosure inside an unenclosed field, data after a closing enclosure and an unterminated
enclosure are errors, whitespace before an enclosure is not silently dropped, and the default line
ending is "\r\n". (This page's earlier summary of version 1.0 said whitespace before an enclosure is kept;
under 1.1's strict parsing it is an error. The 1.0 wording could not be re-read, because the wiki's
revision history requires a login.) Existing functions keep their behavior. The only
backward-compatibility impact named is that the top-level Csv\ namespace becomes reserved.
Version 1.1 listed as an open issue that dialects in which one token is a prefix of another (for example
delimiter :: with EOL :) are ambiguous and could be rejected during argument validation. Version 1.2
replaces that with a "Multibyte and overlapping dialect tokens" section in the proposal. Overlapping tokens
are allowed where rows still round-trip: writers also enclose a field when a token could form across the
boundary with a neighbouring delimiter or EOL sequence (the RFC's example: delimiter --, enclosure aa).
Combinations that cannot represent every row unambiguously throw ValueError in readers and writers, for
example delimiter xy with enclosure xyx. The remaining open issues are whether the extension can be
disabled at build time (the implementation supports --disable-csv; the RFC proposes always enabled), the
name LazyLaxCollection, and whether a strict lazy variant should ship in the first version.
Version 1.2 (whether these parts are new since 1.1 was not checked) names two gaps left by the PHP 8.6 SplFileObject deprecation, raised during that
discussion: SplFileObject::fputcsv() has no drop-in replacement because fputcsv() needs a stream that
SplFileObject does not expose, and SplFileObject::READ_CSV was not deprecated although
setCsvControl(), the only way to configure its dialect, was. Its "Unaffected PHP Functionality" section
says the RFC neither changes nor deprecates fgetcsv(), fputcsv(), str_getcsv() or the SplFileObject
CSV methods. The future scope includes a deprecation timeline for str_getcsv(), fputcsv() and fgetcsv()
("deliberately not part of this RFC"), a separate
RFC to deprecate SplFileObject::READ_CSV, and header/encoding handling. As checked on 9 and 11 October, it also lists a possible
object-oriented Csv\Reader/Csv\Writer API with capability interfaces for a later RFC. None of
these is part of this RFC. The planned vote is one question needing a 2/3 majority.
Discussion so far
The first reply, from Lynn on 9 October (message 132845),
asked for support for already-open streams/resources, for reading and writing, and what "Lax"
means. The author replied at 08:59 UTC:
"Lax" means rows may have different numbers of fields, as in buffer_to_collection_lax(). The name
comes from girgias/csv. The author added a test for it and suggested a LazyCollection with
configurable strictness as a possible alternative name.
The author is "considering" two new entry points, Csv\collection_to_stream($stream, iterable $collection, ...) and Csv\LazyLaxCollection::createFromStream($stream, ...), separate from the
$file parameter. The stream parameter would be untyped (documented as resource) and checked at
runtime with a TypeError. The proposed semantics: parsing starts at the current position, the
stream is borrowed and never closed, repeated iteration seeks back (non-seekable streams iterate
once), and because of read-ahead the stream position after a partial iteration is not defined.
The author said the RFC will be updated after the API discussion. Neither version 1.1 nor version 1.2
(checked at 16:05 UTC on 11 October) contains collection_to_stream() or createFromStream(), so
they are not part of the proposal as written.
On 10 October at 10:37 UTC Artem Ukrainskiy (GitHub user ArtUkrainskiy, whose review the RFC cites) argued for a different
path: improving the existing ext/standard CSV
functions incrementally instead of adding a second parser. They went through the RFC's motivation list:
$escape is, in their words, already addressed by the PHP 8.4 deprecation, with the default
changing to "" in PHP 9.0.
For locale dependence, their php-src PR #24207
("Skip mbrlen() for ASCII bytes in php_mblen()", opened 8 October, open and not merged on 10 October)
removes the per-byte libc lookup for ASCII characters in ASCII-compatible locales. They said the
remaining isspace() check could become an explicit space/tab check. They also argued that mbrlen()
is useful for CJK locales: a Shift_JIS character can contain a | trail byte that is not a delimiter,
and a locale-independent byte parser would split it.
Multibyte delimiters and enclosures currently throw ValueError, so they could be added without
changing valid calls. A new str_putcsv() could be the inverse of str_getcsv().
[null] for empty lines and whitespace before an enclosure could be handled by an opt-in strict
mode. They said enclosing fields that contain spaces on output is allowed by RFC 4180 section 2.5.
Their main concern is the long-term cost of maintaining two CSV parsers, given the reluctance in the
June and August discussions to remove existing APIs without a migration path. They said this is not an
objection to the implementation: the issues they reported were fixed quickly and the parser is now faster
than fgetcsv() in their benchmarks. They published their benchmarks and test scripts in a public GitHub
repository; those benchmarks were not checked here.
The author replied at 11:50 UTC on 11 October, after the
version 1.2 edit:
They agreed that the RFC's statement that the existing behaviour "cannot be fixed without breaking
compatibility" is too broad, since several improvements could be added as new functions or opt-in
behaviour. They also agreed that enclosing fields with spaces is allowed by RFC 4180 and that
locale-independent byte parsing has different implications for encodings such as Shift_JIS. The
version 1.2 page still contains the "cannot be fixed" sentence.
They cited the new DOM API alongside DOMDocument and the URI extension alongside parse_url() as
precedents for a modern API next to an established one, while saying these do not by themselves
justify a second CSV parser.
They proposed three directions: (A) improve the existing ext/standard API, (B) continue with ext/csv,
adding entry points for already-open streams, or (C) rework it as an object-oriented API in Csv\
with file and stream factories. They still prefer a dedicated API but are open to the other routes.
They asked whether a directional vote between these approaches would be useful if discussion does not
settle it. Such a vote would pick a direction for a revised proposal, not approve an API. No such vote
has been announced.
They said the current RFC does not propose deprecating the existing CSV functions, and that any later
consolidation would need its own discussion and a migration path.
On 26 October at about 14:52 UTC the author wrote that there had
been no further feedback on the list or GitHub for about two weeks and that, unless new concerns or objections are
raised, they intend to open the vote on 2 November. The message does not mention the directional vote or the
A/B/C options from 11 October. Checked at about 17:10 UTC, the RFC page still reads version 1.2 (2026-10-11),
Under Discussion, with one proposed 2/3 question ("Add the CSV extension (ext/csv) to PHP core as described in
this RFC?") and no voting widget or dates. It still contains the "cannot be fixed" sentence and does not mention
collection_to_stream() or createFromStream(). A planned vote is not an opened one.
Tim Düsterhus replied at about 22:06 UTC the same day that the
two quiet weeks included the previous week's security release and, as he had suggested for the Io\Terminal
RFC, the vote should wait until things have calmed down. He said he had
not yet read the RFC, but raised one concern: whether CSV is a large enough topic to justify its own core extension and
another reserved top-level namespace (the RFC's BC section says Csv\ would become reserved), suggesting it might be
grouped with something broader such as "file format" or "serialization format". He also asked to hear from Gina Peter
Banyard as the author of the original extension. No reply from the RFC author had appeared at about 23:05 UTC. Checked
at that time, the RFC page was still version 1.2, Under Discussion, with no voting widget.
On 27 October at about 07:11 UTC the author replied that they had not
considered the effect of the security release on contributors' availability and are "happy to postpone the vote to
allow more time for discussion". The 2 November vote plan is therefore withdrawn; no new date was given. On the
namespace, they said they chose Csv because it is simple and descriptive and follows namespaces such as Uri and Dom,
but are open to a broader naming convention. They agreed that hearing from Gina Peter Banyard would be valuable. Checked
at about 11:05 UTC, the RFC page was still version 1.2 (2026-10-11), Under Discussion, with no voting widget.
Implementation
The implementation is php-src PR #24199, "[RFC] Add
CSV extension (ext/csv)", opened on 8 October 2026 at 17:03 UTC. On 11 October (GitHub API, about
16:05 UTC) it was still open, not a draft and not merged. The RFC calls it a port of girgias/csv 0.6.0.
Version 1.1 says a review of the PR by GitHub user ArtUkrainskiy found a use-after-free (also present
in girgias/csv 0.6.0), a quadratic rescan of long rows in createFromFile() and smaller issues. The RFC says
all of them are fixed, covered by tests and checked with AddressSanitizer and a differential fuzzer. It also
claims six girgias/csv 0.6.0 bugs fixed during the port and 90 phpt tests. In the 11 October message the
author said a remaining writer issue with overlapping tokens was fixed in a later PR commit and that all 92
phpt tests pass locally (the RFC page still says 90). On the reviewer's benchmark it reports
createFromFile() reading rows slightly faster than fgetcsv() (363–1,539 ns against 402–1,742 ns per row,
with the php_mblen() fast path of php-src PR #24207) and writing 10–20% slower than fputcsv(). These
are the author's statements; the review reports, fixes and benchmarks were not checked here.
Limitations
This page summarises a proposal whose list discussion began on 9 October. An alternative of extending the
existing functions has been proposed on the list (10 October), and the author has since asked whether the
direction (A, B or C above) should be settled first (11 October). The full raw page was read on 12 October:
its changelog entry for 1.2 (dated 2026-10-11) matches the overlapping-token policy above, says the
ambiguous-dialect open issue is resolved and links php-src commit b7866156 for the implementation. Its
"Rejected Features" section lists an object-oriented Reader/Writer API in this RFC (left to future work) and
compatibility with the legacy fgetcsv() dialect (escape character, [null] rows, locale dependence). The names, behavior and
target version can change, and nothing here is in released PHP. The API description comes from the
RFC text and was not tested against the PR. girgias/csv can already be installed as a
third-party extension (see PIE 1.5).
Draft; not accepted. The RFC page (version 0.1, dated 2026-10-27, author Sjoerd Langkemper) was created at
09:14 UTC on 27 October with the status Draft. The author announced it on internals
at about 09:26 UTC. The page's discussion and voting thread fields still read "tbd", and when checked at about 11:05 UTC the
RFC was not yet in the official RFC index (955 entries). It proposes the next minor version
(PHP 8.7) and says the feature is not eligible for a backport. The implementation is
php-src PR #24035, which the RFC calls a proof of concept.
Proposal
ext/openssl would gain a function and an enum in the existing Openssl namespace:
enum Openssl\ChannelBindingType: string with the cases TlsUnique (tls-unique), TlsServerEndPoint
(tls-server-end-point) and TlsExporter (tls-exporter); the backing values are the IANA channel binding
type names.
The function returns the raw, binary TLS channel binding data of a connected stream that uses an OpenSSL transport
(ssl://, tls:// or a version-specific transport such as tlsv1.2://) after the handshake has completed. It works on
client and server streams, does not perform a handshake and does not accept a stream context, because a context can create
several connections. The type parameter is required, with no default. It returns null when the requested type does not
apply to the connection; according to the RFC this currently happens only for tls-unique over TLS 1.3, where that
binding type is not defined.
The stated motivation is SASL: userland libraries implement SCRAM, but cannot implement the SCRAM-SHA-*-PLUS variants
(RFC 5802/7677) because PHP exposes no way to get the binding data from a TLS stream. The RFC names PEAR Net_SMTP and
Auth_SASL, Roundcube, SnappyMail, SquirrelMail and Horde as examples, and php-src issue #16766 as the original request.
It cites CPython's ssl.SSLSocket.get_channel_binding() as prior art, which implements only tls-unique.
Design decisions and limitations recorded in the RFC
An enum instead of the string parameter that the PR currently accepts; the PR "will be updated for the enum
parameter". A ChannelBindingType|string union, integer constants and a stream_get_channel_binding() name were
rejected. tls-unique-for-telnet is left out as Telnet-specific.
An inapplicable type returns null rather than throwing, so callers can fall back to another type.
Security considerations: channel binding data is not secret (RFC 5929 section 10), but applications must use the type
that the negotiated SASL mechanism expects and must not treat a missing binding as an authenticated connection. The RFC
describes tls-exporter as the choice for TLS 1.3 and tls-unique as meaningful only for TLS 1.2 and earlier.
Backward compatibility: only the new global function name and the new class name are added. The function exists only
when ext/openssl is loaded and, according to the RFC, cannot be polyfilled in userland.
The planned vote is one question requiring a 2/3 majority. The page shows an empty poll template (0–0–0, "closed")
with no dates; no vote has been opened.
The PR's code and tests were not checked here. The RFC says the PR contains PHPT tests for TLS 1.2 and 1.3 and was tested
manually against Prosody and PostgreSQL. At about 11:05 UTC there were no replies on the list.
Scope: an operation identity for long-running PHP (proposal)
Under discussion; not accepted. The RFC page, version 0.9.3 (dated 2026-10-27, last modified 11:51 UTC, author
Frode Børli), reads Status: Under Discussion, with the discussion thread
linked and the voting thread "tbd". The official RFC index collected at 17:01 UTC on 27 October also lists it under
discussion (index date 2026-10-23). Version 0.9.1 (26 October) had read Draft (which edit changed the header was not recorded) although the author had already
started the discussion on internals at about 16:04 UTC that day, so the
earlier conflict between the page header and the thread is resolved. RFC karma was
requested on 13 October and granted on 25 October.
The proposed version is "Next PHP 8.x (PHP 8.7)".
Proposal
The RFC adds a final class Scope that identifies a unit of work, such as an HTTP request, queue job or CLI command,
for servers that handle several, possibly overlapping, operations in one process:
new Scope(), $scope->run(callable $callback, mixed ...$args): mixed (makes the scope current while the callback
runs and restores the previous one afterwards, also on exceptions), $scope->bind(Closure $closure): Closure
(returns a closure that always runs in that scope), Scope::getCurrent() and Scope::getRootScope().
Fiber::getScope() and Generator::getScope(). A fiber or generator belongs, for its whole life, to the scope that
was current when it was created, wherever it is later resumed from. Ordinary closures do not capture a scope.
Code outside any run() is in the root scope: one per PHP request (the whole process under the CLI). getCurrent()
always returns an object, so a scope can always be a WeakMap key; the RFC expects libraries to keep per-scope data
in their own WeakMaps.
A scope is an identity only: it does not hold values, wait for fibers, cancel work or end when run() returns. It
lives while something references it.
The RFC contrasts this with per-coroutine state in the separate Concurrency Support RFC, which it says could assign its
coroutines to scopes, and cites Java ScopedValue, .NET ExecutionContext/AsyncLocal<T>, Python contextvars, Go
context.Context and Node AsyncLocalStorage as prior art.
Votes as proposed
Primary (2/3): add Scope, Fiber::getScope() and Generator::getScope().
Secondary A (50%+1, counted only if the primary passes): $_GET, $_POST, $_COOKIE, $_FILES, $_REQUEST,
$_SERVER and the session follow the current scope; a new scope starts empty and the root keeps the SAPI's values.
$_ENV is excluded. (The 13 October karma request had said $_SERVER would stay shared; version 0.9.1 includes it.)
Secondary B (50%+1, independent of A): the default locale (Locale::setDefault()) and default timezone
(date_default_timezone_set()) follow the scope; a new scope starts from the ini defaults.
Output buffers, error handlers and ini values are left for later RFCs. No vote dates are set.
Version 0.9.3 adds one rule to vote A: session_start() throws a RuntimeException, instead of blocking the process,
when a locking save handler's session ID is already active in another scope of the same process (ext-scope 0.4.4). The
RFC lists this as its only open issue; the alternative named there is to let both scopes share one $_SESSION and one
lock, which avoids the error but gives up vote A's isolation. Version 0.9.2 rewrote the introduction without changing
the proposal, and an implementation note on 27 October says ext-scope 0.4.3 was tested on ZTS builds with threads
(the parallel extension).
Compatibility and implementation
The only listed BC break is that a global class named Scope can no longer be declared; namespaced classes such as
PHPStan's PHPStan\Analyser\Scope are unaffected. The RFC's own sample found a global Scope class in 3 of 100 GitHub
PHP files; that sample was not reproduced here. Code that never creates a scope is described as behaving as today.
The reference implementation is the fiber-interop/ext-scope extension (0.4.2, PHP 8.2–8.5, installable with PIE),
which implements both secondary votes behind scope.superglobals and scope.locale_timezone ini switches, and a userland
polyfill fiber-interop/scope (0.4.0). A php-src pull request is planned before the vote. The extension, its tests
and the polyfill were not checked here.
Limitations
This summarises versions 0.9.1–0.9.3; the design can change. The middle of the 0.9.3 page (about 27,000
characters) was not re-read, so only the changelog-listed changes are recorded for it. Whether vote A's per-scope
superglobals are sound for all SAPIs and event loops is the subject of the discussion, not established fact.
Exception for invalid characters in number base functions
Voting; not accepted. The vote opened on 16 October 2026. The author's
voting thread went out at about 07:41 UTC, and the RFC page
(version 0.3, dated 2026-08-11, last modified 2026-10-16 at 08:13 UTC) changed its status to Voting. The official
RFC index also lists it as voting. There is one question: "Throw a Exception for invalid characters in number base
conversion functions?" It is the primary vote, needs a 2/3 majority and closes on 2026-11-01 at 15:30 UTC. When the page was
read at about 10:05 UTC on 16 October, the interim count was 3 yes, 0 no, 0 abstain. This is an interim count, not a
result. On 21 October at about 16:05 UTC the page listed 22 voters with an interim count of 21 yes, 1 no, 0
abstain, still not a result. On 22 October at about 10:05 UTC (page still last modified 2026-10-16 08:13 UTC)
it listed 23 voters with an interim count of 22 yes, 1 no, 0 abstain, again not a result. On 23 October at about 22:05 UTC (page
still last modified 2026-10-16 08:13 UTC) the interim count was 23 yes, 1 no, 0 abstain (24 voters), still not a
result. On 25 October at about 17:05 UTC (page still last modified 2026-10-16 08:13 UTC) it was 24 yes, 1 no,
0 abstain (25 voters), again not a result. It was unchanged at about 05:05 UTC on 27 October. The proposed version is PHP 8.7. The vote opened on the date the author
announced on 9 October.
Proposal
bindec(), octdec(), hexdec() and base_convert() would throw when the input contains a
character that is not valid in the given base. Today they ignore such characters and emit
E_DEPRECATED ("Invalid characters passed for attempted conversion, these have been ignored"),
so hexdec('z') returns int(0). For base_convert() validity depends on the source base:
'f' is accepted in base 16 but would throw in base 15.
Version 0.3 changed the exception from ValueError to a plain Exception. The page argues that
ValueError implies a bug in the program, which bad input is not necessarily. More specific
exceptions are listed as rejected for now: the SPL exceptions belong to another extension, and
ext/standard has no suitable exception of its own. The voting thread uses the new "Throw exception" title.
Until 22 October the official index still used the older "Throw ValueError" title. The index collected at 10:01 UTC
on 22 October uses "Throw exception for invalid characters in number base functions", matching the page.
Background and affected versions
The Base Convert Improvements RFC,
implemented in PHP 7.4, added the deprecation notice and named an exception in a later version as
the next step. That step never happened. Since PHP 7.4 invalid characters are ignored with a
deprecation notice; the RFC's example lists this behavior for PHP 7.4 through 8.6. The RFC expects separator
characters such as hexdec('1234-5678') to be the main legitimate use broken by the change.
base64_decode(), intval() and other functions are out of scope.
Evidence and limitations
The implementation is php-src PR #22365, opened on
19 June 2026. GitHub labels it "ABI break". Its description says it changes the behavior to an
Exception, but its first commit message still says ValueError. Whether it is merged or matches
version 0.3 was not checked.
An earlier internals message (132379) also said a
vote would open the following Friday, and called the RFC "not really controversial". The fetched
text has no date. No vote followed that message. The vote opened only after the 9 October announcement.
Until 16 October the page's vote block showed "Final result: 0 0 0" and "This poll has been closed". That was
the unopened widget, not a ballot result. The poll has been open since 16 October.
Objection to the plain Exception (21 October)
On 21 October a voter replied in the voting thread that they had voted no
solely because of the generic \Exception, which callers can only catch together with every other exception. They
pointed out that the Base Convert Improvements RFC had named InvalidArgumentException as the intended PHP 8 step,
and asked for the SPL restriction to be resolved or a dedicated exception class introduced. The author answered that
a more specific exception is desirable but not easy to get right now, that throwing Exception now makes it possible to
change to something more specific later, and that InvalidArgumentException is wrong because it signals a type error and extends
LogicException (a programming error), whereas bad input need not be one.
news-web.php.net returned HTTP 502 for the individual messages, so they were read on the externals.io mirror.
Related: Filter enums, another PHP 8.7 proposal about handling invalid
input.
Draft; not accepted. The RFC page was created on 2026-10-23
(wiki change feed 22:34 UTC, last modified 22:36 UTC). It is version 2.0, dated 2026-10-23, by Larry Garfield and
Arnaud Le Blanc, with status Draft. The proposed version is PHP 8.7. The discussion thread and implementation fields
are empty and the voting thread reads "tbd". When first read, the page title was the template placeholder "PHP RFC: Your Title Here". After an edit at
19:43 UTC on 24 October (by crell) it reads "PHP RFC: Context Managers v2". The status is still Draft, the
discussion thread and implementation fields are still empty and the open issues are unchanged. Other parts of that
edit were not compared line by line. The official RFC index collected at 22:01 UTC on 24 October lists "Context
Managers, version 2" as a draft dated 2026-10-23 (it was absent at 04:02 UTC).
The earlier Context Managers RFC (version 0.9, dated 2025-10-15, same
authors) still says In Discussion in its header and in the index.
Proposed behaviour
The RFC adds a semi-reserved keyword using. It opens a block that guarantees setup and teardown work:
using (file_for_write('file.txt') => $fp) {
fwrite($fp, 'data');
};
The expression before => must evaluate to a Generator, which the RFC calls the context manager. If it is not a
Generator, an Error is thrown. Resources are the exception: they are wrapped automatically in a manager that
closes them in a finally block.
The generator runs until its first yield. The yielded value goes to the context variable. The body runs in the
enclosing function's scope, and then control goes back to the generator. A second yield throws an Error at
runtime. When the block ends, the context variable is unset.
An exception thrown in the body passes through the generator, so its catch/finally blocks can handle it. A
return in the body returns from the enclosing function, but the generator's finally still runs.
using is an expression. It evaluates to the generator's return value, or null if the generator returns nothing.
A single-statement body can be written without braces.
Several managers can be listed in one using (using (foo() => $foo, bar() => $bar) { … };), which is the same as
nesting them. try using (…) { … } catch (…) { … } is shorthand for a try around the block. In that form the
using return value is discarded.
The RFC's examples include database transactions, flock() locking, suppressing listed exceptions and asserting
that an exception is thrown in tests.
Difference from version 1
Version 1 defined a context manager as an object with two methods. The v2 RFC says PHP's type handling made the
Python idiom impractical and that "no generally acceptable workaround was discovered". Generators avoid that problem
and also allow uses other than try/catch. The cost is weak typing: a generator function can only declare \Generator
as its return type. The RFC points to the Generator<TKey, TValue, TSend, TReturn> docblock notation that static
analysers already support.
Open issues and limitations
Open issues (from the RFC): with several managers, should using return the outermost result or an array of
all results? Should an optional ContextManager interface with a getContextManager(): \Generator method be added?
send() support is left as future scope.
Value escape: if the body stores the context variable somewhere else, it stays reachable after the block. Each
manager then decides whether to close the value (leaving a closed handle) or not (leaving it open). The RFC calls
this intrinsic to PHP's memory management.
Compatibility:using becomes semi-reserved. It can no longer be used for global constants or functions, but
existing methods and class constants keep working.
Vote: the page has one primary vote, "Implement generator-based context managers?", needing a 2/3 majority. No
ballot is open and no discussion has started. The RFC links no implementation.
This page summarises a newly created draft. Syntax, semantics and the target version can change, and nothing here is
in released PHP. Part of the RFC page (about 4,600 characters in the middle) was read in a second pass with
--offset. The examples section was skimmed, not reviewed.
Filter\Filter and Filter\Flag enums proposal (formerly: deprecate invalid Filter options)
Voting, closes 2026-11-04 00:00 UTC. At 08:54 UTC on 20 October the author posted the
vote announcement, one day after the date given in the intent-to-vote message.
It links the RFC, PR #24111 and discussion thread 132813, and names one item: "Should the Filter\Filter and
Filter\Flag enums be added?" When the page was inspected at about 10:05 UTC (last modified 2026-10-20 08:55 UTC,
still version 0.9), its header said Voting (the "Voting thread" field still said "tbd"). The Voting Choices section
says "Voting ends on 2026-11-04 at 00:00:00 UTC" and has one primary question requiring a 2/3 majority, "Implement
Filter\Filter and Filter\Flag enums as outlined in the RFC?", with Yes/No/Abstain columns. At that time five people
had voted and the widget counted 1 Yes, 4 No, 0 Abstain. This is an interim count of an open poll, not a result;
ballots can still be cast or changed until it closes. At about 16:05 UTC the same day (page still last modified 08:55 UTC) seven people
had voted (crell, cschneid, dharman, kalle, nicolasgrekas, ocramius, timwolla) and the widget counted 1 Yes, 6 No,
0 Abstain; again an interim count. At about 22:05 UTC (page still last modified 08:55 UTC) nine people had voted
(adding jordikroon and marandall) and the widget counted 1 Yes, 8 No, 0 Abstain, again interim. At about 10:05 UTC on
22 October (page still last modified 2026-10-20 08:55 UTC) eleven people had voted (adding dunglas and kguest) and the
widget counted 1 Yes, 10 No, 0 Abstain; the poll is still open until 4 November, so this is not a result. At about 22:05 UTC on 23 October the page had been edited (last modified 2026-10-23 19:31 UTC by sjoerd): the
"Voting thread" field now links 132882 and the "Discussion thread"
field links 132813; version 0.9 and the Voting header are unchanged. Twelve people had voted (adding geekcom) and the
widget counted 2 Yes, 10 No, 0 Abstain, again an interim count of an open poll. At about 05:05 UTC on 27 October (page still last modified
2026-10-23 19:31 UTC) thirteen people had voted (adding theodorejb) and the widget counted 2 Yes, 11 No, 0 Abstain;
the poll is open until 4 November, so this is still not a result. The official RFC index collected at 10:01 UTC lists the RFC as
voting. The leftover Future Scope and ecosystem-impact sentences described below were still on the page.
Before the vote: at 10:03 UTC on 19 October the author posted an
intent-to-vote message in the original thread saying that voting
"will start on October 19, 2026" because "the two-week cool-down period is over". The message uses the
former title, "Invalid Filter Options". When the RFC page was inspected at about 16:05 UTC the same day, its
header still said Under Discussion with "Voting thread: tbd", it was last modified 2026-10-09 08:03 UTC,
and the vote widget still showed 0/0/0. The official RFC index collected at 16:01 UTC still listed it as
discussion. The Future Scope and ecosystem-impact sentences left over from the deprecation draft (see
below) were still on the page. At about 04:05 UTC on 20 October the page was unchanged (version 0.9, Under
Discussion, voting thread "tbd", last modified 2026-10-09 08:03 UTC); the widget read 0/0/0 with "This poll has
been closed", so no ballots had been cast. No voting thread had been collected at that time.
On 7 October the author rewrote the RFC at the same URL.
Instead of deprecating invalid options, it now proposes adding Filter\Filter and Filter\Flag
enums. The page (last modified 2026-10-07 06:06 UTC) is titled "Add Filter\Filter and
Filter\Flag Enums" and its status is Under Discussion. It still says version 0.9 and dated
2026-10-03. Its changelog says: "2026-10-07: Revised RFC to reflect the enum implementation in
php-src PR #24111." When the official RFC index was collected at 10:01 UTC on 7 October, it listed
the page under that title as discussion. Earlier collections did not list it. At 04:16 UTC the
author asked for feedback on the updated proposal
in the original thread.
Current proposal (7 October revision)
Two int-backed enums in the Filter namespace: Filter\Filter, with cases from DEFAULT and
VALIDATE_BOOL through SANITIZE_ADD_SLASHES and CALLBACK, and Filter\Flag, with cases
such as NONE, ALLOW_OCTAL, ALLOW_HEX, IPV4, IPV6 and GLOBAL_RANGE. Each case is backed
by the value of the existing FILTER_* constant. The listed Filter\Filter cases include
SANITIZE_STRING, whose constant has been
deprecated since PHP 8.1. The RFC does not comment on this.
filter_var(), filter_var_array(), filter_input() and filter_input_array() would accept the
enums as well as integers, including in 'filter'/'flags' array definitions.
To combine flags you use their backing values, for example
Filter\Flag::ALLOW_OCTAL->value | Filter\Flag::ALLOW_HEX->value.
The RFC says no constants are removed or changed and integer arguments stay accepted. The
proposed version is PHP 8.7, and the vote template is a single 2/3 question. The vote opened on 20 October (see above).
The implementation is php-src PR #24111. Its state
was not re-checked in this cycle.
Some text from the earlier draft remains on the page. "Future Scope" still says the RFC "is limited
to invalid integer-valued filter and flags options". The ecosystem impact section still says
invalid option values "will no longer be silently accepted". Neither statement matches the enum-only
proposal. On 9 October (page last modified 08:03 UTC) the author changed the vote question to "Implement
Filter\Filter and Filter\Flag enums as outlined in the RFC?" (2/3 majority). The widget still shows
0/0/0 with the generic "This poll has been closed" footer, and no ballot has taken place. The
Future Scope and ecosystem text quoted above was unchanged at that time.
Feedback on 9 October
Tim Düsterhus replied that requiring the backing
value to combine flags as a bitmask "is an abuse of enums" that cancels their type safety and makes
them "fancy constants". They also pointed out the unchanged vote template. The author
answered that many filter_var() calls pass only a
filter ID with no flags (citing a Sourcegraph search), that a Filter\Flag enum could still help for
single flags, and that this should be weighed against the loss of type safety when flags are combined.
The author did not announce a change to the flag design.
Tim Düsterhus answered again at 12:22 UTC. They said
enums would help filter_var() calls without flags only slightly, would not work for
filter_var_array(), and would mix a strong enum with a free-form options field when flags are used.
They argued that, if PHP had tagged unions, per-filter
options could be passed with the case (for example Filter\Int(allowOctal: true, allowHex: true)),
and that adding the enums now would likely block that path. The tagged unions RFC (2020) is listed
as inactive in the official index and is not part of PHP.
History: the invalid-option deprecation draft
As first published, the RFC page (version 0.9, dated 2026-10-03, last modified
2026-10-03 05:37 UTC) had the status Draft. Its implementation, discussion and
voting threads were marked "tbd". The author announced it on internals at 05:38 UTC on
3 October (message 132778), describing it as opened
for feedback. When the official RFC index was collected at 10:01 UTC that day, the RFC was
not yet listed, and it was still absent from the index collected at 22:01 UTC. The page contained
an unfilled vote template ("Implement $feature…", 0/0/0). No ballot has taken place.
The first on-list reply, from Calvin Buckley at 20:22 UTC on 3 October
(message 132779), called the proposal reasonable "at
first glance". It suggested possible follow-on RFCs: turning the filter types into an enum and
removing the SAPI-side input filters for superglobals. These are one participant's suggestions,
not part of this RFC.
At 08:38 UTC on 4 October the author, Muhammed Arshid KV, replied
(message 132780). The author agreed that the
filter types "would be better handled as a separate, focused RFC for enums" and wrote: "I'll
close this RFC and pursue the enum proposal separately". The reply links
php-src PR #24111, opened on 4 October. The PR adds
backed enums Filter\Filter (filter IDs) and Filter\Flag (flags), which filter_var(),
filter_input() and related functions would accept alongside the existing integer constants.
Those constants are kept, and alias constants that share a value get only one enum case. As of
4 October no RFC page for the enum proposal was in the official index, and the PR's requested
code-owner reviews were still pending. It is an implementation proposal, not an accepted change. The reply does not say
whether the invalid-option deprecation will return in another form.
On 4 October at 16:11 UTC a php-src maintainer (iluuu1994) commented on PR #24111 and asked the
author to start a mailing-list discussion first. The maintainer added: "I'm not sure it's a
good idea to extend this API further." The author agreed. At 03:29 UTC on 5 October the author
opened a discussion thread for the enum proposal. They
described the enums as type-safe and more discoverable alternatives to the integer constants,
which remain supported. They asked for feedback on the API, naming and approach "before
preparing the RFC". When checked at 04:01 UTC, no enum RFC page was listed in the official
index. The PR was open, had no submitted reviews, and was labelled "RFC" and "ABI break".
On the original thread, Derick Rethans replied to the suggestion of removing SAPI-side input
filters that removing the filter defaults "was a mistake" and that the deprecation "ought to be
undone, before the extension gets refreshed" (quoted in the author's reply). At 15:15 UTC on
6 October the author answered that the enum PR
only aims to modernize the API, and that they will look into the history of the removed
defaults before proceeding. As of 6 October no new RFC page or status change had followed.
That draft targeted the integer-valued filter and flags options of filter_var(),
filter_var_array(), filter_input() and filter_input_array(). The draft said some invalid
values are currently converted to integers silently. Under that draft, PHP 8.7 would emit
E_DEPRECATED and PHP 8.8 would throw ValueError. The examples cover two cases:
a value of the wrong type, such as 'flags' => 'abc' or 'filter' => 'abc' ("must be of
type int, string given");
an integer that matches no known value, such as 10050 ("Unknown flags with ID…" /
"Unknown filter with ID…").
The draft's backward-compatibility section said that code that relies on implicit conversion of
invalid values to integers would need to use the appropriate constants instead.
The deprecation described above was the content of version 0.9 before the 7 October rewrite. The
current page no longer proposes it, and the author has not said whether it will return.
Limitations: the earlier draft's introduction mentioned an array passed as flags, but its
examples used strings and unknown integers. The flag-combination objection and the API-extension concern raised on the PR are not
addressed in the page text as voted on. Which voters chose which option is not recorded here.
This page does not describe current behavior beyond what the RFC states. Related:
bcrypt length proposal, which uses the same 8.7/8.8
deprecation-then-error schedule.
Accepted 25–0–0 and merged into php-src master (PHP 8.7.0-dev) on 22 October 2026; not in any
released PHP version. The RFC (version 0.4.1, dated 2026-08-09, author Weilin Du) had one primary
question, "Add IntlRelativeDateTimeFormatter as described to ext/intl?", which needed a 2/3
majority. The vote ended on 2026-10-22 at 00:00 UTC. The RFC page shows the closed poll with a final
result of 25 yes, 0 no and 0 abstain, and at 01:44 UTC the author
announced on internals that the RFC is accepted.
An edit at 01:45 UTC ("update status") changed the page header to Status: Implemented, and the
official RFC index collected at 04:01 UTC lists it as implemented.
php-src PR #23514 was merged into master at
01:47 UTC (one commit changing 35 files). When checked at about 04:10 UTC, master reported 8.7.0-dev, and its
UPGRADING lists the class and the three enums
under Intl for PHP 8.7. PHP 8.7 has no release date in the sources read here, and code on master
can still change before a release.
Vote history. The author announced the start of voting
at 16:14 UTC on 7 October, after a page edit at 16:10 UTC. That was earlier than the start the author had
given: an intent-to-vote message on 5 October and a voting
section added at 10:02 UTC on 7 October both said 2026-10-08 00:00 UTC. Interim counts were 7–0–0 on
7 October and 18–0–0 on 14 October, when an edit changed the header from Under Discussion to Voting.
The discussion thread began in August.
What is proposed
A new final class IntlRelativeDateTimeFormatter in ext/intl, wrapping ICU's
URelativeDateTimeFormatter C API (stable since ICU 57, and ext/intl already requires ICU 57.1
or newer). It would produce strings such as "yesterday", "in 3 days" or "5 minutes ago" for a
locale. The class and three pure (unbacked) enums would live in the global namespace:
IntlRelativeDateTimeFormatterUnit (Year through Second, plus Sunday through Saturday).
The constructor takes ?string $locale (where null means the default intl locale), a style, a
capitalization context and an optional NumberFormatter. The formatter keeps the supplied
NumberFormatter, so later configuration changes to it affect later output. Methods:
format(int|float $offset, $unit) uses a text form when the locale has one ("yesterday",
"last week") and otherwise falls back to a numeric form;
formatNumeric() always uses the numeric form ("1 day ago", "in 1.5 hours");
combineDateAndTime(string $relativeDate, string $time) joins two already formatted strings
with the locale's date-time separator. It does not parse or validate them;
getErrorCode() and getErrorMessage() follow the usual ext/intl error conventions. ICU
failures return false, or throw if intl.use_exceptions is on. A wrong enum argument
always throws TypeError.
The RFC does not change IntlDateFormatter::RELATIVE_*, which formats a concrete date. No
procedural aliases or integer constants are added. The backward-compatibility section notes that
the four new global names could conflict with userland declarations while intl is loaded. The
changelog records changes made in response to feedback from Tim Düsterhus and others, such as
adopting the three pure enums on 2026-09-19.
Limitations
The RFC page still says "Voting thread: TBD" and "Patches and Tests: TBD", although the vote was
announced on internals and the implementation PR is merged; this page treats the PR and UPGRADING
as the implementation evidence. The merged code was not reviewed line by line against the RFC text,
so behaviour described above comes from the RFC and UPGRADING. The example output strings depend on
ICU locale data and version. Related: intl_date_format() proposal, a separate
ext/intl draft.
Accepted 40–0–0; not implemented. At 02:06 UTC on 2026-10-21 the author
announced on the internals list that the RFC was accepted with 40 Yes,
0 No and 0 abstentions; its one question needed 2/3. When inspected at about 04:07 UTC that day, the RFC page header said
Accepted (last modified 2026-10-21 02:02 UTC), the poll still read "Final result: 40 / 0 / 0" with "This poll has
been closed", and the official RFC index collected at 04:01 UTC listed it as accepted. Nothing has been implemented or
released.
Before that, the poll closed at its scheduled time (2026-10-19 13:15 UTC) with the same 40 / 0 / 0 result, but the
page header still said Voting when re-inspected at about 16:05 UTC on 19 October and 04:05 UTC on 20 October, and an
internals message at 03:52 UTC on 20 October (132881) noted that the results had
not yet been officially announced. During that gap this wiki kept the status as voting.
On 2026-10-05 at 13:18 UTC the author
announced on the internals list that voting had opened.
The RFC page (version 1.0.0, then status Voting, last modified 2026-10-05 13:11 UTC) and the
official RFC index both listed it as voting. There is one primary question, "Stop endorsing
PEAR?", which needs a 2/3 majority. The poll was set to close on 2026-10-19 at 13:15 UTC. When the page was
inspected at about 16:05 UTC on 5 October it showed 14 Yes, 0 No and 0 Abstain; at about 04:05 UTC
on 6 October it showed 21 Yes, 0 No and 0 Abstain; at about 04:02 UTC on 7 October it showed
23 Yes, 0 No and 0 Abstain; at about 10:02 UTC on 7 October it showed 24 Yes, 0 No and
0 Abstain. Those are interim counts in an open poll, not a
result.
What is proposed
The RFC would end the PHP project's endorsement of the independent PEAR project in four steps:
Serve the public pages of pear.php.net (package details, downloads, manuals, public bug
reports) as a static archive. The browsable archive, including the endpoints legacy PEAR
CLI clients use, would remain until 2027-12-31 and then be offered only as a download.
Stop installing or bundling the PEAR installer with PHP source, proposed for PHP 8.7. The
RFC formalises an existing php-src pull request
(#20124).
Remove PEAR references from official PHP websites and mention Composer as the community
package manager. The RFC says this does not make Composer a PHP project.
Move the PEAR mailing lists to the inactive lists section.
Taking over governance of the PEAR package ecosystem is a stated non-goal; an independent team
could continue PEAR under domains it controls.
Motivation stated by the RFC
The RFC says the PHP project has no access to PEAR's infrastructure although it is hosted on a
php.net subdomain, cannot guarantee the integrity of the content served there, and that the
site is unmaintained with broken features and spam. It cites PEAR metadata from 2026-06-22:
534 of 603 packages marked unmaintained, and 63 of the remaining 69 not updated for extended
periods. These figures are the RFC's own count and were not independently re-measured here.
Affected users
According to the RFC, users would no longer get PEAR bundled with PHP but could install it
manually, and users of the six packages still publishing on PEAR would need their
Composer-installable versions. During the discussion the author stated that the static archive
would keep serving installer resources (for example go-pear.phar and /rest/ paths) on the
same domain, so the switch need not wait for unbundling.
Archive integrity suggestions (20 October)
The RFC leaves the static archive's technical details to the infrastructure team. On 2026-10-20 Sebastian Bergmann
suggested on the internals list: a signed SHA-256 manifest of every file the
archive serves (tarballs, go-pear.phar, install-pear-nozlib.phar, REST metadata), kept also in the archive's Git
repository; checking the installer PHAR that php-src downloads against a pinned hash in every branch that still
supports --with-pear, with a plan for branches supported after 2027-12-31; announced brown-outs of the CLI endpoints
and go-pear.phar before the cut-off and a "tombstone" go-pear.phar that exits non-zero afterwards; and published
aggregate request counts without IP addresses. The message recalls that go-pear.phar was replaced with a malicious
copy in January 2019.
On php-src master, pear/Makefile.frag (checked
2026-10-20) downloads https://pear.php.net/install-pear-nozlib.phar during make install-pear when the PHAR is not
already in the source or build tree, then runs it; that file contains no hash check. Release branches were not
checked. The suggestions are proposals; no reply or decision had been collected.
History and discussion
Two earlier proposals were never brought to a vote:
Deprecate PEAR/PECL & Replace with composer/pickle
(2016, now Inactive in the index) and
Deprecate PEAR and recommend Composer
(2025, now Withdrawn). The RFC changelog for 2026-09-14 records support from a long-time PEAR
Group member for sunsetting the website and removing PEAR from PHP source, and adds the archive
timeline. The discussion thread continued on
2026-10-02. In the thread the author expected that a vote would not end before mid-October and
that nothing would land before November. That was a plan stated before the vote opened.
The vote opened on 2026-10-05; the proposal and BC sections inspected that day match the
summary above. The page's introduction also states that the PEAR web repository was recently
archived. The RFC cites pear/pearweb, but that repository's
archive state was not checked here.
Limitations: the RFC is accepted, but each of its four steps still needs implementation work, and the result
announcement gave no timeline beyond the RFC's own dates. The php-src change it formalises,
PR #20124, was re-checked on 2026-10-06. It is titled
"PECL and PEAR removal", which is wider than this RFC's PEAR scope, and it is an open draft that
has not been merged (last updated 2026-09-03). Nothing in released PHP has changed. Related: support windows.
Under discussion; not accepted. The RFC page (version 0.4, dated 2026-09-29, last modified
2026-10-16 at 19:47 UTC) and the official RFC index both list it as Under Discussion. Until
16 October both had listed it as Draft. The author
opened the discussion on 2026-10-16 at 19:34 UTC. They asked for
feedback in particular on MySQL and PostgreSQL behavior, and on whether the RFC should use a new data type or a flag. They said
they want those points settled before a vote. The voting thread reads "tbd", and no vote has been
scheduled. The proposed version is "Next PHP 8.x", so no specific version is named.
Proposal
The motivation is that PDO drivers handle binary data inconsistently: SQL Server via PDO_DBLIB
needs special quoting, some ODBC drivers return a binary column bound as a string as hex, and
some databases convert character encodings on string fetches. A binary column is not
necessarily a LOB, and some drivers expect PDO::PARAM_LOB to be a stream.
The RFC offers two alternatives: a dedicated PDO::PARAM_BINARY data type (the next free value,
6), or a modifier flag (likely 0x10000000) combined with PDO::PARAM_STR or PDO::PARAM_LOB.
It says the choice will be settled in discussion or, if that is unclear, by a vote. It notes possible effects on emulated prepares,
PDO::ATTR_DEFAULT_STR_PARAM, PDO::ATTR_STRINGIFY_FETCHES and on what drivers report from
getColumnMeta(). A proof-of-concept is php-src PR #11674.
The page has a primary vote that needs a 2/3 majority and a second vote on the approach (separate data type or
flag). Both polls show zero votes and are marked closed. A reviewer points out that they still carry a
2026-01-01 close date. They are templates, not ballots.
Discussion
On 2026-10-16 at 20:43 UTC Ilia Alshanetsky posted a six-point review
based on the current driver code:
PARAM_LOB with a string is already binary in pdo_pgsql and pdo_sqlite, in pdo_mysql only when emulating
prepares, and in pdo_odbc only when SQLDescribeParam() fails. They asked what PARAM_BINARY adds per driver.
A fallback to PARAM_STR corrupts data: pdo_pgsql truncates text-format parameters at the first NUL byte, and
pdo_mysql loses the _binary introducer. They suggested a per-driver table covering native binding, emulated
quoting and fetching.
Neither representation degrades safely. An unknown type 6 is treated as text in the bundled drivers and pdo_oci,
gives IM001 in pdo_ibm and a fatal error in pdo_sqlsrv. A flag survives only where code masks the type with
PDO_PARAM_TYPE(). They asked the RFC to require core to mask it, and to define what PARAM_INT | PARAM_BINARY does
(they suggested a ValueError).
The ODBC hex problem is a driver bug that choosing SQL_C_BINARY by column type would fix without a new constant.
Raw fetches of character columns (EBCDIC/UTF-16) are the new capability.
Changing the pdo_type reported by getColumnMeta() breaks strict comparisons either way, and a separate key would avoid that.
Nits: PDO::PARAM_STRING should be PDO::PARAM_STR, and the proof-of-concept dblib quoter checks the type exactly,
so any added flag would skip it.
This review is the account of one participant and has not been checked against driver source code here.
The author replied at 22:27 UTC the same day. They said they would answer
some points then and research the rest over the next week:
PARAM_LOB inconsistencies were an open issue that they now think must be addressed first, and they will try to add a
per-driver table. PARAM_LOB might cover most binary-string cases, but they find that confusingly named and harder
for niche cases. They would accept making drivers treat PARAM_LOB consistently for binary strings if participants prefer that.
For emulated prepares, checking string contents to pick binary quoting would be possible but slow and driver-specific.
They consider marking the change as a breaking change for drivers reasonable.
pdo_odbc binds result columns as SQL_C_BINARY only when is_unicode is set (Windows-specific), while parameters
are bound as binary for binary columns but not blob columns. They said that could be improved independently of the RFC.
They expect a backward-compatibility break for code relying on getColumnMeta() with any strategy, and mentioned a
separate key like pdo_sqlite's blob key as a way to avoid it.
The data type or flag choice remains open. As of 2026-10-17 04:01 UTC no newer RFC page revision had been collected.
Under discussion; not accepted. The RFC page (version 1.0, status Under Discussion, last modified
2026-10-16 16:58 UTC) and the official RFC index both list it as under discussion. The proposed version is
PHP 8.7. The page header gives its date as 2026-10-17, which is one day after the UTC date on which it was
created and announced. The author announced the RFC on
2026-10-16 at 16:51 UTC. They wrote that voting "will start two weeks after if no further discussion emerged",
so the earliest expected vote is around 30 October. No vote has been scheduled, and the implementation is
listed as "TBD".
Proposal
According to the RFC, extension_loaded(), get_extension_funcs() and phpversion() already accept extension
names in any case, but ini_get_all() requires the lowercase name. ini_get_all('Pcre') raises an E_WARNING
and returns false. The RFC would resolve the $extension argument with ASCII case-insensitive matching,
whatever the current locale, for both values of $details. Then ini_get_all('Pcre') would return the same
result as ini_get_all('pcre').
Compatibility
Calls that differ only in capitalization from a loaded extension's name would succeed instead of warning and
returning false. Code that relies on that failure would behave differently. Calls that already succeed do not
change.
Ballot
One primary vote that needs a 2/3 majority. The poll on the page shows no votes and has no closing date.
History and limitations
The change was first proposed as php-src PR #23293 and raised in a
pre-RFC internals thread. A core developer had asked for it to be
discussed on the list before it was merged. In that thread the author noted that it did not need to land for 8.6.
The current ini_get_all() behavior described above is the RFC's statement. It was not tested here.
The PR's state and the replies in the pre-RFC thread were not reviewed.
Under discussion; not accepted. The RFC page (version 1.0, dated 2026-10-13, status
Under Discussion) and the official RFC index both list it as under discussion. The proposed
version is PHP 8.7. The page was created on 13 October, after RFC karma was requested and granted
that morning. The RFC change feed lists an edit at 19:24 UTC, and the header now links the discussion thread.
The author opened the discussion at 18:36 UTC. The voting
thread reads "tbd", so there is no vote date.
Proposal
Two new global constants in ext/json, accepted in $flags by json_decode() and json_validate():
JSON_ALLOW_COMMENTS (1 << 23) accepts // line comments and /* … */ block comments.
JSON_ALLOW_TRAILING_COMMAS (1 << 24) accepts one comma after the last element or member of a
nonempty array or object.
The flags are independent. Without them, results, error codes and error locations do not change.
json_encode() does not change and ignores both flags. Before this RFC, json_validate() accepted only
JSON_INVALID_UTF8_IGNORE. Other flags still throw ValueError, and its message would name the
three accepted flags.
Comment rules in the RFC:
A comment can appear where JSON allows whitespace, but not inside a token (tr/**/ue and -/**/1
are syntax errors). Comment markers inside strings are string text.
Block comments do not nest. /*/1 is an unterminated comment, and /**/1 is the value 1.
A line comment ends at LF, CR or CR LF, but not at U+2028/U+2029. # comments are not accepted.
Input that contains only comments is a syntax error, the same as empty input.
A NUL byte in a comment raises JSON_ERROR_CTRL_CHAR, even with the invalid-UTF-8 flags. Invalid
UTF-8 raises JSON_ERROR_UTF8 unless JSON_INVALID_UTF8_IGNORE/_SUBSTITUTE is given.
An unterminated block comment raises JSON_ERROR_SYNTAX at the position of its /*. Error
line numbers count lines inside comments.
Trailing-comma rules: [1, 2, 3,] and {"a": 1,} are accepted, but [,], {,}, [1,,], [1,,2]
and a top-level 1, stay syntax errors. [1,} gives the same state-mismatch error as [1}.
No new error codes are added, nesting depth is unchanged, and a UTF-8 BOM is still a syntax error.
Relation to JSON5, JSONC and JWCC
The RFC does not add JSON5 (single quotes, unquoted keys, hexadecimal numbers, NaN/Infinity).
It says JSON_ALLOW_COMMENTS matches the JSONC draft without trailing commas, and that both flags
together match JWCC, except that in this RFC a CR alone also ends a line comment.
A single JSON_ALLOW_JSONC flag, suggested by Tim Düsterhus in the pre-RFC thread, is listed under
rejected features. The reasons given are that the jsonc.org specification is a draft, it makes
trailing commas optional, and the name JSONC has more than one meaning. Later RFCs could add a
combined constant if a stable standard appears.
Ballot
Two primary votes, one per flag, each needing a 2/3 majority. The results are independent.
Evidence the RFC cites
These are the author's measurements, not independently reproduced here:
A differential test of 120,025 generated inputs (840,175 checks) found the same results, error codes
and messages on master and on the branch without the new flags.
Callgrind instruction counts for a 7.6 MB document show +1.60% for json_decode() and +1.69% for
json_validate() on strict JSON without the new flags. The RFC says two scanner changes, not yet in
the pull request, reduce this to +0.56% and +0.59%.
Demand: Packagist install counts for colinodell/json5 and adhocore/json-comment as of 2026-10-12.
Compatibility and limitations
A user-defined global constant with either name now triggers an "already defined" warning, and the
built-in value wins. Namespaced constants are not affected.
json_decode() currently ignores unknown flag bits, so code that already passes bit 23 or 24 by
mistake could start accepting comments or trailing commas.
The implementation pull request is labelled "ABI break"
because it adds macros to php_json.h. The RFC says no struct or function signature changes.
The RFC says no other JSON_* flag uses bits 23 and 24. The pull request description notes that the
proposed duplicate-key flags in php-src #22473 use the same bits, so whichever is merged second must
move. These two statements don't contradict each other, because #22473 isn't merged.
Discussion
On 13 October Tim Düsterhus replied that he was "not happy, but
the rejected [section] is well-argued" and had no other comments. Larry Garfield
agreed: "I have no remaining objections to it." Both had raised points
in the pre-RFC thread. These are list replies, not votes.
Under discussion. The RFC page (version 1.0, dated 2026-09-29, author Jakub Zelenka) reads Under
Discussion, as does the official RFC index collected on 11 October. It follows
the Polling API RFC, which added the Io\Poll namespace to PHP 8.6.
The proposal extends the polling surface with weak handles, socket handles, generic timer/signal/process/notification handles, and priority events.
The weak-handle design addresses event loops unintentionally keeping resources alive.
The broader handle set provides integration points for the related IO hooks work. These
are proposed changes: a description in an RFC is not evidence of release availability.
Discussion
On 11 October Tim Düsterhus posted a 15-point review,
mostly framed as questions. Among them:
They agreed with an earlier suggestion by Ilia to split the RFC into several separately voted parts,
as was done for the PHP 8.6 URI follow-up.
They asked whether separate weak handle classes are needed, or whether something like
new StreamPollHandle(WeakReference::create($stream)) would avoid duplicating every handle.
They questioned the name and namespace of TimerHandle, suggesting a sub-namespace (as with
Random\Engine) or a standalone Io\Timer, and asked whether its timeout and periodic flag should be
readonly properties.
For ProcessHandle, they suggested a proc_get_poll_handle()-style function instead of tying the class
to proc_open() resources, in case a new process API is added later.
They asked for the Context::onWatcherRemoved() callback signature, an ecosystem impact note (for
example ReactPHP), and clarification of whether SignalHandle is limited to the CLI only in thread-safe
builds.
No author reply had been collected by 04:01 UTC on 12 October.
Proposed ballot
As read in full on 12 October, the page proposes a single question, "Should the Polling API additions be
added to PHP?", with Yes/No/Abstain options and a 2/3 majority; the vote dates are placeholders
(2026-XX-XX), so no vote has been scheduled. The split into separately voted parts suggested on the list
is not reflected on the page. The proposed version is "Next minor version, PHP 8.7". The page says a
working implementation is part of the IO hooks pull request
php-src #23997 and will be extracted into its own pull request.
The changelog lists 1.0 (signal handles block signals only while watched; process handles no longer collect
the child) and 0.1 (initial draft).
Recheck the primary page for current scope,
status and ballots. No vote result is inferred here.
Under discussion; not accepted. The RFC page (version 0.2, dated 2026-10-08, author Matthieu
Napoli) and the official RFC index both list it as under discussion. The proposed version is
PHP 8.7. The voting thread reads "tbd". The page's vote widget shows 0/0/0 and "This poll has been
closed". That is the wiki template, and no vote has been opened.
Proposal (version 0.2, 8 October)
Version 0.2 reverses the direction of version 0.1. Instead of linking FPM into php, it links the
CLI SAPI into the php-fpm executable:
there is no configure option. Whenever both the CLI and FPM are built, php-fpm also contains
the CLI. With --disable-cli, or with FPM disabled (the default), nothing changes.
make install still installs two separate executables;
the php executable is unchanged, and there is no --fpm option;
php-fpm runs as the CLI when invoked under the name php, optionally followed by a digit
(for example php8.7 or Alpine's php83) through a symlink, hard link or copy. Under any other
name it is FPM, unchanged. Names such as php-cgi, php-config, phpdbg and phpize are
excluded, and so is php-8.7 (from --program-suffix=-8.7), which therefore runs FPM;
in CLI mode PHP_SAPI is cli, it reads php-cli.ini and accepts the usual CLI options. A
running process cannot switch SAPIs. The RFC says the CLI test suite passes through a php
symlink to php-fpm.
PHP_BINARY is the executable's real path (symlinks are resolved). A distribution that wants a
single executable should therefore install it as /usr/bin/php, with php-fpm as a symlink to it.
Then PHP_BINARY runs the CLI in both modes, while FPM is still started as php-fpm, so service
files, process titles and graceful reload (SIGUSR2, which re-executes through the symlink) keep
working. Tools that read /proc/<pid>/exe see php for FPM processes. The opposite layout
(php as a symlink to php-fpm) makes PHP_BINARY start FPM; the RFC says this will be
documented in UPGRADING.
Listed backward-incompatible changes, only for builds with both SAPIs: php-fpm invoked as
php/php8.7 now runs the CLI, php-fpm grows by about 150 KB in a minimal build, and FPM's C
function zif_apache_request_headers is renamed zif_fpm_request_headers (the PHP functions
apache_request_headers() and getallheaders() are unchanged). There is now a single primary
vote needing a 2/3 majority; the secondary default-on vote of version 0.1 is gone. The RFC lists no
open issues. It cites the PHP 8.6 change that made the CLI available to the embed SAPI
(PR #21385), which FrankenPHP uses, as the model.
The RFC also records two rejected alternatives: a php-fpm --cli option (it would touch FPM's
argument parsing, and some letters such as -F mean different things in the two SAPIs), and a
shared libphp.so (a much larger build and packaging change that adds dynamic linking at start).
Version 0.1 (6 October)
Version 0.1 proposed an --enable-cli-fpm configure option that linked FPM into php, selected
with a leading --fpm argument or a php-fpm* name. It had a secondary simple-majority vote on
whether to enable the option by default. Its implementation,
PR #23558. The RFC now lists that design under
rejected features.
Motivation and evidence
The author measured Bref (PHP on AWS Lambda) builds on PHP 8.5.11, Linux x86-64, by replacing
php-fpm with a symlink to a combined executable. The zipped layer went from 24.3 MB to 19.9 MB
and the unzipped layer from 89.9 MB to 64.5 MB. The median FPM cold start over 50 starts dropped
from 280 ms to 211 ms (difference −70 ms, 95% CI −79 to −59); a control runtime that never starts
FPM showed no difference. The RFC says ARM and other memory sizes were not measured, and that the
gain on hosts with the image on local disk is likely smaller. These are the author's own
benchmarks. The page does not say whether they were repeated with the version 0.2 build.
The new implementation is php-src PR #24192. On
2026-10-08 the GitHub API showed it as open, not a draft and not merged (created 11:39 UTC).
PR #23558 was still open as well.
Discussion
The RFC was announced on 6 October. Replies that
day were broadly positive and raised these points:
Tim Düsterhus (132807) noted that code in FPM
using PHP_BINARY would get a binary that needs --fpm to start FPM, and asked whether the
standalone php-fpm should be kept at all. The author
(132808) preferred removing it in a separate
RFC; Düsterhus (132812) argued for one step.
Ayesh (132811) pointed out
Debian/Ubuntu's separate SAPI packages and that -F means "execute a file" in the CLI but is an
alias of --nodaemonize in FPM, and questioned switching meaning by name or flag.
Another participant raised packaging and service-manager concerns for Linux distributions.
Larry Garfield (132816) asked whether linking
FPM into php privileges FPM over other SAPIs (FrankenPHP, Swoole, CLI-based async servers).
Nicolas Grekas (132819) argued that the FPM
binary should embed the CLI instead, as FrankenPHP does. Jakub Zelenka
(132821) agreed.
On 8 October the author agreed, opened PR #24192
and published version 0.2. Tim Düsterhus disagreed
with the new direction, arguing that selecting a SAPI by executable name is hard to discover and
surprising: a php-like name that does not match the rule (a custom p symlink, or php-8.7)
would start FPM and possibly bind sockets, with no way out except renaming. Düsterhus also rejected the
view that version 0.1 privileged FPM, and preferred an explicit flag on php (--fpm, or for
example --mode=fpm), by analogy with -S for the built-in server.
On 10 October Marc Henderkes agreed with Düsterhus
and gave three reasons:
php --fpm <fpm-args> is clearer than renaming the binary, php-fpm usually lives in /usr/sbin,
which users should not normally call directly, and php-fpm php-cli <cli-args> is awkward.
Henderkes did not share Garfield's concern about privileging FPM, and preferred a top-level
--fpm flag over --mode=fpm.
Later on 10 October (19:07 UTC) Levi Morrison suggested another
alternative, replying to the version 0.1 announcement:
building the Zend engine as a shared library, libzend.so. Morrison said this used to be possible
to build and assumed it was partly removed for performance. It would also let most extensions link
their symbols against libzend.so instead of leaving them undefined for the executable to provide. Morrison said the
performance cost would need measuring, but would personally prefer this solution if it is viable. The
RFC's rejected alternative is a shared libphp.so with small php and php-fpm executables. The
message does not say how libzend.so would relate to that option, and this page does not treat them as
the same proposal.
As of 22:00 UTC on 10 October the author had not replied to either message. The RFC page was still
version 0.2, and PR #24192 was still open, not a draft and not merged (last updated 2026-10-08).
Limitations
This page summarises a version 0.2 proposal that changed fundamentally two days after version 0.1,
with two participants on the list now preferring an explicit --fpm flag on php and a third
suggesting a shared libzend.so instead. The direction, the name-matching rule and the handling of
PHP_BINARY can change before a vote, and nothing here is in released PHP.
Under discussion; not accepted. The RFC page (version 1.0, dated 2026-02-13, last edited
2026-10-06 at 13:08 UTC according to the wiki's change feed) and the official RFC index both list it as Under Discussion. It proposes the
"next minor version after PHP 8.6 (likely PHP 8.7)". Acceptance would need a 2/3 majority.
The proposal was split out of the accepted
ext/uri follow-up RFC and builds on the URI extension
that PHP 8.5 added (Uri\Rfc3986\Uri and
Uri\WhatWg\Url). It would add one immutable class, Uri\QueryParams, that stores query
parameters as an ordered list of name-value pairs, with no global request state. It has:
parsers for RFC 1866 form encoding, RFC 3986 and the WHATWG URL rules, plus fromArray().
Parsing percent-decodes the input. It does not require a syntactically valid query
component; strings are percent-encoded again when the to*String() methods recompose them;
getFirst(), getLast(), getAll() and list() retrieval, and modifiers (append(),
set(), delete(), sort()) that return new instances;
default parsing limits of 10,000 input bytes and 1,000 parameters. These can be configured,
and exceeding them throws Uri\InvalidQueryParamsException;
configurable mappings for boolean values and a Uri\QueryParamNullPolicy enum for null
values (SkipTuple, KeyOnly as the default, EmptyString), and an array API for PHP's
bracket notation. toArray() takes a nesting limit (default 64). The RFC says toArray() is
not a general inverse of fromArray();
getQueryParams() and withQueryParams() methods on Uri\Rfc3986\Uri and Uri\WhatWg\Url;
different empty-field rules per parser. parseRfc1866() and parseRfc3986() keep empty
fields (for example the one after a trailing &) and give a field without = a null
value. parseWhatWgUrlSearchParams() (named parseWhatWg() before 19 October) drops empty fields and gives such a field an empty string. The RFC says
that recomposing and reparsing a list is not guaranteed to reproduce every possible list.
The RFC presents the class as an alternative to $_GET, which it does not propose to change.
It lists the differences someone migrating would see: $_GET replaces dots and spaces in
names with underscores, keeps only the last value of a repeated name, and drops input beyond
max_input_vars with a warning. QueryParams keeps the names as given, keeps all
occurrences, and throws when its own limit is exceeded. The RFC states that the change is
backward compatible.
Evidence and limitations
The implementation, php-src PR #22551, was an
open draft when checked on 2026-10-04. It was last updated 2026-07-05.
The discussion thread opened in February. Its newest
public message was dated 2026-07-16 when checked on 2026-10-04, and no reply mentions the
1, 3 or 4 October page edits. The wiki revision history requires a login, so what those edits
changed is unknown. After the 4 October edit, the status, version, open issues ("None"),
parsing limits and the vote placeholder were unchanged.
The wiki change feed shows another edit on 2026-10-06 at 09:21 UTC; the internals feed has no new
message on the thread. Afterwards the header still read version 1.0, Under Discussion, and the default
parsing limits were still 10,000 bytes and 1,000 parameters. The page and its raw export were
truncated at 18,000 characters, so the open issues and vote block were not re-checked.
The page's vote block still has placeholder dates ("2026-xx-xx") and is marked closed, but
its widget carries a 2026-10-30 close date. This page treats the vote as not opened; a
close date in a template is not a vote announcement.
The opening message noted unresolved points (the array API, and whether the class should be
readonly). The current page lists no open issues and declares the class final readonly.
On 2026-10-06 at 13:37 UTC the author posted a changelog
of the reworked RFC: readonly class, QueryParamNullPolicy replacing a boolean option,
parsing limits applying only during parsing with the nesting limit belonging to toArray(),
documented type conversions, decided array-API questions, the Uri/Url integration methods and
specified handling of empty fields, malformed percent-encoding and invalid UTF-8. The author
wrote that they would like to "bring this proposal to a vote as soon as possible (but not
sooner)". No vote has been announced. The null-policy enum, toArray() nesting default and
Uri/Url methods were checked on the page; the rest of the changelog was not checked
individually because the page is truncated at 18,000 characters.
The wiki change feed shows a further edit on 2026-10-08 at 11:44 UTC, with no edit summary and
no new message on the thread. Afterwards the header still read version 1.0, dated 2026-02-13,
Under Discussion, with PR #22551 as the implementation, and the default parsing limits were
unchanged. What the edit changed is unknown, and no vote has been announced.
On 2026-10-09 at 12:05 UTC Tim Düsterhus posted a 14-point review
of the reworked RFC. They called most points minor and said they are "super happy" with the RFC. The
suggestions include: dropping $maxQueryStringLength (a manual strlen() check is enough) and
perhaps turning the parameter-count limit into a plain argument; passing building options to the
to*() methods instead of storing them; dropping parseRfc3986(), because RFC 3986 does not define
query-parameter handling; renaming parseWhatWg() to something like parseUrlSearchParams();
questioning hasValue(), deleteValue() and withArray(); and noting that the backward
compatibility section should mention the new class name in the Uri namespace. They also called
accepting invalid percent-encoding sequences risky, without describing a concrete issue. No author
reply or page change was seen by 16:02 UTC.
The wiki change feed shows an edit by the author on 2026-10-15 at 13:58 UTC, with no new message on the
internals feed. Afterwards the header still read version 1.0, dated 2026-02-13, Under Discussion, open
issues "None", and the vote block still had placeholder dates. The page still has $maxQueryStringLength,
parseRfc3986(), parseWhatWg(), hasValue(), deleteValue() and withArray(), so the review's main renaming
and removal suggestions were not adopted. What the edit changed is unknown. The middle of the page (about
39,000 characters) was not re-read.
On 2026-10-16 at 12:53 UTC the author replied to the review.
They said they found no vulnerability that the length limit prevents, and would drop $maxQueryStringLength unless
someone has a use case. The parameter-count limit would then become a plain parameter. They would rename list() to
toList() and parseWhatWg() to parseWhatWgUrlSearchParams(), and switch the RFC 1866 and RFC 3986 parsers to strict
parsing, so that invalid query syntax throws (invalid UTF-8 would still be accepted). They would also replace mixed
in append()/set() with string|int|float|BackedEnum|null, where null always adds a key without a value, and split
sorting into sortByBytes() and a WHATWG-compatible sortByUtf16(). They kept parseRfc3986() because of the +
handling (?q=C++ gives C++, not C ), and kept hasValue(), deleteValue() and withArray(), citing the
WHATWG URLSearchParams specification for the first two. They were still undecided about fromArray() conversions and the
building options. They said the backward-compatibility section is fixed, but the change feed shows no page edit after
2026-10-15 13:58 UTC. These are stated intentions, not page changes, and no vote has been announced.
The wiki change feed shows another edit on 2026-10-19 at 07:58 UTC, with no new message on the internals feed.
Afterwards the page declares toList() instead of list(), and its backward-compatibility section says the new classes
may clash with userland symbols but that the Uri namespace belongs to ext/uri since PHP 8.5. Earlier runs did not record
the previous wording of that section, so whether it changed in this edit or on 15 October is unknown. The other changes
announced on 16 October are not on the page: QueryParamParsingOptions still has $maxQueryStringLength, the parser is
still parseWhatWg(), append()/set() still take mixed, there is a single sort(), and the page still describes
tolerant parsing of malformed input. The header still reads version 1.0, Under Discussion, open issues "None", with
placeholder vote dates. The full page (about 52,000 characters) was read.
The change feed shows a further edit on 2026-10-19 at 13:30 UTC, again with no new internals message. The full page,
read at about 16:05 UTC, now names the WHATWG parser parseWhatWgUrlSearchParams() in the API listing and examples;
parseWhatWg() no longer appears. The other announced changes are still absent:
$maxQueryStringLength, mixed values in append()/set()/hasValue()/deleteValue(), a single sort() and the
tolerant-parsing description (malformed percent-encoding is preserved, not rejected) are unchanged. The header still
reads version 1.0, Under Discussion, with placeholder vote dates.
The change feed shows an edit by the author on 2026-10-26 at 10:43 UTC, with no new internals message. The full page
(about 57,000 characters) was read at about 11:05 UTC. The header still reads version 1.0, dated 2026-02-13, Under
Discussion, open issues "None", with placeholder vote dates ("2026-xx-xx") and a 2/3 majority. The announced changes
that were still absent on 19 October are still absent: $maxQueryStringLength (default 10,000), mixed values in
append()/set()/hasValue()/deleteValue(), a single sort() and tolerant parsing of malformed percent-encoding.
The page ends with Rejected Features and Changelog sections. Both say the bracket-aware getArray(),
appendArray() and setArray() methods were replaced by fromArray(), toArray() and withArray(). Earlier runs
did not record whether those sections existed, so what this edit changed is unknown. No vote has been announced.
A further edit at 15:05 UTC on 2026-10-26 (again without an internals message) leaves the header (version 1.0,
Under Discussion), the placeholder vote dates and $maxQueryStringLength unchanged, checked at about 17:10 UTC;
what it changed is unknown.
On 2026-10-27 at about 13:54 UTC the author followed up on their
16 October reply. They now think an automatically enforced $maxQueryStringLength can still be useful: parsing is
cheap, but other operations such as sorting by long keys may be slow (not measured, they said), and memory use matters
"in the light of the recent CVEs". Strict RFC 1866/RFC 3986 parsing would make migrating from $_GET via
parseRfc1866($_SERVER["QUERY_STRING"]) harder, because it would reject malformed input that PHP's existing
query-string parser accepts. They said sortByBytes() and sortByUtf16() are now in the RFC. Read at about 17:10 UTC,
the page (last modified 2026-10-26 15:05 UTC, so presumably that edit) declares sortByBytes() and sortByUtf16() and
still has $maxQueryStringLength (default 10,000); the header still reads version 1.0, Under Discussion. The page was
read in two parts and not every section was rechecked. No vote has been announced.
Under discussion; not accepted. The RFC page (version 0.4; the page keeps the 2026-09-27
date) and the official RFC index both list it as under discussion. Its proposed version is PHP 8.7.
The voting thread reads "tbd", and no vote has been opened. On 21 October the author announced a plan to open the
vote on Friday 23 October, then postponed it the same evening without a new date (see below).
The proposal would add native terminal primitives to ext/standard, for POSIX terminals and
Windows consoles. Today libraries call tools such as stty or use the Windows Console API
directly.
Proposed API (version 0.4)
Version 0.4 was published on 2026-10-05 (20:37 UTC wiki edit). It replaces version 0.3's
userland-implementable interfaces with concrete classes.
Io\Terminal\Terminal is a single final native class with a private constructor. Instances
come only from Terminal::fromStdio() or Terminal::fromStreams($input, $output = null).
fromStdio() resolves the standard descriptors when an operation runs, while fromStreams()
keeps the supplied streams. Terminal and ModeToken cannot be cloned or serialized.
ModeToken is a final opaque class that userland cannot construct. enableRawMode() returns
one lease token, and restoreMode(ModeToken $mode) releases it. Leases are shared per logical
terminal within a request, and the last release restores the saved mode. Destroying a token
and request shutdown restore the mode only on a best-effort basis. A token inherited after
pcntl_fork() cannot be explicitly restored in the child.
getSize(): ?TerminalSize returns null when no usable size is available. It does not fall
back to COLUMNS/LINES. TerminalSize is a final readonly value object with a public
constructor that throws ValueError for non-positive dimensions.
readKey() returns a Key enum case (arrows, function keys, Resize and so on), a string or
null on timeout. readLine() reads one line and returns null on immediate EOF; it has no
timeout and throws while a raw-mode lease is active on the same native terminal.
readSecret() reads input without echoing it; Escape, Ctrl+C and Ctrl+D cancel it with an
exception. Timeouts are Time\Duration values, from the
Duration class RFC, which the official index lists
as implemented.
Operational failures, and EOF during readKey()/readSecret(), throw
Io\Terminal\TerminalException, declared as extending \Io\IoException. Invalid arguments
such as negative durations or consumed tokens throw ValueError.
The declared API block contains five Io\Terminal\ symbols: TerminalException, Key,
TerminalSize, ModeToken and Terminal. The RFC lists prompts, history, completion, line
editing and the existing readline extension as outside its scope. Code that already declares
those names would conflict with them.
Evidence and history
The author's internals announcement names the
ext-terminal extension (Packagist prateekbhujel/php-terminal) as the reference
implementation and draft php-src PR #23941 as the
core implementation. Version 0.3's discussion status recorded that, after review on the list, the
initial draft's Terminal::create() was replaced by SystemTerminal::fromStdio(), the
interfaces and native classes were renamed, readLine() was added, and failures and timeouts
now use TerminalException and null. Version 0.4 then removed the interfaces and renamed SystemTerminal to
Terminal (see below). Whether PR #23941 already matches version 0.4 was not checked.
Testing approach: interfaces removed
Version 0.3 had Terminal and ModeToken interfaces, added after a request for a way to mock
the terminal. Tim Düsterhus and Bob Weinand argued that
the TTY stream, not the terminal object, is the IO boundary, and that a userland ModeToken
could not be restored by the native terminal. Version 0.4 follows that view. Ordinary PHP
streams passed to fromStreams() now provide scripted input for tests: readKey() decodes the
bytes, readLine() reads through the stream layer, readSecret() does not echo the input to the
output stream, and enableRawMode() returns a no-op lease instead of failing. The RFC states that
such streams do not simulate terminal dimensions, resize events or native mode failures, and that
applications needing replaceable implementations can define their own abstraction. Whether
version 0.4 settles the list discussion is not yet known. The inspector truncated the RFC page at
18,000 characters, so its later sections (including any changelog) were not read.
Stream abstraction question
On 2026-10-06 Jakub Zelenka asked whether the
API should use some stream abstraction. The message notes that streams are not used directly in
Io so far: the underlying file descriptors are abstracted through Poll\Handle
implementations, which IO hooks also use for direct reads and writes. The message calls this
something to consider, not a blocker. The RFC author
replied on 2026-10-07, leaning towards keeping
fromStdio() and fromStreams() in this RFC. The reply says fromStreams() should keep the
supplied stream's buffering and input behaviour, including php://memory, and that the API also
needs the native terminal for mode changes and Windows console input. A factory for a shared
abstraction could be added later, but ownership and buffering rules would still need work. The
reply asks which abstraction was meant; no answer had been collected when this page was updated.
The RFC page (version 0.4) has not changed.
Vote widget added
On 2026-10-09 at 12:40 UTC the author said they had
left the voting widget out of the RFC and had now added it, with the API unchanged. The wiki change
feed records the edit ("Add voting choices.") at 12:30 UTC. The page still reads version 0.4, Under
Discussion, voting thread "tbd". No vote date was announced. The bounded fetch cut the page off
before the vote section, so the question and required majority were not read.
Vote planned for 23 October
At 12:32 UTC on 21 October the author wrote in the discussion thread that they
plan to open voting on the Io\Terminal RFC on Friday, 23 October, and asked for any further questions or concerns. A
planned date is not an opened vote. The RFC page was not re-read in this cycle, and the official RFC index collected
at 16:01 UTC still lists the RFC as under discussion.
Vote postponed
At 18:21 UTC on 21 October Tim Düsterhus replied that large parts of the core
team had been busy with that day's security release and might not have caught up with RFCs, said he had not yet read
the latest iteration, and suggested waiting with the vote until things calm down. At 18:44 UTC the author
answered that they will hold off on the 23 October vote and send a fresh
intent-to-vote notice once things have settled. No new date was given. The official RFC index collected at 22:01 UTC
still lists the RFC as under discussion.
Review questions on 23 October
At 20:26 UTC on 23 October Sjoerd Langkemper replied with questions rather
than objections. He asked whether user cancellation, EOF and genuine errors should be told apart (for example with
TerminalException subclasses), whether the RFC's 25-millisecond blocking-read default is long enough over SSH and
whether it is configurable for readSecret(), whether two resizes produce two Key::Resize events and whether one is
still reported after getSize(), and whether a zero (non-blocking) timeout can read escape sequences. No author reply
had been collected at 22:01 UTC. When the RFC page was read at about 22:05 UTC it was unchanged (version 0.4, Under
Discussion, voting thread "tbd", last modified 2026-10-09 12:30 UTC), and no vote date had been announced.
Author reply on 23 October
At 23:44 UTC on 23 October the author replied to those questions. The reply
says that four of the points need changes, but the RFC page has not changed yet:
Exception subclasses: user cancellation, EOF and I/O errors all throw TerminalException today, and its messages
are not stable identifiers. The author would like to add subclasses before the vote and keep TerminalException as
the common type to catch.
25 ms escape wait: the wait starts after an Escape byte arrives, so it does not limit an SSH round trip. Delayed
fragments can still go past it. readKey() lets callers raise sequenceTimeout. readSecret() uses a fixed 25 ms
that cannot be configured, which the author calls "a limitation worth addressing". Native Windows console input
uses input records, so this timing does not apply there.
Resize events: two resizes do not necessarily produce two Key::Resize events, because POSIX notifications can
be merged. getSize() updates the same cached size, which can hide a change. The author thinks getSize() should
query the size without acknowledging a pending notification. Key::Resize would then mean "check the current size".
Zero timeout: with a zero deadline the decoder returns Escape before it reads the rest of a sequence, even when
the whole sequence is already buffered. The author plans a regression test and a fix.
The author wrote that these findings come from reading the code and that the new reproducers had not been run yet.
Follow-up results were promised. When the RFC page was read at about 04:05 UTC on 24 October it was unchanged
(version 0.4, Under Discussion, voting thread "tbd", last modified 2026-10-09 12:30 UTC). No vote date has been
announced.
Fixes pushed on 24 October
At 17:12 UTC on 24 October the author reported that fixes and regression tests
had been pushed to php-src PR #23941. The PR's commit list includes "Fix
zero-timeout escape decoding and preserve pending resize across g…" (title truncated on the page) and "Fix terminal readKey EOF handling for incomplete UTF-8".
According to the message:
zero-timeout reads now decode an escape sequence that is already available, without waiting;
getSize() no longer suppresses a pending resize notification;
testing found that incomplete UTF-8 at EOF could make readKey() keep returning null. It now throws
TerminalException on EOF, while a genuine timeout still keeps the partial bytes.
The message does not mention the other two points from the 23 October reply, TerminalException subclasses and the
fixed 25 ms readSecret() escape wait. When the RFC page was read at about 22:05 UTC it was unchanged (version 0.4,
Under Discussion, last modified 2026-10-09 12:30 UTC), and no vote date had been announced. Only the commit titles
were checked, not the code or test results.
Limitations
This page summarises a proposal under discussion. Names, semantics and the target version can
change before a vote, and nothing here is available in released PHP.
Under discussion. The RFC (version 1.0, dated 2026-09-21) proposes three symbols in the
Time\ namespace: an immutable Time\Instant class for an absolute point on the timeline,
a Time\Clock interface, and a Time\Clock\SystemClock implementation. Its proposed version
is the next minor, PHP 8.7. The page's status line reads "Under Discussion" (it read "Unter
Discussion" when first checked on 2026-10-01); the official RFC index lists it as discussion.
Design points stated in the RFC
An instant carries no timezone or calendar; arithmetic moves it by a Time\Duration.
Leap seconds are ignored, following common language and operating-system practice.
A clock interface lets code obtain "now" through an injectable dependency, which helps testing.
A toInstant() method on DateTimeInterface, DateTime and DateTimeImmutable would
convert an existing object, dropping its timezone but keeping microsecond precision. A
2026-10-06 edit added this method to the backward-compatibility section: it could conflict
with a method of the same name declared in a userland subclass. The RFC notes that adding
symbols is generally not considered a break under policy.
Time\Clock\SystemClock is a singleton. Its constructor is private, and the instance comes
from SystemClock::get(). The authors made this change after list feedback
(message 132825, 7 October). now() returns
values that are not guaranteed to increase monotonically.
Unix-timestamp conversions use a to prefix: toUnixTimestamp() and
toUnixTimestampMilliseconds(). This follows the convention of toIso8601DateTimeString() and
toInstant() (message 132829).
getNanoseconds() keeps its name and returns the sub-second fraction (0 to 999 999 999). The
RFC leaves the instant's epoch unspecified.
Time\Instant will not implement JsonSerializable. In
message 132827 the authors said JSON has no
canonical representation for an instant, and that a method that always throws would make it
look supported. They said json_encode()'s default object output is a problem for ext/json to
solve. Regular PHP serialization is supported, but its format is an implementation detail.
The authors want a configurable-resolution "coarse" clock to be a decorator, not part of
SystemClock, and consider it out of scope, like testing clocks.
The RFC compares Time\Clock with PSR-20's ClockInterface, which returns DateTimeImmutable
instead; ready-made testing clocks are listed as future scope.
It builds on the Duration class RFC, which the
official index lists as implemented. The vote, when opened, is a single 2/3-majority question.
Limitations
This page summarises the proposal only. The page still shows version 1.0 and has no changelog
entry for these edits. The renames and the singleton come from the RFC stubs as checked at
16:01 UTC on 2026-10-07 and from the authors' messages. Other points in the
review thread are still open. On 9 October the reviewer (Marc, who
collected the review points on 6 October) replied:
they accept keeping the coarse clock out of scope, but would prefer a future built-in coarse system
clock over a decorator, because a decorator must read the precise clock first; they cited their own
Linux arm64 measurements of about 13.3 ns for CLOCK_REALTIME and 3.3 ns for
CLOCK_REALTIME_COARSE. They still object to the name getNanoseconds() and propose
getNanoOfSecond() or getNanosecond() (matching DateTime::getMicrosecond()). These are review
comments, not RFC changes. The page's last-modified line was cut off by the bounded fetch on 9 October,
so a later page edit was not ruled out. On 9 October Tim Düsterhus agreed to disagree
with a participant who wanted a clock implementing both Time\Clock and PSR-20's ClockInterface,
and said a short note on this had been added to the rejected features. The wiki change feed summary
for the 12:32 UTC edit instead reads "Add renaming now() to rejected features". The bounded fetch cut
the page off before that section, so neither note was read on the page. Names, methods and the target version can change
before a vote, and nothing here is available in released PHP.
Reject bcrypt passwords longer than 72 bytes proposal
Inactive; not accepted. The status signals conflict. The official RFC index, collected at
10:01 UTC on 5 October, now lists this RFC as inactive. On 4 October it listed it as under
discussion, and before that as a draft. The RFC page itself still says Draft, version 0.1, and
its changelog has only its 2026-09-27 entry. Its discussion-thread field links the internals
thread (news-web.php.net/php.internals/132689). On 5 October the author
wrote that the proposal had drawn "much criticism because
of its backwards incompatibility" and that they did not think it "is worth pursuing further at
the moment". They now propose the opt-in PASSWORD_BCRYPT_SHA256 algorithm
instead. The page does not say the RFC is withdrawn. No vote was opened.
What is proposed
When password_hash() uses PASSWORD_BCRYPT (including PASSWORD_DEFAULT when it resolves
to bcrypt) and the password exceeds 72 bytes:
PHP 8.7 would emit E_DEPRECATED;
PHP 8.8 would throw ValueError.
password_verify() is deliberately left unchanged so that existing hashes made from longer
inputs still verify. The RFC proposes a single 2/3-majority vote. Voting has not started, and the
page's voting-thread and implementation fields read "tbd". Its references section names php-src
pull request #23076 ("Bcrypt 72 byte password handling"). The page's empty vote widget shows
0/0/0 and "This poll has been closed"; that is the template's default rendering, not a ballot.
Discussion so far
The motivation is authentication bypasses caused by silent truncation when applications
prepend nonces, peppers or other hashes to the password (the RFC cites CVE-2025-68402 in
FreshRSS). Early replies on the list are critical: respondents argue that input length is the
application's responsibility and that a runtime error would break users who choose long
passphrases. The outcome is open.
Later in the thread, Derick Rethans said he would vote
against it because of the backward-compatibility break. This is a stated intention; no vote
has been opened. As an alternative, Tim Düsterhus suggested adopting passlib's
bcrypt-sha256 construction, a defined pre-hashing scheme with its own output format. He also
argued that passing a raw binary pre-hash to bcrypt is fragile because the digest can contain
NUL bytes. The RFC author has opened a draft php-src PR,
#24073 "bcrypt_sha256", on 2026-10-02. As of
4 October this RFC page (still version 0.1) does not mention this alternative, and nothing in it
is accepted. At 11:27 UTC on 4 October the same author created a separate draft RFC,
PASSWORD_BCRYPT_SHA256, which proposes the alternative as a new opt-in algorithm.
It describes this RFC as a "previous attempt" but does not say it is withdrawn. That RFC moved to
discussion on 5 October, when the official index moved this one to inactive.
The page has a Discussion section that summarizes the opposition arguments
(backward compatibility, the limit being in bytes, which hits multi-byte scripts, sufficient
entropy below 72 bytes, rehash-on-login exposure) and the support arguments (harm from silent
truncation, NIST guidance against truncation, better API design). It lists no open issues.
Current behavior
Nothing has changed in released PHP. See bcrypt length limits
for today's truncation behavior and mitigations.
PASSWORD_BCRYPT_SHA256 for password_hash() proposal
Under discussion; not accepted. The official RFC index lists this RFC under discussion (it
was listed as a draft on 4 October). At 09:20 UTC on 5 October the author
announced the RFC on the internals list. After a page
edit at 13:13 UTC the RFC page also reads Under discussion (still version 0.1) and links that
announcement as its discussion thread. The earlier conflict between the page header (Draft)
and the index is therefore resolved. The voting thread is "tbd", the changelog still has only the
2026-10-04 entry, and no vote has been opened. The author is Sjoerd Langkemper, who also wrote the
72-byte rejection proposal.
What is proposed
The RFC adds a new, opt-in password_hash() algorithm identifier, PASSWORD_BCRYPT_SHA256
(value "bcrypt-sha256"), plus PASSWORD_BCRYPT_SHA256_DEFAULT_COST = 12. The password is first
run through HMAC-SHA256, keyed with the 22-character bcrypt salt string. The base64-encoded
digest (44 bytes) is then passed to bcrypt. That input can't contain NUL bytes and is far below
bcrypt's 72-byte limit, so long passwords are no longer truncated.
Hashes look like $bcrypt-sha256$v=2,t=2b,r=<cost>$<salt>$<digest>. The RFC says this is
byte-for-byte Passlib's bcrypt_sha256 version 2 format, so PHP and Passlib hashes would be
interchangeable. That interoperability claim comes from the RFC and was not tested here.
password_verify(), password_needs_rehash(), password_get_info() and password_algos()
would recognise the new algorithm. cost keeps bcrypt's 4–31 range, and out-of-range values
throw ValueError.
PASSWORD_BCRYPT and PASSWORD_DEFAULT would not change. Changing the default is listed only
as future scope.
The hashes are longer than plain bcrypt hashes, so stored-hash columns may need widening.
At build level, ext/standard gains a compile-time dependency on ext/hash. The RFC argues
this has no practical effect because hash has been always enabled since PHP 7.4.
The vote, when opened, is planned as one question needing a 2/3 majority. The proposed version
is the next PHP 8.x ("e.g. PHP 8.7").
Relationship to the 72-byte proposal
This RFC follows from the internals discussion of the
72-byte rejection proposal, where Tim Düsterhus suggested
Passlib's construction instead. The new RFC calls that proposal and php-src PR #21675 (a
Blowfish NUL-byte fix) "previous attempts", and rejects changing PASSWORD_BCRYPT itself as too
risky. In the 5 October announcement, the author wrote that the 72-byte proposal had drawn "much
criticism because of its backwards incompatibility" and that they did not think it "is worth
pursuing further at the moment". The official index now lists that RFC as inactive. Neither
proposal is accepted.
Discussion so far
In the thread on 5 October, Tim Düsterhus supported the
proposal, citing Passlib as precedent. He also argued that the RFC overstates the NUL-byte
problem, because PHP already throws ValueError when a new password contains a NUL byte. He
asked separately whether the $2b$ bcrypt identifier should be supported, saying he understood
it to be identical to $2y$. Another participant asked for a separate "rounds" option. Tim
Düsterhus replied that bcrypt's rounds and PHP's cost are the same parameter, and that
keeping the name cost matches PASSWORD_BCRYPT. These are list comments; the RFC text had not
changed in response when it was inspected on 5 October.
Passlib is "not a trusted source for security related issues", and the RFC does not say which
official specification (an IETF RFC or a NIST document) describes bcrypt_sha256.
The scheme differs from the OWASP Password Storage Cheat Sheet, quoted as recommending
bcrypt(base64(hmac-sha384(password, pepper))) with the pepper kept out of the database.
Hashes may not work with other languages, such as C#, that share a credentials database.
The author replied by asking for a standardized
alternative with better interoperability, mentioning PBKDF2, which NIST standardizes but which
they called generally less resistant to offline cracking than bcrypt. A participant who signs as
Andrey objected to the pace. They said the PR had
been written a day after the idea was raised, and asked for time because they have been working on an
alternative for weeks and hope to publish it in a week or two. No alternative RFC page was seen.
The RFC page inspected on 8 October was unchanged (version 0.1, Under discussion, voting thread
"tbd").
On 9 October Rowan Tommins replied to the OWASP
objection. They said the "password shucking" attack it describes needs the same inner hash to exist
elsewhere for that user, which with a per-hash salted HMAC would need the same password and salt.
In their view the salt plays the role of the OWASP pepper. They also noted that OWASP recommends a
72-byte maximum password length, as the inactive length RFC did.
The objector replied that such questions belong with OWASP, and that following standards and
interoperability is what PHP should offer. Rowan Tommins answered
that they had asked no questions. They concluded that the OWASP page describes a weakness in similar
algorithms and that the proposed algorithm, while not identical to the OWASP suggestion, addresses the
same weakness differently, so it is "worth considering further". These are list opinions; the RFC page was
not re-checked in this cycle.
Implementation
The implementation is php-src PR #24073, opened on
2 October 2026 and now titled "ext/standard: bcrypt-sha256 password hash". GitHub labels it
"ABI break", and on 2–3 October a core reviewer requested changes, mostly to the tests. As of
8 October it is still open, not marked as a draft, and not merged (last updated 6 October).
Limitations
This page summarises a draft proposal only. Names, format details and the target version can
change, and nothing here is available in released PHP. For today's behavior, see
bcrypt length limits.
Under discussion; proposed for PHP 8.7. The RFC page (version 1.4, dated 2026-10-03)
specifies :$name in array construction and destructuring. It stands for the explicit
key/value form "name" => $name and applies to [], array() and list(), including
destructuring in foreach.
Only a single directly named variable (T_VARIABLE) qualifies; the key is its exact,
case-sensitive name. Variable variables, array dimensions, object or static properties and
arbitrary expressions are invalid, and so is the function-argument form foo(:$name).
Whitespace and comments may appear between : and the variable. Existing keyed-element rules
still apply: duplicate keys (the later element wins, including with spread), warnings for
missing keys, and the bans on mixing list() with [] and keyed with unkeyed destructuring
elements. Construction copies the value; [:&$name] is invalid, so a reference still needs
'name' => &$name. Destructuring with an ArrayAccess object reads offsets, not properties.
The page says voting has not started. It links a draft implementation,
php-src PR #24034, which was open and marked as
a draft on 3 October.
Spelling history. Version 1.2 (2026-09-30) used =$name, after the original :$name
was dropped because of possible confusion with ternary syntax. In an internals
message on 2 October, the author announced a return to
:$name. Version 1.4 adopts it, lists the equals-sign prefix as a rejected feature, and
documents how ternaries are parsed. The conflict noted on 2 October is resolved on the RFC
page. Until a vote, the spelling can still change in discussion.
This is a proposal, not supported stable PHP syntax. Recheck the
primary RFC before repeating examples or status.
Draft; not accepted. The RFC page (version 1.0, dated and last modified 2026-09-28) lists
its status as Draft and its target as PHP 8.7. It was not present in the collected official
RFC index on 2026-10-02.
The proposal adds a procedural intl_date_format() to ext/intl, wrapping
IntlDateFormatter so that a single call can format a DateTimeInterface, a Unix timestamp
or a date string. Optional parameters cover locale, date/time style constants, timezone,
calendar and an ICU pattern that overrides the style constants. The RFC says it returns a
string on success, never false, and throws TypeError, ValueError or IntlException on
errors. It describes an internal formatter cache and reports no backward-compatibility break.
Limitations: no discussion outcome was reviewed. Today, the same formatting is available through
IntlDateFormatter objects. Related: Time\Instant and Time\Clock.
Draft; not accepted. The RFC page (version 0.2, dated 2026-09-29) lists its status as
Draft. It was not present in the collected official RFC index on 2026-10-02, so its status
here comes only from the page itself. No target PHP version was stated in the reviewed text.
The proposal builds on IO hooks and operations. That RFC's poll-based operation
queue can wait for socket or pipe readiness, but cannot help with operations that have no
readiness notion, such as regular-file reads, fsync() or host-name lookups. The Ring
(Io\Ring\Engine, an Io\OperationQueue) would perform such operations itself so that a Fiber
could suspend instead of blocking the process.
It would be implemented on a bundled C library, ior, with three backends: io_uring on Linux,
IO completion ports on Windows, and a thread pool elsewhere. The page names the thread pool as
the Linux fallback when io_uring cannot be used (for example kernels older than 5.19,
io_uring_disabled or restrictive seccomp profiles). The RFC reports that the backend is chosen
automatically and exposed only informationally. It explicitly does not use libuv.
The RFC includes its own benchmark comparisons and makes some modes opt-in on that basis;
these are the author's measurements, not independent results.
Under discussion. The proposal describes a request-local provider interface through
which blocking waits and IO operations can be handled by an event loop or Fiber scheduler.
It aims to let ordinary blocking-style calls cooperate with such a provider.
The RFC separates the integration mechanism from scheduling policy; it does not itself
supply a built-in scheduler. The proposal depends on the related Polling API additions.
The companion Ring API is described as a separate draft.
Do not treat this as available PHP behavior or infer acceptance from the activity around it.
Read the RFC for operation and platform details.