<?php
// BookPostType.php
class BookPostType {
public function register() {
add_action('init', [$this, 'register_post_type']);
add_filter('manage_book_posts_columns', [$this, 'add_columns']);
add_action('manage_book_posts_custom_column', [$this, 'column_content'], 10, 2);
}
public function register_post_type() {
register_post_type('book', [
'label' => 'Books',
'public' => true,
]);
}
public function add_columns($columns) {
$columns['isbn'] = 'ISBN';
return $columns;
}
public function column_content($column, $post_id) {
if ($column === 'isbn') {
echo get_post_meta($post_id, 'isbn', true);
}
}
}php
If you've spent any amount of time building WordPress themes, you've probably dealt with sprawling functions.php files and plugins packed with unstructured code. That approach may have been the norm a decade ago, but today it’s antiquated. That kind of code is hard to maintain, difficult to scale, and out of step with modern PHP development.
At Imarc, we've seen firsthand how applying modern programming practices to our WordPress projects can dramatically improve both the developer experience and the long-term health of a codebase. Techniques like object-oriented PHP, composer-based tooling, and templating engines lead to cleaner, more reliable, and more maintainable themes that are easier to evolve as your business needs grow.
In this article, we'll explore why object-oriented design is a good fit for WordPress and how to structure your code around it. We'll also look at some current tools that can help support your workflow.
Why object-oriented PHP matters for WordPress
Object-oriented programming (OOP) is more than a stylistic choice. It offers practical benefits like improved maintainability, reusability, and clarity. For WordPress developers used to writing procedural code, switching to OOP might feel like a big shift, but the advantages are immediate and tangible. It's like upgrading from a junk drawer to a neatly labeled filing cabinet. Each feature of your theme has its own place, and you can find and update things without sorting through a tangle of unrelated code.
WordPress itself has been moving in this direction for years, with core components like WP_Query, WP_Error and WP_REST_Controller already following object-oriented patterns. Embracing these same principles in your own code brings your work into alignment with how today’s WordPress is built under the hood.
To see the difference in action, let's look at a common example: registering a custom post type and adding custom columns for it in its list view in the WordPress admin. In many themes, this kind of logic ends up scattered across a bloated functions.php file. Post type registration might be in one place, admin column tweaks in another, and maybe a REST API field added 300 lines later.
It works, but it's chaotic, hard to debug, and even harder to reuse. And as your theme grows in complexity due to the addition of other post types, blocks, or integrations, this kind of setup quickly becomes a maintenance nightmare.
<?php
// Register custom post type
function register_book_post_type() {
register_post_type('book', [
'label' => 'Books',
'public' => true,
]);
}
add_action('init', 'register_book_post_type');
// Add custom columns to the WP Admin list view
function book_custom_columns($columns) {
$columns['isbn'] = 'ISBN';
return $columns;
}
add_filter('manage_book_posts_columns', 'book_custom_columns');
function book_custom_column_content($column, $post_id) {
if ($column === 'isbn') {
echo get_post_meta($post_id, 'isbn', true);
}
}
add_action('manage_book_posts_custom_column', 'book_custom_column_content', 10, 2);
A more maintainable alternative is to group all of that related functionality into a single class. This will make your code easier to understand and minimizes the risk of introducing bugs when you need to make changes later.
<?php
// BookPostType.php
class BookPostType {
public function register() {
add_action('init', [$this, 'register_post_type']);
add_filter('manage_book_posts_columns', [$this, 'add_columns']);
add_action('manage_book_posts_custom_column', [$this, 'column_content'], 10, 2);
}
public function register_post_type() {
register_post_type('book', [
'label' => 'Books',
'public' => true,
]);
}
public function add_columns($columns) {
$columns['isbn'] = 'ISBN';
return $columns;
}
public function column_content($column, $post_id) {
if ($column === 'isbn') {
echo get_post_meta($post_id, 'isbn', true);
}
}
}
To use this class, you just need to instantiate it and call its register() method in your functions.php file, or in whatever bootstrap file you're using to initialize your theme logic:
How to create a modern WordPress development setup
Shifting to object-oriented development means rethinking not just how you write code, but how you structure and manage your projects. Fortunately, the WordPress ecosystem now supports a modern PHP workflow, with tools that make your life easier and your codebase more organized.
Composer & autoloading
Composer is the de facto standard for managing PHP dependencies, and it works well with WordPress themes and plugins. You can use it to install libraries like Carbon, Symfony components, or even WordPress core itself in certain setups. Composer also enables PSR-4 autoloading, which means you no longer have to manually require every class file in your project.
In your theme or plugin's composer.json, you can define an autoload section like this:
"autoload":{
"psr-4":{
"MyTheme\\": "src/"
}
}
After running composer dump-autoload, any class inside of the src/ directory that uses the MyTheme namespace becomes available automatically.
Namespacing for structure & safety
Namespaces help prevent function and class name collisions, which is especially valuable when building large themes or maintaining multiple custom plugins. Instead of naming a class BookPostType, you can namespace it as MyTheme\PostTypes\BookPostType, ensuring it doesn't clash with other code in the ecosystem.
For example:
<?php
/** src/PostTypes/BookPostType.php */
namespaceMyTheme\PostTypes;
class BookPostType {
/** ... */ }
Then in your bootstrap file:
<?php
use MyTheme\PostTypes\BookPostType;
$bookPostType = new BookPostType();
$bookPostType->register();
/** or simply... */
(newBookPostType())->register();
This approach brings clarity and structure to your theme, and it pairs perfectly with Composer’s autoloading. Once your top-level namespace is mapped to the correct folder in composer.json, Composer takes care of the rest.
How to apply OOP principles in your theme
With Composer and autoloading set up, you're ready to start structuring your theme in a more object-oriented way. That starts with organizing your code by what it actually does.
Organize by responsibility
Instead of cramming everything into your functions.php, you'll group related logic into dedicated classes for things like:
Menus, settings pages, shortcodes, AJAX handlers, and more
Each class should encapsulate everything related to that piece of functionality, from registration to admin customizations to any relevant business logic.
Use class methods for hook callbacks
When registering WordPress hooks, avoid using closures and global functions. Instead, use class methods as callbacks. This keeps your logic localized and easier to test in isolation.
WordPress doesn't care if your callback is procedural or method-based—it just needs a callable. Using class methods avoids cluttering the global namespace and gives you full control over scope.
Keep your bootstrap code-focused
Now that your logic has been organized into classes, your functions.php or theme bootstrap file should have little more to do than load those classes and call their register() or init() methods. Your bootstrap will act as a table of contents for your theme's logic.
use MyTheme\PostTypes\BookPostType;
use MyTheme\Blocks\HeroBlock;
(new BookPostType())->register();
(new HeroBlock())->register();
This pattern is simple, declarative, and easy to extend as your theme grows.
Modern WordPress tooling
Object-oriented code is just one part of modern WordPress development. A growing ecosystem of tools is readily available to help you write cleaner templates, enforce coding standards, and streamline your workflow. These tools aren't required, but once you've used them, it's hard to go back!
Templating engines: Timber or Blade
WordPress's native templating system mixes PHP and HTML freely, which often leads to messy templates overloaded with business logic. Templating engines like Timber (which uses Twig) or Blade (available via frameworks like Sage) offer a more structured alternative.
These templating engines separate logic from presentation. Business logic stays in PHP, while the templates take care of rendering. This helps keep your theme code organized and much easier to maintain.
There's no need to commit to a full rewrite to start using a templating engine. Just try converting a single template or component and see how it feels.
WP-CLI for scripting & automation
WP-CLI is a command-line tool for managing WordPress sites. It lets you perform common tasks like installing plugins, creating posts, managing users, or resetting the database, all without touching the admin interface.
It's especially useful during development for automating repetitive tasks. You can use it to quickly scaffold content, clean up the database, and you can write custom commands to handle theme-specific routines. You can also pair WP-CLI with your system’s scheduler to run recurring tasks such as cleaning up transients or executing custom theme scripts on a consistent, predictable schedule.
If you’re working locally and want a fast, scriptable way to interact with WordPress, WP-CLI is an excellent addition to your workflow.
PHPCS for coding standards
Modern WordPress development also benefits from using tools that enforce consistent style and catch common errors. PHP_CodeSniffer with the WordPress Coding Standards is the standard way to do this. Once configured, you can lint your code automatically, either as you type in your editor or as part of a pre-commit hook.
This is especially helpful when working in teams, but even for solo projects, it keeps your codebase clean and readable over time.
Roots
If you're looking for a ready-to-go development stack to modernize your WordPress development, the Roots ecosystem is worth a look. It brings opinionated Laravel-inspired conventions to WordPress projects, with tools that cover everything from theming to project structure.
Sage is a modern starter theme that uses Blade templating, SCSS and ESBuild out of the box. It also pulls in a number of Laravel components, like Illuminate\Container, Illuminate\Support\Collection, and Illuminate\View, to give you a more structured foundation. If you're coming from Laravel, you'll feel right at home.
Bedrock provides a project-level structure for WordPress with Composer-based dependency management, environment configs, and better security defaults.
Trellis (optional) is a provisioning tool based on Ansible, used to spin up local and remote environments with consistent configurations.
The Roots stack might be a good fit if you’re building custom themes for clients or agencies and want something more robust and maintainable than a traditional WordPress setup.
Better web experiences
At Imarc, we believe that great digital experiences start with thoughtful, maintainable code. By integrating modern programming practices into our WordPress themes, we build sites that are easier to maintain, easier to extend, and more enjoyable to work with over time.
These practices don't just benefit developers. They support long-term scalability, reduce technical debt, and make it easier to evolve and grow your digital presence as your business needs change.
Do you need a development partner to help make your website work for you? Say hello.
