--- title: TYPO3 Major Updates with Composer url: "https://b13.com/core-insights/typo3-major-updates-with-composer" date: 2026-02-07 modified: 2026-02-12 lastUpdated: 2026-02-12 --- # TYPO3 Major Updates with Composer Upgrading TYPO3 to a new major version is one of those tasks that every agency knows well. It’s not a single step—it’s a process. Check extension compatibility, find newer versions, update constraints, resolve conflicts, run the Upgrade Wizard, adapt code with Rector, run your test suite, and verify everything works. Most of these steps are well-documented and well-understood. But there’s one part in that process that has always been surprisingly manual: figuring out which Composer packages need to change, and to what version. We built a small tool to fix that. Why Composer Mode Matters ------------------------- If you’re still running TYPO3 in classic (non-Composer) mode, upgrading is a different kind of pain. You download [ZIP files](https://get.typo3.org/), drag folders into `typo3conf/ext/`, and hope that the versions you picked are compatible with each other. There’s no dependency resolution, no lock file, no reproducible state. [Composer](https://getcomposer.org/) mode changes that fundamentally. Every package—TYPO3 core, every extension, every PHP library—is declared with a version constraint, resolved against a dependency tree, and locked to exact versions in `composer.lock`. This gives you: - Reproducibility: The same “composer.lock” gives you the exact same installation on every machine, every deployment, every time. - Dependency resolution: Composer tells you when things conflict, before you find out in production. - A clear upgrade path: Changing a constraint and running `composer update` is a well-defined operation with a well-defined outcome. It either works or it tells you why it doesn’t. For agencies managing multiple TYPO3 projects, Composer mode isn’t optional—it’s the foundation that makes professional workflows with Continuous Integration + Deployment possible. However, when talking to fellow developers, we all have a hard time to understand what composers‘ output means and to simply answer: Why can’t we “just” update TYPO3? The smooth experience ends if people start to remove the `vendor/` folder, the lock file, or manually change contents in the composer.json file. When upgrading from e.g. TYPO3 12 to 13, the Composer part of the process looks something like this: 1. Open “composer.json” in your favorite editor 2. Change every “TYPO3/cms-\*” constraint from ^12.4 to ^13.4 ­ either manually (don’t do this), or build a complex `composer require` statement for your CLI 3. Run `composer update` 4. Watch it fail because three extensions aren’t compatible yet 5. Go to TER or Packagist, search each extension, find which version supports TYPO3 13 6. Update those constraints too 7. Run `composer update` again 8. Maybe it works. Maybe another extension blocks. Repeat. If you’re unlucky, you’ve now modified the “composer.json” file in a state that doesn’t resolve, and you need to carefully revert. If an extension only has a pre-release version for TYPO3 13, you need to find that too. If some extensions are in `require` and others in `require-dev`, you need to handle them separately. None of this is difficult. But it’s tedious, error-prone, and it’s the same set of steps for every single project. That’s exactly the kind of work that should be automated. And I like automation :). Introducing b13/TYPO3-updater ----------------------------- We built [**b13/TYPO3-updater**](https://packagist.org/packages/b13/typo3-updater) — a Composer plugin that automates the dependency side of TYPO3 major upgrades. It provides two commands and a clear three-step workflow. ### Step 1: Prepare extensions **> composer TYPO3:extensions:update ^13.4** While still running on TYPO3 12, this command checks every installed extension against the target version. It queries Packagist for compatible versions, shows you a compatibility table, and interactively offers to update extensions. This is the safest first move—your core stays untouched, but your extensions are already prepared for what’s coming. ### Step 2: Upgrade core and remaining extensions **> composer TYPO3:core:update ^13.4** This updates all “TYPO3/cms-\*” constraints and also detects any extensions that still aren’t compatible. It finds their latest compatible versions—stable first, falling back to pre-releases if necessary—and resolves everything in a single “composer update -W” call. If the update fails, the composer.json file is automatically reverted to its original state. No manual cleanup needed. ### Step 3: Bring extensions to their latest versions **> composer TYPO3:extensions:update ^13.4** After the core upgrade, running the same command again finds the latest available version of each extension for the now-running TYPO3 version. This ensures you’re not stuck on the minimum compatible version that was needed to make the upgrade work, but running the newest release available. Each step shows you exactly what it will do before making any changes. Add `--dry-run` to any command to only see the output without modifying anything. This Is Just the Composer Part ------------------------------ To be clear: Updating Composer dependencies is necessary, but it’s not sufficient. A TYPO3 major upgrade involves more than changing version numbers. Before you start, **make sure your project is in version control**. Use Git. Commit your current state. Create a branch for the upgrade. This way you can always go back, compare changes, and repeat the process if needed. After the Composer update, you’ll typically need to: - Run the Upgrade Wizard in the TYPO3 Install Tool. It handles database schema changes, data migrations, and configuration updates that come with each major version. - Run Rector to automatically migrate deprecated PHP code. The [ssch/TYPO3-rector](https://packagist.org/packages/ssch/typo3-rector) package provides TYPO3-specific rules that handle most of the mechanical code changes. - Run your test suite. If you have unit tests, run them. If you have acceptance tests or end-to-end tests, now is when they earn their keep. A green test suite after an upgrade is worth more than any checklist. - Test manually. Some things only show up when you click through the site. Check the backend, check the frontend, check your custom functionality. The Composer step is the foundation—it gets you to a state where TYPO3 13 is actually installed and running. Everything else builds on top of that. We Can Help ----------- If your TYPO3 project is still running in classic mode and you want to migrate to Composer, or if you’re planning a major version upgrade and want experienced hands on the wheel — [get in touch](https://b13.com/lets-connect). We’ve done this for projects of all sizes, and we know where the edge cases hide. More Articles by Jochen Roth ---------------------------- [ Jochen Roth 07 February 2026 A new Composer Plugin helps us update our TYPO3 projects—read more on how we do it! ](https://b13.com/core-insights/core-insights/typo3-major-updates-with-composer) ![](https://b13.com/core-insights/_pixel?page=1387)