Invite-only beta · 9 free places left · Managed hosting on AWS

AceMedia HostTalk to us

WORDPRESS · ONGOING · PHP 8.6

PHP 8.6 for WordPress: what I check before upgrading

PHP 8.6 is out. I've been testing stock WordPress and Redis against it, including switching back to 8.5. Here is what looks useful, what passed and what still needs checking.

My targeted stock WordPress tests on PHP 8.6 passed. WordPress's published compatibility table has not yet added 8.6, and each site's plugins and extensions still need their own checks.

PHP 8.6.0 was released on 19 November 2026. There are useful additions for developers, and it gives me a good reason to check the code around our sites as well as the runtime underneath them.

The thing I want from an upgrade is fairly straightforward: the site should keep doing its job, background work should still finish, and I should be able to switch back if something goes wrong. Any speed improvement needs measuring on the work the site actually does.

For the wider language changes, I have written a separate guide to PHP 8.6 features and upgrading. Here I am concentrating on a WordPress site, its plugins and the hosting processes which keep it running.

What is useful in PHP 8.6?

These are the additions I'm most interested in. PHP's migration guide and full changelog are the references I use alongside the release announcement.

AdditionWhere it could help
Time\DurationExpressing elapsed time, retry delays and worker timeouts more clearly.
clamp()Keeping a setting within an allowed range, such as a batch size or image quality.
Partial function applicationPreparing a callback with some of its arguments already supplied.
Polling APIHelping event-loop libraries watch several connections efficiently. It needs a suitable worker design to be useful.
Default values for readonly propertiesMaking fixed configuration values easier to express without assigning each one in a constructor.

I won't put new syntax into a shared plugin just because it is available. If that plugin supports an older PHP version, it still needs to load there. A feature check cannot protect older PHP from syntax it cannot parse. I keep the minimum version deliberate and test the oldest runtime the plugin supports.

Does WordPress support PHP 8.6 yet?

When checked on 20 November 2026, WordPress's published PHP compatibility table still stops at PHP 8.5. PHP's release date and WordPress's support statement are separate things, and installed plugins and themes add their own requirements. An absent table entry does not establish incompatibility; it means I cannot cite that table as confirmation of 8.6 support.

I have tested unmodified WordPress 7.1.5 and WordPress development revision 97f5bdf0e0a4, checked on 20 November 2026 on PHP 8.5.12 and 8.6.0. That matters because our hosting also uses shared core files. I want a regular WordPress baseline before looking at anything specific to our setup.

The first selected automated pass covered caching, metadata updates, options, JSON encoding, JSON schema and the REST server. Summed across four combinations of WordPress revision and PHP runtime, they ran 1,348 test cases with 3,234 assertions, 12 matching skips and no failures. The skips were the same on both runtimes. This is a targeted matrix, not the full Core suite or production certification. Further application checks remain.

First targeted pass, 20 November 2026
WordPress / PHPCasesAssertions / skips
7.1.5 / 8.5268714 / 3
7.1.5 / 8.6268714 / 3
trunk / 8.5406903 / 3
trunk / 8.6406903 / 3

A second targeted pass added cron, dates and GD image-processing coverage. Across the same four source/runtime combinations, that pass completed 562 cases and 21,733 assertions, with five skips and no failures. The two passes together total 1,910 cases, 24,967 assertions and 17 skips, with no failures. These are aggregate runs across both PHP versions and both WordPress revisions, rather than 1,910 distinct tests on PHP 8.6. They still do not cover the full Core suite.

I also checked the official WordPress release files against their checksums, served a fresh installation through a private PHP 8.6 FPM process, logged in, loaded the block editor, published a test post and checked the resulting page at desktop and mobile widths.

The PHP extensions need to be ready too

A website can use PHP extensions for Redis, images and compression. Those extensions have to work with the new PHP API. Having the main PHP package available does not settle that.

In the test environment, the existing stable Redis and igbinary extension versions did not build unchanged against PHP 8.6. Existing upstream development work allowed me to continue the isolated tests. The lab used igbinary 3.2.17RC1 and a pinned phpredis development build reporting 6.3.0RC1. Those are experimental builds used only in isolation. I still need a suitable supported extension set before a wider rollout.

That is why I check image processing and compression alongside the homepage. A working page does not tell me whether the next image upload, generated thumbnail, compressed cache hit or scheduled import will work.

Redis has to survive the move in both directions

Redis keeps data outside the PHP worker that wrote it. The next reader might be a web request, a command-line task, another runtime during a gradual move, or PHP 8.5 again after a rollback.

