Modern WordPress Development: PHP 8.3+ Features You Should Be Using

WordPress has a reputation for being conservative about PHP versions. For years, the minimum PHP requirement lagged far behind the latest releases, and plugin developers had to write code that worked on PHP 5.6. But those days are over. WordPress now runs on PHP 8.3+ for most sites, and the ecosystem has fully embraced modern PHP features.

If you’re still writing WordPress code the PHP 7.4 way — with long arrays, clunky match statements, and verbose type declarations — you’re missing out on features that make your code cleaner, faster, and less error-prone.

This guide covers the PHP 8.3 and early 8.4 features that matter most for WordPress development, with practical examples you can use in your plugins today.

Named Arguments: No More Positional Confusion

Named arguments let you pass arguments to a function by specifying the parameter name, regardless of their position. This is transformative for WordPress development because so many core functions accept long lists of optional parameters.

Instead of this PHP 7.4 code where you have to pass null values for parameters you don’t want to set:

register_post_type('portfolio', array(
    'labels' => $labels,
    'public' => true,
    'has_archive' => true,
    'supports' => array('title', 'editor', 'thumbnail'),
    'menu_icon' => 'dashicons-portfolio',
));

You can now use named arguments to be explicit about what each parameter does. The code becomes self-documenting, and you can skip parameters you don’t need without counting positions.

Match Expression: Cleaner Than Switch

The match expression is a more powerful and safer replacement for switch statements. Unlike switch, match does strict type comparison (===), returns a value, and throws an error if no branch matches.

In WordPress plugin development, match is perfect for routing, status handling, and conditional logic that would otherwise require long if-elseif chains.

Readonly Properties: Immutable by Design

Readonly properties, introduced in PHP 8.1 and enhanced in 8.3, allow you to declare class properties that can only be set once. This is invaluable for value objects and DTOs that should be immutable after construction.

In PHP 8.3, you can now declare readonly properties on classes that haven’t been declared readonly, giving you more flexibility. You can also clone readonly properties, which wasn’t possible in 8.1. This makes it practical to use readonly in WordPress development for things like configuration objects, API responses, and settings containers.

Type System Improvements

PHP 8.3 and 8.4 continue to harden the type system, making it easier to write code that’s correct by construction:

• Typed class constants — You can now declare the type of class constants, preventing accidental type mismatches.
• Property hooks (PHP 8.4) — A major new feature that lets you add get/set hooks to properties without breaking encapsulation. This reduces boilerplate code for computed properties and validation.
• Lazy objects (PHP 8.4) — Support for lazy initialization without requiring a proxy library. Useful for expensive WordPress objects that shouldn’t be created until needed.
• Deprecated attribute enhancements — Better support for marking deprecated functionality with detailed messages.

Performance Improvements

Each PHP version brings significant performance improvements. PHP 8.3 is approximately 20-30% faster than PHP 8.0 for WordPress workloads, and PHP 8.4 offers additional gains.

The performance improvements come from JIT compilation refinements, better opcache behavior, and optimizations to the internal data structures. For a WordPress site running on PHP 8.3 vs PHP 7.4, the difference can be 2-3x in page generation time — a free performance upgrade that requires only switching PHP versions in your hosting control panel.

Adopting Modern PHP in WordPress Plugins

If you’re building a plugin for the WordPress.org directory, you need to be mindful of the minimum PHP version your users have. As of 2026, over 80% of WordPress sites run PHP 8.0 or higher, and WordPress itself recommends PHP 8.3+. Setting your plugin’s minimum PHP version to 8.0 is reasonable, and targeting 8.2 as your baseline gives you access to most modern features.

Here’s a practical adoption strategy:

1. Set your plugin’s “Requires PHP” header to 8.0 or higher.
2. Start using named arguments and match expressions — they work in PHP 8.0 and are safe for broad compatibility.
3. Use readonly properties for value objects and configuration classes.
4. Adopt typed class constants and property hooks (PHP 8.3+) for new development.
5. Run PHPStan or Psalm at the highest level to catch type issues before they reach production.

The Bottom Line

Modern PHP is a different language from the PHP of 2018. It’s faster, safer, and more expressive. WordPress developers who embrace these features write code that’s easier to read, harder to break, and performs better under load.

If you haven’t upgraded your development environment to PHP 8.3 or 8.4, do that today. Then start adopting one new feature at a time. Named arguments and match expressions are the easiest places to start — they require minimal changes and deliver immediate readability improvements.