Applies to Joomla 7.0 (in development) · developers, agencies and anyone deciding how much to invest in Joomla Updated 16 Oct 2026

Joomla 4 was the big rewrite. Joomla 7 looks smaller: no redesign, no new requirements, mostly removals. We think it matters more than it looks, for one reason. It's the release where Joomla stops carrying two ways of doing everything. Here is the technical case, with numbers from the code.

Five years of two systems

Joomla 4.0 (2021) introduced the modern architecture: namespaced classes, a dependency injection container, service providers, an MVC factory, event objects, the Web Asset Manager. To avoid breaking the whole extension ecosystem at once, it kept the old architecture working next to it. Joomla 5 and 6 did the same, through a backward-compatibility plugin per major version.

The cost of that is visible in the Joomla 6.2 source:

  • ≈375 APIs in libraries/src marked "will be removed in 7.0", nearly a third of them in the event system alone;
  • ≈450 old class aliases (JFactory, JText …) maintained in the compat plugin;
  • two plugin systems: event subscribers, and the legacy system that matches method names to events.

The plugin system, as an example

On every request, Joomla loads the enabled plugins and registers their listeners. For a plugin that implements SubscriberInterface, that's one call: the plugin says which events it handles. For a legacy plugin, CMSPlugin::registerListeners() does this:

// libraries/src/Plugin/CMSPlugin.php (Joomla 6.2, shortened)
$reflectedObject = new \ReflectionObject($this);
$methods         = $reflectedObject->getMethods(\ReflectionMethod::IS_PUBLIC);

foreach ($methods as $method) {
    if (!str_starts_with($method->name, 'on')) {
        continue;
    }
    $parameters = $method->getParameters();

    // more than one parameter, or not "EventInterface $event": a legacy listener
    if (\count($parameters) !== 1 /* … or not an event object … */) {
        $this->registerLegacyListener($method->name);   // wraps it in a closure that unpacks the event into arguments
        continue;
    }
    $this->registerListener($method->name);
}

Reflection on every public method of every legacy plugin, on every request, plus a wrapper that converts each event object back into positional arguments when the event fires. On its own it's milliseconds. But look at a real site. On our own site, with Joomla 6.2 and a typical set of commercial extensions, we counted the enabled plugins:

Enabled pluginsSubscriberInterfaceLegacy
Joomla core1320
Third-party6134

Core finished its move years ago. The ecosystem mostly hasn't, because nothing forced it to. Joomla 7 is set to remove the legacy path. That's the forcing function, and it's why the release matters more for extension vendors than for Joomla itself.

What the cleanup buys

Code you can reason about

A class that receives its database, user factory and dispatcher in its constructor or through an …AwareInterface declares what it depends on. A class that calls Factory::getDbo() in the middle of a method doesn't, so you find out at runtime. When the static getters go, every dependency becomes visible in the code, to people and to tools.

Static analysis that works

PHPStan and Psalm can't follow magic properties ($app->input), runtime aliases (JFactory) or method-name event wiring. With those gone, "class not found", "undefined method" and wrong argument types turn up in CI instead of on a customer's site. For extension vendors who test against three Joomla versions, that's the difference between hoping and knowing.

Tests that are possible

You can't unit-test a helper that reaches into globals without building half of Joomla around it. You can test one that gets a mock DatabaseInterface injected. Joomla 7 doesn't add a test framework. It removes the reason most extension code was untestable.

Less to load, less to secure

Fewer compatibility layers mean fewer files on every request and less code to keep secure. The 7.0-dev branch has already deleted the PHPass password handler, a hashing scheme from the Joomla 1.5 era. Old crypto classes have moved out of core into the optional compat plugin, which the update installs disabled.

Why it's also a risk

Major releases that remove things have hurt Joomla before. The 3 → 4 transition left many sites on Joomla 3 for years, because their extensions never moved. Two things make 7 different:

  • Nothing new has to be learned. Every replacement has existed since Joomla 4.x, and code written that way today runs on 5.4, 6 and 7 alike. Joomla 4 asked vendors to rewrite. Joomla 7 asks them to finish.
  • The work is measurable today. Joomla 6's "Log Deprecated API" lists every call that will break, with file and line. A vendor can know the exact size of the job a year before release.

The risk is the same as last time: vendors who leave it until release day, and site owners who find out on upgrade day. The 134 legacy plugins in the table above are a fair measure of how much work is still out there.

What we do about it

  • Every extension we write or maintain implements SubscriberInterface, gets its services injected and logs no deprecations on Joomla 6.
  • We test our own extensions against the 7.0-dev branch monthly. Here's the setup.
  • For client sites, we collect the deprecation log now and fix custom code in normal maintenance. The fixes run on Joomla 6, so nothing waits for 7.0.

If you build on Joomla, Joomla 7 is the release that rewards the work you put into modern code, and the one that ends the grace period for code that wasn't. Either way, it's better to know which side you're on now. Start with the breaking changes list.