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/srcmarked "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 plugins | SubscriberInterface | Legacy |
|---|---|---|
| Joomla core | 132 | 0 |
| Third-party | 6 | 134 |
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-devbranch 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.
Vendor extensions you depend on that aren't moving? We port and modernise Joomla extensions, keep your data, and hand back code that runs on 5.4, 6 and 7.
Custom extension development →
This is the checklist we'll use for Joomla 7 upgrades. It's the same process that worked for 5 → 6 on our own site and client sites, adjusted for what the 7.0-dev branch already shows. Most of it happens months before the upgrade, on Joomla 6. The upgrade day itself should be boring.
Phase 1: on Joomla 6, months before
- Get to the latest 6.x and stay current. Every 6.x release fixes things in a backward-compatible way, and the last 6.x is the version Joomla 7's upgrade is tested from.
- Inventory the extensions, with version, vendor and last release date:
# terminal php cli/joomla.php extension:list --type=component php cli/joomla.php extension:list --type=plugin # core extensions are listed too: System → Manage → Extensions, filtered by author, shows only third-party ones - Ask each vendor about Joomla 7. Write the answers down. "No plan" means "find a replacement", and replacing an extension takes longer than upgrading Joomla.
- Collect the deprecation log on a staging copy: Global Configuration → Logging → Log Deprecated API, then use the site.
administrator/logs/deprecated.phplists every call that Joomla 7 is set to remove, with the file responsible. - Switch the compat plugin's "Classes Aliases" off on staging and click through. Whatever breaks needs fixing before Joomla 7, where the compat plugin starts disabled.
- Fix custom code and the template using the log. The fixes run on Joomla 6 too, so deploy them to live as normal updates, one at a time. See Joomla 7 breaking changes.
- Deal with old password hashes: count the accounts still on MD5/PHPass and decide whether to delete them or to email them a reset link before the upgrade.
Phase 2: when Joomla 7 and your extensions are ready
- Wait for the first bug-fix release (7.0.1 or 7.0.2) unless you have a reason not to. On a business site, "first" has no value of its own.
- Check that every extension has a Joomla 7 release, and update them on Joomla 6 first if the vendor ships versions that run on both.
- Make a fresh staging copy from live, with outgoing mail caught and payment plugins in test mode.
- Back up live, and restore that backup somewhere once. Then you know it works.
Phase 3: the upgrade, on staging first
# terminal – on the staging copy
php cli/joomla.php core:update:check
php cli/joomla.php core:update # latest 6.x first
php cli/joomla.php core:update:channel next # offer the next major version
php cli/joomla.php core:update # → 7.0.x
php cli/joomla.php update:joomla:remove-old-files
php cli/joomla.php maintenance:database # every table must be up to date
php cli/joomla.php cache:clean
Two lessons from the 5 → 6 upgrade apply here as well:
- If the CLI crashes before the update starts, an enabled plugin that uses removed classes is crashing the console application. Disable it for the upgrade and enable it afterwards (with its Joomla 7 version installed).
- "Files updated" is not "upgrade finished". The database maintenance report is. If finalisation fails, run it again with the new code before you test anything.
Phase 4: test like a visitor, then like an editor
| Test | Pass when |
|---|---|
| Every page type (home, category, article, contact, search, login, 404, each component) | renders, no PHP errors in the server log |
| Forms: contact, registration, password reset, any extension forms | submit, and the mail arrives in the catcher |
| Shop / donations / bookings | a full test transaction in sandbox mode |
| Editors' work: create, edit, publish, upload an image, restore a version | works for a normal editor account, not just a Super User |
| Plugins that act on events (SEO, redirects, notifications) | they still do their job; legacy plugins fail silently |
| Scheduled tasks and cron | scheduler:list shows them, and each one ran successfully once |
| URLs | the old sitemap's URLs all return 200 or a deliberate 301 |
| Logs | deprecated.php and the PHP error log are quiet |
The fifth row is the one people skip. A legacy plugin doesn't throw an error on Joomla 7, it just isn't called. Check the result of each plugin (the redirect happens, the email is sent, the meta tag is there), not the absence of errors.
Phase 5: live
- Pick a quiet time. Freeze content edits for the duration.
- Back up live again (files and database).
- Run the same commands as on staging, or deploy the upgraded staging copy with live's configuration values.
- Clear Joomla's cache and the CDN.
- Repeat the visitor tests from phase 4 on live, and watch the PHP error log for an hour.
- Keep the pre-upgrade backup for at least a month.
Leave the compat plugin off
If something fails after the upgrade, enabling Backward Compatibility 7 may bring it back, and that's fine as a stop-gap. Note which extension needed it, and get it fixed or replaced. What it carries is already on the next removal list (parts of it are tagged "removed with 8.0"), so a site that depends on it is deferring the same problem to the next major version.
Want us to run the checklist? We prepare your site on Joomla 6, do the upgrade on staging, test it, and switch live in a quiet window. Fixed price after a free check.
Joomla upgrades →
For people who use Joomla, Joomla 7 will look a lot like Joomla 6. For the code behind a site, it's the version that stops accepting Joomla 3-era shortcuts. This post separates the two, so you can tell whether Joomla 7 is a routine update for your site or a project.
It's based on the Joomla 6.2 source and the 7.0-dev branch as of October 2026 (alpha). Details can still change, but the direction is set.
What stays the same
- Articles, categories, menus, modules, custom fields, tags, workflows, Smart Search, multilingual associations.
- The database: no structural change so far beyond the plugin swap below. Content and users come across as in any update.
- PHP 8.3 as the minimum. If your host runs Joomla 6, it runs Joomla 7.
- The admin (Atum) and Cassiopeia, which keep evolving in minor releases rather than being redesigned.
- Extensions built on Joomla 4+ patterns: namespaced classes, service providers, event subscribers, the Web Asset Manager.
What changes
| Area | Joomla 6 | Joomla 7 |
|---|---|---|
| Compatibility plugin | "Backward Compatibility 6", enabled | "Backward Compatibility 7", installed disabled |
Old J* class names | available if Classes Aliases is on | only if someone enables the compat plugin and its aliases |
Factory::getUser(), getDbo() … | work, deprecated | marked for removal |
| Legacy plugins (method-name events) | work, deprecated | marked for removal: such a plugin stops reacting |
$doc->addScript(), HTMLHelper::stylesheet() | work, deprecated | marked for removal |
| MD5 / PHPass password hashes | accepted, re-hashed on login | PHPass handler removed: those accounts need a reset |
The pattern: Joomla 6 kept old code running and logged it. Joomla 7 stops running it. A site that shows no deprecation warnings on Joomla 6 is in good shape. A site that only works because the compatibility plugin is on will break, quietly in the case of plugins, loudly in the case of missing classes.
Check your own site in 15 minutes
These checks need shell or file access to a copy of the site, not the live one.
1. Is the site leaning on the compat plugin?
System → Plugins → search "compatibility". If Backward Compatibility 6 has "Classes Aliases" switched on, find out which extension needed it: switch it off on the copy and click through the site. Whatever breaks will break on Joomla 7.
2. Does the template use old APIs?
# terminal – in the site root of the copy
grep -rnE "addScript\(|addStyleSheet\(|HTMLHelper::(stylesheet|script)\(|JFactory|JHtml|JText|Factory::get(User|Document|Language|Dbo)\(" \
templates/*/index.php templates/*/html templates/*/*.php
Each hit is a small fix in the template or an override. Templates from vendors that still release updates usually get fixed for you. Templates nobody maintains need a developer.
3. What does Joomla itself report?
Turn on Log Deprecated API (Global Configuration → Logging) on the copy, use the site's main pages and forms, then look at administrator/logs/deprecated.php. Every line names the file responsible, so you can see at a glance whether it's the template, a third-party extension or your own code.
4. Old password hashes?
# terminal – accounts that never logged in since their hash became outdated
mysql -e "SELECT COUNT(*) FROM jos_users WHERE password NOT LIKE '\$2y\$%' AND password NOT LIKE '\$argon2%';" mydb
A handful of old accounts is normal on long-running sites. Decide whether to delete them or to warn them before the upgrade.
What it means by type of site
- Brochure site on core + a maintained template: expect a normal major update, like 5 → 6. Test on staging, update, done.
- Site with a shop, forum, membership or CRM extension: the extension's Joomla 7 release decides your timing. Ask the vendor now. See how this played out for VirtueMart and CiviCRM on Joomla 6.
- Site with custom extensions: budget for code work, and start before Joomla 7 is released. The fixes run on Joomla 6 too, so there's no reason to wait. The developer's side is in Joomla 7 breaking changes.
Timing
There's no release date. Joomla's two-year major cycle points to late 2027, which is also when Joomla 5.4's security support ends. Joomla 6 will keep getting security fixes well after 7.0 is out, as 5.4 does now. So there's no rush to be first on Joomla 7. There is good reason to be ready for it, because being ready is mostly fixing what Joomla 6 already logs.
Want to know where your site stands? We run the checks above on a copy of your site and send you a short report: routine update, or a project, and what it costs.
Joomla upgrades →
The cheapest moment to find out what Joomla 7 breaks in your extension is now, while the changes are still small and land one pull request at a time. This is the setup we use to test extensions against the next major version: a local Joomla built from the 7.0-dev branch, installed from the command line, with the settings that make deprecated code impossible to miss.
Every command below was checked against the branch in October 2026, when it reported version 7.0.0-alpha1-dev.
What you need
| Tool | Version on 7.0-dev | Where it's defined |
|---|---|---|
| PHP | 8.3 or newer (test on 8.4 and 8.5 too) | composer.json → "php": "^8.3.0" |
| Composer | 2.x | |
| Node.js / npm | Node 20+, npm 10.1+ | package.json → engines |
| Database | MySQL 8 or MariaDB 10.4+ (or PostgreSQL) | |
| Git | any |
PHP extensions: the usual Joomla set (gd, intl, mbstring, mysqli or pdo_mysql, zip, xml, sodium), and xdebug if you step through code.
1. Get the branch and build it
# terminal
git ls-remote --heads https://github.com/joomla/joomla-cms.git | grep -E 'refs/heads/[0-9]' # see which -dev branches exist
git clone --branch 7.0-dev --single-branch https://github.com/joomla/joomla-cms.git joomla7-dev
cd joomla7-dev
composer install
npm ci
npm ci takes a few minutes. The repository's install script runs the full asset build (build/build.mjs build) right after the packages are installed, compiling the SCSS and JavaScript into media/. If the admin looks unstyled after installation, this step didn't finish. Run it again and read the error.
To update later, pull, then repeat both installs. The lock files change often on a dev branch:
# terminal
git pull && composer install && npm ci
2. Install Joomla from the command line
The installer has a CLI (installation/joomla.php). Its options are generated from the installation form, so they match the fields of the web installer:
# terminal – inside joomla7-dev, with an empty database "j7dev"
php installation/joomla.php install \
--site-name="Joomla 7 dev" \
--admin-user="Dev Admin" --admin-username=admin --admin-password='a-long-local-password' \
--admin-email=This email address is being protected from spambots. You need JavaScript enabled to view it. \
--db-type=mysqli --db-host=127.0.0.1 --db-user=root --db-pass=root \
--db-name=j7dev --db-prefix=j7_ --db-encryption=0
Run php installation/joomla.php install --help to see every option on your checkout. The CLI install also makes resetting fast. Drop the database, delete configuration.php, run the same command, and you have a clean site in seconds. That's what you want before each test round.
Serve it with whatever you use locally (MAMP, Herd, DDEV, nginx). For a quick look, PHP's built-in server works for the front end and back end:
# terminal
php -S 127.0.0.1:8070 -t .
3. Settings that make problems visible
# terminal – the Joomla CLI can set configuration values directly
php cli/joomla.php config:set error_reporting=maximum
php cli/joomla.php config:set debug=true
php cli/joomla.php config:set log_deprecated=true
- Error reporting "maximum" shows notices and deprecations from PHP itself, not only from Joomla.
- Debug System adds the debug console with queries, timing and the language strings that are missing.
- Log Deprecated API writes every call to a deprecated Joomla API to
administrator/logs/deprecated.php, with file and line. This is the most useful file in the whole exercise.
Then check System → Plugins → "Behaviour – Backward Compatibility 7". On the dev branch it is installed but disabled, and that's how you want to test first. Your extension should run with it off. If it only runs with it on, you know exactly what to fix: J* class names or the moved Filesystem/Input/CLI classes.
4. Install your extension
# terminal – from a built package
php cli/joomla.php extension:install --path=/path/to/pkg_example.zip
# or from a folder (unpacked package)
php cli/joomla.php extension:install --path=/path/to/build/pkg_example
For day-to-day work, symlink your source folders into the dev site after the first install, so edits show up without reinstalling. Joomla follows the symlinks:
# terminal – a module and its language files
ln -sfn ~/code/mod_example/src modules/mod_example/src
ln -sfn ~/code/mod_example/tmpl modules/mod_example/tmpl
ln -sfn ~/code/mod_example/language/en-GB/mod_example.ini language/en-GB/mod_example.ini
5. Test, then read the logs
- Use every view and every task of the extension, front end and back end, as a guest, as a registered user and as an admin.
- Read the logs:
# terminal
grep -v '^#' administrator/logs/deprecated.php | cut -f4- | sort | uniq -c | sort -rn | head -30
tail -n 50 administrator/logs/everything.php 2>/dev/null
tail -n 50 /path/to/php-error.log
Errors you'll typically see on 7.0-dev with older code:
Class "JFactory" not found, or anyJ*class: the compat plugin is off, as it is by default. Use the namespaced class.Class "Joomla\CMS\Filesystem\File" not found: useJoomla\Filesystem\File, which throws exceptions instead of returning false.- A plugin that simply doesn't react: a legacy plugin whose method-name listeners aren't registered. Move it to
SubscriberInterface. TypeErroronJoomla\CMS\Input\Inputtype hints: hintJoomla\Input\Input.
The full list of what's marked for removal, with replacements, is in Joomla 7 breaking changes.
6. Static analysis against the dev branch
Clicking through finds what runs. PHPStan finds the rest, including code paths you never trigger by hand. Point it at your extension and let it read the Joomla 7 checkout for class definitions:
# ~/code/mod_example/phpstan.neon
parameters:
level: 3
paths:
- src
- tmpl
scanDirectories:
- ../joomla7-dev/libraries
- ../joomla7-dev/administrator/components
- ../joomla7-dev/components
- ../joomla7-dev/plugins
bootstrapFiles:
- ../joomla7-dev/includes/defines.php
# terminal
composer require --dev phpstan/phpstan
vendor/bin/phpstan analyse
"Call to an undefined method" and "class not found" here are exactly the Joomla 7 breakages. Running the same config against a Joomla 6 checkout shows which of them are new in 7.
Keep it running
The branch changes weekly. Once a month we pull, rebuild, reinstall from scratch and repeat steps 4–6 for each extension we maintain. It takes an hour, and it means that on release day, "Joomla 7 compatible" is a version bump, not a project.
No time to test your extensions against Joomla 7? We run this setup for you, fix what breaks, and keep your code working on Joomla 5.4, 6 and 7 from one codebase.
Custom extension development →
Most "Joomla 7 breaking changes" lists are guesses. This one is built from two sources you can check yourself. First, the Joomla 6.2 source: Joomla marks every API it plans to remove with a @deprecated … will be removed in 7.0 tag, and libraries/src alone contains about 375 of them. Second, the 7.0-dev branch on GitHub, compared file by file with 6.2 (October 2026, version string 7.0.0-alpha1-dev).
What the 7.0-dev branch has already changed
- The compatibility plugin is renamed and switched off. Backward Compatibility 6 is gone, and Backward Compatibility 7 (
plg_behaviour_compat7) replaces it. It still carries the ≈450J*aliases (JFactory,JText…), off by default, plus the moved Filesystem, Input, CLI, Crypt and Form classes. But the 7.0 update script installs it disabled. Code that only runs on Joomla 6 because the compat plugin is on will stop on Joomla 7 unless someone turns it back on. - PHPass passwords: the PHPass password handler is deleted (more below).
- Moved to the compat plugin:
Cryptand its ciphers, the old Mcrypt AES class, andRadiobasicFieldwith its layout. - PHP: the minimum is still 8.3 on the branch.
Most of the APIs below are still present in the branch at the time of writing: removal happens in steps, and some will move into the compat plugin instead of disappearing. Treat "marked for removal in 7.0" as "don't start a release cycle depending on it". There is no fixed release date. Joomla's two-year major cycle (4.0 in 2021, 5.0 in 2023, 6.0 in 2025) points to late 2027, when Joomla 5.4's security support also ends.
Find them in your own code first
Joomla can tell you exactly which of these your extension uses. On a Joomla 6 test site, turn on Log Deprecated API (Global Configuration → Logging), use every screen of your extension, and read the log:
# terminal – group the log by message, most frequent first
grep -v '^#' administrator/logs/deprecated.php | cut -f4- | sort | uniq -c | sort -rn | head -40
The log only sees code that runs. A grep catches the rest:
# terminal – from your extension's root
grep -rnE "Factory::(getUser|getDbo|getSession|getLanguage|getDocument|getConfig|getCache|getMailer|getDate)\(" --include=*.php .
grep -rnE "::getInstance\(|addIncludePath\(|addModelPath\(|getDbo\(\)|setDbo\(" --include=*.php .
grep -rnE "new CMSObject|extends CMSObject|->getProperties\(\)|->get\('(items|item|state|pagination|form)'" --include=*.php .
grep -rnE "triggerEvent\(|->addScript\(|->addStyleSheet\(|HTMLHelper::(stylesheet|script)\(|HTMLHelper::_\('(behavior|bootstrap\.framework|jquery|formbehavior|sortablelist)" --include=*.php .
grep -rnE "class Plg[A-Z]\w+ extends CMSPlugin|allowLegacyListeners" --include=*.php .
Marked for removal in 7.0 – high impact: found in most older extensions
Static Factory getters
| Removed in 7.0 | Use instead |
|---|---|
Factory::getUser() | $app->getIdentity(), or UserFactoryInterface for another user |
Factory::getDbo(), Factory::$database | DatabaseInterface from the container, or $this->getDatabase() in models and tables |
Factory::getSession(), getLanguage(), getDocument(), getConfig() | $app->getSession(), getLanguage(), getDocument(), getConfig() |
Factory::getCache() | CacheControllerFactoryInterface → createCacheController() |
Factory::getApplication() and Factory::getContainer() stay. They're the two entry points everything else goes through. The details and a migration walkthrough are in Factory getters after Joomla 6.
Legacy plugins
Since Joomla 5.4, CMSPlugin::registerListeners() and the whole mechanism that maps method names to events are deprecated, and $allowLegacyListeners goes with them. In Joomla 7 a plugin must implement SubscriberInterface and receive event objects. A plugin class like PlgContentExample with onContentPrepare($context, &$article, &$params, $page) stops being called. It doesn't throw, which makes it the quietest breaking change on this list. The pattern is in Joomla 6 plugin events explained.
Event classes change too: the positional "legacy arguments order" support is deprecated, and argument setters move from setFoo() to onSetFoo(). That matters if you wrote your own event classes.
MVC: the old way to get models, tables and controllers
| Removed in 7.0 | Use instead |
|---|---|
BaseDatabaseModel::getInstance(), BaseModel::addIncludePath(), LegacyModelLoaderTrait | $app->bootComponent('com_x')->getMVCFactory()->createModel('Items', 'Administrator') |
Table::getInstance(), Table::addIncludePath() | $mvcFactory->createTable(…) or new MyTable($db) |
BaseController::getInstance(), addModelPath() | the component's MVC factory |
$model->getDbo() / setDbo(), $table->getDbo(), $this->_db | getDatabase() / setDatabase() |
$view->get('Items') (deprecated in 5.3) | $this->getModel()->getItems() |
$view->document (public property) | $this->getDocument() |
Joomla\CMS\MVC\Model\State | Joomla\Registry\Registry |
$this->get('Items') in views deserves special mention. It's in nearly every component written since Joomla 1.5, including code generators' output, and it was deprecated only in 5.3:
// administrator/components/com_example/src/View/Items/HtmlView.php
public function display($tpl = null): void
{
$model = $this->getModel();
$this->items = $model->getItems(); // was: $this->get('Items')
$this->pagination = $model->getPagination(); // was: $this->get('Pagination')
$this->state = $model->getState(); // was: $this->get('State')
$this->filterForm = $model->getFilterForm(); // was: $this->get('FilterForm')
parent::display($tpl);
}
CMSObject
Joomla\CMS\Object\CMSObject, the base of countless helper and item classes since Joomla 1.5, is removed. Its get(), set(), getProperties() and setError() go with it. Joomla names the replacement: \stdClass for plain data, Registry for key/value data. Your own classes get typed properties and exceptions instead of setError().
Assets added the old way
| Removed in 7.0 | Use instead |
|---|---|
$doc->addScript(), $doc->_scripts, _styleSheets, _script, _style | Web Asset Manager: registerAndUseScript(), addInlineScript() |
HTMLHelper::stylesheet() (deprecated in 5.3) | $wa->registerAndUseStyle() |
HTMLHelper::_('behavior.core' / 'formvalidator' / 'keepalive' / 'multiselect' / 'combobox') | $wa->useScript('core' / 'form.validate' / 'keepalive' / 'multiselect' / 'awesomplete') |
HTMLHelper::_('jquery.framework'), 'bootstrap.framework' | $wa->useScript('jquery'); load Bootstrap components individually |
HTMLHelper::_('formbehavior.chosen'), 'sortablelist.sortable' | choices.js (fancy-select layout); draggablelist.draggable |
Templates and overrides are affected here as much as extensions. Many older templates call $doc->addScript() in index.php.
Marked for removal – medium impact: common in older components
- Application:
$app->getCfg()→$app->get().triggerEvent()→$app->getDispatcher()->dispatch(). StaticgetRouter()andgetInstance()→ the container.$app->input(magic property) →getInput(). - Toolbar:
Toolbar::getInstance()→ToolbarFactoryInterfaceor$this->getDocument()->getToolbar(). Custom buttons implementingfetchButton()→render().addButtonPath()→ namespaced buttons. - Forms and language:
Form::getInstance()→FormFactoryInterface.Language::getInstance()→LanguageFactoryInterface. - Routing:
Route::_()stops failing silently on router errors, and the old integer/-1 forms of the TLS argument go away. - Users:
User::getInstance()→UserFactoryInterface. - CLI:
Joomla\CMS\Input\Cliand the old CLI application → console commands.
Low impact, but check this one: old password hashes
UserHelper::HASH_MD5 and HASH_PHPASS are marked for removal, and the PHPass password handler is already deleted from the 7.0-dev branch. Joomla has re-hashed passwords on login for years, so active users are fine. But accounts migrated from Joomla 1.5/2.5 that haven't logged in since still carry the old hash, and on Joomla 7 they can't log in. They'll need a password reset. Check before the upgrade:
# terminal – accounts still on legacy hashes (bcrypt starts with $2y$, argon2 with $argon2)
mysql -e "SELECT COUNT(*) AS legacy, MAX(lastvisitDate) AS last_login
FROM jos_users
WHERE password NOT LIKE '\$2y\$%' AND password NOT LIKE '\$argon2%';" mydb
Also on the list, rarely used
Table\UcmandCoreContent::storeUcmBase(), part of the old UCM layer (5.4).HtmlDocument::countMenuChildren(): count the active menu item's children yourself.AdministratorApplication::purgeMessages(): use the Messages model.CMSApplication::isTwoFactorAuthenticationRequired(), a leftover of pre-4.2 2FA.Form\Field\RadiobasicField:RadioField(moved to the compat plugin in 7.0, removed in 8.0).Tag::ajaxfield()andBehavior::highlighter(), without replacement.
What doesn't change
If your code already uses namespaced classes, a service provider, the MVC factory, SubscriberInterface, the Web Asset Manager and getDatabase(), almost nothing on this list applies to you. Those patterns have been the recommended way since Joomla 4.0. Joomla 7 removes the bridges, not the road. Code that runs on Joomla 6 with the compat plugin's options switched off and an empty deprecated.php is very likely Joomla 7 ready today.
Want to know how much of this is in your extension? Send us the code or the site. We run the checks above and give you a list of what to change, with a fixed quote to do it.
Custom extension development →
"JFactory is dead" is only half the story. The JFactory name already left Joomla core in 6.0: it now loads only through the Backward Compatibility 6 plugin. The bigger job is what comes next. The static getters on the namespaced Factory class are next: getUser(), getDbo(), getSession(), getLanguage(), getDocument(), getConfig(), getCache() and getMailer() are all marked "will be removed in 7.0". Replacing JFactory::getDbo() with Factory::getDbo() gets you through Joomla 6, and possibly no further.
On the 7.0-dev branch (October 2026, alpha) these getters are still there, and the compat plugin that carries JFactory is now Backward Compatibility 7, installed disabled. Don't plan on either surviving the final release.
This post shows where each of those services comes from in modern Joomla, per extension type, using the patterns core itself uses.
What stays on Factory, and what goes
| Factory method | Status | Replacement |
|---|---|---|
getApplication() | stays | (but prefer the injected application where you have one) |
getContainer() | stays | the DI container |
getDate(), getStream() | stay | (new Date() works just as well) |
getUser() | marked for removal in 7.0 | $app->getIdentity(); other users: UserFactoryInterface::loadUserById() |
getDbo() | marked for removal in 7.0 | DatabaseAwareTrait + injection, or DatabaseInterface from the container |
getSession(), getLanguage(), getDocument(), getConfig() | marked for removal in 7.0 | the same getters on the application |
getCache() | marked for removal in 7.0 | CacheControllerFactoryInterface::createCacheController() |
getMailer() | marked for removal in 7.0 | MailerFactoryInterface::createMailer() |
The rule behind the table: a class should receive its dependencies, not fetch them from a global. Joomla 4 added the container and the "aware" interfaces to make that possible. Joomla 7 is set to remove the shortcuts that let code ignore them.
Modules: the helper factory
A module written the Joomla 3 way has a static helper that calls Factory::getDbo(). The modern module (core's mod_articles_latest is a good reference) registers a helper factory in its service provider. The factory injects the database into any helper that implements DatabaseAwareInterface:
// modules/mod_example/services/provider.php
use Joomla\CMS\Extension\Service\Provider\HelperFactory;
use Joomla\CMS\Extension\Service\Provider\Module;
use Joomla\CMS\Extension\Service\Provider\ModuleDispatcherFactory;
use Joomla\DI\Container;
use Joomla\DI\ServiceProviderInterface;
return new class () implements ServiceProviderInterface {
public function register(Container $container): void
{
$container->registerServiceProvider(new ModuleDispatcherFactory('\\Example\\Module\\Example'));
$container->registerServiceProvider(new HelperFactory('\\Example\\Module\\Example\\Site\\Helper'));
$container->registerServiceProvider(new Module());
}
};
// modules/mod_example/src/Dispatcher/Dispatcher.php
namespace Example\Module\Example\Site\Dispatcher;
use Joomla\CMS\Dispatcher\AbstractModuleDispatcher;
use Joomla\CMS\Helper\HelperFactoryAwareInterface;
use Joomla\CMS\Helper\HelperFactoryAwareTrait;
class Dispatcher extends AbstractModuleDispatcher implements HelperFactoryAwareInterface
{
use HelperFactoryAwareTrait;
protected function getLayoutData(): array
{
$data = parent::getLayoutData();
$data['items'] = $this->getHelperFactory()
->getHelper('ExampleHelper')
->getItems($data['params'], $this->getApplication());
return $data;
}
}
// modules/mod_example/src/Helper/ExampleHelper.php
namespace Example\Module\Example\Site\Helper;
use Joomla\CMS\Application\CMSApplicationInterface;
use Joomla\Database\DatabaseAwareInterface;
use Joomla\Database\DatabaseAwareTrait;
use Joomla\Registry\Registry;
class ExampleHelper implements DatabaseAwareInterface
{
use DatabaseAwareTrait;
public function getItems(Registry $params, CMSApplicationInterface $app): array
{
$db = $this->getDatabase(); // was: Factory::getDbo()
$user = $app->getIdentity(); // was: Factory::getUser()
$query = $db->createQuery()
->select($db->quoteName(['id', 'title']))
->from($db->quoteName('#__example_items'))
->whereIn($db->quoteName('access'), $user->getAuthorisedViewLevels())
->setLimit((int) $params->get('count', 5));
return $db->setQuery($query)->loadObjectList();
}
}
The helper is now a normal object. It can be unit-tested with a mock database, and it no longer depends on global state.
Plugins: inject in the service provider
Plugins get the application from CMSPlugin ($this->getApplication()). Everything else is injected when the plugin is built:
// plugins/system/example/services/provider.php
$container->set(PluginInterface::class, function (Container $container) {
$plugin = new Example(
$container->get(DispatcherInterface::class),
(array) PluginHelper::getPlugin('system', 'example')
);
$plugin->setApplication(Factory::getApplication());
$plugin->setDatabase($container->get(DatabaseInterface::class)); // the plugin uses DatabaseAwareTrait
$plugin->setUserFactory($container->get(UserFactoryInterface::class)); // UserFactoryAwareTrait
return $plugin;
});
// plugins/system/example/src/Extension/Example.php
final class Example extends CMSPlugin implements SubscriberInterface
{
use DatabaseAwareTrait;
use UserFactoryAwareTrait;
public function onUserAfterSave(AfterSaveEvent $event): void
{
$author = $this->getUserFactory()->loadUserById((int) $event->getUser()['id']); // was: Factory::getUser($id)
$lang = $this->getApplication()->getLanguage(); // was: Factory::getLanguage()
// …
}
}
Components: models, views and controllers already have it
Inside a component, most of what you need is already a method call away, because the MVC factory injects it:
| In a… | Old | Modern |
|---|---|---|
| Model | Factory::getDbo(), $this->_db | $this->getDatabase() |
| Model, HTML view | Factory::getUser() | $this->getCurrentUser() (CurrentUserTrait) |
| Controller | Factory::getUser() | $this->app->getIdentity() |
| Controller | Factory::getApplication() | $this->app, injected |
| View | Factory::getDocument(), $this->document | $this->getDocument() |
| View | $this->get('Items') | $this->getModel()->getItems() |
| Anywhere | BaseDatabaseModel::getInstance('Items', 'ExampleModel') | $app->bootComponent('com_example')->getMVCFactory()->createModel('Items', 'Site') |
Templates and layouts: use what you're given
In a template's index.php, $this is the document, so Factory::getDocument() is never needed there. In a layout override, the view is $this. Factory::getApplication() stays in Joomla 7 and is what core's Cassiopeia uses:
// templates/yourtemplate/index.php
$app = Factory::getApplication(); // stays in Joomla 7
$wa = $this->getWebAssetManager(); // was: Factory::getDocument()->getWebAssetManager()
$user = $app->getIdentity(); // was: Factory::getUser()
$lang = $app->getLanguage(); // was: Factory::getLanguage()
When there is no injection point
Some code really has nothing injected: a static callback, a legacy helper you can't restructure yet. Then go through the container, not a removed getter. It's still a global lookup, but it survives Joomla 7, and it is easy to find and refactor later:
use Joomla\CMS\Factory;
use Joomla\CMS\Mail\MailerFactoryInterface;
use Joomla\Database\DatabaseInterface;
$db = Factory::getContainer()->get(DatabaseInterface::class);
$mailer = Factory::getContainer()->get(MailerFactoryInterface::class)->createMailer();
How we migrate an extension
- Log first. On Joomla 6, turn on Log Deprecated API and use every screen.
administrator/logs/deprecated.phpis the to-do list. - Grep for the rest, see the commands in Joomla 7 breaking changes.
- Fix by class, not by line. Make the class "aware" (
DatabaseAwareInterface,UserFactoryAwareInterface,MailerFactoryAwareInterface), inject in the provider or factory, then replace the calls. Replacing calls one by one with container lookups just moves the global around. - Switch off the compat plugin options on the test site and click through again.
- Keep Joomla 5.4 support if your users need it. Everything above exists since Joomla 4.4, so one codebase covers 5.4, 6 and 7.
Extension full of Factory calls? We modernise Joomla extensions to the patterns above, with tests, so the next major version is a version bump and not a rewrite.
Custom extension development →
Joomla 7 is not released and has no release date. It is being built, though, in public, and you can already see what kind of release it will be. This is where it stands, checked against the code rather than announcements, and what we would do now in your place.
Where Joomla 7 stands (October 2026)
| Branch | 7.0-dev in joomla/joomla-cms, next to 6.3-dev for the next 6.x release |
|---|---|
| Version string | 7.0.0-alpha1-dev |
| PHP minimum | 8.3, unchanged from Joomla 6 |
| Compatibility plugin | Backward Compatibility 7 replaces version 6, and the update installs it disabled |
| Already removed | the PHPass password handler; Crypt classes and RadiobasicField moved to the compat plugin |
| Marked for removal | about 375 APIs in libraries/src tagged "will be removed in 7.0" |
| Expected | no official date; the two-year major cycle points to late 2027 |
You can check every line yourself. Clone the branch and grep, or compare it with your Joomla 6 install. We describe the setup in a Joomla 7 dev environment.
What kind of release it is
Joomla 4 was the rewrite: namespaces, DI container, new MVC, Bootstrap 5. Joomla 5 and 6 kept the old ways working next to the new ones, through compatibility plugins. Joomla 7 is the release where that bridge is meant to come down:
- Static shortcuts:
Factory::getUser(),getDbo(),getDocument(),getLanguage(),getSession()and friends, in favour of injected services. - Legacy plugins: method names matched to events. Plugins must implement
SubscriberInterface. - Old MVC entry points:
BaseDatabaseModel::getInstance(),Table::getInstance(), include paths,$view->get('Items'). CMSObject, the base class of much Joomla 1.5–3 era code.- Old asset APIs:
$doc->addScript(),HTMLHelper::stylesheet(), the behavior/jQuery/Bootstrap framework helpers. - Old password hashes (MD5, PHPass) from sites that started on Joomla 1.5 or 2.5.
None of this is new to developers who followed Joomla 4+ practice. Every replacement exists since Joomla 4.x. The details per API are in Joomla 7 breaking changes.
Who is affected
| You have… | Joomla 7 impact |
|---|---|
| A site using only core and well-maintained extensions | low: wait for your vendors' Joomla 7 releases, then upgrade like 5 → 6 |
| Custom extensions written before 2022 | high: most use Factory::get*, legacy plugins and $this->get() in views |
A template with $doc->addScript() or old overrides | medium: the template's index.php and overrides need updating |
| Extensions that only run on Joomla 6 with "Classes Aliases" on | high: the compat plugin is off after the 7.0 update |
| Users from a Joomla 1.5/2.5 site who never logged in since | those accounts will need a password reset |
What to do now
- Turn on "Log Deprecated API" on a Joomla 6 staging copy of each site you maintain, click through, and keep
administrator/logs/deprecated.php. It's a free, exact inventory of what will break. - Try running with the compat plugin off. On Joomla 6 that's "Backward Compatibility 6" → Classes Aliases off. Whatever fails is your Joomla 7 list, today.
- Fix custom code by pattern, not by line: inject the database and user factory, move plugins to
SubscriberInterface, get models from the MVC factory. How we do it. - Ask your vendors. For every commercial extension: is there a Joomla 7 plan, and does the current version log deprecations on Joomla 6? A vendor whose current release is full of deprecated calls in late 2026 is a risk to plan around.
- Don't wait for Joomla 7 to leave Joomla 5. Joomla 5.4's security support ends in late 2027, around when Joomla 7 is expected. Sites that are cleanly on Joomla 6 by then have one step to take, not two.
Following the work
The 7.0-dev branch history and its pull requests are the primary source. Each removal comes with a PR that names the replacement, and the Joomla manual's migration pages follow. We recheck the branch regularly and update our breaking changes list when something moves from "marked" to "removed".
Custom Joomla code you'll need on Joomla 7? We audit it against the 7.0 branch and give you a fixed quote to make it ready, while it still runs on 5.4 and 6.
Custom extension development →
