Shopware 6 PHP 8.5 Migration: Performance Boost Guide 2026

With the release of Shopware 6.7.6 in January 2026, full PHP 8.5 compatibility has been officially confirmed. PHP 8.5 brings, among other things, the pipe operator, clone() with changed property values, a URI extension and the NoDiscard attribute (php.net); property hooks and asymmetric visibility already arrived with PHP 8.4. What performance effect the switch has for your Shopware shop only shows in your own measurement. In this guide, you will learn how to plan the migration, which measuring points to record before and after, and what to watch out for with plugins. Also facing a version or platform switch? See our Shopware migration page.

PHP 8.5: Key New Features at a Glance

PHP 8.5 was released in November 2025. As of 1 September 2026, PHP ran on 70.2% of all websites whose server-side programming language is known (W3Techs). Besides new language features, the release changes operations: from PHP 8.5, the OPcache bytecode cache is built into the PHP binary and always loaded (PHP project). For e-commerce applications like Shopware, this means: the OPcache settings still matter, loading the extension is no longer needed.

Performance Benchmarks: PHP 8.5 vs. 8.3 vs. 8.1

The performance differences between PHP versions are noticeable for Shopware shops, but how large they turn out depends on the individual shop: the number of products and variants, the state of the plugins, the hardware and the caching setup. External benchmarks therefore indicate a direction, not a promise for your shop. Only a measurement on your own machine is dependable – recorded before the migration and repeated afterwards under identical conditions. The table below names the measurement points that have proven useful.

Higher throughput on product listings means in practice: your hosting server serves more concurrent visitors on the same hardware. That pushes back the point at which a more expensive server package becomes necessary, while simultaneously improving Core Web Vitals, which Google uses as a ranking factor. Whether PHP 8.5 delivers pages faster or uses less memory in your shop is shown by a comparison under the same load before and after the switch.

Shopware 6.7.6 and PHP 8.5 Compatibility

Shopware introduced official PHP 8.5 support with version 6.7.6 (January 2026). The release notes list PHP 8.2, 8.4 and 8.5 as tested versions (GitHub shopware/shopware). For shop operators, this means: the core of the shop system is ready – the challenge lies in plugins and custom code. The package base of the release is listed in its composer.json:

• Shopware core: Full PHP 8.5 compatibility from version 6.7.6
• Symfony 7.3: framework foundation of release 6.7.6
• Doctrine DBAL 4.3: database abstraction
• Twig 3: template engine
• PHPUnit 11: test framework of the core tests

Important to note: in the 6.6 line, Shopware only allows PHP 8.5 from 6.6.10.11 (January 2026) onwards; older 6.6 builds and the 6.5 line do not support PHP 8.5 (GitHub shopware/shopware). If your shop still runs on an older Shopware version, a Shopware update is required first before the PHP migration can proceed.

Migration Path: Step by Step to PHP 8.5

A successful PHP migration requires systematic planning. The following migration path has proven effective in practice and minimizes the risk of downtime. From analysis to production deployment, a well-prepared migration is usually a matter of several weeks; the plugin inventory and custom code determine the timeframe.

1. Inventory: Document current PHP version, Shopware version, and all installed plugins
2. Update Shopware: Ensure at least Shopware 6.7.6 is installed
3. Compatibility analysis: Run PHPStan and Rector against the codebase to identify incompatibilities
4. Plugin check: Verify all plugins for PHP 8.5 compatibility (details in the next section)
5. Staging environment: Install PHP 8.5 on a test server and deploy the shop there
6. Automated tests: Run the entire test suite on the staging environment
7. Manual tests: Manually test checkout, payment processes, and critical business workflows
8. Performance baseline: Measure and compare benchmarks on old and new versions
9. Production migration: Activate PHP 8.5 on the live server, ideally outside peak hours
10. Monitoring: Closely monitor error logs and performance metrics for the first 48 hours

Common Pitfalls with Deprecated PHP Functions

PHP 8.5 deprecates several notations that may appear in older Shopware code and plugins (php.net). On top of that come legacy issues from earlier versions that surface together when jumping from 8.1 or 8.3: utf8_encode(), utf8_decode() and ${} interpolation have been deprecated since PHP 8.2, implicitly nullable parameters since PHP 8.4. The following overview shows examples for Shopware developers:

// PHP 8.5 DEPRECATED: backtick operator as an alias for shell_exec()
// Old:
$output = `ls -la`;
// New:
$output = shell_exec('ls -la');

// PHP 8.5 DEPRECATED: non-canonical cast names
// Old:
$active = (boolean) $value;
// New:
$active = (bool) $value;

// PHP 8.5 DEPRECATED: null as an array offset
// Old:
$label = $labels[null];
// New:
$label = $labels[''];

// since PHP 8.4 DEPRECATED: implicitly nullable parameters
// Old:
function setName(string $name = null) { }
// New:
function setName(?string $name = null) { }

