PHP - BlogFlockAll things PHPhttps://blogflock.com/list/VqY0J2026-11-19T10:56:28.000ZBlogFlockexakatRecently updated PIE extensions #16 (since November 12th, 2026) - Exakathttps://www.exakat.io/?p=165992026-11-19T10:56:28.000ZExakat<h1><a href="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16529" src="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300.png" alt="Recently updated PIE extensions #14" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150@2x.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150.png 150w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-500x500.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-100x100.png 100w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png 640w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300@2x.png 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Recently updated PIE extensions #16 (since November 12th, 2026)</h1>
<p>41 PHP Pie extensions were updated.</p>
<ul>
<li><a href="https://packagist.org/packages/flow-php/arrow-ext">flow-php/arrow-ext</a> (0.48.0): Apache Arrow and Parquet bindings for flow-php/parquet (Rust)</li>
<li><a href="https://packagist.org/packages/aheinze/scriptlite-ext">aheinze/scriptlite-ext</a> (0.1.3): C extension for ScriptLite — high-performance ECMAScript interpreter with native C parser</li>
<li><a href="https://packagist.org/packages/openswoole/ext-openswoole">openswoole/ext-openswoole</a> (v26.11.0): High Performance Programmatic Server for PHP with Async IO, Coroutines and Fibers</li>
<li><a href="https://packagist.org/packages/symfony/deepclone">symfony/deepclone</a> (v0.8.11): Export any serializable PHP values as pure arrays – accelerator for Symfony’s DeepCloner</li>
<li><a href="https://packagist.org/packages/php-debugger/php-debugger">php-debugger/php-debugger</a> (0.5.0): Zero-overhead debugging for PHP</li>
<li><a href="https://packagist.org/packages/intelligent-intern/king-ext">intelligent-intern/king-ext</a> (v1.0.15-beta): King native PHP extension packaged for PIE</li>
<li><a href="https://packagist.org/packages/flow-php/flow-php-ext">flow-php/flow-php-ext</a> (0.48.0): Flow PHP native extension (Rust) – native column backend, CSV/JSON readers, Parquet ETL through arrow-ext</li>
<li><a href="https://packagist.org/packages/xberg-io/tree-sitter-language-pack">xberg-io/tree-sitter-language-pack</a> (v1.27.0): Pre-compiled tree-sitter grammars for 371 programming languages</li>
<li><a href="https://packagist.org/packages/xberg-io/liter-llm">xberg-io/liter-llm</a> (v2.7.3): Universal LLM API client with Rust-powered polyglot bindings.</li>
<li><a href="https://packagist.org/packages/xberg-io/xberg">xberg-io/xberg</a> (v1.4.2): High-performance document intelligence library</li>
<li><a href="https://packagist.org/packages/xberg-io/html-to-markdown">xberg-io/html-to-markdown</a> (v3.22.2): High-performance HTML to Markdown converter</li>
<li><a href="https://packagist.org/packages/grpc/grpc-php-ext">grpc/grpc-php-ext</a> (v1.85.3): gRPC PHP Extension</li>
<li><a href="https://packagist.org/packages/extport/grpc">extport/grpc</a> (1.85.3): Unofficial PIE-compatible mirror of grpc/grpc</li>
<li><a href="https://packagist.org/packages/libaura/ext-aura">libaura/ext-aura</a> (v1.0.6): PHP extension for the Aura color palette extraction library, inspired by Google’s Palette library</li>
<li><a href="https://packagist.org/packages/iliaal/fast_uuid">iliaal/fast_uuid</a> (0.9.0): Fast RFC 9562 UUID generation (v1/v2/v3/v4/v5/v6/v7/v8 + nil/max) as a PHP C extension, with a ramsey/uuid-shaped object API and procedural fast-path functions.</li>
<li><a href="https://packagist.org/packages/phpstan/turbo">phpstan/turbo</a> (2.3.7): Native acceleration extension for PHPStan</li>
<li><a href="https://packagist.org/packages/cachewerk/ext-relay">cachewerk/ext-relay</a> (v0.61.1): The fastest Redis client for PHP. 100× faster cache reads, near-zero bandwidth, no code changes required.</li>
<li><a href="https://packagist.org/packages/libsnobol4/snobol">libsnobol4/snobol</a> (v1.1.1): SNOBOL4-style pattern matching for PHP — native C extension</li>
<li><a href="https://packagist.org/packages/xberg-io/crawlberg">xberg-io/crawlberg</a> (v1.13.1): High-performance web crawling engine</li>
<li><a href="https://packagist.org/packages/valkey-io/valkey-glide-php">valkey-io/valkey-glide-php</a> (v1.2.0): Valkey GLIDE for PHP</li>
<li><a href="https://packagist.org/packages/orieg/expanse-extension">orieg/expanse-extension</a> (v0.19.0): Native PHP Zend Engine extension for Expanse: modern Judy arrays in pure Rust (ext-php-rs). Userland API: orieg/expanse.</li>
<li><a href="https://packagist.org/packages/xqkeji/xqkeji">xqkeji/xqkeji</a> (v1.2.2): xqkeji low-code development framework PHP extension</li>
<li><a href="https://packagist.org/packages/kjdev/bzip3">kjdev/bzip3</a> (0.1.3): A compression/decompression with BZip3</li>
<li><a href="https://packagist.org/packages/maxmind-db/reader-ext">maxmind-db/reader-ext</a> (v1.15.0): C extension for MaxMind DB Reader – provides significantly faster lookups</li>
<li><a href="https://packagist.org/packages/osmanov/pecl-ev">osmanov/pecl-ev</a> (1.3.1): PECL extension providing interface to libev library</li>
<li><a href="https://packagist.org/packages/solarwinds/apm_ext">solarwinds/apm_ext</a> (3.0.0): C extension for solarwinds/apm</li>
<li><a href="https://packagist.org/packages/swoole/swoole">swoole/swoole</a> (v6.3.0-rc2): Swoole is an event-driven, asynchronous, coroutine-based concurrency library with high performance for PHP.</li>
<li><a href="https://packagist.org/packages/vergil-lai/lexsift">vergil-lai/lexsift</a> (v0.2.0): PHP extension for fast keyword and phrase matching using Aho–Corasick.</li>
<li><a href="https://packagist.org/packages/phasync/ext-phasync">phasync/ext-phasync</a> (2.0.9): PHP extension that makes blocking I/O (PDO, mysqli, curl, streams, sleep) wait cooperatively in fibers an event loop manages (phasync\ext\Suspension), and per-coroutine requests (sapi()).</li>
<li><a href="https://packagist.org/packages/fiber-interop/ext-scope">fiber-interop/ext-scope</a> (v0.6.1): The Scope class from the PHP RFC “Scope”, as a PHP extension (PHP 8.2+).</li>
<li><a href="https://packagist.org/packages/pecl/ssh2">pecl/ssh2</a> (1.6.1): Bindings for the libssh2 library</li>
<li><a href="https://packagist.org/packages/flyingmana/php-openvc">flyingmana/php-openvc</a> (4.0.1-beta): PHP extension bindings for OpenCV</li>
<li><a href="https://packagist.org/packages/skunkwerkx/hypertabular">skunkwerkx/hypertabular</a> (v1.1.0): Delimited text (CSV, TSV) and workbooks (XLSX, ODS, Numbers) read a batch at a time into typed columns, every cell a HyperCast Success/Fault verdict — a PHP extension over a Rust core, installed with PIE.</li>
<li><a href="https://packagist.org/packages/osmanov/pecl-eio">osmanov/pecl-eio</a> (4.0.1): Provides interface to libeio library.</li>
<li><a href="https://packagist.org/packages/chaikivskyi/php-pdfium">chaikivskyi/php-pdfium</a> (0.2.0): Fast native PDF extension for PHP, built on PDFium</li>
<li><a href="https://packagist.org/packages/danog/mongo-php-async-driver">danog/mongo-php-async-driver</a> (v0.2.0): Drop-in replacement for the mongodb PHP extension (ext-mongodb 2.5.6) in pure Rust, with async I/O in fibers through Revolt</li>
<li><a href="https://packagist.org/packages/janalis/php-profiler">janalis/php-profiler</a> (v0.1.0-alpha.13): Local PHP profiler implemented in Rust</li>
<li><a href="https://packagist.org/packages/protectyourephp/pyp-ext">protectyourephp/pyp-ext</a> (0.3.0): PYP (ProtectYourePHP) – native PHP extension for the PYP loader</li>
<li><a href="https://packagist.org/packages/zydbkqf/ext-onnxruntime">zydbkqf/ext-onnxruntime</a> (0.4.10): Native ONNX Runtime inference for PHP: Tensor conversion, I/O Binding, async tasks, device tensors, CoreML and CUDA Plugin EP support.</li>
<li><a href="https://packagist.org/packages/tacman/opencv-php">tacman/opencv-php</a> (0.2.0): PHP bindings for OpenCV 5, generated from OpenCV’s own header annotations</li>
<li><a href="https://packagist.org/packages/paddor/omq-binding.php">paddor/omq-binding.php</a> (0.1.4): OMQ.php: the zmq PHP extension, with the ext-zmq API, on the OMQ engine</li>
</ul>
<p>The post <a href="https://www.exakat.io/16599-2/">Recently updated PIE extensions #16 (since November 12th, 2026)</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>PhpStorm Light: Experimenting With a Lighter Version of PhpStorm - PhpStorm : The IDE that empowers PHP developers | The JetBrains Bloghttps://blog.jetbrains.com/?post_type=phpstorm&p=7578102026-11-17T13:59:39.000ZPhpStorm : The IDE that empowers PHP developers | The JetBrains Blog<p>You may have never heard of PhpStorm Light, or you may be using it and wondering if this Early Access build is ever going to make its way into a major release.</p>
<p>In this post, we explain what PhpStorm Light is, what we’ve learned from this experiment, and what’s happening next.</p>
<figure class="wp-block-image size-full"><img fetchpriority="high" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/image-51.png" alt="" class="wp-image-757811" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h2 class="wp-block-heading">What is PhpStorm Light?</h2>
<p><a href="https://phpstorm.dev/light-mode" target="_blank" rel="noopener">PhpStorm Light</a> has been available since June under the <a href="https://www.jetbrains.com/phpstorm/nextversion/" target="_blank" rel="noopener">Early Access Program (EAP)</a> as an experimental, trimmed-down version of PhpStorm. Its goal was to test quickly and boldly which optimizations could improve startup time, reduce memory consumption, and eliminate whatever slows PHP developers down – without disrupting the workflows they rely on. </p>
<p>Like every JetBrains IDE, PhpStorm is built on the IntelliJ Platform and benefits from many of the improvements introduced there. For example, version 2026.3 added an <a href="https://blog.jetbrains.com/phpstorm/2026/11/whats-new-in-phpstorm-2026-3/#jetbrains-air-one-place-to-run-your-agents-and-verify-their-work">agent-first development workspace</a>, a <a href="https://blog.jetbrains.com/phpstorm/2026/11/whats-new-in-phpstorm-2026-3/#quick-tasks-and-edits-without-opening-a-project">projectless Welcome screen</a>, and <a href="https://blog.jetbrains.com/phpstorm/2026/11/whats-new-in-phpstorm-2026-3/#github-and-gitlab-changes-in-a-separate-worktree">separate worktrees for PR/MR reviews</a>.</p>
<p>PhpStorm Light, on the other hand, focuses on tools, project structures, and workflows that are specific to PHP development. We experimented with:</p>
<ul class="wp-block-list">
<li><strong>Faster startup:</strong> Smarter project scanning and indexing order, less unnecessary work during startup, and clearer indexing progress.</li>
<li><strong>Smoother editing:</strong> A lighter inspection profile by default, a smart mode toggler, and other optimizations.</li>
<li><strong>Lighter footprint:</strong> Not loading tools (e.g. for databases) until you actually need them, and making rarely used features and plugins opt-in.</li>
</ul>
<h2 class="wp-block-heading">Why a separate build?</h2>
<p>We wanted to explore what would happen if we rethought some of PhpStorm’s long-standing defaults. But it’s hard to test this in a regular release that development teams rely on every day. Changing what loads at startup, which inspections run by default, and which plugins come bundled affects everyone at once.</p>
<p>A separate build gave us the freedom to experiment with these changes and gather feedback from PHP developers who had opted in and understood what they were testing. </p>
<p>That is also why it’s distributed separately: PhpStorm Light is an experiment, not a product.</p>
<h2 class="wp-block-heading">What we’ve learned</h2>
<ul class="wp-block-list">
<li><strong>Much of the overhead is work you haven’t asked for yet.</strong> PhpStorm does a lot in the background as soon as a project opens: checking for updates, scanning for places to make suggestions, and preparing information you may never look at. In PhpStorm Light, this work is deferred until you actually need it. This means less work during startup and while you’re typing.</li>
</ul>
<ul class="wp-block-list">
<li><strong>Faster doesn’t have to mean fewer features.</strong> PhpStorm Light changes what’s enabled by default, not what is available. Features and plugins that aren’t enabled out of the box are still there, and you can enable them whenever you need them.</li>
</ul>
<ul class="wp-block-list">
<li><strong>Not every change is right for everyone.</strong> Some of the new defaults will not suit every developer or workflow. We’re still evaluating them, and we are <a href="https://youtrack.jetbrains.com/newIssue?project=WI&description=%23%23%23+Steps+to+Reproduce%0A%0A1.%0A2.%0A3.%0A%0A%23%23%23+Expected+Result%0A%0A%0A%0A%23%23%23+Actual+Result%0A%0A%0A%0APlease+attach+the+log+files+%28Help+%7C+Collect+Logs+and+Diagnostic+Data%29+and+provide+any+additional+information+below.%0A%0AAttach+a+code+sample+as+text%2C+a+screenshot%2C+or+a+screencast+if+possible%0A&c=Assignee+Ivan.Fedorov&c=State+Open&c=Triaged+Yes&c=tag+phpstorm-light" target="_blank" rel="noopener">open to your feedback</a>.</li>
</ul>
<p>So, here’s the plan: We’re bringing some of PhpStorm Light’s improvements right into PhpStorm, making sure that every change to a long-standing default comes with a simple way to restore the previous behavior.</p>
<h2 class="wp-block-heading">What’s next?</h2>
<p><strong>If you’re using the standard PhpStorm build,</strong> several PhpStorm Light improvements will arrive through regular updates. We’ll explain each change when it ships. There is no need to install a separate build.</p>
<p><strong>If you’re using PhpStorm Light, </strong>nothing changes for now. However, PhpStorm Light builds will eventually be discontinued once the changes are merged into the mainstream PhpStorm build. </p>
<p>Thank you to everyone who tried this experimental build and took the time to tell us what worked and what didn’t. </p>
<p>Is there anything else we should take into account? Let us know in the comments to this blog post or provide your feedback <a href="https://youtrack.jetbrains.com/newIssue?project=WI&description=%23%23%23+Steps+to+Reproduce%0A%0A1.%0A2.%0A3.%0A%0A%23%23%23+Expected+Result%0A%0A%0A%0A%23%23%23+Actual+Result%0A%0A%0A%0APlease+attach+the+log+files+%28Help+%7C+Collect+Logs+and+Diagnostic+Data%29+and+provide+any+additional+information+below.%0A%0AAttach+a+code+sample+as+text%2C+a+screenshot%2C+or+a+screencast+if+possible%0A&c=Assignee+Ivan.Fedorov&c=State+Open&c=Triaged+Yes&c=tag+phpstorm-light" target="_blank" rel="noopener">on YouTrack</a>. Your input is helping shape the future of PhpStorm.</p>Agents Did Not Kill the “Our Team Knows PHP” Argument - Exakathttps://www.exakat.io/?p=165922026-11-14T12:14:29.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/11/zen.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16593" src="https://www.exakat.io/wp-content/uploads/2026/11/zen.640-300x300.jpg" alt="Agents Did Not Kill the "Our Team Knows PHP" Argument" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/zen.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/11/zen.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/11/zen.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/zen.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/11/zen.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/zen.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Agents Did Not Kill the “Our Team Knows PHP” Argument</h1>
<p>There is a particular kind of blog post that starts with a confident thesis and ends with a shrug. The thesis is usually “X is dead”.The shrug is usually “but I would still pick it for this one thing.”</p>
<p>The post making the rounds today follows that pattern beautifully. Its core claim: agents have erased the “our team already knows PHP” advantage, so we should choose languages on raw economics. Faster throughput, lower memory, fewer servers, and Rust wins on the spreadsheet.</p>
<p>I have been reading it with a pen in one hand and a cup of coffee in the other, and I have some objections. Let’s go through them in order, with code, because a language argument without code is just a feeling with a logo.</p>
<h2 id="toc_1">Syntax Was Never the Hard Part</h2>
<p>The argument goes like this: agents write boilerplate in any language, so the learning curve no longer matters. Fair enough. Agents do write boilerplate in any language, and they are very good at it.</p>
<p>But the hard part of a language was never the boilerplate. The hard part is the stuff that bites you at 3 a.m. Take a classic that PHP has been quietly fixing for years. In PHP 7, loose comparison between a number and a non-numeric string was a trap:</p>
<div>
<pre><code class="language-php"><?php
var_dump(0 == "a"); // PHP 7: true, PHP 8: false
var_dump("1" == "01"); // true, still
var_dump(100 == "1e2"); // true, still, and nobody is happy about it</code></pre>
</div>
<p>An agent can write <code>==</code> in its sleep. It cannot tell you which of your twelve legacy controllers relies on the PHP 7 behavior, and it cannot know that your ops team has a runbook for the day that bug shows up in production. That knowledge lives in people, in incident reports, and in the one senior developer who remembers why the <code>if</code> is there.</p>
<p>Agents erase the typing. They do not erase the knowing. And the same argument applies to Rust, Go, and Java: the team’s knowledge of <em>its own</em> stack is the asset, and it is not transferable by prompt.</p>
<h2 id="toc_2">Six Times Faster, on One App, Measured by One Author</h2>
<p>The benchmark says 6 to 9 times more requests per second, and 12 times less idle memory. I believe the numbers. I am less convinced they describe your application.</p>
<p>It is one API workload, on two cores, measured by the author who wrote the post. That is a fine experiment. It is not a verdict. A traffic pattern that spikes at lunchtime and sleeps at night behaves differently from a flat synthetic load, and “idle memory” is only interesting if your servers are actually idle.</p>
<p>PHP’s model is also widely misunderstood. The classic setup is PHP-FPM with OPcache, and since PHP 7.4 you can add preloading so the framework’s core classes are compiled once and sit in shared memory:</p>
<div>
<pre><code class="language-ini">; php.ini
opcache.enable=1
opcache.preload=/var/www/app/preload.php
opcache.preload_user=www-data</code></pre>
</div>
<div>
<pre><code class="language-php">
<pre class="brush: php; title: ; notranslate">
<?php
// preload.php
foreach (glob('/var/www/app/src/Core/*.php') as $file) {
opcache_compile_file($file);
}
</pre>
<p></code>
</div>
<p>With that in place, a fluctuating request volume is handled by a pool of workers that come and go. Not glamorous, but it works, and it has been running large sites for years.</p>
<p>And then there is “shared-nothing”,which the post treats as a 2009 shared-hosting relic. It is actually a robustness feature. Each request starts with a clean slate: globals, objects, and request state vanish at the end. Nothing leaks from one visitor to the next, and horizontal scaling becomes boring, which is the highest compliment an ops person can pay.</p>
<p>Boring has one exception, and I will admit it is my favorite trap in the whole language. Static variables persist for the lifetime of the worker process, not the request:</p>
<div>
<pre><code class="language-php">
<pre class="brush: php; title: ; notranslate">
<?php
function hit() {
static $n = 0;
return ++$n;
}
echo hit(), hit(), hit(), "\n"; // 1 2 3
</pre>
<p></code>
</div>
<p>Under FPM, that counter keeps counting across visitors as long as the same worker process serves them. So “shared-nothing” is true, with a footnote. Every good architecture has footnotes. The trick is knowing where they are.</p>
<h2 id="toc_3">Shipping Is a Feature Too</h2>
<p>The post concedes that Laravel “still wins on the only axis that matters, which is whether it ships”.Then it prices that advantage at zero.</p>
<p>I am going to be a little rude here. For most new applications, the cost that matters is not the RAM on a $10 VPS. It is:</p>
<ul>
<li>how many days until the first login page works;</li>
<li>how many packages already solve the problem you are about to solve;</li>
<li>how many answers exist for the error message you are staring at;</li>
<li>how many people can be hired next month to maintain it.</li>
</ul>
<p>Those numbers are not in the benchmark, and they dominate the lifetime cost of most apps. Idle memory is a line item. Being able to ship on a Tuesday is the whole budget.</p>
<h2 id="toc_4">The Plugin Problem Is Not a PHP Problem</h2>
<p>The security section focuses on remote code execution in WordPress plugins. Those vulnerabilities are real, and they are ugly. But they live in unaudited third-party code, and that is the story of every ecosystem with a long tail of packages. npm has its incidents. Crates have their incidents. The thing that changes is the size of the tail, not the language.</p>
<p>PHP core, meanwhile, shipped an emergency release when a serious bug turned up. That proves the patching process works, which is not the same as proving the platform is uniquely unsafe. Nobody writes a blog post about the day a Rust crate got a same-day fix, but it happens too.</p>
<p>If you want to know what is actually inside a plugin, stop reading the marketing and start reading the code. A tokenizer is a good first step. Here is a small audit script that walks a directory and lists calls to the usual suspects:</p>
<div>
<pre><code class="language-php">
<pre class="brush: php; title: ; notranslate">
<?php
// audit.php: list the risky calls in a plugin tree
$risky = ['eval', 'exec', 'system', 'shell_exec', 'passthru', 'unserialize'];
$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($argv[1]));
foreach ($files as $file) {
if ($file->getExtension() !== 'php') {
continue;
}
$tokens = token_get_all(file_get_contents($file->getPathname()));
foreach ($tokens as $token) {
if (is_array($token) && in_array($token[0], [T_STRING, T_EVAL], true) && in_array($token[1], $risky, true)) {
echo "{$file->getPathname()}:{$token[2]} {$token[1]}()\n";
}
}
}
</pre>
<p></code>
</div>
<p>Run it on a sample tree with a <code>bad.php</code> containing <code>eval($_GET['x'])</code> and <code>unserialize($_POST['data'])</code>, and you get:</p>
<div>
<pre><code class="language-none">plugin/bad.php:2 eval()
plugin/bad.php:3 unserialize()
plugin/ok.php:2 exec()</code></pre>
</div>
<p>Notice the third line. That <code>exec()</code> is <code>$db->exec()</code>, a perfectly innocent PDO method, and the tokenizer flagged it anyway, because a tokenizer has never heard of your objects. Welcome to static analysis. The tool finds the candidates, and a human decides which ones are guilty. It is still far better than trusting a README that says “secure by design.”</p>
<p>There, I rebuild an entire static code analysis with very rough checks that will spot 90% of the vulnerabilities.</p>
<h2 id="toc_5">Where the Post Agrees With Itself</h2>
<p>My favorite part of the post is its own honesty. The author admits that rewrites are usually mistakes, that Rust hiring is thinner and more expensive, and that models are better at PHP than at Rust, simply because there is more PHP in the training data.</p>
<p>Think a moment about the consequences of those three admissions, and you can draw the actual conclusion. If the strongest objection to PHP is “agents are better at it”, then the rational pick for a new app is closer to “PHP is fine” than to the headline. The post’s own “what I would actually pick” section mostly agrees: the PHP-adjacent choices are fine. The disagreement is about a narrow case, and the title is about everything.</p>
<p>So what is the post really about? I think it is an argument for Rust in throughput-constrained systems, a place where the benchmark matters and the team is ready to invest. That is a respectable position. It is just not an argument against PHP for the blog, the admin panel, the marketing site, or the internal tool that the company needs next quarter.</p>
<h2 id="toc_6">The Bigger Picture</h2>
<p>Agents changed how fast we type. They did not change what a production system is: a pile of decisions, histories, and failure modes, owned by people who have to answer the pager.</p>
<p>So here is the question I would put back to anyone writing “X is dead” this year. When the agent writes the code in whatever language you pick, who will know, six months from now, why the static counter is there, which PHP 7 comparison the old controller depends on, and what the audit flagged on the second line of <code>bad.php</code>?</p>
<p>If the answer is “the team”,then the team’s language is still an asset. And it is a little early to bury the one that already runs a large part of the web.</p>
<p>The post <a href="https://www.exakat.io/agents-did-not-kill-the-our-team-knows-php-argument/">Agents Did Not Kill the “Our Team Knows PHP” Argument</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Recently updated PIE extensions #15 (since November 5th, 2026) - Exakathttps://www.exakat.io/?p=165892026-11-12T05:38:55.000ZExakat<h2 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16529" src="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300.png" alt="Recently updated PIE extensions #14" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150@2x.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150.png 150w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-500x500.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-100x100.png 100w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png 640w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300@2x.png 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Recently updated PIE extensions #15 (since November 5th, 2026)</h2>
<p>35 PHP Pie extensions were updated.</p>
<p>They fall into three groups:</p>
<ul>
<li><strong>Native GUI and graphics bindings</strong> (12): the <code>php-io-extensions</code> family (SDL3, GLFW, Vulkan, OpenGL, Metal, AppKit, GTK, Qt, fontconfig, rasterize, fb) plus <code>phpolygon/php-vio</code>.</li>
<li><strong>Rust-powered</strong> (5): liter-llm, corvus-json-schema, expanse, phit and mongo-php-async-driver, which state Rust as their core.</li>
<li><strong>Databases and data stores</strong> (4): the MongoDB extension and async driver, pdo-duckdb-php and valkey-glide-php.</li>
</ul>
<p> </p>
<ul>
<li><a href="https://packagist.org/packages/phpolygon/php-vio">phpolygon/php-vio</a> (2.45.0): PHP extension for GPU rendering (OpenGL, Vulkan, Metal), audio, video recording, streaming, and input</li>
<li><a href="https://packagist.org/packages/paragonie/ext-pqcrypto">paragonie/ext-pqcrypto</a> (v0.3.3): PHP extension for post-quantum cryptography (ML-KEM, X-Wing, ML-DSA, SLH-DSA)</li>
<li><a href="https://packagist.org/packages/intelligent-intern/king-ext">intelligent-intern/king-ext</a> (v1.0.14-beta): King native PHP extension packaged for PIE</li>
<li><a href="https://packagist.org/packages/mongodb/mongodb-extension">mongodb/mongodb-extension</a> (2.5.7): MongoDB driver extension</li>
<li><a href="https://packagist.org/packages/php-io-extensions/sdl3">php-io-extensions/sdl3</a> (v0.11.1): 1:1 PHP bindings of SDL 3: windows, surfaces, the GL, Metal and Vulkan hooks, and SDL_GPU</li>
<li><a href="https://packagist.org/packages/xberg-io/tree-sitter-language-pack">xberg-io/tree-sitter-language-pack</a> (v1.25.0): Pre-compiled tree-sitter grammars for 371 programming languages</li>
<li><a href="https://packagist.org/packages/xberg-io/liter-llm">xberg-io/liter-llm</a> (v2.7.0): Universal LLM API client with Rust-powered polyglot bindings.</li>
<li><a href="https://packagist.org/packages/xberg-io/html-to-markdown">xberg-io/html-to-markdown</a> (v3.22.0): High-performance HTML to Markdown converter</li>
<li><a href="https://packagist.org/packages/thomas-0816/pdo-duckdb-php">thomas-0816/pdo-duckdb-php</a> (2.0.0.0-beta5): PHP PDO Driver for DuckDB, modern analytics</li>
<li><a href="https://packagist.org/packages/grpc/grpc-php-ext">grpc/grpc-php-ext</a> (v1.85.2): gRPC PHP Extension</li>
<li><a href="https://packagist.org/packages/php-io-extensions/glfw">php-io-extensions/glfw</a> (v0.11.1): 1:1 PHP bindings of GLFW 3.4 for staged windows: monitors and video modes, windows, hints, attributes and callbacks, events, contexts, Vulkan surfaces and native handles</li>
<li><a href="https://packagist.org/packages/open-telemetry/ext-opentelemetry">open-telemetry/ext-opentelemetry</a> (1.5.0): Auto-instrumentation extension for OpenTelemetry</li>
<li><a href="https://packagist.org/packages/php-io-extensions/vulkan">php-io-extensions/vulkan</a> (v0.11.1): 1:1 PHP bindings of Vulkan: devices, memory, pipelines, commands, swapchains and the Linux dmabuf export</li>
<li><a href="https://packagist.org/packages/php-io-extensions/open-gl">php-io-extensions/open-gl</a> (v0.11.1): 1:1 PHP bindings of the OpenGL 4.1 core / OpenGL ES 3 calls both dialects share, with CGL on macOS and EGL on Linux</li>
<li><a href="https://packagist.org/packages/php-io-extensions/metal">php-io-extensions/metal</a> (v0.11.1): 1:1 PHP bindings of Metal and CAMetalLayer, as classes named after their native counterparts</li>
<li><a href="https://packagist.org/packages/xberg-io/crawlberg">xberg-io/crawlberg</a> (v1.13.0): High-performance web crawling engine</li>
<li><a href="https://packagist.org/packages/pecl/krb5">pecl/krb5</a> (v1.3.0): Kerberos/GSSPI and KAdmin bindings for PHP</li>
<li><a href="https://packagist.org/packages/php-io-extensions/appkit">php-io-extensions/appkit</a> (v0.11.1): 1:1 PHP bindings of AppKit and the CoreFoundation run loop it runs on, as classes named after their native counterparts</li>
<li><a href="https://packagist.org/packages/php-io-extensions/gtk">php-io-extensions/gtk</a> (v0.11.1): 1:1 PHP bindings of GTK 4 and the GLib main loop it runs on, as functions and classes named after their C counterparts</li>
<li><a href="https://packagist.org/packages/valkey-io/valkey-glide-php">valkey-io/valkey-glide-php</a> (v1.2.0-rc2): Valkey GLIDE for PHP</li>
<li><a href="https://packagist.org/packages/orieg/expanse-extension">orieg/expanse-extension</a> (v0.18.0): Native PHP Zend Engine extension for Expanse: modern Judy arrays in pure Rust (ext-php-rs). Userland API: orieg/expanse.</li>
<li><a href="https://packagist.org/packages/ptondereau/biscuit-php">ptondereau/biscuit-php</a> (v0.8.1): PHP bindings for Biscuit authorization tokens</li>
<li><a href="https://packagist.org/packages/mosuka/litsea">mosuka/litsea</a> (v0.16.0): PHP extension for Litsea, a compact word segmentation and POS tagging library (no embedded models)</li>
<li><a href="https://packagist.org/packages/php-io-extensions/fb">php-io-extensions/fb</a> (v0.11.1): Pixel storage in C: FbFormat describes a byte layout, FbBuffer holds one surface in it and reads, writes, converts and copies it</li>
<li><a href="https://packagist.org/packages/corvus-dotnet/corvus-json-schema">corvus-dotnet/corvus-json-schema</a> (0.2.2): A high-performance JSON Schema evaluator (draft 4, 6, 7, 2019-09 and 2020-12) as a PHP extension, backed by Rust.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/rasterize">php-io-extensions/rasterize</a> (v0.11.1): Shapes into coverage spans in C: RasterScanner answers paths, ellipses, rings and one-pixel polylines as span bytes, hard-edged or anti-aliased</li>
<li><a href="https://packagist.org/packages/php-io-extensions/qt">php-io-extensions/qt</a> (v0.11.1): 1:1 PHP bindings of Qt 6 as classes named after their C++ counterparts</li>
<li><a href="https://packagist.org/packages/phasync/ext-phasync">phasync/ext-phasync</a> (2.0.8): PHP extension that makes blocking I/O (PDO, mysqli, curl, streams, sleep) wait cooperatively in fibers an event loop manages (phasync\ext\Suspension), and per-coroutine requests (sapi()).</li>
<li><a href="https://packagist.org/packages/vanta/meminfo">vanta/meminfo</a> (0.2.1): PHP extension that dumps the content of PHP memory as JSON, to hunt down memory leaks</li>
<li><a href="https://packagist.org/packages/phpstats/phit">phpstats/phit</a> (v0.9.0): Native Rust statistical modeling for PHP: regression, likelihood, and mixed models</li>
<li><a href="https://packagist.org/packages/caronc/dateblock">caronc/dateblock</a> (v2.2.0): Block (sleep) until a cron-style moment in time</li>
<li><a href="https://packagist.org/packages/sentry/sentry-php-tracer">sentry/sentry-php-tracer</a> (0.1.1): Experimental Sentry tracing extension for PHP</li>
<li><a href="https://packagist.org/packages/php-io-extensions/fontconfig">php-io-extensions/fontconfig</a> (v0.11.1): 1:1 PHP bindings of fontconfig: configuration, patterns, font matching and sorting, and character sets</li>
<li><a href="https://packagist.org/packages/chrfritsch/nocopy">chrfritsch/nocopy</a> (0.0.5): Zero-copy shared-memory cache for PHP</li>
<li><a href="https://packagist.org/packages/danog/mongo-php-async-driver">danog/mongo-php-async-driver</a> (v0.1.2): Drop-in replacement for the mongodb PHP extension (ext-mongodb 2.5.6) in pure Rust, with async I/O in fibers through Revolt</li>
</ul>
<p>The post <a href="https://www.exakat.io/recently-updated-pie-extensions-15-since-november-5th-2026/">Recently updated PIE extensions #15 (since November 5th, 2026)</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Partial Function Application in PHP 8.6 use cases - Exakathttps://www.exakat.io/?p=165862026-11-10T07:10:54.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/11/partial.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16587" src="https://www.exakat.io/wp-content/uploads/2026/11/partial.640-300x300.jpg" alt="Partial Function Application in PHP 8.6 use cases" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/partial.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/11/partial.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/11/partial.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/partial.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/11/partial.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/partial.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Partial Function Application in PHP 8.6 use cases</h1>
<p>Here is a classic PHP line:</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$names = array_map(fn($user) => strtoupper($user), $users);
?>
</pre>
</div>
<p>It could be possibly shortened with a string, but that would look like so PHP 4 that this post starts with an arrow function. It is short, the intent is clear, and not so recent PHP versions made it cheap to type. And, when you look closely at what that function is doing, you discover it exists only to receive a value and hand it straight to another call: I call them relay functions. We need it to hand over a function call to another place.</p>
<p>PHP has come a long way to do that in various forms. PHP 5.3 brought closures in 2009, with the <code>use</code> keyword to capture variables from the surrounding scope. PHP 7.4 added arrow functions, so the capture became automatic and the syntax shrank. PHP 8.1 introduced the first-class callable syntax, <code>strtoupper(...)</code>, which turns any function into a value without writing a wrapper at all, or at least explicitely. Each step removed a little more ceremony between “I have a function” and “I have a handle to that function”.</p>
<p>PHP 8.6 goes one step further with partial function application, or <code>PFA</code> (Peefa, anyone?). The idea is simple. You set some arguments of a function now. You leave the others open, and so, you get a new callable that is half backed. The open spots are marked with a question mark, and the function you get back is a real closure with a real signature. Once you start looking for them, a surprising number of arrow functions in a typical codebase turn out to be partial applications in disguise.</p>
<p>There are already articles which cover the definitions for PFA. Taking my hat of a static code analysis author, I want to cover what current situations may be improved with PFA. So, this article walks through the situations where PFA can replace code you already have. We start with the simplest case and end with the most niche ones, grouped in five parts. Every example is a refactoring of something PHP developers write today, so you can judge the gain for yourself. Among so many of them, there are certainly a few that you are currently using.</p>
<h2 id="toc_1">Part I: Feeding the function one hole at a time</h2>
<h3 id="toc_2">Unary callbacks</h3>
<p>Let us start with the elementary form. You know some arguments of a function, and you want to leave exactly one slot open for the data. This is the flagship case, and it is the example the RFC uses to introduce the feature.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Before
$numbers = array_filter($values, fn($value) => is_numeric($value));
// After
$numbers = array_filter($values, is_numeric(?));
// Competing syntax: identical to the above, because is_numeric() has one argument.
$numbers = array_filter($values, is_numeric(...));
?>
</pre>
</div>
<p>The arrow function existed only to route a value into a call. The partial does the same job with the routing built into the syntax. Note the question mark rather than three dots. A single placeholder accepts exactly one argument, and any extra value that <code>array_filter</code> or <code>array_map</code> might pass along is simply not forwarded. We will come back to why this matters in the caveats, because a variadic placeholder can surprise you in the least pleasant way.</p>
<h3 id="toc_3">Fixing several arguments</h3>
<p>This is a direct extension of the previous case. You bake in several known values at build time, and the function runs when the data finally arrives. The closure factory is the classic pattern here: a function that builds a closure with a <code>use</code> clause, so that the configuration gets stored somewhere.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Before
function makeLogger(string $channel, string $level): Closure {
return function (string $message) use ($channel, $level) {
log_message($channel, $level, $message);
};
}
$logger = makeLogger('payments', 'warn');
// After
$logger = log_message('payments', 'warn', ?); // a closure taking one string
$logger('Payment declined');
?>
</pre>
</div>
<p>The factory function did nothing except hold on to two strings. Now the holding is done by the language itself. Nobody will miss the factory, although its unit tests may need a moment of silence. Nobody will miss that the arguments are fixed here with literal values. How these possible <code>magic numbers</code> reach that place is another problem entirely.</p>
<h3 id="toc_4">Pipelines and holes</h3>
<p>PHP 8.5 gave us the pipe operator, <code>|></code>, which passes the result of each step to the next one. In a pipeline, each step is usually a small function call with the data implied. Partial applications fit this shape perfectly, because the data is the hole, and the hole is the only thing the pipe needs to fill.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$slug = $title
|> str_replace(' ', '-', ?)
|> strtolower(?)
|> mb_substr(?, 0, 200);
?>
</pre>
</div>
<p>The result reads from top to bottom like a recipe, with no intermediate variables to invent and no nested calls to untangle from the inside out. The pipe is good for readability, and the partials are good at giving each step its arguments. Together they make a slug that you can explain to a colleague in one breath. Good names are hard, and the best variable is the one you don’t have to name.</p>
<h2 id="toc_5">Part II: Naming the holes</h2>
<h3 id="toc_6">Named arguments</h3>
<p>Positional partials can only fix leading arguments. You fill the first slots, then the holes come after. Named arguments remove that limit. You can fix any parameter by name, and the holes follow the signature that remains.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$roundTwo = round(precision: 2, num: ?); // Closure(float $num)
$isoDate = date(format: 'Y-m-d', timestamp: ?); // Closure(?int $timestamp = null)
?>
</pre>
</div>
<p>Note two important details. First, the default values of the remaining parameters are preserved, so <code>$isoDate</code> still accepts a missing timestamp and uses the current time: there is no need to repeat them. Secondly, the hole itself needs a name. A positional question mark placed after a named argument is refused by the compiler with a fatal error. The compiler is right to be strict, and the error message is clear enough to make you feel slightly embarrassed about the attempt.</p>
<h3 id="toc_7">Turning the order around</h3>
<p>Functions are written in the order that suited their author. As per convention, the needle comes first in <code>in_array()</code>, the haystack second. And the strictness flag last. When you create a callback, the order may work against you. Before PFA, the fix was a hand-written closure that swapped the arguments back.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Before
$hasAccess = fn($role) => in_array($role, $allowedRoles, true);
// After
$hasAccess = in_array(?, $allowedRoles, true); // Closure($needle)
?>
</pre>
</div>
<p>Named placeholders go one step further. They let you choose which hole comes first, independently of the position in the signature.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
function stuff(int $i1, string $s2): string { /* ... */ }
$c = stuff(s2: ?, i1: ?); // Closure($s2, $i1)
?>
</pre>
</div>
<p>The second hole in the signature becomes the first parameter of the new closure. The dependency between your data and your configuration is inverted without any ceremony at all.</p>
<p>This might come very handy: when the list of argument is long, the interesting arguments might happen at the end of that list, after a long list of default parameters. The PFA give you a chance to promote arguments to their right precedence.</p>
<h3 id="toc_8">PFA of PFA</h3>
<p>Partials can themselves be partialed, one argument at a time. This is the progressive refinement pattern, and it replaces the telescoping builder that developers sometimes use to configure an object step by step.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$c = $e->foo(?, ?, 3); // Closure($a, $b)
$c2 = $c(1, ?); // Closure($b)
?>
</pre>
</div>
<p>Builders are a perfectly honest pattern, and many libraries use them well. But a builder with <code>->withContext()->withField()</code>chains is a way to fill in a form one method at a time, and each method has to return a new object for the next one to work. A partial fills the same form in a single expression, and the result is a plain callable that you can store, pass around, or throw away.</p>
<h2 id="toc_9">Part III: Deferring execution</h2>
<h3 id="toc_10">The first-class callable, the degenerate case</h3>
<p>Here is the case where nothing is fixed at all. <code>count(...)</code> creates a callable from <code>count</code> with every argument still open. This is the first-class callable syntax that arrived in PHP 8.1, and it is the partial application with all its holes left empty.</p>
<p>There is no refactoring value in this entry on its own. It is included because every other example in this article builds on the same mechanism, and because it reminds us that PFA is not a brand new idea wearing an old name. It is the same idea, with a few more ways to fill the gaps.</p>
<h3 id="toc_11">Thunks: everything is applied, call it later</h3>
<p>Sometimes all the arguments are known, and the only thing you want to delay is the execution itself. The result is a thunk, a parameterless callable that runs the work only when you ask for it. You get it by supplying every argument and keeping the ellipsis at the end.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$default = expensive(3, 4, $point, ...);
if ($some_condition) {
$result = $default();
}
?>
</pre>
</div>
<p>This is useful for pushing a heavy computation off until someone actually needs its result. The thunk is a niche tool, and most codebases will not need it every day. Still, it is pleasant to have a way to write a deferred call without wrapping it in a closure with an empty <code>use</code>clause, which is the kind of code that makes readers stop and ask why it exists. This might not replace a job queue, but it may help postpone a smaller task after the client has received the results, and it is a little gain.</p>
<p>I also didn’t know that PHP had thunk. Now, you know too.</p>
<h2 id="toc_12">Part IV: Object territory</h2>
<h3 id="toc_13">Methods and invokable objects</h3>
<p>PFA works with any callable, and that includes the callables that live inside objects. Static methods, instance methods with <code>$this</code>already bound, invokable objects, and magic <code>__call</code> methods all accept holes. This is where the boilerplate tends to pile up in object-oriented code.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$eMaker = E::make(1, ?); // static method, a Closure
$debug = $logger->log('debug', ?); // $this is bound to $logger
$handler = $middleware(?, $request); // invokable object
?>
</pre>
</div>
<p>Think about how many times you have written <code>fn($x) => $this->service->transform($x, $this->config)</code>. Each of those lines is a small wrapper that exists only to fix two arguments and leave one open. The partial version says the same thing in fewer characters and without a <code>$this</code> lookup hidden inside a closure. Your future self will read the code in the order the ideas were written, which is always a relief.</p>
<h3 id="toc_14">The object is the hole</h3>
<p>The previous case fixes the arguments of one object. The next one turns the question around. You have a list of different objects, and you want to apply the same method to each of them. Only the instance changes from one call to the next. In PFA, the <code>this</code> slot can be a hole, which means the object becomes the parameter of the new callable.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
$formatted = array_map(DateTimeImmutable::format(this: ?, format: 'c'), $dates);
$c = DateTimeImmutable::setTimestamp(?, this: ?); // fn(int, DateTimeImmutable)
?>
</pre>
</div>
<p>The class name becomes the type of the hole, so the same code works against interfaces and parents as well. The <code>this</code> slot can be reordered like any named placeholder, which means the object does not have to come first in the signature. This is the point where a method call starts to behave like a function that happens to know about its object. The RFC is precise about the syntax here, and its rules are worth reading before you rely on them in production code.</p>
<h3 id="toc_15">Scope and late static binding</h3>
<p>A partial inherits the scope where it was created. This matters for <code>static::</code>, which is resolved at creation time, not at call time. Private methods can be partialed inside their class and passed outside, so the caller gets the operation without getting the access.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
class P {
private static function m($x) { return static::class . ": $x"; }
public static function get() {
return static::m(?); // P::get() and C::get() each yield their own m()
}
}
?>
</pre>
</div>
<p>This removes a whole family of public wrapper methods whose only purpose was to expose a private operation to the outside world. The wrapper used to be a small act of diplomacy. Now the partial carries the permission with it, and the class can keep its private methods private.</p>
<h2 id="toc_16">Part V: Meta and ecosystem cases</h2>
<h3 id="toc_17">Preconfigured callables in constants</h3>
<p>Partial applications are legal in constant expressions, property defaults, and parameter defaults. This means you can declare a callable at the place where the class is defined, rather than building it lazily the first time someone uses it.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
class Example {
public const BASE = 10;
// two nested PFA as a default value
private Closure $arrayToInt = array_map(intval(?, self::BASE), ?);
}
?>
</pre>
</div>
<p>The lazy initializer is a familiar pattern: <code>if (!$this->callback) { $this->callback = ...; }</code> scattered through the methods, each one a small place where a bug can hide. A declarative default says what the callback is, once, in the same place as the data it depends on. It is a modest improvement, but modest improvements add up across a large codebase.</p>
<h3 id="toc_18">Reflection-friendly callables</h3>
<p>A partial application produces a real Closure, and that Closure carries a full signature. Names, types, default values, by-reference parameters, and attributes such as <code>#[SensitiveParameter]</code> are all visible through <code>ReflectionFunction</code>. Dependency injection containers and framework code can inspect the callable and decide what to pass to it, without guessing from a string or an array.</p>
<p>This is mainly good news for framework authors. A string callable like <code>'strtoupper'</code> tells the container almost nothing, and an array callable is not much better. A Closure with a precise signature is the kind of thing a type-safe tool can work with, and it is the kind of thing that a static analyzer can count, check, and report on.</p>
<h2 id="toc_19">Caveats, or the places where it bites</h2>
<p>Partial function application is clean, but a few rules are worth keeping in mind before you rewrite a large part of your code.</p>
<p><strong>Arguments are evaluated at creation time</strong>. The expression <code>speak(?, getArg())</code> calls <code>getArg()</code> immediately, not when the partial is finally invoked. If you expected the call to be deferred, the surprise will arrive at the worst possible moment, usually in a production log.</p>
<p><strong>Question mark or dots as a callback</strong>. A variadic placeholder forwards every extra argument. Consider <code>array_find</code> passing the key as a second argument. That key may land in the optional <code>$base</code> parameter of <code>intval</code>, and your code will convert strings in a base that nobody chose on purpose. For callbacks, prefer the single question mark, which accepts exactly one value and ignores what it does not need.</p>
<p><strong>What is not supported</strong>. The <code>new</code> expression cannot be partialed, so use a static factory method or the lazy objects of PHP 8.4 instead. Functions that work on the current scope, such as <code>compact</code>, <code>extract</code>, and the <code>func_get_args</code> family, are also out of reach. The <code>this:</code> placeholder is only available with the <code>Class::method()</code> syntax, and it can only be used as a placeholder.</p>
<p><strong>Common errors</strong>. Too many or too few placeholders, a positional placeholder after a named argument, and a named parameter that overwrites a placeholder all produce clear error messages. The compiler is strict, and its messages are a good place to learn the rules quickly.</p>
<h2 id="toc_20">The bigger picture</h2>
<p>PFA does make PHP faster, safer, and more modern, a little bit with each aspect. What it actually does is shrink the gap between a function and the values you need to run it. Each of the situations above is a small, local refactoring, and each one looks harmless on its own. Yet, I was first surprised to realize how often they are going to be useful. And the more interesting question is what happens when you put them all together and run them over an entire codebase.</p>
<p>New features are introduced by their own merit: easily create a closure by setting some of its parameters, and leaving the others open; or use it with the pipe operator <code>|></code> for readability. And such aspects are critical, yet they are not the only impact in the code. It is always interesting to see what current patterns may be replaced by this new one, and what it tell us about the organisation of the code as a whole.</p>
<p>The post <a href="https://www.exakat.io/partial-function-application-in-php-8-6-use-cases/">Partial Function Application in PHP 8.6 use cases</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>PHP 8.6 Rewrites Some of Your Calls Before You Notice - Exakathttps://www.exakat.io/?p=165792026-11-07T08:41:53.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/11/fire.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16580" src="https://www.exakat.io/wp-content/uploads/2026/11/fire.640-300x300.jpg" alt="PHP 8.6 Rewrites Some of Your Calls Before You Notice" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/fire.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/11/fire.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/11/fire.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/fire.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/11/fire.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/fire.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>PHP 8.6 Rewrites Some of Your Calls Before You Notice</h1>
<p>Most PHP speed-ups ask something of you: upgrade the extension, turn on the JIT, rewrite the hot loop in C. The PHP 8.6 changes in the NEWS file ask nothing. The compiler looks at a few specific call shapes and emits something else in their place. Your source stays the same, and the bytecode changes underneath it.</p>
<p>This article covers all the rewrites, and, in detail, the two that matter most. I checked them by dumping the optimized opcodes of PHP 8.6 itself, then measured the code against PHP 8.5 on the same machine. The 8.6 build is a development snapshot, <code>8.6.0-dev</code>, at the time of writing.</p>
<h2 id="toc_1">Where the time goes</h2>
<p>A PHP function call is not free, but it is not the expensive part here. Three costs matter for the changes in PHP 8.6.</p>
<p><strong>Parsing the format string</strong>. <code>printf()</code> and <code>sprintf()</code> read the format on every call, walk it character by character, and dispatch each <code>%</code> specifier. The work is small, tiny even, but it happens every time, even when the format never changes. These are not cached.</p>
<p><strong>Creating a Closure</strong>. A first-class callable such as <code>double(...)</code> or a closure such as <code>fn($x) =>; double($x)</code> produces a <code>Closure</code> object. That is an allocation, paid once per expression evaluation, not once per written line of code. In a loop, closures multiply.</p>
<p><strong>Calling back into userland from C</strong>. When <code>array_map()</code> runs a userland callback, C code calls back into the Zend VM. Each call goes through <code>zend_call_function()</code>, which builds a frame from the outside and re-enters the executor. A <code>foreach</code> loop in userland never leaves the VM: the callee is an ordinary opcode in the same loop.</p>
<p>The 8.6 rewrites attack these costs in different ways. printf removes the format parse. <code>array_map()</code> removes the callback machinery, and with it the need for a Closure object. Let’s see them in action, before they pass.</p>
<h2 id="toc_2">printf becomes string interpolation</h2>
<p>When <code>printf()</code> receives only <code>%s</code> and <code>%d</code>, the compiler replaces it with string interpolation. Here is the source:</p>
<div>
<!--?php <br ?--> $name = ‘Damien’;<br />
$count = 3;printf(‘%s has %d messages’, $name, $count);<br />
[hp]
</div>
<p>PHP 8.6 compiles that call into the same opcodes as this:</p>
<div>
<!--?php <br ?--> $name = ‘Damien’;<br />
$count = 3;echo “$name has ” . (int) $count . ” messages”;<br />
[hp]
</div>
<p>The optimizer dump for the <code>sprintf()</code> version confirms it. The four opcodes that build the string are the same ones interpolation uses:</p>
<div>
<pre><code class="language-none">T3 = ROPE_INIT 3 CV0($a)
T3 = ROPE_ADD 1 T3 string(" ")
T5 = CAST (long) CV1($b)
T2 = ROPE_END 2 T3 T5
[hp]
</code></pre>
</div>
<p>Two things make the rewrite correct.</p>
<p>The first is that <code>%s</code> and interpolation agree. Both convert the value with the same rules, including calling <code>__toString()</code> on objects.</p>
<p>The second is that <code>%d</code> is not interpolation. <code>%d</code> converts its argument to an integer, so the compiler must insert the <code>(int)</code> cast, which is the <code>CAST (long)</code> line above. Without it, the output changes:</p>
<div>
<!--?php <br ?--> $x = 1.9;echo sprintf(‘%d’, $x), “\n”; // 1<br />
echo “$x”, “\n”; // 1.9<br />
[hp]
</div>
<p>That is why the rewrite is limited to <code>%s</code> and <code>%d</code>. Other specifiers, or more complex configurations of these specifiers, such as <code>%05.2f</code> or <code>%'*10s</code>, carry padding and precision rules that a string concatenation cannot express without a second function call.</p>
<p>Note that this optimisation is actually already available in PHP 8.4 and 8.5, via sprintf(). PHP 8.6 is porting it to <code>printf()</code>. You can detect simple <code>printf()</code> calls by parsing the format string, and rewrite it to concatenation when it is simple to handle.</p>
<p>Besides the fact that this is a micro-optimisation, it may also run against the established rules of always using printf() for concatenation, and it makes any modification, such as adding extra configuration, another rewrite. So, unless you need to speed up the application by a few milliseconds, it is recommended to upgrade PHP to 8.6, and let the engine do it for you.</p>
<h2 id="toc_3">array_map loses its callback</h2>
<p>The second rewrite is the one I find more interesting. <code>array_map()</code> with a first-class callable or a partial function application is compiled into a <code>foreach</code>:</p>
<div>
<!--?php <br ?--> function double(int $x): int { return $x * 2; }$numbers = [1, 2, 3, 4];</p>
<p>$doubled = array_map(double(…), $numbers);<br />
[hp]
</div>
<p>The optimizer dump for that call shows a loop, not a function call. The function body is a foreach over the array, with a direct call to <code>double</code> inside it:</p>
<div>
<pre><code class="language-none">V2 = FE_RESET_R CV0($arr) 0010
T4 = FE_FETCH_R V2 T3 0010
INIT_FCALL 1 112 string("double")
SEND_VAL T3 1
T3 = DO_UCALL
FE_FREE V2
[hp]
</code></pre>
</div>
<p>The rewrite also covers internal callables. <code>array_map(intval(...), $ids)</code> becomes a loop that calls <code>intval</code> directly, with <code>ADD_ARRAY_ELEMENT</code> building the result.</p>
<p>The compiled form keeps <code>array_map()</code> semantics. With a single input array, <code>array_map()</code> preserves keys, including string keys. The loop does the same, because <code>ADD_ARRAY_ELEMENT</code> takes the key from the source iteration:</p>
<div>
<!--?php print_r(array_map(strtoupper(...), ['a' =>; 'x', 'b' =>; 'y']));<br ?--> // [a] =>; X<br />
// [b] =>; Y<br />
[hp]</div>
<p>The rewrite does not apply to a closure written with <code>fn</code>. The dump for <code>array_map(fn($x) =>; double($x), $arr)</code> still shows a call to <code>array_map</code> itself (<code>DO_ICALL</code>). That matches the NEWS entry, which names only first-class callables and partial application.</p>
<p>The benefit is what the JIT can see. Inside the rewritten function there is a plain loop with a visible call, instead of an opaque internal function that calls back. The NEWS entry puts it as better insight for the JIT.</p>
<p>This will address an ongoing pain point, where inlining the content of the closure into a local foreach makes the code faster than using the closure, or an established method: in particular, the context switching, which happens at each cycle of the loop adds a lot of overhead. With this optimisation, the inlining is done at the engine level.</p>
<p>Given how much loops hold as speed potential, this might be a visible speed up.</p>
<h2 id="toc_4">The smaller changes</h2>
<p>The PHP 8.6 NEWS file lists more speed-ups, which I group into the following sections. None of them rewrites your code the way <code>printf()</code> and <code>array_map()</code> do. Each one is a faster path inside a function you already call, so the code stays the same and only the cost changes.</p>
<p>I have measured these with a simple loop, repeating the same operation. The NEWS entries say that each path is faster, and the path may be a special one. Each section below shows the code the change targets, and I ran every snippet on PHP 8.6 to confirm the output.</p>
<h3 id="toc_5">addcslashes(): octal escapes</h3>
<p><code>addcslashes()</code> escapes the characters you list. Control characters that have no short form, such as <code>\x01</code>, come out as three-digit octal escapes.</p>
<div>
<!--?php <br ?--> // Escape every control character (ASCII 0 to 31).<br />
echo addcslashes(“tab\there\x01end”, “\0..\37”), “\n”;<br />
// tab\there\001end<br />
[hp]</div>
<p>The <code>\t</code> stays a short escape, and the <code>\x01</code> becomes <code>\001</code>. The octal branch is the one that got faster, so the change matters most when you escape binary data, for example before writing a string into a generated source file. You might also need a large loop to feel the benefits.</p>
<h3 id="toc_6">sort(): single-element arrays</h3>
<p>Sorting one element needs no comparisons. Whatever time <code>sort()</code> spends on such an array is setup, not sorting.</p>
<div>
<!--?php <br ?--> $tags = [‘php’];<br />
sort($tags);<br />
echo json_encode($tags), “\n”; // [“php”]
[hp]</div>
<p>The result is the same as before, so you only see the gain when you sort many small arrays in a loop, such as one array per database row. A long list of one-element arrays is certainly a coding pattern, applied to data whose shape is defined somewhere else. An actual micro-optimisation.</p>
<h3 id="toc_7">array<em>fill</em>keys(): building a lookup from a list</h3>
<p><code>array_fill_keys()</code> takes a list of keys and one value, and returns an array where each key maps to that value. It is the usual way to build a set of flags or defaults in one line.</p>
<div>
<!--?php <br ?--> $flags = array_fill_keys([‘read’, ‘write’, ‘admin’], false);<br />
echo json_encode($flags), “\n”;<br />
// {“read”:false,”write”:false,”admin”:false}<br />
[hp]</div>
<p>The NEWS entry says the function is faster, without saying which part of the work changed. <code>hrtime()</code> could not spot significant differences in execution, with many calls, and with many keys.</p>
<p>Note: also remember that the SAME value is assigned to each provided key. This is inconsequential with a scalar, but it means the same object is everywhere, when the value is an instantiation.</p>
<h3 id="toc_8">array_intersect(): keeping the first array’s keys</h3>
<p><code>array_intersect()</code> returns the values of the first array that also appear in every other array. The keys of the first array are kept, and values are compared as strings.</p>
<div>
<!--?php <br ?--> $all = [1, 2, 3, 4];<br />
$paid = [2, 4, 6];<br />
echo json_encode(array_intersect($all, $paid)), “\n”;<br />
// {“1″:2,”3”:4}<br />
[hp]</div>
<p>The output keeps the original keys, <code>1</code> and <code>3</code>. Code that expects a list has to call <code>array_values()</code> afterwards, which the speed-up does not change. The entry names this function without giving a case, so the gain could apply to any input size.</p>
<p>The speed gain is 90% on small arrays as in the illustration. They still need to be executed 100 000 times, so it is a micro optimisation, but the impact is significant, and might become visible.</p>
<h3 id="toc_9">array_map() with several arrays</h3>
<p>With one array, <code>array_map()</code> calls the callback once per element. With several arrays, it takes one element from each on every step, and pads the shorter arrays with <code>null</code>. The NEWS entry says this case is faster.</p>
<div>
<!--?php $quantities = [1, 2, 3, 4, 5]; $prices = [10, 20, 30]; echo json_encode(array_map(fn($q, $p) =>; $q * $p, $quantities, $prices)), "\n";<br ?--> // [10,40,90]
[hp]</div>
<p>This is a separate entry from the first-class callable rewrite described earlier. The NEWS file does not say whether <code>array_map(double(...), $a, $b)</code> is also rewritten into a loop. No significant speed up was measured.</p>
<h3 id="toc_10">array<em>sum() and array</em>product() on integers</h3>
<p><code>array_sum()</code> and <code>array_product()</code> add or multiply every element. The NEWS entry limits the gain to arrays that contain only integers. That is a natural place for a faster path, because the function does not need to check each element’s type or convert it.</p>
<div>
<!--?php <br ?--> echo array_sum([1, 2, 3, 4]), “\n”; // 10<br />
echo array_product([2, 3, 4]), “\n”; // 24// Overflow still promotes to float, so the fast path has to keep this:<br />
var_dump(array_sum([PHP_INT_MAX, 1])); // float(9.223372036854776E+18)<br />
[hp]
</div>
<p>The last line is the part a fast integer path must not break. When the total no longer fits in an integer, the result has to become a float rather than wrap around. The output above is what PHP 8.6 returns.</p>
<h3 id="toc_11">array<em>unshift() and array</em>walk()</h3>
<p><code>array_unshift()</code> puts new values at the front of an array and renumbers the integer keys. <code>array_walk()</code> calls a callback for each element, and the callback can change the element by reference. The NEWS entry names both functions.</p>
<div>
<!--?php $stack = [3, 4]; array_unshift($stack, 1, 2); echo json_encode($stack), "\n"; // [1,2,3,4] $prices = ['a' =>; 10, 'b' =>; 20];<br ?--> array_walk($prices, function (&$price) { $price *= 2; });<br />
echo json_encode($prices), “\n”; // {“a”:20,”b”:40}<br />
[hp]</div>
<p><code>array_unshift()</code> gains 10% with a 2 elements array, as above. With a 100 element array, it is faster by 50% over the previous implementation. It stays much slower than appending, by a factor of 3, and depending on the size of the array. So, it is better than before, and LIFO stacks are still a better performance choice.</p>
<p><code>array_walk()</code> is in the same family as <code>array_map()</code>: it calls a userland callback from C, so the cost of re-entering the executor applies to it too. The entry does not say whether the gain comes from that path or from the array rebuild in <code>array_unshift()</code>.</p>
<h3 id="toc_12">intval() with base 2</h3>
<p>PHP syntax supports <code>0b</code> for binary. Then, <code>intval()</code> can read a binary string when you pass base 2. PHP accepts an optional <code>0b</code>prefix in that case, and the NEWS entry says the prefixed form is now faster.</p>
<div>
<!--?php <br ?--> echo intval(‘0b1010’, 2), “\n”; // 10<br />
echo intval(‘0b1010’, 0), “\n”; // 10<br />
[hp]</div>
<p>The base-0 call and the base-2 call return the same value, and the prefix is what tells PHP the string is binary. Code that parses bit flags from a configuration file or a protocol field is the usual case where this matters.</p>
<h3 id="toc_13">pathinfo() with one component</h3>
<p><code>pathinfo()</code> normally builds an array with every part of a path: <code>directory</code>, <code>basename</code>, <code>extension</code> and <code>filename</code>. If you only want one of them, the rest of that array is wasted work. <code>pathinfo()</code> has been optimized when requesting only one of the elements.</p>
<div>
<!--?php <br ?--> echo pathinfo(‘/var/www/index.php’, PATHINFO_FILENAME), “\n”; // index<br />
echo pathinfo(‘/var/www/index.php’, PATHINFO_EXTENSION), “\n”; // php<br />
[hp]</div>
<p>The output is the same as earlier PHP versions. The cost saving is in the function, not in your code, so no change to your calls is needed.</p>
<h3 id="toc_14">str<em>split() and str</em>pad()</h3>
<p><code>str_split()</code> cuts a string into fixed-size pieces, and <code>str_pad()</code> extends a string to a target length. Both build a new string or array from parts, and both sit in loops in formatting code. The NEWS entry says both are faster.</p>
<div>
<!--?php <br ?--> echo json_encode(str_split(‘abcdef’, 4)), “\n”; // [“abcd”,”ef”]
echo ‘[‘, str_pad(‘7’, 3, ‘0’, STR_PAD_LEFT), “]\n”; // [007]
[hp]</div>
<p>The first call shows that the last piece can be shorter than the rest. Padding a number to a fixed width, as in the second call, is common in invoice numbers and log lines, which is where a faster <code>str_pad()</code> pays off. The gain is about 20%, and grows with the size of the string, padded or split.</p>
<h3 id="toc_15">str_repeat() with a multiplier of 1</h3>
<p><code>str_repeat()</code> with a multiplier of 1 returns its input unchanged. The NEWS entry says that case is faster, which means the function can return the string without running the repeat loop. This helps with dynamically generated repeat values, which is a niche case.</p>
<div>
<!--?php <br ?--> echo str_repeat(‘ab’, 1), “\n”; // ab<br />
echo str_repeat(‘ab’, 3), “\n”; // ababab<br />
[hp]</div>
<h3 id="toc_16">new self() with known constructors</h3>
<p>The NEWS entry says that arguments are passed more efficiently to known constructors, and gives <code>new self()</code> as the example. <code>self</code> always names the class the code is written in, so the compiler knows at build time which constructor runs.</p>
<div>
<!--?php <br ?--> class Point<br />
{<br />
public function __construct(public int $x, public int $y) {}public static function origin(): static<br />
{<br />
return new self(0, 0);<br />
}<br />
}</p>
<p>echo json_encode(Point::origin()), “\n”; // {“x”:0,”y”:0}<br />
[hp]
</div>
<p>Because the constructor is known, the call can pass its arguments directly, instead of going through a general lookup. The time measurement on this speed up was inconclusive.</p>
<h2 id="toc_17">Measuring it</h2>
<p>The machine ran PHP 8.5.12 and PHP 8.6.0-dev side by side, on macOS with 8 cores. Each number is the best of five runs, each in a separate process, with the work inside a function. Within one table, the cases ran interleaved, so both versions saw the same load. Compare ratios within a table. Absolute times drift between runs.</p>
<p>The callback cases, 300 × 1,000 items per run:</p>
<table>
<thead>
<tr>
<th>Case</th>
<th>PHP 8.5.12 (ms)</th>
<th>PHP 8.6-dev (ms)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>array_map(double(...), $arr)</code></td>
<td>38.1</td>
<td>18.5</td>
</tr>
<tr>
<td><code>foreach</code> calling <code>double($v)</code></td>
<td>57.9</td>
<td>17.6</td>
</tr>
<tr>
<td><code>array_map(intval(...), $arr)</code></td>
<td>10.9</td>
<td>11.3</td>
</tr>
<tr>
<td><code>foreach</code> calling <code>intval($v)</code></td>
<td>24.1</td>
<td>10.7</td>
</tr>
<tr>
<td><code>array_map(fn($x) =>; $x * 2, $arr)</code></td>
<td>30.4</td>
<td>20.2</td>
</tr>
</tbody>
</table>
<p>The first two rows are the callback the rewrite targets. On 8.6, the compiled <code>array_map</code> and the hand-written loop time the same, and so do the internal-callable pair. The rewrite itself costs nothing in speed. On 8.5, the hand-written loop was about 1.5 times slower than <code>array_map</code>. The 8.6 engine made the loop 3.3 times faster and <code>array_map</code> 2.1 times faster, so the gap closed.</p>
<p>The string cases, 1 million calls each, from one run:</p>
<table>
<thead>
<tr>
<th>Case</th>
<th>PHP 8.5.12 (ms)</th>
<th>PHP 8.6-dev (ms)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>$s = $a</code> (baseline)</td>
<td>41.1</td>
<td>12.4</td>
</tr>
<tr>
<td><code>"$b"</code> (int to string)</td>
<td>25.9</td>
<td>61.5</td>
</tr>
<tr>
<td><code>$a . ' ' . $b</code></td>
<td>43.6</td>
<td>127.1</td>
</tr>
<tr>
<td><code>"$a $b"</code></td>
<td>34.2</td>
<td>116.7</td>
</tr>
<tr>
<td><code>sprintf('%s %d', $a, $b)</code></td>
<td>36.0</td>
<td>129.0</td>
</tr>
</tbody>
</table>
<p>The bare loop in 8.6 is four times faster than in 8.5. But anything that turns an integer into a string is two to three times slower on this 8.6 build, and that includes both sides of the printf comparison. This may be a regression in the dev snapshot.</p>
<h2 id="toc_18">The estimate</h2>
<p>These estimates are for PHP 8.6 as it stood on the test machine. They are not release numbers, so there is still room for last-minute improvements.</p>
<p><strong>printf to interpolation</strong> In the table, interpolation is 5% faster than <code>sprintf()</code> on 8.5 and 10% faster on 8.6. Estimate: a gain of 5 to 10% on the formatting line itself, and invisible inside a web request. No effort required for this one.</p>
<p><strong>array_map with a first-class callable</strong> The rewrite to a loop is speed-neutral on 8.6: the same loop, the same time. The gain people will see comes from the 8.6 engine, which is about 2 times faster on this callback than 8.5. Estimate: 2 times faster on 8.6 against 8.5, for callback-heavy loops, with the rewrite itself adding nothing measurable. This makes <code>array_map()</code> a lot more useful now.</p>
<p><strong>closures</strong> The rewrite does not reach them. My closure row uses an inline body (<code>fn($x) =>; $x * 2</code>), not <code>double()</code>, so it does not compare like with like. The one fair pair on 8.6 is the <code>double()</code> row and the <code>foreach</code> row, which match. I did not measure a first-class callable against a closure wrapping the same function, so I have no number for the closure penalty on 8.6. Write whichever reads better, and measure before you change working code for speed.</p>
<h2 id="toc_19">The bigger picture and the JIT</h2>
<p><code>array_map()</code> is a function, and the compiler now treats it as a loop. Why did it need to be a function at all? The answer is historical: <code>array_map()</code> predates the Closure, the first-class callable, and the JIT. It was written when the callback had to be a string name, and a loop was the only way to call it from userland. Each new feature has made the function more of a wrapper and less of a primitive.</p>
<p>If the rewrite gives no speed gain, what is it for? The loop is the same, but the JIT can now see the call inside it instead of a black box. The speed comes later, when the JIT has more to work with.</p>
<p>So the question for the next version is which other functions are doing the same thing. <code>str_repeat()</code> with a multiplier of 1 is an identity. <code>pathinfo()</code> with a single component is a substring. <code>array_sum()</code> on an integer array is a loop. If the compiler can see through those, the function call stops being a cost you pay and becomes an annotation you write for the reader.</p>
<p>Which of your hot functions would you be happy to see the compiler replace with a loop, and which would you want it to leave alone?</p>
<p>The post <a href="https://www.exakat.io/php-8-6-rewrites-some-of-your-calls-before-you-notice/">PHP 8.6 Rewrites Some of Your Calls Before You Notice</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Recently updated PIE extensions #14 (since October 29th, 2026) - Exakathttps://www.exakat.io/?p=165772026-11-05T20:43:04.000ZExakat<h2 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16529" src="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300.png" alt="Recently updated PIE extensions #14" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150@2x.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150.png 150w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-500x500.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-100x100.png 100w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png 640w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300@2x.png 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Recently updated PIE extensions #14 (since October 29th, 2026)</h2>
<p>25 PHP Pie extensions were updated.</p>
<ul>
<li><a href="https://packagist.org/packages/flow-php/arrow-ext">flow-php/arrow-ext</a> (0.47.0): Apache Arrow and Parquet bindings for flow-php/parquet (Rust)</li>
<li><a href="https://packagist.org/packages/phpolygon/php-vio">phpolygon/php-vio</a> (2.40.3): PHP extension for GPU rendering (OpenGL, Vulkan, Metal), audio, video recording, streaming, and input</li>
<li><a href="https://packagist.org/packages/mongodb/mongodb-extension">mongodb/mongodb-extension</a> (2.5.6): MongoDB driver extension</li>
<li><a href="https://packagist.org/packages/flow-php/flow-php-ext">flow-php/flow-php-ext</a> (0.47.0): Flow PHP native extension (Rust) – native column backend, CSV/JSON readers, Parquet ETL through arrow-ext</li>
<li><a href="https://packagist.org/packages/xberg-io/tree-sitter-language-pack">xberg-io/tree-sitter-language-pack</a> (v1.23.0): Pre-compiled tree-sitter grammars for 372 programming languages</li>
<li><a href="https://packagist.org/packages/xberg-io/liter-llm">xberg-io/liter-llm</a> (v2.5.0): Universal LLM API client with Rust-powered polyglot bindings.</li>
<li><a href="https://packagist.org/packages/xberg-io/html-to-markdown">xberg-io/html-to-markdown</a> (v3.20.0): High-performance HTML to Markdown converter</li>
<li><a href="https://packagist.org/packages/thomas-0816/pdo-duckdb-php">thomas-0816/pdo-duckdb-php</a> (2.0.0.0-beta4): PHP PDO Driver for DuckDB, modern analytics</li>
<li><a href="https://packagist.org/packages/grpc/grpc-php-ext">grpc/grpc-php-ext</a> (v1.85.1): gRPC PHP Extension</li>
<li><a href="https://packagist.org/packages/iliaal/phpser">iliaal/phpser</a> (0.10.3): Fast binary serializer for PHP cache workloads. Decoder-optimized, beats igbinary on packed numerics, deep-nested structures, and same-class DTO batches.</li>
<li><a href="https://packagist.org/packages/phpstan/turbo">phpstan/turbo</a> (2.3.5): Native acceleration extension for PHPStan</li>
<li><a href="https://packagist.org/packages/satwareag/pdo-fbird">satwareag/pdo-fbird</a> (v13.3.1): PDO driver for Firebird SQL (pdo_fbird) — separate from the main php-firebird extension</li>
<li><a href="https://packagist.org/packages/satwareag/php-firebird">satwareag/php-firebird</a> (v13.3.1): PHP Firebird database extension — native fbird_* API for PHP 8.2+</li>
<li><a href="https://packagist.org/packages/cachewerk/ext-relay">cachewerk/ext-relay</a> (v0.61.0): The fastest Redis client for PHP. 100× faster cache reads, near-zero bandwidth, no code changes required.</li>
<li><a href="https://packagist.org/packages/orieg/expanse-extension">orieg/expanse-extension</a> (v0.17.0): Native PHP Zend Engine extension for Expanse: modern Judy arrays in pure Rust (ext-php-rs). Userland API: orieg/expanse.</li>
<li><a href="https://packagist.org/packages/corvus-dotnet/corvus-json-schema">corvus-dotnet/corvus-json-schema</a> (0.2.1): A high-performance JSON Schema evaluator (draft 4, 6, 7, 2019-09 and 2020-12) as a PHP extension, backed by Rust.</li>
<li><a href="https://packagist.org/packages/martinjuul/duckdb">martinjuul/duckdb</a> (2.0.0): Native DuckDB driver for PHP (C extension). Synchronous, streaming and asynchronous queries, prepared statements, transactions, bulk appender, typed errors.</li>
<li><a href="https://packagist.org/packages/phasync/ext-phasync">phasync/ext-phasync</a> (2.0.7): PHP extension that makes blocking I/O (PDO, mysqli, curl, streams, sleep) wait cooperatively in fibers an event loop manages (phasync\ext\Suspension), and per-coroutine requests (sapi()).</li>
<li><a href="https://packagist.org/packages/fiber-interop/ext-scope">fiber-interop/ext-scope</a> (v0.6.0): The Scope class from the PHP RFC “Scope”, as a PHP extension (PHP 8.2+).</li>
<li><a href="https://packagist.org/packages/pvmlibs/flexid_utils">pvmlibs/flexid_utils</a> (1.1.0): Tools for encoding, encrypting and signing numbers</li>
<li><a href="https://packagist.org/packages/vanta/meminfo">vanta/meminfo</a> (0.2.0): PHP extension that dumps the content of PHP memory as JSON, to hunt down memory leaks</li>
<li><a href="https://packagist.org/packages/mindee/bernard-ledit">mindee/bernard-ledit</a> (v0.1.0): PDF and image processing for the Mindee PHP SDK, as a native PHP extension.</li>
<li><a href="https://packagist.org/packages/phpstats/phpolars">phpstats/phpolars</a> (v0.2.2): Polars data frames for PHP, as a native Rust extension</li>
<li><a href="https://packagist.org/packages/phpstats/phit">phpstats/phit</a> (v0.6.2): Native Rust statistical modeling for PHP: regression, likelihood, and mixed models</li>
<li><a href="https://packagist.org/packages/caronc/dateblock">caronc/dateblock</a> (v2.1.0): Block (sleep) until a cron-style moment in time</li>
</ul>
<p>The post <a href="https://www.exakat.io/recently-updated-pie-extensions-14-since-october-29th-2026/">Recently updated PIE extensions #14 (since October 29th, 2026)</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>What’s New in PhpStorm 2026.3 - PhpStorm : The IDE that empowers PHP developers | The JetBrains Bloghttps://blog.jetbrains.com/?post_type=phpstorm&p=7519482026-11-05T14:15:38.000ZPhpStorm : The IDE that empowers PHP developers | The JetBrains Blog<p>PhpStorm 2026.3, the third major update of the year, is here! This release includes a new workspace for agentic development and multi-agent setups, support for PHP 8.6, improvements to remote development and WSL scenarios, and PHP code insight enhancements.</p>
<p class="has-text-align-center"><a class="jb-download-button" href="https://www.jetbrains.com/phpstorm/download/" target="_blank" rel="noopener">Download PhpStorm 2026.3</a></p>
<figure class="wp-block-image size-full is-style-default"><img style="width:100% !important; height:auto !important; max-width:100% !important;" fetchpriority="high" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/PS-releases-BlogFeatured-1280x720-1-3.png" alt="" class="wp-image-752397"/></figure>
<h2 class="wp-block-heading">JetBrains Air – one place to run your agents and verify their work</h2>
<p>PhpStorm 2026.3 ships with <a href="https://www.jetbrains.com/air/ides/" target="_blank" rel="noopener">Air</a>, a new layer for agentic development in JetBrains IDEs. Work with the coding agents and subscriptions you already have, and manage multi-agent setups inside PhpStorm. </p>
<p>The IDE’s code intelligence helps agents make fewer wrong turns and gives you the tools to review every change before it ships. Open agent sessions, project files, and diffs in the editor tabs side by side – no switching between the editor and agent workspace views.</p>
<figure class="wp-block-image size-full"><img decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/air-in-phpstorm.png" alt="" class="wp-image-751954" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h3 class="wp-block-heading">Your agents, your models, your subscriptions – with Junie Lite for free </h3>
<p>Air in PhpStorm works with Claude Agent, Codex, Gemini, GitHub Copilot, Junie, OpenCode, and other <a href="https://www.jetbrains.com/acp/" target="_blank" rel="noopener">ACP-compatible agents</a>. It detects the agents already installed on your machine, so you can connect them with a single click and add more from the agent registry.</p>
<p>Your existing setup carries over, too: provider subscriptions, API keys, and even a custom base URL all work, with no JetBrains AI subscription required. Run Claude Agent on your Claude subscription in the terminal or in a full-screen IDE tab, use other agent subscriptions in the chat or terminal, and switch between subscriptions at any moment, even mid-session.</p>
<p>Air in PhpStorm includes free AI with the <a href="https://junie.jetbrains.com/" target="_blank" rel="noopener">Junie</a> Lite configuration, so you can use an agent without a subscription. You only need a JetBrains Account.</p>
<figure class="wp-block-image size-full"><img decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/your-agents-models-subscriptions.png" alt="" class="wp-image-751965" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h3 class="wp-block-heading">A central workspace to review changes and guide the agent</h3>
<p>Review an agent’s changes with the surrounding code and your project tools in view, and send feedback straight back to the agent. Anchor a note to a specific line in the diff, or comment directly from the code, so the agent gets concrete context about the change you want. Work in the chat or the terminal, whichever suits you.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/explain-changes-guide-agent.png" alt="" class="wp-image-751978" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h2 class="wp-block-heading">PHP and Laravel</h2>
<h3 class="wp-block-heading">PHP 8.6 support </h3>
<p>PhpStorm 2026.3 adds support for PHP 8.6, which will be released later this November. You can configure the IDE to check your code against PHP 8.6 in the settings (by going to <em>PHP</em> | <em>PHP language level</em>) or through the php requirement in <code>composer.json</code>. This lets you:</p>
<ul class="wp-block-list">
<li><strong>Migrate existing codebases to PHP 8.6.</strong> <br>The new <em>Deprecated since PHP 8.6</em> inspection reports <a href="https://wiki.php.net/rfc/deprecate-return-value-from-construct" target="_blank" rel="noopener">constructors and destructors that return a value</a> or use <code>yield</code>. The <em>Remove return value</em> quick-fix removes the returned value and keeps early exits. Calls to the deprecated <code data-enlighter-language="generic" class="EnlighterJSRAW">mb_ereg*</code> functions are reported too.<br><br><img loading="lazy" decoding="async" class="wp-image-752036" style="width: 706px;; width:100% !important; height:auto !important; max-width:100% !important;" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/php-86-deprecarions-1.png" alt=""><br> </li>
<li><strong>Deliver quality PHP 8.6 code from day one.</strong> <br>PhpStorm adds code completion and type inference for PHP’s new functions, classes, and APIs and reports deprecated patterns and potential runtime errors before you or your agents run it.<br> <br><img loading="lazy" decoding="async" class="wp-image-752049" style="width: 706px;; width:100% !important; height:auto !important; max-width:100% !important;" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/php-86-features.png" alt=""><br> </li>
<li><strong>Keep supporting older PHP versions. </strong><br>If your project targets PHP 8.5 or earlier, PhpStorm reports 8.6-only syntax and calls to new functions such as <code>clamp()</code>.<strong> </strong>For a <a href="https://wiki.php.net/rfc/readonly_property_defaults" target="_blank" rel="noopener">readonly property with a default value</a>, it offers the <em>Initialize property in constructor</em> quick-fix.<br> </li>
</ul>
<p>These checks work the same way whether you wrote the code or an agent did. With PhpStorm’s MCP server enabled, agents can run the inspections and apply the quick-fixes themselves.</p>
<blockquote class="wp-block-quote alignleft is-layout-flow wp-block-quote-is-layout-flow">
<p>The <em>php-runtime-tools</em> skill that comes bundled with PhpStorm 2026.3 gives your agent the project’s PHP interpreter, so it doesn’t fall back to the system <code>php</code> and run with the wrong version or missing extensions.</p>
</blockquote>
<h3 class="wp-block-heading">Type inference improvements</h3>
<p>PhpStorm 2026.3 further improves type inference in code that uses generics templates, callables, and array shapes. The enhancements and bug fixes include support for the <code>@param-closure-this</code> tag and parameter types from PHPDoc callable signatures, templates in <code>@method</code> declarations, return types for generic factories that take a <code>class-string<T></code> argument, and arrays built with the spread operator.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/type-inference-callable-signature-method-declaration.png" alt="" class="wp-image-752064" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h3 class="wp-block-heading">Laravel support enhancements</h3>
<p>Laravel support adds new inspections that work in the editor and via PhpStorm’s MCP server, so your agents can check their own changes too. These inspections include <em>Unknown config keys</em>, <em>Laravel routes</em> for missing resource route methods, and <em>Unknown Livewire component method</em>. The inspections catch config keys and methods that don’t exist – errors that look correct in a diff and only show up at runtime.</p>
<p>The <em>Laravel</em> tool window also adds a <em>Processes</em> tab for managing long-running processes like the dev server, queue workers, and <code>npm dev</code> commands. You can list, start, stop, restart, or view output from them all in one place instead of switching between terminal tabs.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/Laravel_processes_tab.png" alt="" class="wp-image-752075" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h2 class="wp-block-heading">Version control</h2>
<h3 class="wp-block-heading">Git worktrees for parallel work and easy code reviews</h3>
<p>PhpStorm can now copy your local project configuration into new Git worktrees, including run configurations and other settings stored in <code>.idea</code>. You no longer need to commit those settings to Git or recreate them for each worktree.</p>
<p>You can also list local and ignored files in <code>.worktreeinclude</code> for the IDE to copy, and configure a custom script to run when a worktree is created, for example, to install dependencies.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/new-worktree-copy-local-project-setup.png" alt="" class="wp-image-752088" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h3 class="wp-block-heading">GitHub and GitLab changes in a separate worktree</h3>
<p>Open a GitHub pull request or GitLab merge request in a separate Git worktree to review changes with full IDE support. Your current branch and uncommitted changes stay intact, so you can review code without stashing your work or switching branches.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/image-20.png" alt="" class="wp-image-752099" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h3 class="wp-block-heading">GitLab connections with OAuth</h3>
<p>Connect your GitLab account to your JetBrains IDE by signing in through your browser, without creating and pasting a personal access token. OAuth authentication works with GitLab.com and custom GitLab instances, and you can use the connected account for merge requests and Git operations over HTTPS.</p>
<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/image-21.png" alt="" class="wp-image-752110" style="object-fit:cover; width:100% !important; height:auto !important; max-width:100% !important;"/></figure>
<h2 class="wp-block-heading">UX/UI</h2>
<h3 class="wp-block-heading">Quick tasks and edits without opening a project</h3>
<p>Not every task needs an open project. The new <em>Home</em> window replaces the <em>Welcome</em> screen, so you can get to work the moment PhpStorm opens. Edit a file, run a terminal command, use database tools, or perform Git actions – all without waiting for a full project to load.</p>
<p>Create a standalone file and start typing immediately, choosing its name and location when you save. When you need the full power of the IDE, your recent projects, along with actions to open or create a project, are on the left.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/phpstorm-home-screen.png" alt="" class="wp-image-752136"/></figure>
<h3 class="wp-block-heading">Sound cues for IDE events and editor line marks</h3>
<p>We’re continuing our work on making PhpStorm accessible to every developer. This release introduces sound cues, built-in responses to requests that give you information without requiring that you have the context in view.</p>
<p>Screen reader users now get audio cues for editor line marks: errors and warnings, lines added, changed, and removed under version control, and code folding. You can also hear when things finish. With screen reader support enabled, line-mark cues and sounds for the most important events (builds, tests, breakpoint hits) are enabled by default. Agents in Air come with sound cues of their own, and they’re enabled by default for everyone, whether or not you enable screen reader support. </p>
<p>You can explore and preview the sounds on the new <em>Accessibility</em> settings page, and use the <em>Play sound</em> checkbox on the <em>Notification settings</em> page to enable cues for a specific notification group. Learn more from <a href="https://jb.gg/jb-ide-sound-cues" target="_blank" rel="noopener">this blog post</a>. </p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/Sound_settings_with_SSR.png" alt="" class="wp-image-752147"/></figure>
<h2 class="wp-block-heading">Terminal</h2>
<h3 class="wp-block-heading">A more reliable terminal for your command-line tools</h3>
<p>PhpStorm’s terminal now runs on <a href="https://ghostty.org/docs/about#libghostty" target="_blank" rel="noopener">libghostty</a>, the terminal emulation library that powers Ghostty itself. This improves support for keyboard shortcuts, emoji, and styling in terminal applications, including AI coding agents such as Claude Code, Codex, and Junie.</p>
<p>You get the compatibility of a modern standalone terminal, along with IDE features such as file links and command blocks, keeping your terminal workflow close to your code. Ghostty’s support for evolving terminal standards also helps the IDE keep pace with the CLI tools you use. Learn more from <a href="https://blog.jetbrains.com/platform/2026/10/jetbrains-terminal-now-uses-ghostty/">this blog post</a>. </p>
<h3 class="wp-block-heading">Terminal tabs in the editor</h3>
<p>Give build logs, long command output, and terminal-based agents such as Claude Code more room alongside your code. In PhpStorm 2026.3, you can simply drag a terminal tab into the editor area, choose <em>Open as Editor Tab</em> from its context menu, or use the dedicated shortcut Alt+Shift+Enter, even while a session is running.</p>
<p>Split terminal tabs beside source files, switch between them with the switcher, and name them yourself or let them take the name of the process you start. You can drag a tab back to the <em>Terminal</em> tool window or invoke <em>Return to Tool Window</em> from the tab context menu when you want to change the layout.</p>
<p>If a session is running, the IDE will warn you when you try to close its tab or restart the IDE, helping prevent unintentional session termination and potential data loss.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/terminal-tabs-in-editor_preview.png" alt="" class="wp-image-752158"/></figure>
<h2 class="wp-block-heading">Performance</h2>
<h3 class="wp-block-heading">Freeze fixes in everyday PHP workflows</h3>
<p>PhpStorm 2026.3 fixes a significant number of user-reported UI freezes in Composer projects, deployment connections, Twig debugging, and the IDE’s type inference by moving blocking operations off the UI thread. Now the editor keeps responding while operations like file I/O or network calls run in the background.</p>
<h3 class="wp-block-heading">Automatic error and freeze reporting</h3>
<p>In version 2026.3, PhpStorm automatically sends error and UI freeze reports to JetBrains, helping us identify the problems that interrupt your work and prioritize fixes based on their impact.</p>
<p>Reports contain only technical data. Personal details such as file paths, URLs, and usernames are removed from report messages before they leave your machine. You can turn automatic reporting off in <em>Settings | Appearance & Behavior | System Settings | Data Sharing</em>.</p>
<p>Details in the<a href="https://youtrack.jetbrains.com/articles/SUPPORT-A-4885/Automatic-Error-Reports-enabled-in-2026.3-release" target="_blank" rel="noopener"> FAQ</a>.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/data-sharing-phpstorm.png" alt="" class="wp-image-752172"/></figure>
<h2 class="wp-block-heading">WSL</h2>
<h3 class="wp-block-heading">Project setup in WSL</h3>
<p>PhpStorm 2026.3 further improves how you work with PHP projects in WSL, including:</p>
<ul class="wp-block-list">
<li>PHP interpreter setup: The IDE now detects all PHP binaries installed in your WSL distribution, setting the WSL connection, the distribution, and the binary path for each automatically.<br><br><img loading="lazy" decoding="async" class="wp-image-752183" style="width: 706px;; width:100% !important; height:auto !important; max-width:100% !important;" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/select-interpreter-wsl.png" alt=""><br></li>
</ul>
<ul class="wp-block-list">
<li>Xdebug configuration: PhpStorm 2026.3 forwards the debugger connection into the WSL distribution, so you can debug a PHP script or tests with a WSL interpreter without extra network setup.<br></li>
<li>Browsing files in the quality tool, test framework, and Composer settings: The file chooser now opens files in the WSL distribution directly. PhpStorm inserts the Linux path of the file that you select.<br><br><img loading="lazy" decoding="async" class="wp-image-752197" style="width: 706px;; width:100% !important; height:auto !important; max-width:100% !important;" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/browse-files-phpstan.png" alt=""></li>
</ul>
<h2 class="wp-block-heading">Remote development</h2>
<h3 class="wp-block-heading">Remote development directly from the IDE</h3>
<p>You can now work on projects hosted on a remote machine directly from PhpStorm. An integrated SSH connection flow lets you connect to a host, start a development session, and reconnect to existing sessions, keeping remote work part of your everyday coding workflow.</p>
<p>With connection and session management built into the IDE, your team will have fewer applications to configure, maintain, and keep secure.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/New_Flow9.png" alt="" class="wp-image-752215"/></figure>
<h3 class="wp-block-heading"><em>Light </em>mode for remote development</h3>
<p>You can now start working on a remote project while the remote IDE is still downloading, installing, and launching. <em>Light </em>mode opens the project early and gives you immediate access to editing, the terminal, and file search, with no additional downloads. Once the remote IDE is ready, your session transitions to full mode automatically, preserving your work and state.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/remote-light-mode.png" alt="" class="wp-image-752232"/></figure>
<h3 class="wp-block-heading">Native OpenSSH support</h3>
<p>JetBrains IDEs now use OpenSSH for SSH connections, improving compatibility with the authentication methods and tools your team already uses.</p>
<p>Expanded support includes certificate-based authentication, hardware security tokens such as YubiKey, kerberos-sspi, X11 forwarding, and <code>ProxyJump</code>, along with a broader range of SSH agents and wrappers.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/OpenSSH.png" alt="" class="wp-image-752243"/></figure>
<h2 class="wp-block-heading">Databases</h2>
<h3 class="wp-block-heading">Database-specific features in JetBrains Air </h3>
<p>You can now work with your databases directly in chats with AI agents. Run SQL from the chat, view CSV data in the data editor, and reference database objects with completion and <em>Quick Definition</em> support. SQL snippets use your IDE’s syntax highlighting and formatting settings, so queries in the chat read the same way they do in the editor.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/dg_20263_transparent_query_console.png" alt="" class="wp-image-752254"/></figure>
<h3 class="wp-block-heading">Cross-database queries</h3>
<p>When related data lives in different databases, comparing or joining it previously required copying data from one system to another first. That step is no longer needed. You can now<a href="https://www.jetbrains.com/help/datagrip/2026.3/cross-database-queries.html" target="_blank" rel="noopener"> query across data sources</a>, even when they use different DBMSs, and view the results directly.</p>
<p>This is possible thanks to the new <em>Workspace</em> data source, based on DuckDB. It runs in memory by default, so it doesn’t require a database file. Each project can have one Workspace data source. To add it, click <em>Add</em> on the <em>Database Explorer</em> toolbar and select <em>Workspace Data Source</em>. Its default query console opens automatically, and you can create more as needed. In the console, you can reference tables from other data sources using a<a href="https://www.jetbrains.com/help/datagrip/2026.3/cross-database-queries.html#syntax" target="_blank" rel="noopener"> dedicated syntax</a>.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/dg_20263_cross_database_query_join.png" alt="" class="wp-image-752276"/></figure>
<h2 class="wp-block-heading">Extend your IDE</h2>
<h3 class="wp-block-heading">Ability to connect any language server from the IDE settings</h3>
<p>Missing language support in your JetBrains IDE no longer has to be a blocker. <a href="https://plugins.jetbrains.com/plugin/34030-lsp-connection-manager" target="_blank" rel="noopener">LSP Connection Manager</a> is a new plugin that lets you configure and use any Language Server Protocol server straight from the IDE settings. If a technology doesn’t have a dedicated plugin yet but has an existing LSP server, you can point the IDE at its binary and enable it for your project in a few clicks, with no custom plugin development required.</p>
<p>Open <em>Settings | Languages & Frameworks | Language Servers</em>, point the IDE to the server executable, and choose the file types it should handle. You can configure multiple servers and manage their file mappings from the same page.</p>
<figure class="wp-block-image size-full"><img style="width:100% !important; height:auto !important; max-width:100% !important;" loading="lazy" decoding="async" src="https://blog.jetbrains.com/wp-content/uploads/2026/11/Lua-Settings.png" alt="" class="wp-image-752287"/></figure>Half of PHP Projects Still Promise an Unsupported PHP Version - Exakathttps://www.exakat.io/?p=165672026-11-05T09:21:39.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/11/older.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16568" src="https://www.exakat.io/wp-content/uploads/2026/11/older.640-300x300.jpg" alt="" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/older.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/11/older.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/11/older.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/older.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/11/older.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/older.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Growing Old With PHP, 2026</h1>
<p>In 2020, Exakat looked at its corpus of PHP projects and reviewed them by the date of their last commit. Six years later, we are running the same analysis, with a modernized sample, with the same questions: how alive are PHP code bases. The original from 2020 is available at <a href="https://www.exakat.io/growing-older-with-php/">exakat.io</a>.</p>
<h2 id="toc_1">Sourcing PHP Codes</h2>
<p>The corpus is the basis for the internal tests of Exakat, the static code analysis. It covers currently 3314 projects, extracted from packagist, and various other public sources, published as archived or different source host like github, gitee, gitlab or framasoft.</p>
<p>In these projects, we set aside 850 of them which are not hosted with git. That leaves <strong>2,462 repositories</strong>, with an existing remote hosting. As a rule of thumb, the corpus measurements stabilize with any set of 300 random of these projects, and this goes well beyond.</p>
<h2 id="toc_2">Last Commits Per Year</h2>
<p>The chart shows the calendar year of each project’s last commit, for the last ten years. Anything older is grouped as “Before 2017”. This illustrates is how recently PHP projects are updated: the more recent the better.</p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-scaled.png"><img decoding="async" class="aligncenter wp-image-16570 size-large" src="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-1024x478.png" alt="" width="1020" height="476" srcset="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-1024x478.png 1024w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-300x140.png 300w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-1536x717.png 1536w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-2048x956.png 2048w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-500x233.png 500w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-year-300x140@2x.png 600w" sizes="(max-width: 1020px) 100vw, 1020px" /></a></p>
<p> </p>
<p>Within last year, 34.9% of projects have been update, or 859 repositories. Within two years, that is 41.2%. Within five years, it is 60.0%. Within ten years, 92.7%. The “Before 2017” group holds 190 projects, last updated before 2016. That category includes PHP nuke, though that famous project has a more modern version, if you really want it.</p>
<p>The 2020 article reported 45% within a year and 77% within two years. This is a notable discrepancy. The main effect is attributable to the larger sample, which favor the number of stale projects.</p>
<p>The 2026 bar is the tallest by far, at 818 projects, and it counts everything up to 3 November. Before that, the bars are fairly flat: between 122 and 236 projects per year from 2017 to 2025, peaking at 236 for 2021. It seems that projects are dying at a constant rate over the years.</p>
<h2 id="toc_3">Last Commits By Month</h2>
<p>The chart covers the last two years, from November 2024 to the collection date: this time, the interval are by month. Only November 2026 is partial, with 42 projects in its first three days: there aren’t too many updates in such a truncated month.</p>
<p> </p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-scaled.png"><img decoding="async" class="aligncenter wp-image-16572 size-large" src="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-1024x478.png" alt="" width="1020" height="476" srcset="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-1024x478.png 1024w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-300x140.png 300w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-1536x717.png 1536w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-2048x956.png 2048w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-500x233.png 500w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-month-300x140@2x.png 600w" sizes="(max-width: 1020px) 100vw, 1020px" /></a></p>
<p>Through 2025, the months stay between 7 and 21 projects. From January to August 2026 they rise to 25 to 50 projects a month, and September reaches 85. Then October arrives with 396, the largest month in the whole dataset. You have to understand that a project that is updated in January, then February, then.. is only counted once. There is a fract effect with the previous graph, where the number of last update is very recent, and then, it flattens over time.</p>
<p>October is not a spike: it is the freshness ramp. Between 1 and 18 October, about 5 projects a day had their last commit. From 19 to 27 October, 266 projects did, peaking at 61 on the 26th. Then it falls back to about 8 a day for the last four days of the month. It gives an idea that live projects are usually active in the last month.</p>
<p>The 2020 article found two peaks: May 2020 and the run-up to PHP 7.4 in late 2019. The 2026 ramp sits on the release candidates for PHP 8.6, with the release scheduled for 19 November 2026, and php.net reports <a href="https://www.php.net/archive/2026.php#2026-10-21-6">8.6.0RC4 on 21rst October</a>.</p>
<p>One caveat. Of the 396 projects with a last commit in October, 211 or 53% contain at least one bot commit in their history, against 21% for the whole sample. Dependabot and Renovate may be doing some of the updating. I have not checked who made each last commit, so I cannot say how much of the ramp is people, or bots or AI. So many… things are adding their grain of salt in our code bases.</p>
<h2 id="toc_4">Commits by weeks and days</h2>
<p>The weekly chart covers the last two years, from the week of 4 November 2024 to the 3 November 2026 collection date. The final bar is partial: it counts only November 2nd and 3rd.</p>
<p> </p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-scaled.png"><img loading="lazy" decoding="async" class="aligncenter wp-image-16571 size-large" src="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-1024x478.png" alt="" width="1020" height="476" srcset="https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-1024x478.png 1024w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-300x140.png 300w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-1536x717.png 1536w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-2048x956.png 2048w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-500x233.png 500w, https://www.exakat.io/wp-content/uploads/2026/11/chart-last-commit-per-week-300x140@2x.png 600w" sizes="auto, (max-width: 1020px) 100vw, 1020px" /></a></p>
<p>Through 2025, no week has more than 10 projects touched. Summer 2026 settles around 10 a week, then the counts rise from late August (24 in the week of 31 August) and reach 36 and 50 in early October. The two busiest weeks are the last full ones of October, with 176 projects in the week of 19 October and 139 in the week of 26 October.</p>
<h2 id="toc_5">Commits by weekday</h2>
<p>By weekday, the pattern is clearer:</p>
<table>
<thead>
<tr>
<th>Day</th>
<th>Projects</th>
</tr>
</thead>
<tbody>
<tr>
<td>Monday</td>
<td>427</td>
</tr>
<tr>
<td>Tuesday</td>
<td>394</td>
</tr>
<tr>
<td>Wednesday</td>
<td>383</td>
</tr>
<tr>
<td>Thursday</td>
<td>394</td>
</tr>
<tr>
<td>Friday</td>
<td>396</td>
</tr>
<tr>
<td>Saturday</td>
<td>225</td>
</tr>
<tr>
<td>Sunday</td>
<td>243</td>
</tr>
</tbody>
</table>
<p>The split is flat across Monday to Friday, with Thursday level with Tuesday and Friday. The weekend is where it drops: Saturday and Sunday are each about 40% below an average weekday. Packages are mostly worked on during the working week, and far less at weekends. On the other hand, they get something on Monday.</p>
<p>This counts the day each project was last touched, not every commit, so it shows when projects were last worked on rather than the full rhythm of development.</p>
<h2 id="toc_6">Idea: What About A ‘Commit Day’ for 2027?</h2>
<p>PHP’s birthday is June 8th, and in 2026 it turned 31. Four projects had their last commit that day. June as a whole averaged about 1.3 last commits a day, so four is three times the usual.</p>
<p>The PHP birthday count be a celebration of time that pass, and act as a reminder to update your composer.json file, and its dependencies. It falls in June, half a year away from the November releases, which makes it a good reminder for everyone to actually take into account the newest requirements. The question for each project is which PHP version it still promises, and whether that version is still supported.</p>
<p> </p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version.png"><img loading="lazy" decoding="async" class="aligncenter wp-image-16569 size-large" src="https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-1024x620.png" alt="" width="1020" height="618" srcset="https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-1024x620.png 1024w, https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-300x182.png 300w, https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-1536x929.png 1536w, https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-2048x1239.png 2048w, https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-500x303.png 500w, https://www.exakat.io/wp-content/uploads/2026/11/chart-requested-php-version-300x182@2x.png 600w" sizes="auto, (max-width: 1020px) 100vw, 1020px" /></a></p>
<p>Of the 2,462 repositories, 1,573 or 64% declare a PHP requirement. The rest are split between 704 projects with a <code>composer.json</code>that names no PHP version, and 185 with no <code>composer.json</code> at all. The lowest version requested, as a share of all 2,462 projects, reads as follows:</p>
<ul>
<li>PHP 8.3 and later: 195 projects (8%)</li>
<li>PHP 8.2: 168 projects (7%)</li>
<li>PHP 8.0 to 8.1: 320 projects (13%)</li>
<li>PHP 7.x: 566 projects (23%)</li>
<li>PHP 5.x: 313 projects (13%)</li>
</ul>
<p>PHP 8.1 and older are out of support as of today, and PHP 8.2 reaches end of life on 31 December 2026 (<a href="https://endoflife.ai/article-php-eol.html">endoflife.ai</a> lists the dates; check php.net for the authoritative table). Applying that to the pie:</p>
<ul>
<li>1,199 projects (49% of the sample) still accept a PHP version that is no longer supported. This is 313 on PHP 5.x, 566 on 7.x, and 320 on 8.0 to 8.1.</li>
<li>Of those, 344 were touched in the last year. These are active projects that still tell Composer they will run on unsupported PHP.</li>
<li>Another 168 declare 8.2 as their floor. In less than two months, that floor becomes unsupported too.</li>
</ul>
<p>These are the projects that a composer review would reach first. The count of 344 is the actionable number: they are being worked on, so someone will read the requirement.</p>
<h2 id="toc_7">Still Committing, Still Promising Old PHP</h2>
<p>Each project’s <code>composer.json</code> names a floor, and that is the oldest PHP it promises to run on. Setting that floor against the year of the last commit separates three kinds of project: those still maintained with an old promise, those that stopped while their floor was still supported, and those that are slow to raise it.</p>
<p> </p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit.png"><img loading="lazy" decoding="async" class="aligncenter wp-image-16573 size-large" src="https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-1024x837.png" alt="" width="1020" height="834" srcset="https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-1024x837.png 1024w, https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-300x245.png 300w, https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-1536x1256.png 1536w, https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-2048x1674.png 2048w, https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-500x409.png 500w, https://www.exakat.io/wp-content/uploads/2026/11/chart-floor-vs-last-commit-300x245@2x.png 600w" sizes="auto, (max-width: 1020px) 100vw, 1020px" /></a></p>
<p>Each row is a PHP version. The black step line marks the year that version lost security support. A blue dot sits to the right of the line: the project was committed to after its floor had expired. A grey dot sits on or left of the line: the project stopped while its floor was still supported.</p>
<p>Of the 1,562 projects with a parseable floor, 843 (54%) were last committed after their floor’s end of support. The largest blue groups sit on the 5.x, 7.x and 8.0 to 8.1 rows, which is where the unsupported promises are.</p>
<p>The most important group is the one still moving. 759 projects were last committed in 2025 or 2026, and 380 of them or 50%, still promise a PHP version that is out of support. These are not dead projects with a stale requirement. They are maintained projects that have not yet looked at the line in <code>composer.json</code>.</p>
<p>The grey dots are the projects that died with their version. On the 7.1 row, 46 of 141 projects stopped by 2019, while 7.1 was still supported, and 95 were committed later, after it had died. Those 46 are the case where a composer review has no point: nobody was going to raise the floor, because nobody was still there.</p>
<p>The slow group is harder to read. On the 8.1 row, 104 of 192 projects were last committed after 8.1 lost support in 2025. Those are living projects that can raise their floor with a single line, and simply have not. The chart cannot tell the difference between a project that is slow and one that is waiting for a reason. The commit history can, and that is the next thing to look at.</p>
<p>The change should come with a cool-down. A floor is a promise to users, and raising it will drop some of them. Announce the new floor, give a few months for dependent projects to adapt, then raise it. Do it on the same day each year, and the birthday turns into a habit rather than a fever. It actually brings everyone, maintainer and users together. Everyone would know that early June, compatibility numbers would change. It gives time and reasons to get ready.</p>
<h1 id="toc_8">Growing old with PHP</h1>
<p>Age by last commit tells you when a project last moved. It does not tell you why it stopped. A library untouched for five years may be finished, doing one job well and waiting for nothing. Or it may be dead, stopped in its tracks, by simple lack of steam. The same timestamp fits both. So the question is not only how old a project is, but what would have to be true for it to count as finished rather than abandoned.</p>
<p>If we run this audit again in 2032, will we still be measuring the age of the last commit, or will we have learned to measure what the commit was for?</p>
<p>If you want other measurements over large number of PHP code bases, join me on <a href="https://discord.phpc.chat/">discord</a> or on <a href="https://phpc.social/@dseguy">mastodon</a> or your favorite communication system.</p>
<p>The post <a href="https://www.exakat.io/half-of-php-projects-still-promise-an-unsupported-php-version/">Half of PHP Projects Still Promise an Unsupported PHP Version</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Eight PHP Myths That Need to Finally Retire - Exakathttps://www.exakat.io/?p=165632026-11-03T11:02:48.000ZExakat<figure id="attachment_16564" aria-describedby="caption-attachment-16564" style="width: 300px" class="wp-caption alignleft"><a href="https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640.jpg"><img fetchpriority="high" decoding="async" class="size-medium wp-image-16564" src="https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-300x300.jpg" alt="" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/minotaur.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a><figcaption id="caption-attachment-16564" class="wp-caption-text">Eight PHP Myths That Need to Finally Retire</figcaption></figure>
<h1 id="toc_0">Eight PHP Myths That Need to Finally Retire</h1>
<p>PHP left bad memories with a slice of its audience, 20 years ago. Indeed, some of it was earned. The language genuinely did ship some bad ideas in the ancient PHP 4 and early PHP 5 era, and recent memory-safety CVEs in the Zend Engine are a serious, ongoing concern worth patching today. None of that is in dispute, and neither should significant modernization be ignored.</p>
<p>A lot of what gets repeated about PHP in 2026 is just fossilized experience. Like mammoths, these claims teach us a lot about the past, and they belong in a museum. Some claims were true in 2008 and have been false for a decade, almost two. Other claims sound technical but are not. Still, they get repeated because they are fossilized and do not evolve anymore. Meanwhile, PHP cleaned its room, tidied its syntax, and got better with age.</p>
<p>This article attempts to straighten out eight of the stubborn ones. Its goal is to stop the same dead arguments from being used as if they are current. They are relics of the past.</p>
<h2 id="toc_1">Myth 1: “PHP is interpreted, so it’s slow”</h2>
<p>This one is at least twelve years out of date.</p>
<p>PHP has shipped <strong>OPcache</strong> as a bundled default since <strong>PHP 5.5, released in 2013</strong>. OPcache is an opcode cache that eliminates the parse-and-compile step on every request. The PHP source you write is compiled to Zend opcodes once, cached in shared memory, and executed from there on subsequent requests. The first request is slow, and the second one is much faster.</p>
<p>Since <strong>PHP 8.0, released in November 2020</strong>, PHP also ships a <strong>JIT compiler</strong>. The JIT is configured through the <code>opcache.jit</code> family of ini settings, and it further compiles hot paths to native machine code at runtime. It is not AOT in the Rust/Go sense, but it is also emphatically not interpreted line by line on every request. Give it heavy loads of math and string work, and it gets noticeably more athletic.</p>
<p>The “PHP is interpreted” framing was reasonable in 2010, before opcode caching became the norm. In 2026, it is a category error. PHP is a managed runtime that compiles to opcodes and can use a JIT. It is usually still slower than Rust on raw CPU-bound benchmarks, but the gap has long moved away from what the “interpreted” label implies. For I/O-bound web work, the difference is dominated by network and database latency anyway. The “interpreted” label is a bit like a 2010 phone: still in the drawer, and nobody has used it in years.</p>
<h2 id="toc_2">Myth 2: “PHP is still dragging around all those awkward features from the PHP 4 era”</h2>
<p>I have a whole book of arcane PHP features inherited from this era, and I now have a hard time finding new ones, since they get mercilessly removed from the code. I really wonder if there is a relationship between these two facts. Either way, this is the myth that ages the worst. If you actually list the cited awkward features, almost all of them have been gone for years, almost decades. The list shrinks faster than a sweater in a hot wash.</p>
<p>Consider the usual suspects:</p>
<ul>
<li><strong><code>register_globals</code></strong> was removed in PHP 5.4, which shipped in March 2012. It had been off by default since PHP 4.2.0, released in 2002.</li>
<li><strong><code>magic_quotes_gpc</code></strong> was removed in PHP 5.4, which shipped in March 2012.</li>
<li><strong>Call-time pass-by-reference</strong> was deprecated in PHP 5.3 and removed in PHP 5.4, which shipped in March 2012.</li>
<li><strong><code>preg_replace</code> with the <code>/e</code> modifier</strong>, often called the “hidden <code>eval()</code>“, was deprecated in PHP 5.5 and removed in PHP 7.0, which shipped in December 2015. Developers replaced it with <code>preg_replace_callback</code>.</li>
<li><strong>ASP tags <code><% %></code> and <code><script language="php"></code></strong> were removed in PHP 7.0, which shipped in December 2015, through the “Remove alternative PHP tags” RFC.</li>
<li><strong>Dynamic properties on objects</strong> were deprecated in PHP 8.2, released in December 2022, and they will cause a fatal error in PHP 9.0.</li>
<li><strong>String increment</strong>, where <code>'AZ'++</code> produces <code>'BA'</code>, was deprecated in PHP 8.3, released in November 2023, through the “Path to Saner Increment/Decrement Operators” RFC. This one was a beloved PHP easter egg that people used to share while grinning. I did. I guess we are becoming more mature.</li>
</ul>
<p>That is the entire usual list. Every single one of them is either removed or formally deprecated. The most recent two, dynamic properties and string increment, remain in their deprecation window, but they are on a clear, scheduled path out. Beware PHP 9!</p>
<p>When someone lists those features as evidence of PHP’s current dysfunction, what they are really showing is that they have not caught up with PHP since about 2015. The critique is historically accurate, and the framing as a present-tense problem is not valid anymore.</p>
<h2 id="toc_3">Myth 3: “PHP’s memory bugs come from being weakly typed”</h2>
<p>This one is not just wrong. It goes well beyond PHP, and it is a category error.</p>
<p>Weak typing and C-level memory unsafety are <strong>independent properties</strong>. They have nothing to do with each other. JavaScript is weakly typed, and in some respects it is looser than PHP, since <code>[] + {}</code> evaluates without error. JavaScript considers this a reasonable Tuesday. Yet JavaScript does not expose the same class of memory-safety bugs at the language level, because V8 is a virtual machine that never hands raw pointers to user code. Conversely, C is statically typed, and it is the single most memory-unsafe mainstream language in existence.</p>
<p>PHP’s memory issues, the kind that recent CVEs exploit, come from the <strong>C implementation of the Zend Engine</strong>. They do not come from <code>==</code> versus <code>===</code>. The fix is to rewrite the runtime in a memory-safe language such as Rust or Go, not to make PHP strongly typed. Those are different conversations.</p>
<p>This conflation matters because it misdirects the diagnosis. If you think weak typing causes memory bugs, you will waste time arguing about type systems. If you correctly identify the C runtime as the source, you can have the actually useful conversation about whether the engine itself should be ported.</p>
<h2 id="toc_4">Myth 4: “PHP’s runtime is unmanaged, and that’s a PHP-specific problem”</h2>
<p>No, this is both true and not unique to PHP. It is a property of every VM-based language, and every VM language keeps its C runtime in the basement, where nobody invites guests. It is easy to see the same feature in action in other VM languages.</p>
<p>Every widely used VM language has one or more runtimes written in C or C++:</p>
<ul>
<li>The <strong>JVM</strong> relies on OpenJDK, which is largely C++.</li>
<li>The <strong>V8</strong> engine, which powers Node.js, Deno, and Bun, is written in C++.</li>
<li><strong>CPython</strong> is written in C.</li>
<li><strong>MRI Ruby</strong> is written in C.</li>
<li>The <strong>Zend Engine</strong> that powers PHP is written in C.</li>
</ul>
<p>And every one of those runtimes has shipped memory-safety CVEs over the years. V8 has had critical remote code execution bugs, the JVM has had its share, and CPython and MRI Ruby have had them too. PHP is not unique here. It is a member of a category, and the category has a known property: the safety guarantees apply to user code, not to the runtime itself.</p>
<p>This does not make PHP’s runtime vulnerabilities side concerns. It does mean that framing “managed language, unmanaged runtime” as a PHP indictment is misleading. The same sentence describes Java, JavaScript, Python, and Ruby. If your critique applies equally to four of the most popular languages in the world, it is not really a critique of one of them.</p>
<h2 id="toc_5">Myth 5: “PHP is stuck in the LAMP era, and nobody does serverless or microservices in PHP”</h2>
<p>This one is simply contradicted by several production-grade serverless and event-driven PHP stacks. The following list is short and non-exhaustive:</p>
<ul>
<li><strong>Laravel Vapor</strong> runs serverless PHP on AWS Lambda and is officially maintained by Laravel.</li>
<li><strong>Bref</strong> runs PHP on AWS Lambda and predates Vapor.</li>
<li><strong>FrankenPHP</strong> is a Caddy-based PHP application server that runs PHP as a long-lived process, with built-in metrics and Mercure support.</li>
<li><strong>RoadRunner</strong> is a high-performance PHP application server written in Go and widely used in production. Cycle ORM is designed to work with it.</li>
<li><strong>Swoole</strong> and <strong>OpenSwoole</strong> provide async, coroutine-based PHP, with HTTP, WebSocket, and coroutine-aware database drivers.</li>
<li><strong>Laravel Octane</strong> runs long-lived PHP workers through Swoole, RoadRunner, or FrankenPHP, which dramatically increases throughput per instance.</li>
<li><strong>Symfony Runtime</strong> decouples the application from the runtime and supports worker modes and custom application servers.</li>
</ul>
<p>The “ye olde LAMP” stereotype describes a deployment pattern that is still common. It is not the only one, and it has not been for years. Modern PHP can run as a long-lived process, in an event loop, on Lambda, behind a Go-based application server, or as a classic PHP-FPM pool. The choice exists, and it is sometimes difficult to make, which is a first-world problem for a language that was supposed to be dead.</p>
<h2 id="toc_6">Myth 6: “Nobody builds new apps in PHP anymore, you only use it because of WordPress”</h2>
<p>Again, that claim is empirically false. Major greenfield PHP projects have shipped significant releases in recent years:</p>
<ul>
<li><strong>Laravel 11</strong>, released in March 2024, and <strong>Laravel 12</strong>, released in February 2025, brought a restructured skeleton and first-class health checks.</li>
<li><strong>Symfony 7</strong>, released in November 2023, and the ongoing 7.x line form the foundation under Drupal 11 and many enterprise projects.</li>
<li><strong>Filament 4</strong> forms a rapidly growing TALL-stack admin panel and application framework, and it enjoys adoption well beyond the Laravel core community.</li>
<li><strong>Pest 3</strong> forms a modern testing framework built on PHPUnit, and developers actively choose its expression-based syntax over PHPUnit for new projects.</li>
<li><strong>Statamic 5</strong> is a flat-first CMS that is gaining ground as a headless or hybrid option against WordPress.</li>
<li><strong>Craft CMS 5</strong>, released in March 2024, is a major release of a CMS that teams actively choose for content-heavy commercial work.</li>
<li><strong>FrankenPHP</strong> is a relatively young PHP application server that reached its first stable release in December 2023.</li>
<li><strong>Cycle ORM 2</strong> is a DataMapper ORM designed specifically for daemonized PHP runtimes such as RoadRunner and Swoole.</li>
</ul>
<p>Recently, PHP has shipped on microcontrollers, in Rust application servers, in online games, and in CLI and TUI applications. It turns up in more places than its critics ever look.</p>
<p>You can absolutely argue that PHP’s greenfield share is shrinking relative to TypeScript, Go, and Rust. That claim is defensible. A shrinking share is partly a matter of arithmetic, since a language that already powers a large share of applications has less room to grow. Arithmetic is not a conspiracy, and it is not an obituary. The statement “no one starts new projects in PHP” is simply not true. The ecosystem above is actively maintained, actively shipped, and actively adopted.</p>
<h2 id="toc_7">Myth 7: “Writing Rust or Go today is sometimes even faster than writing PHP”</h2>
<p>Sometimes it is, yes. As a general statement, it is not.</p>
<p>For systems work, such as daemons, CLI tools, networked services, and embedded software, Go is competitive with PHP on developer speed. Rust has also gotten dramatically better with <code>cargo</code>, <code>clippy</code>, and AI assistance. If the workload is “build a TCP server” or “write a Kubernetes operator,” the comparison favors Go.</p>
<p>For typical web application work, which includes forms, authentication, CRUD, ORM, templates, queues, mail, jobs, caching, sessions, file uploads, pagination, and admin interfaces, PHP remains dramatically faster to develop in than Go. It is also much faster to develop in than Rust. This is not a controversial measurement. It shows up consistently in framework benchmarks, in developer surveys, and in the simple empirical observation that the overwhelming majority of CRUD web apps in production are still written in PHP, even at companies that employ Go and Rust engineers for other parts of their stack.</p>
<p>The claim that AI assistants make Rust as fast to write as PHP is the kind of thing that sounds plausible at a whiteboard and falls apart the moment you try to ship a multi-tenant SaaS in both and time it. An AI can draft a mail queue in Rust, and then you get to debug it. AI assistance compresses the gap on syntax. It does not compress the gap on ecosystem maturity for the typical CRUD workload. Laravel’s auth, migrations, mail, queues, broadcasting, and Eloquent still have no real Rust equivalent. Asking an AI to write them is not the same as having them already exist and documented.</p>
<h2 id="toc_8">Myth 8: “PHP has no cost or security advantage over Rust or Go”</h2>
<p>The security comparison is debatable and workload-dependent. The cost comparison is not.</p>
<p><strong>On cost</strong>, shared PHP hosting remains dramatically cheaper and more widely available than Rust or Go hosting. PHP developer labor is also more abundant and, in most markets, cheaper than Rust or Go developer labor. This is not a marginal difference. The salary gap between a senior PHP engineer and a senior Rust engineer is often substantial, and the talent pool for PHP is meaningfully larger in essentially every major market. For an organization optimizing for cost-to-ship, this is a real, durable advantage that no amount of Rust enthusiasm erases.</p>
<p><strong>On security</strong>, PHP has had serious runtime-level CVEs, including recent ones, and the Zend Engine’s C-level memory safety track record is real. These are well documented. The comparison only works when Rust and Go have no equivalent, and they do. Rust’s <code>unsafe</code>blocks have produced their own CVEs, and popular <code>unsafe</code> crates have shipped memory-safety bugs. Go has had its share of standard library vulnerabilities. Both languages also carry supply-chain risk through crates.io and the Go module proxy. The shape of the risk differs, but “Rust has no security disadvantages relative to PHP” is not a defensible statement. It is a marketing line, and marketing lines do not pass code review.</p>
<p>The honest version of this comparison is that PHP has a different security profile than Rust or Go, with a worse memory-safety history in its runtime and better tooling maturity for typical web workloads. That is a real conversation worth having. The phrase “PHP has no security advantage” is a slogan, not an argument.</p>
<h2 id="toc_9">What’s actually true</h2>
<p>None of the above means PHP is perfect. The Zend Engine’s memory safety record is a real problem. WordPress plugin security is a swamp, and the alligators are mostly plugins. Legacy PHP codebases from 2008 are, in the long term, awful to maintain. PHP is not always the fastest language on raw CPU benchmarks: it might never be.</p>
<p>And the eight myths above do not help anyone fix those problems. Myths 1, 2, and 5 are factually outdated. Myths 3 and 4 are conceptually confused. Myths 6, 7, and 8 are empirically false. Repeating them does not make PHP better, and it does not make the critic look informed. It just makes the conversation slower.</p>
<p>If you want to criticize PHP in 2026, criticize it for what it actually is. It is a managed, JIT-compiled, increasingly typed language. It has a real memory-safety problem in its C runtime, an enormous installed base, a thriving modern framework ecosystem, and a long tail of legacy code that nobody enjoys maintaining.</p>
<p>That is a real critique. And, in the end, PHP delivers.</p>
<p>The post <a href="https://www.exakat.io/eight-php-myths-that-need-to-finally-retire/">Eight PHP Myths That Need to Finally Retire</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>PHP can run DOOM. And in several ways - Exakathttps://www.exakat.io/?p=165602026-11-02T21:00:12.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/11/toy.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16561" src="https://www.exakat.io/wp-content/uploads/2026/11/toy.640-293x300.jpg" alt="PHP can run DOOM. And in several ways" width="293" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/11/toy.640-293x300.jpg 293w, https://www.exakat.io/wp-content/uploads/2026/11/toy.640-500x513.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/11/toy.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/11/toy.640-293x300@2x.jpg 586w" sizes="(max-width: 293px) 100vw, 293px" /></a>PHP can run DOOM. And in several ways</h1>
<p><code>Can it run DOOM?</code> is the internet’s oldest benchmark. Printers, thermostats, pregnancy tests: if it has a CPU, someone has ported DOOM to it. PHP, the language of personal home page counters and extensive frameworks, is no exception. In fact, DOOM is also the de facto “Hello World” of the PHP gaming scene: nearly every time someone builds a new way for PHP to touch pixels, DOOM arrives within months as proof of concept.</p>
<p>But PHP games are far more than DOOM clones. From a 21,000-line Sonic remake running at 60 fps in your browser, to a classic trading game rebuilt in your terminal, to the massive browser strategy games that once ruled the web, there is a wide ranging panorama of PHP games. Let’s review them, organized by the underlying technology that makes them possible.</p>
<p>And yes, we’ll check at every step: how does DOOM fit here too?</p>
<h2 id="toc_1">1. php-sdl: Sonic, Running at 60 FPS</h2>
<h3 id="toc_2">The games:</h3>
<ul>
<li><a href="https://github.com/davidnurdin/sonicGamePhp"><strong>Sonic the Hedgehog (Master System remake)</strong></a>: a fan remake of the 1991 classic, ~21,000 lines of pure PHP, running at 60 fps with online multiplayer for up to 6 players (race, flag, rings, deathmatch). <a href="https://github.com/davidnurdin/sonicGamePhp">Repository</a> · <a href="https://davidnurdin.github.io/php-wasm-sdl/">Play it in the browser</a></li>
<li><a href="https://github.com/davidnurdin/sonic-jumphp"><strong>sonic-jumphp</strong></a>: the same game ported to the <a href="https://jumphp.net/?lang=en">JumPHP</a> runtime (<a href="https://github.com/davidnurdin/jumPhp">repository</a>). <a href="https://github.com/davidnurdin/sonic-jumphp">Repository</a></li>
<li>The same author’s PHP-compiled-to-WASM retro arcade: <strong>Rainbow Islands, Moktar, Sapiens, Breakout, Pong (with online play), a 3D runner</strong> (<a href="https://dev.to/mimi_chat_b3bf7a39a962a82/php-games-create-and-remix-retro-games-or-build-your-own-php-compiled-to-webassembly-running-320f">write-up</a>).</li>
</ul>
<h3 id="toc_3">What makes php-sdl work</h3>
<p><a href="https://github.com/davidnurdin/php-wasm-sdl">php-sdl</a> is a PHP extension for <a href="https://www.libsdl.org/"><strong>SDL2</strong></a>, the same C library that powers countless native games. PHP was built for request/response: a request comes in, a response goes out, the process dies. SDL2 inverts that: the game holds a native window open, and PHP runs a continuous game loop: <code>Game.php</code> orchestrates the scene, camera, HUD, tilesets, physics and replays. The masterstroke is the second target: PHP 8.3 itself is compiled to WebAssembly with Emscripten, alongside an SDL2 extension, so the exact same PHP code runs in the browser: SDL2 renders to WebGL, sound goes through Web Audio, saves live in IndexedDB. One codebase, desktop and mobile.</p>
<h3 id="toc_4">Where does DOOM fit? <a href="https://github.com/vagucs/php_doom"><strong>php_doom</strong></a> is Doomgeneric, the deliberately portable DOOM skeleton, ported to 100% PHP source with SDL2. Same library, same rendering model as Sonic. When a new SDL binding for PHP appears, DOOM is rarely far behind.</h3>
<h2 id="toc_5">2. PHP-GLFW / VISU: OpenGL for PHP</h2>
<h3 id="toc_6">The games:</h3>
<ul>
<li><a href="https://visu.phpgl.net/games/flappyphpant.html"><strong>FlappyPHPant</strong></a>: a Flappy Bird-like where you are an elephant with wings flying through pipes.</li>
<li><a href="https://github.com/phpgl/php-craft"><strong>Mining PHPotentials</strong></a>: a Minecraft-inspired game written in PHP. <a href="https://github.com/phpgl/php-craft">Repository</a></li>
<li>The whole catalog lives on the <a href="https://visu.phpgl.net/games/0-php-games.html">VISU PHP games list</a>.</li>
</ul>
<h3 id="toc_7">What makes php-glfw work</h3>
<p><a href="https://github.com/mario-deluna/php-glfw"><strong>PHP-GLFW</strong></a> binds PHP to <a href="https://www.glfw.org/"><strong>GLFW</strong></a> and OpenGL, giving PHP a real GPU pipeline: vertex buffers, shaders, textures. On top of it sits <a href="https://visu.phpgl.net/"><strong>VISU</strong></a>, a game framework with scene management, vector math, input handling and a drawing context. Think about it as a tiny game engine, in PHP. The maintainers actively collect example games because, as they put it, example code is the best way to learn a framework. Even in these times of AI.</p>
<h3 id="toc_8">Where does DOOM fit?</h3>
<p>Almost by definition. SerafimArts’ <a href="https://github.com/SerafimArts/PHP-Doom"><strong>PHP-Doom</strong></a> takes the same idea one level deeper: pure PHP, with built-in extensions only, driving the <a href="https://www.vulkan.org/"><strong>Vulkan API</strong></a>, with ray tracing. DOOM’s 1993 level geometry lit by a 2020s rendering technique, from PHP. If VISU doesn’t have a DOOM port yet, it’s clearly only a matter of time: and that’s an open invitation.</p>
<h2 id="toc_9">3. FFI: DOOM, Three Different Ways</h2>
<h3 id="toc_10">The games:</h3>
<ul>
<li><a href="https://github.com/nawarian/dumm"><strong>dumm</strong></a> — a DOOM port to PHP using FFI and Raylib. <a href="https://github.com/nawarian/dumm">Repository</a></li>
<li><a href="https://github.com/vagucs/php_doom"><strong>php_doom</strong></a> — see above; SDL2 through PHP bindings. <a href="https://github.com/vagucs/php_doom">Repository</a></li>
<li><a href="https://github.com/getelephc/doom"><strong>elephc/doom</strong></a>: DOOM rendered in PHP and compiled to a native binary by <a href="https://elephc.dev/">elephc</a>, a PHP-to-native compiler written in Rust (<a href="https://github.com/illegalstudio/elephc">repository</a>). <a href="https://news.ycombinator.com/item?id=47628079">Show HN discussion</a></li>
</ul>
<h3 id="toc_11">What makes FFI work</h3>
<p>PHP’s FFI, the Foreign Function Interface, extension lets PHP call C libraries directly, such as Raylib, SDL2, Vulkan, without writing a PHP extension in C. This is the pragmatic middle path: all game logic in PHP, all heavy rendering in battle-tested native code, glued at runtime. The elephc project goes further: instead of calling native code from PHP, it compiles PHP to native code, and renders DOOM E1M1 in real time: BSP traversal, perspective projection, distance fog, sector lighting, collision detection, all written in PHP, running at 15+ FPS.</p>
<h3 id="toc_12">Where does DOOM fit?</h3>
<p>This is the DOOM category. FFI is the technology that made <code>PHP runs DOOM</code> true, and every new low-level binding gets validated the same way.</p>
<h2 id="toc_13">4. Plain Old BBS-Style: The Games PHP Was Born For</h2>
<h3 id="toc_14">The games:</h3>
<ul>
<li><a href="https://github.com/lotgd/lotgd"><strong>Legend of the Green Dragon (LotGD)</strong></a>: the classic text MMORPG, web successor to the BBS legend <code>Legend of the Red Dragon</code>. <a href="https://github.com/lotgd/lotgd">Repository</a></li>
<li><a href="https://sourceforge.net/projects/blacknova/"><strong>BlackNova Traders</strong></a>: space exploration and trading, inspired by the BBS staple TradeWars. <a href="https://sourceforge.net/projects/blacknova/">Home page</a></li>
<li><a href="https://github.com/WaveHack/opendominion"><strong>OpenDominion</strong></a>: a persistent browser strategy game. <a href="https://github.com/WaveHack/opendominion">Repository</a> · <a href="https://wiki.opendominion.net/wiki/OpenDominion">Wiki</a></li>
<li>The <strong>2Moons / XG-Project</strong> family: open-source engines for building OGame-style strategy worlds (<a href="https://github.com/DocKob/PHP-Games-Archives">archive list</a>). The 2Moons engine is on <a href="https://github.com/jkroepke/2Moons/">GitHub</a>, where it describes itself as an open source browser game framework. The repository is archived. XG-Project has since moved to Laravel: <a href="https://github.com/XGProyect/XGProyect">XGProyect</a>.</li>
</ul>
<h3 id="toc_15">What makes BBS work:</h3>
<p>Nothing but PHP + MySQL, and that’s the point. These are persistent browser-based games (PBBGs): every action is a form submission, every page load is a turn, sessions track the player. PHP’s share-nothing request/response model, though fatal for a platformer, is a perfect match for a game where the world persists in the database between clicks. This genre produced the most popular PHP games ever, back when OGame and its clones commanded hundreds of thousands of players.</p>
<h3 id="toc_16">Where does DOOM fit?</h3>
<p>Well, you won’t believe me: it doesn’t fit in this section. DOOM is real-time first-person action; a request/response turn loop cannot express it. The best you could do is a turn-based <code>DOOM MUD</code>, which would be a different game wearing the license. Every category has its emblematic game because of what the technology cannot do: here, LotGD rules precisely where DOOM can’t follow. Don’t even try it at home!</p>
<h2 id="toc_17">5. TUI Games: Taipan! in Your Terminal</h2>
<h3 id="toc_18">The games:</h3>
<ul>
<li><a href="https://www.exakat.io/rebuilding-taipan-with-an-ai-pair-programmer-in-php/"><strong>Taipan! (2026 PHP rebuild)</strong></a>: a faithful rebuild of the classic Apple II trading game, buy low in Hong Kong, sell high, dodge pirates, take on Brother Wu loans at brutal interest. Playable right now: clone the <a href="https://github.com/dseguy/taipan">repository</a> and run <code>php bin/taipan</code>. Notably co-built with an AI pair programmer, with the human’s real job shifting from writing code to playing the game to find what felt wrong.</li>
<li><a href="https://github.com/velkuns/game-text-engine"><strong>velkuns/game-text-engine</strong></a>: a PHP engine for building text games, with choices, items and more. <a href="https://github.com/velkuns/game-text-engine">Repository</a></li>
</ul>
<h3 id="toc_19">What makes TUI work:</h3>
<p>Plain PHP CLI, like <code>php bin/taipan</code>, and you’re trading opium in 19th-century China. PHP can use ncurses through an optional PECL extension, and can emit raw ANSI escape codes (colors, cursor positioning), though for games like Taipan the line-by-line terminal output of the original barely needs them. The game loop runs in a long-lived CLI process with <code>fgets(STDIN)</code> for input: again a small heresy for PHP, and again entirely workable.</p>
<h3 id="toc_20">Where does DOOM fit?</h3>
<p>It doesn’t fit. Or, more precisely, not yet: but it could. Raycasting is just math; an ASCII rendering of E1M1 through <code>@</code>, <code>#</code> and <code>.</code> characters driven by ncurses is entirely feasible in PHP. Nobody has done it. If you build it, the panorama gets its final cell filled: so, challenge accepted?</p>
<h2 id="toc_21">6. JavaScript-Based Games: PHP as the Dungeon Master</h2>
<h3 id="toc_22">The games:</h3>
<ul>
<li><a href="https://github.com/Nadawoo/invazion"><strong>Azimutant</strong> (formerly InvaZion)</a>: a collaborative strategy game inspired by Hordes.fr/Die2Nite.</li>
<li><a href="https://ultimate-warfare.com/"><strong>Ultimate Warfare</strong></a>: an online multiplayer strategy game, modernized to PHP + Symfony. <a href="https://github.com/FrankProjects/UltimateWarfare">Repository</a></li>
<li><a href="https://github.com/jalbam/lavilladel6"><strong>La Villa del Seis</strong></a> and <a href="https://github.com/jalbam/yquest"><strong>Yasmina’s Quest</strong></a>: point-and-click + text adventures entirely in PHP and DHTML. Home pages: <a href="https://sourceforge.net/projects/lavilladel6/">La Villa del Seis</a> · <a href="https://sourceforge.net/projects/yquest/">Yasmina’s Quest</a>.</li>
</ul>
<h3 id="toc_23">What makes it work:</h3>
<p>The classic division of labor: all rendering in the browser, with Canvas, WebGL or Three.js; all authority on the server. PHP validates every move, persists the world in MySQL, runs the combat math, and exposes it over AJAX or WebSockets (<a href="https://www.workerman.net/">Workerman</a> is a popular PHP socket server for real-time titles). High scores, anti-cheat, multiplayer matchmaking: that’s PHP’s home turf. The medium article “<a href="https://medium.com/@annxsa/building-a-2d-game-in-php-makes-no-sense-but-it-works-b92e77a25bac">Building a 2D game in PHP: makes no sense, but it works</a>” captures the spirit: keep the logic server-side where PHP lives, send only player input from the client.</p>
<h3 id="toc_24">Where does DOOM fit?</h3>
<p>It fits in a specific role: PHP parses the WAD, holds the game state and referees multiplayer while JavaScript/WebGL does the drawing. And the WASM route blurs the line entirely, just as Sonic proved. PHP compiled to WebAssembly is the client.</p>
<h2 id="toc_25">PHP Is The Beast Of The Game</h2>
<p>There is one more category where PHP quietly dominates, and where it has nothing to do with rendering: applications that manage games. If you run a Minecraft, Rust, CS:GO or Garry’s Mod server, the ecosystem around you is largely PHP:</p>
<ul>
<li><a href="https://pterodactyl.io/"><strong>Pterodactyl</strong></a>: the free, open-source game server management panel, made with Laravel + Docker, and its fork <a href="https://pelican.dev/"><strong>Pelican</strong></a>.</li>
<li><a href="https://azuriom.com/"><strong>Azuriom</strong></a>: a complete open-source web solution for game servers, complete with CMS, forums, store, player profiles, and trusted by thousands of servers and millions of players.</li>
<li><a href="https://github.com/pH-7/H2OGame"><strong>H2O Game</strong></a> and various PHP arcade scripts: ready-made platforms to run your own games portal.</li>
</ul>
<p>This approach feels more familiar: PHP may be an outsider as a game language, but as a game-adjacent language to manage any piece of data, with panels, dashboards, leaderboards, stores, wikis, community sites, it’s the industry standard. DOOM itself would feel at home: even if PHP couldn’t render a single imp, it would happily run the tournament bracket, the server browser, and the mod repository.</p>
<h2 id="toc_26">PHP player has entered the game</h2>
<p>So, can PHP run DOOM? On SDL, OpenGL, Vulkan, FFI and WebAssembly: yes, it already does. In a terminal: not yet, and that sounds like an open PR waiting to happen.</p>
<p>If you build the missing ASCII DOOM in PHP, or any PHP game at all, drop me a note! I want to play it!</p>
<p>The post <a href="https://www.exakat.io/php-can-run-doom-and-in-several-ways/">PHP can run DOOM. And in several ways</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Telling Your Terminal What Your PHP CLI Is Doing: OSC 7501 Comes to PHP - Exakathttps://www.exakat.io/?p=165512026-10-31T11:00:14.000ZExakat<h1 id="toc_0">Telling Your Terminal What Your PHP CLI Is Doing: OSC 7501 Comes to PHP</h1>
<h2 id="toc_1">The problem: you keep guessing the CLI’s status</h2>
<p>If you have more than one terminal tab open, you know the routine. You start a long-running command in one tab, switch to another, and come back periodically to check if it finished: or worse, if it stopped to ask you something. Is that <code>composer update</code> still resolving dependencies, or has it been sitting on a prompt for the last ten minutes?</p>
<p>AI coding agents have made this problem very very common. Anyone running several Claude Code, Codex, or Gemini sessions in parallel quickly learned that they had no reliable way to know which session was working, which was done, and which was quietly waiting for permission. That’s why the major harnesses all shipped their own status reporting: Claude Code, Codex CLI, Crush, Amp, and others can now tell you when they’re busy or blocked. But each one invents its own mechanism, may it be hooks, socket APIs, screen scraping, which is exactly the kind of fragmentation terminals hate.</p>
<p>In October 2026, Mitchell Hashimoto, of <a href="https://ghostty.org/">Ghostty</a> fame, published a spec to fix this once and for all: <a href="https://mitchellh.com/writing/program-status-osc7501"><strong>OSC 7501, the Program Status Protocol</strong></a>. And this isn’t just for AI agents: it’s for any program that runs longer than a few seconds. So, CLI brings us to PHP, naturally.</p>
<h2 id="toc_2">Composer supports it</h2>
<p><a href="https://x.com/naderman/status/2115751978512912769"><strong>Composer 2.11 </strong></a>is the first major PHP tool to adopt OSC 7501. If you run <code>composer install</code> or <code>composer update</code> in a terminal that understands the protocol, Composer now reports its state: working while it resolves and downloads packages, blocked when it needs an answer, like a plugin prompt or a credential request, done when everything installed cleanly, and error when it failed or was cancelled.</p>
<p>Why is this useful? Composer commands are exactly the kind of somtimes long-running operations the spec has in mind. A <code>composer update</code> on a large project with a slow mirror can easily run for minutes. Meanwhile:</p>
<ul>
<li>Your terminal can show a small badge on the tab, working, or waiting for you, so you don’t have to keep switching back.</li>
<li>Multiplexers and “inbox” tools can list every running command across panes and sessions, telling you which ones finished and which one is blocked on a question you forgot to answer.</li>
<li>It works over SSH and through <code>tmux</code>, because the reports travel through the pty the program already writes to, no side channel, no socket, no extra dependency.</li>
</ul>
<p>Composer’s implementation is careful and conservative. Reports are controlled by the <code>COMPOSER_TERMINAL_STATUS</code> environment variable, which defaults to <code>auto</code>: OSC 7501 reports are always sent, and terminals that don’t know the sequence simply ignore it, while the older OSC 9;4 progress reports are only added when the environment identifies a known terminal such as Windows Terminal, ConEmu, Ghostty, or iTerm2. Reports are suppressed for quiet output, non-TTY streams, and redirected stderr. So piping Composer’s output to a file won’t fill it with escape sequences.</p>
<p>If you build PHP CLI tools, Composer’s PR is worth reading: it registers an <code>OscHelper</code> in the Symfony Console helper set, which means the mechanism slots neatly into the same component most PHP CLI tools already use.</p>
<h2 id="toc_3">Symfony is next: TUI and Console</h2>
<p>Composer’s implementation being built on Symfony Console is no coincidence, and it points to where this goes next. Symfony has an open pull request adding OSC 7501 support to its new TUI component, with an API along these lines:</p>
<div>
<pre><code class="language-php">use Symfony\Component\Tui\Terminal\ProgramStatus\ProgramBlockKind;
use Symfony\Component\Tui\Terminal\ProgramStatus\ProgramState;
use Symfony\Component\Tui\Terminal\ProgramStatus\ProgramStatus;
$terminal = $tui->getTerminal();
$terminal->setProgramStatus(new ProgramStatus(ProgramState::Working, 'Deploying v2.4.1', app: 'deploy'));</code></pre>
</div>
<p>The discussions around the PR also cover the natural follow-up: bringing OSC 7501 to Symfony Console itself, which already emits the older OSC 9;4 progress from <code>ProgressBar</code> and pauses it while <code>QuestionHelper</code> waits for input. Once that lands in the component, every tool built on Symfony Console, which is to say, most of the PHP CLI ecosystem, gets status reporting for a very small effort. That was exactly the reasoning Pantheon’s maintainers gave when they parked their own experimental OSC 7501 implementation in Terminus: don’t maintain it per-tool, wait for the shared component.</p>
<h2 id="toc_4">Who should be next in PHP?</h2>
<p>The spec is deliberately easy to implement. It’s a single escape sequence, <code>ESC ] 7501 ; state=working:msg=<base64> ESC \</code>, with a few key/value pairs. Any PHP CLI that runs longer than a coffee sip is a candidate. A few that come to mind:</p>
<ul>
<li><strong>Laravel Prompts</strong>. It already makes PHP CLIs interactive: spinners, progress bars, forms, confirmations. Every one of those is a moment where a program is either working or blocked on the user. An opt-in status report emitted alongside its existing output would make any Laravel-based CLI instantly visible to OSC 7501-aware terminals, and it’s the natural place for Laravel Artisan commands to inherit the behavior.</li>
<li><strong>PHPUnit</strong>. A test run is the textbook use case: it reports <code>working</code> while the suite runs, <code>done</code> when it’s green, and <code>error</code>, with the failure count as the message, when it isn’t. If you run tests in one tab while coding in another, your terminal could simply mark the tab red or green. Nobody has even opened an issue on it yet; PHPUnit also sits on top of the Console ecosystem, so it may prefer to wait for the upstream support.</li>
<li><strong>PsySH and interactive consoles</strong>. A REPL is idle most of the time, working while it evaluates, and blocked whenever it waits for multi-line input. Reporting <code>idle</code>/<code>blocked</code> states would let a multiplexer tell you which of your open PsySH sessions actually needs attention.</li>
<li><strong>Other long-running PHP tools</strong>. Deployment scripts, queue workers run from a terminal, migration tools, static analyzers grinding through a large codebase — the pattern is the same everywhere.</li>
</ul>
<p>Beyond PHP, the early adopters set a good example of how fast this can move: <a href="https://github.com/charmbracelet/bubbletea">Bubble Tea</a>, the Go TUI framework behind many modern CLIs, shipped support within days, dedicated emitter libraries like osc-status in TypeScript and osc7501 in Python, already exist, and tools like Hugo have it too. The ecosystem pages tracking adoption, called <a href="https://areweosc7501yet.com/">“Are we OSC 7501 yet?”</a>, read like a land-grab at the moment, with a new tool shipping support every day or two. It includes a <a href="https://areweosc7501yet.com/test">test tool</a>.</p>
<p>There is also a <a href="https://github.com/hyeebeen/awesome-osc7501">aweswome OSC 7501</a> page, and it is in Chinese.</p>
<h2 id="toc_5">If you can’t wait</h2>
<p>You don’t need to wait for your framework. The whole protocol is one <code>printf</code>:</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
function oscStatus(string $state, string $message = ''): void
{
$msg = rtrim(strtr(base64_encode($message), '+/', '-_'), '=');
fwrite(STDERR, "\033]7501;state={$state}:app=mytool:msg={$msg}\033\\");
}
oscStatus('working', 'Building assets');
// ... do the work ...
oscStatus('done', 'Build complete');
?>
</pre>
</div>
<p>Send it unconditionally: terminals that don’t implement OSC 7501 ignore it, exactly as they ignore every other escape sequence they don’t know. Only suppress it when stderr isn’t a TTY.</p>
<h2 id="toc_6">OSC 7501 for PHP</h2>
<p>First the AI harnesses, then the package managers, and soon the frameworks: programs are finally learning to tell their terminal what they’re doing instead of making it guess from spinner characters and window titles. Composer is the first mover in PHP, Symfony looks likely to be the foundation everyone else builds on, and Laravel Prompts, PHPUnit, PsySH, and the rest of the CLI ecosystem are all natural candidates. If you maintain a PHP command-line tool, now is a good time to think about what your tool would say — working, blocked, or done — because your terminal is finally listening.</p>
<p>The post <a href="https://www.exakat.io/telling-your-terminal-what-your-php-cli-is-doing-osc-7501-comes-to-php/">Telling Your Terminal What Your PHP CLI Is Doing: OSC 7501 Comes to PHP</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Recently updated PIE extensions #13 (since October 23rd, 2026) - Exakathttps://www.exakat.io/?p=165492026-10-30T22:17:29.000ZExakat<h2 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16529" src="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300.png" alt="Recently updated PIE extensions #12" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150@2x.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150.png 150w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-500x500.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-100x100.png 100w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png 640w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300@2x.png 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Recently updated PIE extensions #13 (since October 23rd, 2026)</h2>
<p>43 PHP Pie extensions were updated.</p>
<ul>
<li><a href="https://packagist.org/packages/iliaal/mdparser">iliaal/mdparser</a> (0.8.2): Native C CommonMark + GitHub Flavored Markdown parser for PHP, targeting CommonMark 0.31 + GFM. ~10-20x faster than pure-PHP parsers, zero runtime dependencies.</li>
<li><a href="https://packagist.org/packages/phpolygon/php-vio">phpolygon/php-vio</a> (2.38.1): PHP extension for GPU rendering (OpenGL, Vulkan, Metal), audio, video recording, streaming, and input</li>
<li><a href="https://packagist.org/packages/iliaal/lchash">iliaal/lchash</a> (1.0.1): String-keyed hash table extension for PHP, backed by vendored klib khash.</li>
<li><a href="https://packagist.org/packages/iliaal/php_clickhouse">iliaal/php_clickhouse</a> (0.13.1): Native PHP extension for ClickHouse using the official ClickHouse/clickhouse-cpp client. Connects over the native TCP protocol with LZ4 / ZSTD compression and optional TLS.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/sdl3">php-io-extensions/sdl3</a> (v0.11.0): 1:1 PHP bindings of SDL 3: windows, surfaces, the GL, Metal and Vulkan hooks, and SDL_GPU</li>
<li><a href="https://packagist.org/packages/xberg-io/liter-llm">xberg-io/liter-llm</a> (v2.4.3): Universal LLM API client with Rust-powered polyglot bindings.</li>
<li><a href="https://packagist.org/packages/iliaal/phonetic">iliaal/phonetic</a> (0.4.6): Native phonetic matching for PHP: Double Metaphone, Beider-Morse Phonetic Matching, Daitch-Mokotoff Soundex, NYSIIS, and Match Rating Approach.</li>
<li><a href="https://packagist.org/packages/grpc/grpc-php-ext">grpc/grpc-php-ext</a> (v1.85.1): gRPC PHP Extension</li>
<li><a href="https://packagist.org/packages/iliaal/pdo_duckdb">iliaal/pdo_duckdb</a> (0.8.1): PDO driver for DuckDB, the in-process analytical database.</li>
<li><a href="https://packagist.org/packages/extport/grpc">extport/grpc</a> (1.85.0): Unofficial PIE-compatible mirror of grpc/grpc</li>
<li><a href="https://packagist.org/packages/displace/ext-whisper">displace/ext-whisper</a> (v0.1.3): PHP 8.3+ native, in-process speech-to-text via whisper.cpp: 16kHz WAV in, text + timestamped segments out.</li>
<li><a href="https://packagist.org/packages/displace/ext-turbovec">displace/ext-turbovec</a> (v0.2.1): PHP 8.3+ native, in-process vector indexing and ANN search via TurboQuant.</li>
<li><a href="https://packagist.org/packages/displace/ext-infer">displace/ext-infer</a> (v0.2.2): PHP 8.3+ native, in-process LLM inference and embeddings via llama.cpp.</li>
<li><a href="https://packagist.org/packages/iliaal/fast_uuid">iliaal/fast_uuid</a> (0.8.2): Fast RFC 9562 UUID generation (v1/v2/v3/v4/v5/v6/v7/v8 + nil/max) as a PHP C extension, with a ramsey/uuid-shaped object API and procedural fast-path functions.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/ftdi">php-io-extensions/ftdi</a> (0.11.0): PHP bindings of libftdi1: FTDI USB devices, MPSSE, async transfers and EEPROM</li>
<li><a href="https://packagist.org/packages/iliaal/phpser">iliaal/phpser</a> (0.10.2): Fast binary serializer for PHP cache workloads. Decoder-optimized, beats igbinary on packed numerics, deep-nested structures, and same-class DTO batches.</li>
<li><a href="https://packagist.org/packages/iliaal/fastjson">iliaal/fastjson</a> (0.10.2): Fast JSON encode/decode/validate for PHP 8.1+, backed by yyjson. Drop-in alternative to ext/json with namespaced fastjson<em>* functions and json</em>last_error-compatible error reporting.</li>
<li><a href="https://packagist.org/packages/iliaal/fastchart">iliaal/fastchart</a> (1.8.1): Native C PHP extension for fast chart rendering: 38 chart families (line, area, bar, pie, scatter, bubble, stock with technical indicators, radar, polar, surface, contour, treemap, funnel, waterfall, heatmap, gauge, linear meter, gantt, box plot, bullet, pareto, calendar heatmap, sunburst, sankey, marimekko, vector, arc diagram, chord diagram, network, population pyramid, violin plot, circle packing, pictogram, venn diagram, word cloud, serpentine timeline, dendrogram, partition) plus a 2-class Symbol family (Code128, QrCode). SVG-canonical pipeline rasterized via vendored plutovg + plutosvg; PNG / JPEG / WebP encoders via libpng / libjpeg-turbo / libwebp.</li>
<li><a href="https://packagist.org/packages/phpstan/turbo">phpstan/turbo</a> (2.3.4): Native acceleration extension for PHPStan</li>
<li><a href="https://packagist.org/packages/osmanov/pecl-event">osmanov/pecl-event</a> (3.2.0): Provides interface to libevent library.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/glfw">php-io-extensions/glfw</a> (v0.11.0): 1:1 PHP bindings of GLFW 3.4 for staged windows: monitors and video modes, windows, hints, attributes and callbacks, events, contexts, Vulkan surfaces and native handles</li>
<li><a href="https://packagist.org/packages/satwareag/pdo-fbird">satwareag/pdo-fbird</a> (v13.3.1): PDO driver for Firebird SQL (pdo_fbird) — separate from the main php-firebird extension</li>
<li><a href="https://packagist.org/packages/satwareag/php-firebird">satwareag/php-firebird</a> (v13.3.1): PHP Firebird database extension — native fbird_* API for PHP 8.2+</li>
<li><a href="https://packagist.org/packages/cachewerk/ext-relay">cachewerk/ext-relay</a> (v0.61.0): The fastest Redis client for PHP. 100× faster cache reads, near-zero bandwidth, no code changes required.</li>
<li><a href="https://packagist.org/packages/laruence/yac">laruence/yac</a> (3.0.2): Yac is a shared and lockless memory user data cache for PHP.</li>
<li><a href="https://packagist.org/packages/kjdev/brotli">kjdev/brotli</a> (0.21.1): A compression/decompression with Brotli</li>
<li><a href="https://packagist.org/packages/goopil/rabbit-rs-native">goopil/rabbit-rs-native</a> (v0.3.14): High-performance RabbitMQ transport for PHP and Laravel, powered by Rust</li>
<li><a href="https://packagist.org/packages/orieg/expanse-extension">orieg/expanse-extension</a> (v0.16.0): Native PHP Zend Engine extension for Expanse: modern Judy arrays in pure Rust (ext-php-rs). Userland API: orieg/expanse.</li>
<li><a href="https://packagist.org/packages/pecl/timezonedb">pecl/timezonedb</a> (2026.6): This extension is a drop-in replacement for the builtin timezone database that comes with PHP.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/pcurl">php-io-extensions/pcurl</a> (0.11.0): libcurl’s multi socket API bound 1:1 into PHP on top of ext-curl handles</li>
<li><a href="https://packagist.org/packages/mosuka/litsea">mosuka/litsea</a> (v0.15.0): PHP extension for Litsea, a compact word segmentation and POS tagging library (no embedded models)</li>
<li><a href="https://packagist.org/packages/php-io-extensions/fb">php-io-extensions/fb</a> (v0.11.0): Pixel storage in C: FbFormat describes a byte layout, FbBuffer holds one surface in it and reads, writes, converts and copies it</li>
<li><a href="https://packagist.org/packages/php-io-extensions/epoll">php-io-extensions/epoll</a> (v0.11.0): Linux epoll(7) bindings as global PHP functions</li>
<li><a href="https://packagist.org/packages/php-io-extensions/kqueue">php-io-extensions/kqueue</a> (v0.11.0): 1:1 PHP bindings of kqueue(2): kqueue(), kevent(), kevent64(), EV<em>SET(), EV</em>SET64()</li>
<li><a href="https://packagist.org/packages/php-io-extensions/imgdec">php-io-extensions/imgdec</a> (v0.11.0): PNG, JPEG and TIFF into straight RGBA8 in C, through libpng, libjpeg and libtiff</li>
<li><a href="https://packagist.org/packages/php-io-extensions/rasterize">php-io-extensions/rasterize</a> (v0.11.0): Shapes into coverage spans in C: RasterScanner answers paths, ellipses, rings and one-pixel polylines as span bytes, hard-edged or anti-aliased</li>
<li><a href="https://packagist.org/packages/php-io-extensions/qt">php-io-extensions/qt</a> (v0.11.0): 1:1 PHP bindings of Qt 6 as classes named after their C++ counterparts</li>
<li><a href="https://packagist.org/packages/php-io-extensions/box2d">php-io-extensions/box2d</a> (v0.11.0): 1:1 PHP bindings of Box2D 3.1.1, with the library compiled into the extension</li>
<li><a href="https://packagist.org/packages/phasync/ext-phasync">phasync/ext-phasync</a> (2.0.7): PHP extension that makes blocking I/O (PDO, mysqli, curl, streams, sleep) wait cooperatively in fibers an event loop manages (phasync\ext\Suspension), and per-coroutine requests (sapi()).</li>
<li><a href="https://packagist.org/packages/fiber-interop/ext-scope">fiber-interop/ext-scope</a> (v0.6.0): The Scope class from the PHP RFC “Scope”, as a PHP extension (PHP 8.2+).</li>
<li><a href="https://packagist.org/packages/corvus-dotnet/corvus-regex-ecma262">corvus-dotnet/corvus-regex-ecma262</a> (0.2.5): ECMA-262 (JavaScript) regular expressions as a PHP extension: the grammar and the answers of RegExp, every flag, UTF-8 and UTF-16, backed by Rust.</li>
<li><a href="https://packagist.org/packages/vanta/meminfo">vanta/meminfo</a> (0.2.0): PHP extension that dumps the content of PHP memory as JSON, to hunt down memory leaks</li>
<li><a href="https://packagist.org/packages/mindee/bernard-ledit">mindee/bernard-ledit</a> (v0.1.0): PDF and image processing for the Mindee PHP SDK, as a native PHP extension.</li>
</ul>
<p>The post <a href="https://www.exakat.io/recently-updated-pie-extensions-13-since-october-23rd-2026/">Recently updated PIE extensions #13 (since October 23rd, 2026)</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Compromised eMudhra Certificates: Update Your JetBrains IDEs, ReSharper, .NET Tools, Toolbox App, and Gateway Now - PhpStorm : The IDE that empowers PHP developers | The JetBrains Bloghttps://blog.jetbrains.com/?post_type=security&p=7502732026-10-30T15:24:48.000ZPhpStorm : The IDE that empowers PHP developers | The JetBrains Blog<h2 class="wp-block-heading">Summary</h2>
<ul class="wp-block-list">
<li>The private keys of eight eMudhra intermediate certificates were compromised. A network attacker could use them to impersonate websites and services that JetBrains tools connect to.</li>
<li>JetBrains IDEs, the Toolbox App, Gateway, and ReSharper are affected because they use the trust store of the bundled JetBrains Runtime (JBR). For IDEs, the embedded browser (JCEF) is also affected. Operating system updates don’t protect against this issue. </li>
<li>The Toolbox App and JetBrains IDEs use a background service, <code>jetbrainsd</code>. It has its own built-in list of trusted certificates and is fixed separately, in <code>jetbrainsd</code> 0.9.9728.</li>
<li>At the time of publishing, we are not aware of any exploitation of this issue against JetBrains users.</li>
</ul>
<h2 class="wp-block-heading">Available fixed versions</h2>
<p>The issue is fixed in the following versions:</p>
<ul class="wp-block-list">
<li><strong>IntelliJ IDEA:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.6.2, 2025.2.6.4.</li>
<li><strong>PyCharm:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.6.2, 2025.2.6.3.</li>
<li><strong>PhpStorm:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.6.2, 2025.2.6.3.</li>
<li><strong>RubyMine:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.6.2, 2025.2.6.3.</li>
<li><strong>WebStorm:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.6.2, 2025.2.6.3.</li>
<li><strong>Rider:</strong> 2026.3 EAP 9, 2026.2.4, 2026.1.5.3, 2025.3.5.3.</li>
<li><strong>CLion:</strong> 2026.3 RC, 2026.2.4.1, 2026.1.5.2, 2025.3.6.3, 2025.2.6.3.</li>
<li><strong>DataSpell:</strong> 2026.1.3.1, 2025.3.3.1, 2025.2.4.1.</li>
<li><strong>DataGrip:</strong> 2026.3 RC, 2026.2.6.1, 2026.1.4.1, 2025.3.6.1, 2025.2.6.1.</li>
<li><strong>GoLand:</strong> 2026.3 RC, 2026.2.4, 2026.1.5.1, 2025.3.5.2, 2025.2.6.3.</li>
<li><strong>RustRover:</strong> 2026.3 EAP 8, 2026.2.5, 2026.1.4.1, 2025.3.7.1, 2025.2.6.1.</li>
<li><strong>Gateway:</strong> 2026.3 RC, 2026.2.4, 2026.1.4, 2025.3.3, 2025.2.6.</li>
<li><strong>ReSharper:</strong> 2026.3 EAP9, 2026.2.4, 2026.1.5.3, 2025.3.5.3.</li>
<li><strong>Toolbox App</strong> 3.9.1, 3.8.2.</li>
</ul>
<p>The 2025.2.6.* updates for all IDEs now contain only the JBR fix. They will get a separate hotfix for the JCEF problem. Until then, use a workaround to disable JCEF in your IDE (see instructions below).</p>
<p><strong>IDE versions 2025.1 and earlier, and Toolbox App 3.7 and earlier, will not receive this fix. </strong>You must update to a fixed version.</p>
<h2 class="wp-block-heading">Details</h2>
<p>In October 2026, the private keys of eight intermediate certificates issued by the certificate authority eMudhra were compromised. An attacker who can intercept your network traffic could use them to impersonate websites and services.<br><br><a href="https://emudhra.we-have-a-problem.com/" target="_blank" rel="noopener">Full details of the incident</a>.</p>
<p>JetBrains IDEs check certificates against the trust store of their bundled runtime, JetBrains Runtime (JBR), so updating your operating system doesn’t protect against this issue. We’ve integrated Oracle’s fixes for <a href="https://www.oracle.com/security-alerts/alert-cve-2026-91403.html" target="_blank" rel="noopener">CVE-2026-91403</a> and <a href="https://www.oracle.com/security-alerts/alert-cve-2026-114820.html" target="_blank" rel="noopener">CVE-2026-114820</a> into JBR as-is. The updated runtime blocks the compromised certificates and no longer trusts these root certificates:</p>
<ul class="wp-block-list">
<li>emSign ECC Root CA – G3</li>
<li>emSign Root CA – G1</li>
<li>emSign Root CA – G2</li>
<li>AAA Certificate Services</li>
</ul>
<p>In the fixed versions of 2025.3 and later, the embedded browser now receives Chrome’s certificate updates, which block the compromised certificates (<a href="https://www.cve.org/CVERecord?id=CVE-2026-118696" target="_blank" rel="noopener">CVE-2026-118696)</a>. It downloads them from Google’s update servers shortly after the IDE starts. If your network blocks access to Google’s update servers, the embedded browser stays unprotected. In this case, turn it off as described below.</p>
<p>The Toolbox App and JetBrains IDEs also install a background service, <code>jetbrainsd</code>. Its list of trusted certificates is built into the service itself, so updating JBR doesn’t fix it. We’ve released a separate fix in <code>jetbrainsd</code> 0.9.9728, tracked as <a href="https://www.cve.org/CVERecord?id=CVE-2026-118697" data-type="link" data-id="https://www.cve.org/CVERecord?id=CVE-2026-118697" target="_blank" rel="noopener">CVE-2026-118697</a>. Only one copy of <code>jetbrainsd</code> runs for each user, and a newer version always replaces an older one. Updating any app that includes jetbrainsd 0.9.9728 fixes it for all JetBrains apps.</p>
<h2 class="wp-block-heading">What you should do: Update now</h2>
<p>The fix is available in the latest versions of <strong>JetBrains IDEs</strong>, from 2025.2 up to 2026.3 RC. The upcoming 2026.3 release will include it too. Updating to the latest bugfix release of your current version is enough. Versions 2025.1 and earlier will not receive a fix. If you use one of them, please update to one of the versions above.</p>
<p>If you use ReSharper or other JetBrains .NET tools, update them to the latest version.</p>
<p><strong>Important for Toolbox App users:</strong> versions 3.7 and earlier won’t receive this fix. If you’re on 3.7, update to version 3.9.1 or 3.8.2.</p>
<p>If you use <strong>JetBrains Gateway</strong>, update it to one of the following versions: 2026.1.4, 2025.3.3, 2025.2.6.</p>
<p>If you use <strong>JetBrains Runtime</strong> directly, update to one of the fixed builds: <a href="https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-25.0.4.1b635.79" target="_blank" rel="noopener">jbr25.635.79</a>, <a href="https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-25.0.4.1b508.41" target="_blank" rel="noopener">jbr25.508.41</a>, <a href="https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-25.0.4.1b329.142" target="_blank" rel="noopener">jbr25.329.142</a>, <a href="https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-21.0.11b1163.125" target="_blank" rel="noopener">jbr21.1163.125</a>, <a href="https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-21.0.9b1038.91" target="_blank" rel="noopener">jbr21.1038.91</a>.</p>
<p>In rare cases, the IDE will no longer connect to a server whose certificate chains to one of the removed root certificates. The server’s owner will need to replace the certificate.</p>
<h2 class="wp-block-heading"><strong>If you can’t update right away</strong></h2>
<div class="wp-block-pb-accordion-item c-accordion__item js-accordion-item no-js" data-initially-open="false" data-click-to-close="true" data-auto-close="true" data-scroll="false" data-scroll-offset="0"><h3 id="at-7502730" class="c-accordion__title js-accordion-controller" role="button">Clean your certificates manually</h3><div id="ac-7502730" class="c-accordion__content">
<p>The Java runtime bundled with these IDEs and Toolbox App still trusts two eMudhra-related root certificates. If you can’t update the IDE, give it a cleaned copy of its certificate list and turn off its built-in browser, which has its own list that can’t be changed. It takes about five minutes and is fully reversible.</p>
<ol class="wp-block-list">
<li><strong>Copy the certificate list</strong> from the IDE folder to your home folder:<br>macOS: <code><IDE>.app/Contents/jbr/Contents/Home/lib/security/cacerts</code> <br>Windows / Linux: <code><IDE>/jbr/lib/security/cacerts</code><br> </li>
<li><strong>Remove the two affected roots</strong>, using the keytool in the IDE’s jbr/bin folder:<br><code>keytool -delete -keystore <copy> -storepass changeit -alias "comodoaaaca [jdk]"</code><br><code>keytool -delete -keystore <copy> -storepass changeit -alias "emsigneccrootcag3 [jdk]"</code><br> </li>
<li>Open <em>Help | Edit Custom VM Options</em>, add this line, then restart the IDE:<br><code>-Djavax.net.ssl.trustStore=<full path to the copy></code><br><strong>Important:</strong> write the full path, with no ~, no variables, and no quotes. A wrong path silently leaves you unprotected.<br> </li>
<li>In <em>Settings | Tools | Server Certificates</em>, make sure “<em>Accept non-trusted certificates automatically</em>” is off.<br> </li>
<li><strong>Linux only:</strong> update the ca-certificates package.</li>
</ol>
<p><strong>What to expect: </strong>If the IDE shows an “untrusted server certificate” dialog for an eMudhra certificate, click <em>Reject</em>.</p>
</div></div>
<div class="wp-block-pb-accordion-item c-accordion__item js-accordion-item no-js" data-initially-open="false" data-click-to-close="true" data-auto-close="true" data-scroll="false" data-scroll-offset="0"><h3 id="at-7502731" class="c-accordion__title js-accordion-controller" role="button">Disable JCEF in your IDE</h3><div id="ac-7502731" class="c-accordion__content">
<p>To workaround the JCEF problem in <strong>2025.2.6.4 and previous versions, or in any version if your network blocks Google’s update servers:</strong></p>
<ol class="wp-block-list">
<li>Open <em>Search Everywhere -> Actions</em></li>
<li>Type “Registry”</li>
<li>Open <em>Registry</em></li>
<li>Search for ‘<code>ide.browser.jcef.enabled</code>’ key</li>
<li>Switch it off</li>
<li>Restart</li>
</ol>
<p><strong>Note:</strong> Turning off the embedded browser affects features that use it, for example, Markdown and HTML previews and Jupyter notebook output. Some plugins may also stop working correctly. After you update to a fixed version, turn <code>ide.browser.jcef.enabled</code> back on and restart the IDE.</p>
</div></div>
<div class="wp-block-pb-accordion-item c-accordion__item js-accordion-item no-js" data-initially-open="false" data-click-to-close="true" data-auto-close="true" data-scroll="false" data-scroll-offset="0"><h3 id="at-7502732" class="c-accordion__title js-accordion-controller" role="button">Update <code>jetbrainsd</code> background service</h3><div id="ac-7502732" class="c-accordion__content">
<p>The Toolbox App and JetBrains IDEs use a background service, <code>jetbrainsd</code>. It has its own built-in list of trusted certificates, so updating JBR doesn’t fix it, and the workarounds above don’t apply to it.</p>
<p>The fix is in <code>jetbrainsd</code> 0.9.9728. You get it when you install or update a fixed version of the Toolbox App or an IDE and start it. Only one copy of <code>jetbrainsd</code> runs for each user, and the newest version replaces older ones. So updating the Toolbox App fixes <code>jetbrainsd</code> for all your IDEs, even if you can’t update the IDEs themselves.</p>
<p><strong>If you can’t update the Toolbox App or an IDE</strong>, update jetbrainsd manually:</p>
<ol class="wp-block-list">
<li><strong>Download the archive</strong> for your platform and check its SHA-256 checksum with shasum -a 256 <file> (macOS), sha256sum <file> (Linux), or Get-FileHash <file> (Windows PowerShell):</file></file></file>
<ul class="wp-block-list">
<li>Linux x64: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd-linux-x86_64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd-linux-x86_64-0.9.9728.tar.gz<br></a><code>SHA-256: 6916c5a20e9971be55caa73dc935cbabfb002e86910f2146a2e5dd01747f6b8e</code></li>
<li>Linux ARM64: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd-linux-aarch64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd-linux-aarch64-0.9.9728.tar.gz<br></a><code>SHA-256: abecdf7775475fe2073b46f6f9cae1272b2b9809355cc973de70c4e552a00420</code></li>
<li>macOS Intel: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd.app-macos-x86_64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd.app-macos-x86_64-0.9.9728.tar.gz<br></a><code>SHA-256: 2c35b0b90b4f8255de399d408ad01dd171200737f8c1aeffb6b7ba9ce11279f4</code></li>
<li>macOS Apple silicon: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd.app-macos-aarch64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd.app-macos-aarch64-0.9.9728.tar.gz<br></a><code>SHA-256: a26c459e8665a9c1bcc229384476527e1be8e7e3c1230a59e5a3eb3a8108fd08</code></li>
<li>Windows x64: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd-windows-x86_64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd-windows-x86_64-0.9.9728.tar.gz<br></a><code>SHA-256: 06b8dd29aa5c99fa9f17adfbc4417e5e8b13599aa1d8e45eea1d9590c8c493d0</code></li>
<li>Windows ARM64: <a href="https://download.jetbrains.com/resources/jetbrainsd/jetbrainsd-windows-aarch64-0.9.9728.tar.gz" target="_blank" rel="noopener">jetbrainsd-windows-aarch64-0.9.9728.tar.gz<br></a><code>SHA-256: d5186973f7ddc803d4cabbe03202e1fed942cfc64628ef65af104bb664ee8865</code><br> </li>
</ul>
</li>
<li><strong>Unpack the archive and run jetbrainsd once</strong> without arguments. It replaces the older version. To unpack, use <code>tar -xzf</code><file>. On Windows 10 and later, <code>tar</code> is built in.</file>
<ul class="wp-block-list">
<li>Linux: <code>./jetbrainsd/bin/jetbrainsd</code></li>
<li>macOS: <code>./jetbrainsd.app/Contents/MacOS/jetbrainsd</code></li>
<li>Windows: <code>.\jetbrainsd\bin\jetbrainsd.exe</code><br> </li>
</ul>
</li>
<li><strong>Check the installed version.</strong> It should be 0.9.9728 or later:
<ul class="wp-block-list">
<li>Linux: <code>"${XDG_DATA_HOME:-$HOME/.local/share}/JetBrains/Daemon/bundles/current/jetbrainsd/bin/jetbrainsd" --version</code></li>
<li>macOS: <code>"$HOME/Library/Application Support/JetBrains/Daemon/bundles/current/jetbrainsd.app/Contents/MacOS/jetbrainsd" --version</code></li>
<li>Windows (PowerShell): <code>& "$env:LOCALAPPDATA\JetBrains\Daemon\bundles\current\jetbrainsd\bin\jetbrainsd.exe" --version</code></li>
</ul>
</li>
</ol>
</div></div>
<h2 class="wp-block-heading"><strong>Also check</strong></h2>
<p>Your project JDKs and any tools that bring their own runtime, such as Node.js, Python, or Go, use their own trust stores. Update them as <a href="https://emudhra.we-have-a-problem.com/#developers" target="_blank" rel="noopener">their vendors recommend</a>.</p>
<h2 class="wp-block-heading"><strong>Support</strong></h2>
<p>If you have any questions about this issue or have trouble updating, please contact <a href="https://www.jetbrains.com/support/" target="_blank" rel="noopener">our Support team</a>.</p>The Advantage of Fixing All PHP Warnings - Exakathttps://www.exakat.io/?p=165462026-10-30T10:52:46.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/warnings.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16547" src="https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-300x300.jpg" alt="The Advantage of Fixing All PHP Warnings" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/10/warnings.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/10/warnings.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>The Advantage of Fixing All PHP Warnings</h1>
<p>I have spent a ungodly amount of my life reading other people’s PHP warnings. Scanning codebases for a living does that to you. And after a few million lines, I’ve come to a conclusion that sounds boring until you think about what it actually means: a warning is not decoration. It’s not the code equivalent of a yellow check engine light that’s been on since the car was new and clearly means nothing. A warning is PHP, mid-request, telling you that it just had to take a detour to not answer it. Ignore it, and you don’t just keep the mess: you keep paying for the detour, on every request, forever.</p>
<p>First, let’s be precise about scope, because PHP’s error levels are a genuinely confusing family tree: E<em>ALL absorbed E</em>STRICT in 5.4, then along came <code>E_DEPRECATED</code>: everyone’s mental model is still catching up. So, this post is about <strong>warnings</strong>, that is <code>E_WARNING</code> specifically. Not deprecation notices, where this will break in the next major version, so please prepare your code, not <code>TypeError</code>/<code>Error</code>, since those already stop you, no persuasion needed here. Warnings are the interesting, dangerous middle ground: annoying enough that everyone wants them gone, harmless-looking enough that gone usually means hidden under the rug rather than fixed.</p>
<h2 id="toc_1">The cost of handling a warning, instead of fixing it</h2>
<p>Projects often miss the actual cost of warnings: raising a warning is not free, even the ones you never look at. Under the hood it goes through <code>zend_error()</code>, and that function has real work to do: <a href="https://www.php.net/manual/en/function.set-error-handler.php">the manual is refreshingly blunt about how much control you have over it</a>. In a word: yes, this runs code, every time.</p>
<ul>
<li>The warning message gets built. File, line, a <code>sprintf</code>-flavoured string with your variable’s sins spelled out: all needed even if nobody’s reading the log.</li>
<li>Your handler gets called. Every. Single. Time. If you’ve wired up <a href="https://www.php.net/manual/en/function.set-error-handler.php"><code>set_error_handler()</code></a>directly, via a framework, or because your APM vendor’s SDK quietly did it for you: that’s a real function call per occurrence, not per bug.</li>
<li>Backtraces are not a courtesy, they’re billed. A lot of logging/monitoring integrations grab a full stack trace on every warning so they can group and report it nicely. <a href="https://www.php.net/manual/en/function.debug-backtrace.php"><code>debug_backtrace()</code></a>walks the entire call stack and allocates a frame for each level. Do that 50,000 times in a loop and you’ve built 50,000 stack traces to tell you the same one thing.</li>
<li>Logging is I/O, and I/O is never free. <code>error_log</code>, syslog, a network call to your error tracker: they are blocking, they are multiplied by every occurrence, every request, every box in the fleet. This is, incidentally, a wonderful way to accidentally DDoS your own logging pipeline. Ask me how I know. Actually don’t, it’s a long story involving a client, a Black Friday, and a very confused on-call engineer.</li>
<li><code>@</code> doesn’t make any of this go away. The <a href="https://www.php.net/manual/en/language.operators.errorcontrol.php">error control operator</a>, aka no scream operator, hides the message, not the work. PHP still executes the slow fallback path first, then throws the report in the bin. You paid full price and kept the receipt out of sight.</li>
</ul>
<p>None of this matters once. It matters when the same warning fires 50,000 times inside a loop, or once per request across a fleet handling a few million requests a day. Logging the symptom means paying that cost on a subscription. Fixing the cause pays it once, then never again. Which, if you enjoy irony, is the one piece of technical debt advice that’s also literally a performance optimization.</p>
<h2 id="toc_2">Warnings that are secretly a performance tip</h2>
<p>Below are common <code>E_WARNING</code>s in modern PHP 8.x where fixing them isn’t just tidiness: it moves execution from a defensive check-everything path onto the fast one PHP actually optimizes for. Yes, the fix often looks like more code, like an <code>isset()</code>, a cast, a guard clause, a <code>??=</code> operator. But the the joke’s on the one not writing them: the lazy version is the one doing more work at runtime. Here are some examples.</p>
<h3 id="toc_3">1. Undefined array key / undefined variable</h3>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Warning: Undefined array key "user_id"
$id = $data['user_id'];
?>
</pre>
</div>
<p>A hash-table miss still has to fall all the way through the warning subsystem before handing you <code>null</code>. Walk a large payload like this and you’re paying the format-and-dispatch tax thousands of times over. Think that finding the key in the list means the execution can stop searching. On the other hand, not finding it means you’ll have to check everything before failing. So, an <code>isset()</code> or <code>??</code>resolves the key in one cheap opcode and never wakes up <code>zend_error()</code> at all. <a href="https://www.php.net/manual/en/language.types.array.php">Manual: array key existence</a>.</p>
<h3 id="toc_4">2. Accessing an array offset on <code>null</code>/<code>false</code></h3>
<p>This one always draws a big laugh. Then, comes the epiphany that it is usually the fallout of an unchecked function result: <code>$row = $stmt->fetch(); $row['col']</code> when <code>fetch()</code>handed back <code>false</code>. And, most of the time, it is considered too safe to check. In fact, it belongs to the same family as the first section. Guard the fetch once; don’t let every subsequent offset access rediscover the same problem.</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// admin always exists
$stmt = $db->query("SELECT name FROM users WHERE login='admin'");
$row = $stmt->fetch();
// Warning: Trying to access array offset on null
echo $row['name'];
?>
</pre>
</div>
<h3 id="toc_5">3. Illegal / uninitialized string offset</h3>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Warning: Uninitialized string offset 3
$char = $str[3];
?>
</pre>
</div>
<p>Reading past a string’s length triggers the same warn-then-return-empty routine. A <code>strlen()</code>bounds check before the loop is one comparison; letting every out-of-range read hit the warning path is not. And all that applies to clever manipulations with string offsets, so a <code>$position + 3</code> also needs to be checked.</p>
<p>String manipulations may be handed to regex, and avoid juggling with offsets. <code>substr()</code> also allows to go outside the string interval, returning empty strings without errors.</p>
<h3 id="toc_6">4. <code>count()</code>/<code>sizeof()</code> on something that isn’t Countable</h3>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Warning: count(): Argument #1 ($value) must be of type Countable|array
count($maybeArray);
?>
</pre>
</div>
<p><a href="https://www.php.net/manual/en/function.count.php"><code>count()</code></a> on a genuine array or <code>Iterable</code> is about reading the hash table’s size directly: it is as cheap as PHP gets. Feed it something else and it has to check, fail, and dispatch a warning before falling back, on every single call. Keep the argument honestly array-shaped with <code>is_countable()</code> and it stays on the fast path. If not countable, well, you already know the answer.</p>
<h3 id="toc_7">5. Array to string conversion</h3>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
// Warning: Array to string conversion
$log = "Items: " . $item;
// Warning: Array to string conversion, for each error
$log = "The list: " . implode(', ', $items);
?>
</pre>
</div>
<p>This warning almost always means someone tried to <a href="https://www.php.net/manual/en/function.implode.php"><code>implode()</code></a> a multi-dimensional array. In a loop, every concatenation pays for the type check, the warning, and building the utterly useless literal string <code>"Array"</code>. <code>implode()</code> is a dedicated, optimized function with no per-iteration detour through the error subsystem.</p>
<p><code>implode()</code> is actually a double layer trap, as the loop is not visible, but hidden inside the function call itself. And there are no native protection, except may be the type trick:</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
function myLog(string ...$items) {
$log = "Items: " . $items;
}
// otherwise
$str = implode(', ', array_map(
fn($v) => is_array($v) ? '[' . implode(', ', $v) . ']' : (string) $v,
$array
));
```
Note that static analysis and another preceding loop that checks or filter the array are also valid defense against that situation.
### 6. Non-numeric value in arithmetic
```php
// Warning: A non-numeric value encountered
$total = $price + $quantity; // one of these is "12 units"
```
Arithmetic on a string makes PHP run its own[numeric-string scanner](https://www.php.net/manual/en/language.types.numeric.php), find the trailing garbage, warn, then coerce. This happens every single time the line executes. This got a whole [RFC to itself](https://wiki.php.net/rfc/saner-string-to-number-comparisons) in PHP 8, which tells you it wasn't just me finding it annoying. Cast once at the boundary, `(int) $quantity` the moment it enters your system, and every later arithmetic op in a loop hits the native int/float add opcode instead of re-parsing a string on repeat.
In this case, PHP does not offer a validation system. Either use a cast `(int)`, which always works, but does not tell you what went wrong, and clamp the result to the maximum size of an integer. `is_numeric()` only checks the type of the value, not its content.
### 7. Division by zero
```php
// Warning: Division by zero
$rate = $count / $total; // $total might be 0
```
`if ($total !== 0)` up front is one easy comparison: it is cheaper, categorically, than letting the division fire, warn, and hand you `INF`/`NAN`. This is the rare case where the safe code and the fast code are the exact same expression.
### 8. `include`/`require` failing to find the file
```php
// Warning: include(): Failed opening '...' for inclusion
include $maybeWrongPath;
```
This one surprises people. Before PHP admits defeat, it `stat()`s the path across every directory in [`include_path`](https://www.php.net/manual/en/ini.core.php#ini.include-path). On a network filesystem, or inside certain container setups, that's real wall-clock latency, not just wasted CPU cycles, for a file that was never going to be found. An explicit correct path, or better, autoloading, which resolves through a class map instead of scanning directories, skips the stat storm entirely.
Admittedly, rare are the one that are still using `include()` to do JIT code inclusion, without the `autoload()`. But the autoload may also have to search these path, so it is recommended to make these files easy to find, as much as possible.
### 9. Streams failing to open
```php
// Warning: file_get_contents(https://...): failed to open stream
$content = file_get_contents(https://www.exakat.io/);
```
For network wrappers, the warning only fires after the connection attempt. This means you can sit through a full connection timeout just to arrive at the failure you already suspected. Checking reachability ahead of time, or using a client with an explicit, short timeout, means you fail fast instead of failing slow-and-eventually. See [`file_get_contents()`](https://www.php.net/manual/en/function.file-get-contents.php) and, if you want to do this properly, a real HTTP client with timeout support instead of the streams wrapper.
### 10. Invalid encoding in escaping functions
```php
// Warning: htmlspecialchars(): Argument #1 ($string) must be valid UTF-8
```
When PHP can't confirm the encoding, [`htmlspecialchars()`](https://www.php.net/manual/en/function.htmlspecialchars.php) falls back to a defensive byte-by-byte validation pass before it can attempt the actual fast conversion. Guarantee UTF-8 at the input boundary once, and every escaping call downstream takes the direct route instead of re-litigating your encoding on every single request. For that, PHP offers [mb_check_encoding](https://www.php.net/manual/en/function.mb-check-encoding.php), or, with a detour, `if (preg_match('//u', $string)) {}`, or also `json_encode()`, as this last one needs a valid unicode value, and returns false in case of error.
## Fix them, and it will just come to you
A warning is PHP telling you it had to take the defensive branch to give you an answer. Treat it as noise to suppress or quietly log, and you keep paying for that defensive branch. That, plus pay for your own logging pipeline's overhead, on every occurrence, forever. I always recommend to fix the actual condition, and the cost collapses to zero the moment the fix ships.
I'll also admit there's a selfish reason I like this framing: it's the one argument for cleaning up warnings that doesn't require anyone to believe in code quality as a virtue. You don't have to care about craftsmanship. You just have to care about milliseconds, and it turns out milliseconds were on the side of clean code the whole time. The [engine warnings RFC](https://wiki.php.net/rfc/engine_warnings) that reshuffled a bunch of these levels between PHP 7 and 8 makes for surprisingly good reading if you want the reasons behind which of today's warnings used to be silent notices, or worse, silent nothings. PHP's error levels have a history; it's just one nobody tells you unless you go looking, or unless you're the kind of person who scans other people's warnings for a living.
Zero warnings isn't a tidiness goal you get to feel virtuous about. It's a performance budget, handed to you for free, by an engine that's been trying to tell you this the entire time. And, as usual, along the way, there are some real bugs to confront and fix.
?>
</pre>
</div>
<p>The post <a href="https://www.exakat.io/the-advantage-of-fixing-all-php-warnings/">The Advantage of Fixing All PHP Warnings</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Sort git branches by date - Rob Allenhttps://akrabat.com/?p=76022026-10-26T15:16:58.000ZRob Allen<p>I'm sure everyone is already doing this, but I've just discovered:</p>
<pre>git config --global branch.sort -committerdate</pre>
<p>Now, `git branch` sorts my branches by last commit date, most recent first.</p>
<p>To reset:</p>
<pre>git config --global --unset branch.sort</pre>When Your Lint Tool Calls Your Method “Difficult”: A Halstead Story - Exakathttps://www.exakat.io/?p=165432026-10-24T06:07:16.000ZExakat<h1 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640.jpg"><img fetchpriority="high" decoding="async" class="alignleft size-medium wp-image-16544" src="https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-300x300.jpg" alt="When Your Lint Tool Calls Your Method "Difficult": A Halstead Story" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-150x150@2x.jpg 300w, https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-150x150.jpg 150w, https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-500x500.jpg 500w, https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-100x100.jpg 100w, https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640.jpg 640w, https://www.exakat.io/wp-content/uploads/2026/10/halsteadbell-.640-300x300@2x.jpg 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>When Your Lint Tool Calls Your Method “Difficult”: A Halstead Story</h1>
<h2 id="toc_1">Start with the report itself</h2>
<p>Static analyzers love to tell you that your method is too long, too complex, or too nested. But every once in a while, one of them produces a warning that feels more personal. This one passes judgment not just on your code’s shape, but on its <em>density</em>.</p>
<div>
<pre>warning[halstead]: Method has a high halstead difficulty
┌─ file.php:479:5
│
479 │ ╭ private function scrollDown(int $n = 1): bool
480 │ │ {
481 │ │ if ($this->mode !== 'entry') {
482 │ │ $max = max(0, count($this->filteredEntries) - 1);
· │
500 │ │ return true;
501 │ │ }
│ ╰─────^ Method exceeds halstead difficulty threshold(s)
│
= Halstead difficulty is 14.06 (threshold 12). Difficulty reflects how hard the code is to write or understand.
= Help: Consider breaking this into smaller, more focused functions.</pre>
</div>
<p>The warning is a single number, with decimals, accusing a 20-line method of being hard to understand. The natural first reaction is disbelief. The method is called <code>scrollDown</code>. It moves a selection cursor down in a TUI list. How hard can it be?</p>
<p>The interesting part is that the metric is not wrong. It measures something real. It simply measures something different from what you expect.</p>
<h2 id="toc_2">Four counts and one ratio</h2>
<p>Maurice Halstead published his theory in 1977, in the book <code>Elements of Software Science</code>. His goal was ambitious. He wanted to turn “how hard is this program to understand?” into a number that you could compute from the source code, without running it. Thomas McCabe had proposed cyclomatic complexity a year earlier, so the two metrics grew up side by side and measure different things.</p>
<p>His theory starts from a simple observation. Source code is made of two kinds of tokens.</p>
<ul>
<li><strong>Operators</strong> are the tokens that do something, such as <code>!==</code>, <code><=</code>, <code>-</code>, <code>+</code>, <code>if</code>, <code>return</code>, and function calls.</li>
<li><strong>Operands</strong> are the tokens that get acted upon, such as variables, literals, and method names.</li>
</ul>
<p>From those two categories, you count four numbers:</p>
<table>
<thead>
<tr>
<th>Symbol</th>
<th>Meaning</th>
</tr>
</thead>
<tbody>
<tr>
<td>η₁</td>
<td>number of <strong>distinct</strong> operators</td>
</tr>
<tr>
<td>η₂</td>
<td>number of <strong>distinct</strong> operands</td>
</tr>
<tr>
<td>N₁</td>
<td>total number of operator occurrences</td>
</tr>
<tr>
<td>N₂</td>
<td>total number of operand occurrences</td>
</tr>
</tbody>
</table>
<p>The first pair describes your vocabulary, and the second describes your length.</p>
<p>Halstead then derived a whole family of metrics from these counts, including volume, effort, estimated bugs, and time to write. The time metric divides effort by 18, the Stroud number, a figure built on the psychologist John Stroud’s estimate of how many mental discriminations a person makes per second. The metric our analyzer complains about is difficulty, and its formula is remarkably simple:</p>
<div>
<pre><code class="language-text">D = (η₁ / 2) × (N₂ / η₂)
?>
[/php]
</code></pre>
</div>
<p>The formula has two factors. The first, η₁ / 2, counts how many different kinds of operations you juggle. The second, N₂ / η₂, measures how much you reuse the same operands. A value of 1 means that every operand appears exactly once. A value of 5 means that each distinct variable or literal gets touched five times on average.</p>
<p>The second factor is the one people find surprising. Reusing the same variable over and over does not just make a method longer. Under Halstead, it makes the method harder. The intuition is that a reader must keep the state of <code>$this->selected</code> in mind at every point, and every re-reference is another chance for that mental model to go wrong.</p>
<h2 id="toc_3">Mapping a 1977 model onto 2026 PHP</h2>
<p>Halstead’s original work predates PHP by nearly two decades, so any tool must decide how tokens map onto modern language features. In a PHP analyzer, the mapping looks roughly like this:</p>
<ul>
<li>Operators include <code>if</code>, <code>elseif</code>, <code>return</code>, <code>===</code>, <code>!==</code>, <code><=</code>, <code>-</code>, and <code>+</code>.</li>
<li>Function calls such as <code>max</code> and <code>count</code> count as one operator each, and their arguments count as operands.</li>
<li>Variables and literals such as <code>$this->selected</code>, <code>$this->filteredEntries</code>, <code>$n</code>, <code>1</code>, <code>0</code>, and <code>'entry'</code> count as operands.</li>
</ul>
<p>Now look at what <code>scrollDown</code> actually does. It manipulates a handful of distinct properties, <code>$this->mode</code>, <code>$this->selected</code>, and <code>$this->filteredEntries</code>. It mixes comparisons, arithmetic, function calls, clamping with <code>max</code>, and boundary checks with <code>count</code>.</p>
<p>That is precisely the recipe for a high Halstead difficulty.</p>
<ul>
<li>The operator vocabulary grows because the method uses many different operators. A cursor method needs comparisons, arithmetic, and calls. That is already a rich vocabulary for something that “just scrolls down”.</li>
<li>The ratio N₂ / η₂ grows because the operands are all different. <code>$this->selected</code> is read, compared, modified, and clamped. <code>$this->filteredEntries</code> is counted. Every occurrence pushes N₂ up, while η₂ stays fixed.</li>
</ul>
<p>Multiply the two factors and the result is 14.06.</p>
<p>The metric does not say that the method is long, since twenty lines is modest. It does not say that the method nests deeply, since a couple of <code>if</code> statements is tame. It says that the method is <strong>dense</strong>: a lot of varied computation packed onto a small set of shared state. McCabe’s cyclomatic complexity counts how many paths a method has. Halstead difficulty estimates how much a reader must hold in mind to follow it.</p>
<p>Density is inherent to the job of a method that owns a selection cursor. The new value depends on the list length, the current position, and the step size, and it must stay clamped at both ends. The real question is whether that density lives in one place or spreads across helpers.</p>
<h2 id="toc_4">Where the 12 comes from</h2>
<p>Halstead never published recommended limits. The threshold of 12 is a default policy choice of the analyzer, and the metric itself offers no reason for that choice. That could be changed, of course.</p>
<p>A metric without a calibrated threshold is just trivia. A difficulty of 14.06 against a threshold of 12 puts the method roughly 17 percent over the line. That is not a catastrophe, but it is a persistent signal. Unlike a one-off violation caused by odd code, this warning fires on every method written in the same style, with the same properties, operators, and density.</p>
<p>Thresholds cut both ways. A low threshold catches real problems early, but it also produces noise on methods where density is unavoidable or where splitting does more harm than good. In my view, twelve is a defensible middle ground. Below it, most methods read at a glance. Above it, you usually find mixed concerns or heavy state juggling.</p>
<p>The honest question to ask when a threshold is exceeded is not “how do I silence this?” It is “is this density structural?” Does the method do several jobs that deserve separate names, or is it one job whose formula is simply long?</p>
<h2 id="toc_5">A small method with a big idea</h2>
<p>Here is the practical dilemma. The method is short, and it works. Rewriting it adds indirection, new method names, parameter passing, and more total code. Isn’t that worse?</p>
<p>Sometimes it is. But a Halstead warning on a short method usually points at an opportunity rather than a defect. The density often comes from mixed concerns, and extracting them produces functions that are individually easy to read:</p>
<div>
<pre class="brush: php; title: ; notranslate">
<?php
private function entryCount(): int
{
return max(0, count($this->filteredEntries) - 1);
}
private function clampSelection(int $value): int
{
return max(0, min($value, $this->entryCount()));
}
?>
</pre>
</div>
<p>With those helpers in place, <code>scrollDown</code> shrinks to its essential decision logic: what changes and by how much. The fiddly parts, such as off-by-one list lengths and clamping, get one obvious home. Each helper has a small operator set and low operand reuse, so each one scores well on its own. The arithmetic of the metric decomposes the same way the code does.</p>
<p>There is a second benefit that metrics do not capture. The helpers become named concepts. <code>clampSelection</code> documents a rule that used to live implicitly across scattered <code>max</code> calls. The next method you write, such as <code>scrollUp</code> or <code>pageDown</code>, can reuse it rather than reimplement the clamping slightly differently. That is how these warnings quietly prevent drift, the slow process by which two methods that should mirror each other stop doing so.</p>
<p>The warning works best as a conversation starter, not a verdict. If the density is irreducible, with one formula, one job, and nothing to name, the sensible move is to suppress the warning with a comment and move on. More often, though, a twenty-line method that trips a Halstead threshold hides a small, well-defined concept waiting to be extracted. The rewrite costs about five minutes, and the metric simply spotted it before you did.</p>
<p>Metrics do not know what your code means. Halstead difficulty measures token counts, not semantics. “Many different operations repeatedly touching a few pieces of state” is still a decent statistical proxy for “a reader will have to work here.” In this case, the proxy pointed at something worth naming. So the next time an analyzer calls one of your methods difficult, which piece of state is it really complaining about, and what would you call it?</p>
<p>The post <a href="https://www.exakat.io/when-your-lint-tool-calls-your-method-difficult-a-halstead-story/">When Your Lint Tool Calls Your Method “Difficult”: A Halstead Story</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>From Commit to Production: How a PHP Fix Actually Reaches You - Exakathttps://www.exakat.io/?p=165312026-10-22T14:54:19.000ZExakat<h1 id="toc_0">From Commit to Production: How a PHP Fix Actually Reaches You</h1>
<p>A security fix landed in PHP: 2026, Oct 21rst. The announcement is summed up in one line: “2 CVE, fixed in PHP 8.5.12”. Then an impressive machinery, usually invisible, is set in motion, and pushes that fix to your servers. The fix itself has to travel a gigantic supply chain first, and that chain is longer and have more branches than most people expect. This is its story.</p>
<p>I observed this phenomenon in action during the publication of the 8.5.12 version of PHP, yesterday. I was thunderstruck by the number of paths a fix can take, from the source code to the machines running it, all over the world. The result looks less like a pipeline and more like a family tree. Each branch has its own agenda, its own people, and its own delays. And in the end, it delivers.</p>
<p> </p>
<p><a href="https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP.png"><img fetchpriority="high" decoding="async" class="aligncenter wp-image-16536 size-full" src="https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP.png" alt="The PHP fix tree" width="1000" height="667" srcset="https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP.png 1000w, https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP-300x200.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP-500x334.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/Larbre-des-correctifs-PHP-300x200@2x.png 600w" sizes="(max-width: 1000px) 100vw, 1000px" /></a></p>
<h2 id="toc_1">Layer 0: Merged, not running anywhere yet</h2>
<p>It starts with a commit. May be several commits, with a merge, but that’s technical jargon. In any cases, a bug is reported, fixes are proposed and evaluated, and finally, a patch is written, merged into <code>master</code>, the main branch of the source code repository at <a href="https://github.com/php/php-src">php-src</a>. This is the job of the PHP security team.</p>
<p>Nobody runs <code>master</code> in production, though. The fix must be merged again into each current and maintained branch: 8.2, 8.3, 8.4 and 8.5 at the time of writing. PHP 8.6 gets its by default, and will be published next Nov. 19th. This is the first fork in the tree, and the most important one.</p>
<p>The branches that are past their end-of-life do not receive the fix. If you run PHP 8.1, the fix exists in the world, but it is not coming to you from this source. But you can always count on the unsung heroes of the community, so when you are using <a href="https://www.linuxcompatible.org/story/php2shell-patch-suryorg-ships-debian-ubuntu-updates-for-every-php-version-from-56-to-85/">Ondrej Sury packages</a> on Debian and Ubuntu, you can know that he ported the fix himself. On any other distribution, check your package manager.</p>
<h2 id="toc_2">Layer 1: The release managers and the tarball</h2>
<p>Each branch has a release manager. Once the fix is in their branch, they tag a patch release, such as 8.5.12, or 8.3.36. Patch numbers, that is the last number of the three, only go up, so when your version changes, you know the fix is inside. You can even use <code>version_compare()</code> to do such comparison.</p>
<p>This is also where the fix becomes publicly available in raw form: a source tarball on php.net, plus pre-compiled Windows binaries. In theory anyone can start here. Nowadays, <a href="https://linuxcapable.com/how-to-install-php-8-5-on-ubuntu-linux/">almost nobody</a> compiles PHP by hand, so the real journey begins one layer down.</p>
<h2 id="toc_3">Layer 2: The packagers, where the fix multiplies</h2>
<p>Every packager in the ecosystem now waits for that tarball, and each adds its own build and its own schedule:</p>
<ul>
<li><strong>Linux distributions</strong>: Debian, Ubuntu, Fedora, RHEL, etc.. They run their own review and build processes.</li>
<li><strong>Independent packagers</strong>: <a href="https://rpms.remirepo.net/">Remi Collet</a> for the Red Hat family, <a href="https://launchpad.net/%7Eondrej/+archive/ubuntu/php">Ondřej Surý</a> for Debian and Ubuntu, <a href="https://github.com/shivammathur/homebrew-php">Shivammatur</a> on OSX, etc. Usually the fastest channels.</li>
<li><strong>Homebrew and MacPorts</strong> on macOS.</li>
<li><strong>The official <code>php</code> Docker images</strong>, built from the php.net tarballs, not from distribution packages. <a href="https://hub.docker.com/_/php">Docker images</a> are a siblings of the distributions, not a child of them.</li>
<li><strong>Static builds</strong>: <a href="https://github.com/crazywhalecc/static-php-cli">static-php-cli</a>, <a href="https://frankenphp.dev/">FrankenPHP</a>, <a href="https://static-php.dev/en/">staticPHP</a> and friends.</li>
</ul>
<p>Then comes the trap: backports. A stable distribution like Debian or RHEL does not move you to 8.3.36. It patches the version you already have and keeps its number. So <code>php -v</code> still reports 8.3.x, while the fix sits inside:</p>
<div>
<pre><code class="language-console">$ php -v
PHP 8.3.x (cli) ...
$ apt changelog php8.3-cli # Debian and Ubuntu
$ rpm -q --changelog php # RHEL family</code></pre>
</div>
<p>Backports are made for the stability of distributions, so this is by design. In practice, it make checking your PHP version a misleading task. Audit a fleet by version number and the fix is invisible: present, but invisible.</p>
<h2 id="toc_4">Layer 3: Rebuilds of rebuilds</h2>
<p>The packages and images from layer 2 feed a second generation of artifacts, each waiting for the previous one:</p>
<ul>
<li><strong>RHEL rebuilds</strong>: AlmaLinux, Rocky, Oracle Linux and Amazon Linux, which are build on RHEL’s source packages.</li>
<li><strong>Vendor images</strong>: Bitnami and friends.</li>
<li><strong>CI runner images</strong>: GitHub Actions and GitLab templates pin specific PHP images: it is now time to update them.</li>
<li><strong>Framework images</strong>: Laravel Sail, the official WordPress images.</li>
<li><strong>Control panels</strong>: <a href="https://www.cpanel.net/">cPanel</a>, <a href="https://www.plesk.com/">Plesk</a>, <a href="https://ploi.io/">Ploi.io</a> and CloudLinux’s Alt-PHP. A huge amount of shared hosting flows through, with its own updating process.</li>
<li><strong>One-click local stacks</strong>: Laragon, DDEV, Lando. Check for release date and published PHP versions, as version numbers for these projects are independant: XAMP, MAMP and WAMP have all stopped updating for a while, and won’t probably get this recent version.</li>
</ul>
<p>Local developer tools such as <a href="https://herd.laravel.com/">Herd</a>, <a href="https://yerd.app/">Yerd</a> and <a href="https://lerd.sh/">Lerd</a> ship their own managed PHP binaries. They do get the fix, but the urgency is not as high as online systems. Developers rarely attack their own laptops.</p>
<h2 id="toc_5">Layer 4: Somebody else’s calendar</h2>
<p>PaaS and managed platforms wait for their base images, then schedule their own rollouts. That covers Heroku, digital ocean, Platform.sh, <a href="https://www.ovhcloud.com/en/">OVH</a>, Fly.io, Tencent, Google CLoud, Azure App Service, etc, etc, etc. It also covers serverless through AWS Lambda and Bref layers. It covers managed hosts such as WP Engine, Pantheon, Acquia and Laravel Vapor.</p>
<p>Each of these is two intermediaries away from php.net, with a rollout calendar that is independant of your own, but related to many other customers. A customer of a managed WordPress host may wait some time after the fix is commited, but it will get the update without asking for it. For the platform, this is a process. For you, it is a risk you are renting.</p>
<h2 id="toc_6">Layer 5: Finally, your pipeline</h2>
<p>The fix finally arrives at the threshold of where it was always headed: your build pipeline. You pull the new base image, rebuild your application image, run CI, and deploy.</p>
<p>And, by deploy, you have to understand that there are three destinations, not just one:</p>
<ol>
<li><strong>Production</strong>, the one that matters most, that everyone sees.</li>
<li><strong>Preproduction, staging, testing</strong>. Second in importance, but usually updated before production, because the actual tests are run there. Paradoxically, they may run the old binary for longer, for fallback reasons, and they may be reachable from the internet. Too frequently, they hold copies of production data. Preprod is part of the attack surface, even when it is more confidential than public.</li>
<li><strong>Developer machines</strong>. Theses ones are low criticality: developers don’t attack their own machine. But they want to be up to date with the latest versions for their own testing. Upgrade when convenient.</li>
</ol>
<h2 id="toc_7">That is a large tree, indeed</h2>
<p>Take a momentot count the way the PHP supply chain unfolds. There is a new layer each time an actor must wait for the previous one to finish. The tree is up to six layers deep. Layer 1 takes days. Layer 2 takes days to weeks, because stability is deliberately slow. Layers 3 and 4 each add another cycle, and may become months. On October 21st, this was not the case.</p>
<p>This representation is also a bit simpler than reality. There are three caveats.</p>
<p>First, this organigram allows some skips. A company compiling from the tarball jumps straight to layer 5. Anyone writing <code>FROM php:8.5</code>in a Dockerfile skips layers 3 and 4. There are shortcuts, that are often taken in cases of high emergency.</p>
<p>Second, the cumulative delay is a daily scourge of the field. From the commit on <code>master</code> to a site on a managed host, the journey is measured in weeks. And on an EOL branch, it is never. Next time you wonder why it takes so long between the news and the update of your binaries: this is it.</p>
<p>Third, PHP engine rewrites are not part of this process. A PHP engine written in another language, such as a Rust or Go, does not carry a C bug fix and does not need for the fix. Indeed, it has its own bugs, which is a different story, even if the process is very similar.</p>
<h2 id="toc_8">Publishing a fix in emergency</h2>
<p>On Oct. 21st, 2026, the story starts actually even before the publication of the fix itself.</p>
<p>It actually starts with an embargo: that is a moment in time where the fix is ready, but not made public yet. While a bit strange at first, it is made to give time to all these actors to get prepared. Between the commit of the fix, and the first installation, there are recompilations, then sending the checked binaries to the delivery network. Because these systems will face a tsumani of requests at the publication time, so they need to be prepared for the event.</p>
<p>Some editors are also provided with the fix early, so they can prepare to serve their own community. This also spreads the load, and make the same solution available to more users across the different layers.</p>
<h2 id="toc_9">Conclusion: a good day for the community</h2>
<p>Behind every layer of this tree, there are people. On October 21st, 2026, a lot of them did something remarkable, and the least we can do is say so.</p>
<p>First, the finders. The <a href="https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w">advisories for CVE-2026-109618</a> and <a href="https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp">CVE-2026-109619</a> credit four reporters: lcfr-hax, sagitzadik-wiz, tomash-areion and amyb-oai. Finding a remote code execution in a language that runs a large part of the web is not a weekend hobby. It takes skill, patience, and the discipline to report it privately rather than posting it online. Thank you.</p>
<p>Second, the fixers. Four remediation developers are credited on the same advisories: arnaud-lb, iluuu1994, bukka and ndossche. Two bugs, two different root causes: one in how out-of-memory handling can leave request data half-initialized, the other in stale global state. Untangling that inside the engine, without breaking everything else, is the kind of work nobody notices until it is missing. bukka also published the advisory itself, the same day.</p>
<p>Third, everyone who carried it downstream. Four branches were patched at once: <a href="https://www.php.net/archive/2026.php">8.2.35, 8.3.36, 8.4.27 and 8.5.12</a>. The release managers tagged them, the independent packagers rebuilt them, and the Docker image maintainers followed the tarballs, all within hours rather than weeks. Security vendors published write-ups and free checks on the same day, and <a href="https://www.cisa.gov/news-events/alerts/2026/10/21/critical-vulnerabilities-php-require-immediate-patching">CISA issued its own alert</a>. Each of these people and teams had a small part of the chain, and they all moved at once.</p>
<p>The embargo, the early warnings to the editors, the preloaded delivery networks: none of that is glamorous. It is quiet coordination, and it worked. A fix that could have sat in the truck for weeks reached the machines that needed it in a matter of hours.</p>
<p>So the next time you read “Fixed in PHP 8.5.12”, remember the four people who found the bug, the four who fixed it, and the many four who made sure it travelled. Make sure your server is on the route, and thank them while you’re at it.</p>
<p>The post <a href="https://www.exakat.io/from-commit-to-production-how-a-php-fix-actually-reaches-you/">From Commit to Production: How a PHP Fix Actually Reaches You</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Recently updated PIE extensions #12 (since October 15th, 2026) - Exakathttps://www.exakat.io/?p=165282026-10-22T14:45:47.000ZExakat<h2 id="toc_0"><a href="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png"><img decoding="async" class="alignleft size-medium wp-image-16529" src="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300.png" alt="Recently updated PIE extensions #12" width="300" height="300" srcset="https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150@2x.png 300w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-150x150.png 150w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-500x500.png 500w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-100x100.png 100w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640.png 640w, https://www.exakat.io/wp-content/uploads/2026/10/php-pie.640-300x300@2x.png 600w" sizes="(max-width: 300px) 100vw, 300px" /></a>Recently updated PIE extensions #12 (since October 15th, 2026)</h2>
<p>24 PHP Pie extensions were updated.</p>
<ul>
<li><a href="https://packagist.org/packages/phpolygon/php-vio">phpolygon/php-vio</a> (2.35.0): PHP extension for GPU rendering (OpenGL, Vulkan, Metal), audio, video recording, streaming, and input</li>
<li><a href="https://packagist.org/packages/iliaal/php-excel">iliaal/php-excel</a> (2.9.1): PHP extension for reading and writing Excel files using LibXL</li>
<li><a href="https://packagist.org/packages/iliaal/php_clickhouse">iliaal/php_clickhouse</a> (0.13.0): Native PHP extension for ClickHouse using the official ClickHouse/clickhouse-cpp client. Connects over the native TCP protocol with LZ4 / ZSTD compression and optional TLS.</li>
<li><a href="https://packagist.org/packages/phalcon/cphalcon">phalcon/cphalcon</a> (v5.23.0): Phalcon is an open source web framework delivered as a C extension for the PHP language providing high performance and lower resource consumption.</li>
<li><a href="https://packagist.org/packages/xberg-io/liter-llm">xberg-io/liter-llm</a> (v2.3.0): Universal LLM API client with Rust-powered polyglot bindings.</li>
<li><a href="https://packagist.org/packages/xberg-io/html-to-markdown">xberg-io/html-to-markdown</a> (v3.18.6): High-performance HTML to Markdown converter</li>
<li><a href="https://packagist.org/packages/thomas-0816/pdo-duckdb-php">thomas-0816/pdo-duckdb-php</a> (2.0.0.0-beta2): PHP PDO Driver for DuckDB, modern analytics</li>
<li><a href="https://packagist.org/packages/iliaal/pdo_duckdb">iliaal/pdo_duckdb</a> (0.8.0): PDO driver for DuckDB, the in-process analytical database.</li>
<li><a href="https://packagist.org/packages/iliaal/fastchart">iliaal/fastchart</a> (1.8.0): Native C PHP extension for fast chart rendering: 38 chart families (line, area, bar, pie, scatter, bubble, stock with technical indicators, radar, polar, surface, contour, treemap, funnel, waterfall, heatmap, gauge, linear meter, gantt, box plot, bullet, pareto, calendar heatmap, sunburst, sankey, marimekko, vector, arc diagram, chord diagram, network, population pyramid, violin plot, circle packing, pictogram, venn diagram, word cloud, serpentine timeline, dendrogram, partition) plus a 2-class Symbol family (Code128, QrCode). SVG-canonical pipeline rasterized via vendored plutovg + plutosvg; PNG / JPEG / WebP encoders via libpng / libjpeg-turbo / libwebp.</li>
<li><a href="https://packagist.org/packages/kjdev/lz4">kjdev/lz4</a> (0.8.0): A compression/decompression with LZ4</li>
<li><a href="https://packagist.org/packages/laruence/yac">laruence/yac</a> (3.0.1): Yac is a shared and lockless memory user data cache for PHP.</li>
<li><a href="https://packagist.org/packages/xberg-io/crawlberg">xberg-io/crawlberg</a> (v1.11.1): High-performance web crawling engine</li>
<li><a href="https://packagist.org/packages/php-io-extensions/appkit">php-io-extensions/appkit</a> (v0.10.2): 1:1 PHP bindings of AppKit and the CoreFoundation run loop it runs on, as classes named after their native counterparts</li>
<li><a href="https://packagist.org/packages/php-io-extensions/gtk">php-io-extensions/gtk</a> (v0.10.2): 1:1 PHP bindings of GTK 4 and the GLib main loop it runs on, as functions and classes named after their C counterparts</li>
<li><a href="https://packagist.org/packages/orieg/expanse-extension">orieg/expanse-extension</a> (v0.15.0): Native PHP Zend Engine extension for Expanse: modern Judy arrays in pure Rust (ext-php-rs). Userland API: orieg/expanse.</li>
<li><a href="https://packagist.org/packages/axcherednikov/php-websocket">axcherednikov/php-websocket</a> (1.4.0): Native PHP extension providing RFC 6455 WebSocket protocol helpers and a WebSocket server runtime.</li>
<li><a href="https://packagist.org/packages/ptondereau/biscuit-php">ptondereau/biscuit-php</a> (v0.7.0): PHP bindings for Biscuit authorization tokens</li>
<li><a href="https://packagist.org/packages/corvus-dotnet/corvus-json-schema">corvus-dotnet/corvus-json-schema</a> (0.1.4): A high-performance JSON Schema evaluator (draft 4, 6, 7, 2019-09 and 2020-12) as a PHP extension, backed by Rust.</li>
<li><a href="https://packagist.org/packages/martinjuul/duckdb">martinjuul/duckdb</a> (1.4.1): Native DuckDB driver for PHP (C extension). Synchronous, streaming and asynchronous queries, prepared statements, transactions, bulk appender, typed errors.</li>
<li><a href="https://packagist.org/packages/php-io-extensions/qt">php-io-extensions/qt</a> (v0.10.2): 1:1 PHP bindings of Qt 6 as classes named after their C++ counterparts</li>
<li><a href="https://packagist.org/packages/alien1225/basisu">alien1225/basisu</a> (v0.1.1): No description available.</li>
<li><a href="https://packagist.org/packages/phasync/ext-phasync">phasync/ext-phasync</a> (2.0.2): PHP extension that makes blocking I/O (PDO, mysqli, curl, streams, sleep) wait cooperatively inside phasync coroutines, with an epoll Poller and per-coroutine requests (sapi()).</li>
<li><a href="https://packagist.org/packages/fiber-interop/ext-scope">fiber-interop/ext-scope</a> (v0.3.1): The Scope class from the PHP RFC “Scope”, as a PHP extension (PHP 8.2+).</li>
<li><a href="https://packagist.org/packages/corvus-dotnet/corvus-regex-ecma262">corvus-dotnet/corvus-regex-ecma262</a> (0.1.2): ECMA-262 (JavaScript) regular expressions as a PHP extension: the grammar and the answers of RegExp, every flag, UTF-8 and UTF-16, backed by Rust.</li>
</ul>
<p>The post <a href="https://www.exakat.io/recently-updated-pie-extensions-12-since-october-15th-2026/">Recently updated PIE extensions #12 (since October 15th, 2026)</a> appeared first on <a href="https://www.exakat.io">Exakat</a>.</p>Find the slowest PHPUnit tests - Rob Allenhttps://akrabat.com/?p=75952026-10-20T10:26:02.000ZRob Allen<p>We have a <a href="https://phpunit.de">PHPUnit</a> test suite that's taking a while, so I wanted to find out the which tests were taking the longest.</p>
<p>With the help of Google, I discovered the <tt>--log-junit phpunit-results.xml</tt> command line option to <tt>phpunit</tt> which creates an XML file with the info I need. Running on <a href="https://www.slimframework.com">Slim</a>'s codebase, we create the XML file with: </p>
<pre lang="bash">
$ ./vendor/bin/phpunit --log-junit phpunit-results.xml
...
Tests: 436, Assertions: 832, PHPUnit Notices: 37.
</pre>
<p>It looks like this (formatted by me):</p>
<pre lang="bash">
$ head -n 7 phpunit-results.xml
<?xml version="1.0" encoding="UTF-8"?>
<testsuites>
<testsuite
name="/Users/rob/Projects/slim/slimphp/Slim/phpunit.xml"
tests="436"
assertions="832"
errors="0"
failures="0"
skipped="0"
time="0.595106">
<testsuite
name="Slim Test Suite"
tests="436"
assertions="832"
errors="0"
failures="0"
skipped="0"
time="0.595106">
<testsuite
name="Slim\Tests\Routing\RouteContextTest"
file="/Users/rob/Projects/slim/slimphp/Slim/tests/Routing/RouteContextTest.php"
tests="5"
assertions="14"
errors="0"
failures="0"
skipped="0"
time="0.004264">
<testcase
name="testCanCreateInstanceWithoutRoute"
file="/Users/rob/Projects/slim/slimphp/Slim/tests/Routing/RouteContextTest.php"
line="43"
class="Slim\Tests\Routing\RouteContextTest"
classname="Slim.Tests.Routing.RouteContextTest"
assertions="4"
time="0.002566"/>
<testcase
name="testCanCreateInstanceWithoutBasePathAndThrowExceptionIfGetBasePathIsCalled"
file="/Users/rob/Projects/slim/slimphp/Slim/tests/Routing/RouteContextTest.php"
line="57"
class="Slim\Tests\Routing\RouteContextTest"
classname="Slim.Tests.Routing.RouteContextTest"
assertions="4"
time="0.000505"/>
</pre>
<p>Each <tt>testcase</tt> has a <tt>time</tt> attribute, so I asked my LLM to create some Python to sort by time and list the top 5:</p>
<pre lang="bash">
$ python3 -I -c '
import sys, heapq, xml.etree.ElementTree as ET
cases = ET.parse(sys.argv[1]).iter("testcase")
slowest = heapq.nlargest(5, cases, key=lambda c: float(c.get("time", 0)))
for c in slowest:
print(f"{float(c.get("time", 0)):8.3f}s {c.get("class")}::{c.get("name")}")
' phpunit-results.xml
</pre>
<p>For this test, I get:</p>
<pre>
$ python3 -I -c 'import sys, heapq, xml.etree.ElementTree as ET; print(*(f"{float(c.get("time", 0)):8.3f}s {c.get("class")}::{c.get("name")}" for c in heapq.nlargest(5, ET.parse(sys.argv[1]).iter("testcase"), key=lambda c: float(c.get("time", 0)))), sep="\n")' phpunit-results.xml
0.028275 Slim\Tests\AppTest testAnyRoute
0.026482 Slim\Tests\AppTest testInvokeSequentialProcessAfterAddingAnotherRouteArgument
0.020176 Slim\Tests\AppTest testInvokeSequentialProcessToAPathWithOptionalArgsAndWithoutOptionalArgsAndKeepSetedArgs
0.016482 Slim\Tests\MiddlewareDispatcherTest testExecutesMiddlewareLastInFirstOut
0.013571 Slim\Tests\Factory\AppFactoryTest testCreateAppWithContainerUsesContainerDependenciesWhenPresent
</pre>
<p>Obviously, Slim's tests are quick, so there's no much to see here, but for my client's project, the numbers are larger!</p>