Using those experimental extensions in the private 8.6 lab, I tested values written by 8.5 and read by 8.6, then reversed the direction. The recorded round trips passed in both directions for matching formats. The fixtures included stored false values, missing keys, Unicode, binary strings, arrays, objects and compressed page strings. I also tested the actual object-cache drop-in on stock WordPress and checked its counters to make sure reads really reached Redis.

The formats have to agree. If one connection writes igbinary and another expects PHP serialization, using the same Redis server does not make the result readable. I have written more about that in PHP CLI and web cache formats.

Failure cases matter as well: an unavailable decompressor, incomplete object or damaged cache value should lead to a safe miss and fresh rendering. I am checking those paths before a site move. A compressed blob must never become the HTML sent to a visitor.

Multisite, sessions and forms: the next results

On a disposable three-site WordPress network, 58 cache integration checks passed across both runtime directions. Site-specific posts and transients stayed separate, network settings remained shared where intended, and deleting one site's cached entry preserved its neighbour's value. I checked actual Redis hits as well as the returned values.

Another ten checks covered ordinary WordPress sessions: create a session on one PHP version, validate its token and logged-in cookie on the other, then revoke it and confirm both become invalid. The 32 edit and recache checks covered the queue entries created by content changes. They do not prove a background worker fetched and rendered every queued page.

For our forms plugin, 326 checks passed, split equally between PHP 8.5 and 8.6. They exercised screening, review, site separation and reporting permissions against disposable data. Verification was mocked, mail intercepted and external WordPress HTTP blocked. That gives me useful failure-path evidence without contacting customers. A real browser submission and a verified delivery journey remain separate checks.

These are our plugin and application checks. I keep them separate from the pristine WordPress Core totals above.

Shared files and OPcache memory are different things

OPcache keeps compiled PHP code in memory. AceCore and AceLink are our tools for sharing WordPress core and plugin source files between sites. Reusing the same canonical file paths can let pools under one FPM master reuse compiled entries, subject to configuration. Sharing files alone does not prove a memory saving, so I check the effective paths and cache entries.

PHP 8.5 and 8.6 run separate FPM services with separate OPcache memory. Keeping both available during testing therefore needs a budget for both. I check the actual web pool, loaded extensions and cache settings rather than relying on php -v in my shell.

The release tools need the same care. Clearing a site's compiled code must select the runtime serving that site. A helper which only knows about yesterday's PHP version can report success while leaving the new runtime untouched.

A graceful reload still needs a request test

In private FPM tests on both PHP 8.5 and 8.6, all six deliberately slow requests were interrupted when I reloaded with the default process_control_timeout = 0. Repeating the experiment with a five-second setting let all six requests finish their two seconds of work. All 72 requests sent after the 12 reload cycles succeeded.

The five-second setting is a lab result, not a recommendation for every server. A longer upload or export needs a suitable drain policy and its own test. PHP documents what the FPM setting controls; I check the actual service reload with work in flight before calling it safe.

The private runtime probes also reproduced issues in FPM status counters and specific OPcache reset, file-cache and cross-pool configurations. A wrong status count does not establish extra workers, and a successful reload does not establish correct cache behaviour. I keep those findings with the runtime rollout checks. They are not evidence that a customer site has suffered those failures.

Background jobs need a complete test

An upgrade can look fine while visitors are seeing cached pages. Imports, media work and cache refreshes may only reach the changed code later.

I want to see a job claimed, processed and completed, with the expected result available afterwards. A scheduler saying it started is only part of the evidence. Timeouts, retries and worker limits need checking too, including a budget for background refresh work.

For a shop, that includes checkout, payment callbacks, invoices and stock changes against disposable data. For a multisite, it includes switching between sites without sharing the wrong cached result. For an events site, dates and daylight-saving changes still need to produce the right time.

Can I switch back from PHP 8.6?

In the isolated WordPress test, I moved the private FPM process back to PHP 8.5, checked that the published post and authenticated session survived, then returned to 8.6. I kept the same synthetic database throughout.

That proves something useful about this test environment. Each real site still needs its own recovery check. Switching the PHP route back will not undo a database migration, restore a replaced file or reconcile an order. I keep those changes separate and record exactly what the rollback restores.

My WordPress compatibility checklist

I split a WordPress check into journeys I can observe. That makes a failed test easier to trace to the runtime, a plugin, a cache layer or the surrounding configuration.