// since PHP 8.2 DEPRECATED: utf8_encode() / utf8_decode()
// Old:
$encoded = utf8_encode($string);
// New:
$encoded = mb_convert_encoding($string, 'UTF-8', 'ISO-8859-1');

Implicitly nullable parameters ran without a notice up to PHP 8.3 and may therefore be found in older plugin code. Tools like Rector can automate part of these adjustments. For custom plugin development, we recommend a professional code review to identify subtle compatibility issues early on.

Checking and Ensuring Plugin Compatibility

Plugins are typically the most critical aspect of a PHP migration. While the Shopware core is officially tested, PHP 8.5 readiness among third-party plugins varies considerably. A systematic check is essential to prevent production issues.

• Composer check: composer why-not php 8.5 shows all packages with incompatible PHP constraints
• PHPStan Level 8: Static analysis with --php-version=80500 reveals type errors and deprecated calls
• Rector audit: rector process --dry-run shows required code changes without executing them
• Check plugin metadata: Look up the PHP requirement (require.php) and the supported Shopware versions in each plugin's composer.json
• Contact vendors: For business-critical plugins, ask vendors directly about their PHP 8.5 timeline

Whether an extension runs under PHP 8.5 is decided plugin by plugin and cannot be quantified across the board. Actively maintained extensions tend to follow soon after a PHP release; older and unmaintained ones often never do. For a plugin that does not follow, there are three options: wait for an update, adapt the code yourself, or replace the plugin with a compatible alternative. For custom-developed plugins, we handle the PHP 8.5 adaptation as part of the migration.

Server Configuration for High PHP 8.5 Performance

PHP 8.5 alone brings performance benefits, but the right server configuration makes the decisive difference. The following settings are optimized for Shopware 6 on PHP 8.5 and should be adjusted in the php.ini or pool configuration.

; OPcache configuration for PHP 8.5
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0
opcache.jit=tracing
opcache.jit_buffer_size=256M

; Memory and limits
memory_limit=512M
max_execution_time=60
upload_max_filesize=32M
post_max_size=32M

; Realpath cache (important for Symfony)
realpath_cache_size=4096K
realpath_cache_ttl=600

Beyond PHP configuration, web server setup also plays a role. Nginx with PHP-FPM and a dedicated worker pool for Shopware, combined with a CDN and HTTP/3, delivers good results.

Pipe Operator and clone() in Practice

PHP 8.5 introduces language features that can make plugin code shorter: the pipe operator makes nested function calls readable, and clone() takes changed property values while copying (php.net). Property hooks, which can replace getter and setter methods, have been available since PHP 8.4.

// new in PHP 8.5: pipe operator for readable pipelines
$result = $input
    |> trim(...)
    |> strtolower(...)
    |> htmlspecialchars(...);

// new in PHP 8.5: clone() with changed properties
final readonly class Price {
    public function __construct(
        public int $amount,
        public string $currency,
    ) {}

    public function withAmount(int $amount): static {
        return clone($this, ['amount' => $amount]);
    }
}

// since PHP 8.4: property hooks replace getters/setters
class Product {
    public string $name {
        set(string $value) => trim($value);
    }
}

For Shopware plugins, these features can make code shorter and more readable. Asymmetric visibility (public private(set), since PHP 8.4) also allows API designs where properties can be read externally but only set internally – useful for entity classes in Shopware.

Impact on SEO and Core Web Vitals

PHP performance directly impacts search engine optimization. Since 2021, Google has evaluated Core Web Vitals as a ranking factor, where Largest Contentful Paint (LCP) and Time to First Byte (TTFB) are heavily influenced by server-side processing speed. A shorter TTFB moves the starting point for everything that loads afterwards – LCP only benefits from it if images and fonts do not slow things down in turn.

The effect on conversion has been measured: a mere 0.1 second faster mobile load time lifted retail conversions by 8.4% and average order value by 9.2% (Google/Deloitte). How much of that reaches your shop is something only your own measurement before and after the migration will show. The PHP 8.5 migration is therefore not just a technical upgrade but an investment in your e-commerce success.

Migration Checklist for Shop Operators

The following checklist summarizes all steps to be carried out before, during, and after the PHP 8.5 migration. Use this list as the basis for your planning – or contact us to have us handle the migration professionally.

• Database, files, and configuration backup created
• Shopware updated to version 6.7.6 or higher
• All plugins checked for PHP 8.5 compatibility (composer why-not, PHPStan)
• Staging environment with PHP 8.5 set up and tested
• Deprecated functions in custom code replaced
• OPcache and JIT configuration optimized for PHP 8.5
• Checkout and payment processes manually tested on staging
• Performance benchmark measured before and after migration
• Rollback plan documented (PHP version can be switched back quickly)
• Error monitoring set up for the first 48 hours after go-live