Journeys to check on a development copy
AreaWhat I exerciseWhat counts as useful evidence
Admin and editorSign in, open the block editor, save a draft and publish a disposable post.The saved content appears through the REST API and on the rendered page, with no new PHP errors.
MediaUpload representative images and generate the sizes the theme uses.The files exist, their dimensions are correct and the page loads them successfully.
Forms and integrationsSubmit valid and invalid fixtures using contained test destinations.Validation, stored results and expected callbacks agree. No customer mail or payment is triggered.
CacheWarm a page, repeat the request and exercise a damaged entry or missing decoder.A real hit serves the expected response; an unreadable value becomes a miss and is rebuilt safely.
Scheduled workRun an import or queue item through its complete lifecycle.The expected result exists, the job completes once and a failed item can retry without duplicating work.
Multisite and shopsSwitch sites, check cache separation and exercise disposable checkout and callback journeys.Data stays with the right site and transaction. These checks need their own fixtures and results.

This table is my acceptance checklist. The completed stock tests above cover part of it. The targeted network cache and forms checks have now passed, but media uploads, payment journeys and complete site acceptance still need their own evidence.

Check plugins, themes and Composer dependencies separately

A plugin's Requires PHP header states a minimum version. I also check its changelog and maintainer guidance for the candidate runtime, especially where an optional integration is involved.

I make an inventory before the switch: active and must-use plugins, the current theme, cache drop-ins and any background executables. A plugin can load cleanly on a homepage while an optional exporter or payment handler still fails when it is called.

Where a project uses Composer, I check its PHP constraint, locked dependencies and the platform requirements against the candidate runtime. I keep dependency updates separate from the PHP switch where possible, so a regression has a smaller set of possible causes.

I collect errors with consistent reporting on both runtimes and keep diagnostic output out of public responses. Existing notices need an owner and a baseline too. A test that ignores every warning cannot tell me whether the upgrade introduced a new one.

WordPress cron and WP-CLI need the same attention as FPM

The PHP version serving a page may be different from the one used by a cron command. I check the executable in the actual scheduler and worker configuration, including any wrapper scripts. A successful shell command does not prove the web pool loaded the same extensions or configuration.

If a gradual move intentionally uses both runtimes, I test the formats they exchange and record that arrangement. If it is accidental, I fix the routing before treating the site as a useful canary. For a queue, I also check ownership, retry limits and whether another process can claim the same work.

The installed WP-CLI 2.6.0 passed the contained forms checks but produced dependency deprecations on PHP 8.6. A checksum-verified WP-CLI 2.12.0 reduced the captured diagnostics from 421 to 14 lines per integration run; its remaining warnings came from bundled WP-CLI and React Promise code. That is a tooling finding, not a failure in the forms plugin or WordPress Core. The hook-ID change is already fixed in upstream WP-CLI. A pinned official development PHAR then passed the 224 repeated integration checks across both runtimes with no captured diagnostic lines. That is a private candidate result; I have not replaced the installed tool or treated a nightly build as a stable release.

How I would move a real WordPress site

I start with a development copy using safe test data and disabled outbound side effects. I record the working configuration and recovery route, then change the PHP runtime without bundling in a core, plugin or schema update.

After the switch I check the actual web process, run the agreed journeys, inspect errors and compare resource use. I include uncached requests so a warm page cache cannot hide an application failure. Any cache invalidation is scoped to that site's data.

I would return to the known working runtime if a required journey fails, unreadable cached data reaches a response, new fatal errors appear or resource use exceeds the agreed budget. Any database or file change still needs its own recovery decision. I record the observation and the return check before trying again.

Where the rollout stands

The targeted stock WordPress, cross-runtime cache, network and session checks give me a useful baseline. I have prepared cache-failure and atomic file-publication fixes for review. The next gates are a reproducible supported extension set, command-line tooling, safe service configuration and a representative development-site canary. Existing hosted sites remain on their working runtime while those checks continue.

The general PHP 8.6 guide explains the measurements I will use. I have not established a production speed percentage.

If you're planning the same move, start with the actual PHP version serving your website, the extensions it loads, your plugins' requirements and one site you can safely test. Keep the working runtime available until the new one has earned its place.

PHP pixel logo adapted from Colin Viebrock's PHP logo, under CC BY-SA 4.0. The adaptation uses a reduced pixel grid. The WordPress W mark follows the official WordPress reference and identifies the application under test.

More hosting notesTalk about your WordPress hosting

INVITE-ONLY BETA

Tell us about your site.

Nine free hosting beta invites remain for open-source projects, charities, community organisations and other public-benefit work. Tell us what you’re building; we’ll review the fit and reply personally. Fields marked * are required.

Please do not send passwords or private customer data. We’ll use these details to reply. Privacy notice.

Prefer email? Write to [email protected].