
Symfony 8.2 is expected at the end of November 2026. Drupal 12.0.0 is scheduled for the week of 7 December. The two dates are close, and the Symfony blog is currently publishing a “New in Symfony 8.2” post almost every day.
The catch is that most of those features are about the full-stack Symfony framework (FrameworkBundle, Messenger, Forms, Security, AssetMapper…). Drupal doesn’t use the framework: it uses about fifteen components. Reading the whole series while asking “what does this change for my Drupal site?” wastes a lot of time.
This article sorts it out: the timeline, what actually touches Drupal code, what you can ignore, and what to do now.
The information comes from the Symfony 8.2 upgrade notes (UPGRADE-8.2.md, beta at the time of writing) and from the 11.5.x and 12.0.x branches of Drupal core. Symfony 8.2 isn’t out yet, so some details may still change.
The timeline at a glance
| Version | Released | End of support | Used by |
|---|---|---|---|
| Symfony 7.4 LTS | November 2025 | bugs: November 2028, security: November 2029 | Drupal 11.3, 11.4, 11.5 |
| Symfony 8.1 | May 2026 | January 2027 | Drupal 12.0 (beta) |
| Symfony 8.2 | November 2026 | July 2027 | not Drupal yet |
Two takeaways:
- Drupal 11 runs on Symfony 7.4 LTS and will stay there. The LTS is maintained well beyond Drupal 11’s own support (planned until mid-to-late 2028). For a Drupal 11 site, Symfony 8.2 changes nothing.
- Drupal 12.0 is currently built on Symfony 8.1, which stops being maintained in January 2027, one month after Drupal 12 ships. Moving to 8.2 is a matter of weeks, not years.
Drupal follows Symfony minor releases
This isn’t a guess; it’s what the history of core/composer.json shows:
| Drupal | Symfony required | Pinned by drupal/core-recommended |
|---|---|---|
| 11.0.0 | ^7.1 |
~v7.1.3 |
| 11.1.0 | ^7.2 |
~v7.2.0 |
| 11.2.0 | ^7.3 |
~v7.3.0 |
| 11.3.0 | ^7.4 |
~v7.4.0 |
| 12.0.0-beta1 | ^8.1 |
~v8.1.6 |
Each Drupal 11 minor release adopted the next Symfony minor, up to the 7.4 LTS. Drupal 12 will follow the same path: 8.1, then 8.2, and so on up to the next LTS. Following Symfony’s usual cycle (one release in May, one in November), that will be 8.4, expected at the end of 2027.
What remains open is whether Drupal 12.0.0 ships directly on 8.2 or switches right after. At the time of writing, the 12.0.x branch still pins 8.1. The Drupal core issue queue is the place to watch.
drupal/core vs drupal/core-recommended: the difference matters here
The right-hand column of that table matters. Check what your project requires:
composer show drupal/core-recommended 2>/dev/null && echo "core-recommended" || echo "drupal/core only"
composer why symfony/http-kernel
- With
drupal/core-recommended(whatdrupal/recommended-projectuses), Symfony is pinned to a patch range (~v8.1.6). You’ll move to 8.2 when Drupal core has decided and tested it. That’s the behaviour you want in production. - With
drupal/coreonly, the constraint is^8.1. Acomposer updatethe day after Symfony 8.2 ships will install 8.2 before Drupal core has validated it. On Drupal 11 this can’t happen:^7.4can’t go beyond 7.4, the last release of the 7 branch. On Drupal 12, it’s a real minor version jump.
If a Drupal 12 project of yours depends on drupal/core only, keep this in mind during the December and January updates.
What Drupal actually uses from Symfony
These are the components required by core/composer.json on the 12.0.x branch:
console, dependency-injection, event-dispatcher, filesystem, finder, http-foundation, http-kernel, mailer, mime, process, psr-http-message-bridge, routing, runtime, serializer, validator, yaml (plus a polyfill).
No FrameworkBundle, no Messenger, no Form, no Security, no Translation, no ExpressionLanguage. And even for the components it does use, Drupal often replaces the central piece with its own:
- the container is compiled with Symfony’s
ContainerBuilder, then exported by Drupal’s dumper (OptimizedPhpArrayDumper), not Symfony’s; - Drupal’s normalizers (
NormalizerBase, JSON:API) are Drupal’s own and don’t extendAbstractObjectNormalizer; - routing goes through Drupal’s
UrlGeneratorand router.
That’s what makes it possible to sort the 8.2 changes quickly.
Changes that affect Drupal code
1. Console: exit codes after a signal
With Symfony Console 8.2, a command stopped by a signal no longer exits with 0, but with 128 + the signal number: 130 for SIGINT (Ctrl+C), 143 for SIGTERM.
Drush is built on Symfony Console. In practice, on a Drupal 12 project once it moves to Console 8.2:
- a
drush queue:run, or any other worker started by systemd, supervisord or Kubernetes and stopped cleanly withSIGTERM, will exit with143; - systemd will then mark the service as failed after a
systemctl stop, unless the command handlesSIGTERMitself; - alerts or deployment scripts that check the exit code may fire for nothing.
The systemd fix is simple:
[Service]
ExecStart=/var/www/vendor/bin/drush queue:run my_queue --time-limit=3600
SuccessExitStatus=143
Another, rarer Console 8.2 change: if both app:import and app:import:users exist, app:import users now runs app:import:users instead of passing users as an argument to app:import. If you have custom Drush commands nested that way, test them.
2. Sessions: changing an object read from the session without saving it back
Symfony 8.2 deprecates a very common pattern:
// Before: the object read from the session is changed, set() is never called.
$session = $request->getSession();
$session->get('my_module.cart')->addItem($item);
In Symfony 9.0, objects read from the session will be copies: only what’s passed to set() will be saved. The code above will silently lose its changes.
The form to adopt now:
$session = $request->getSession();
$cart = $session->get('my_module.cart');
$cart->addItem($item);
$session->set('my_module.cart', $cart);
One point that matters for Drupal: Drupal’s session.attribute_bag service is Symfony’s AttributeBag, created without the $debug argument. This deprecation won’t show up in your Drupal logs. You have to look for these patterns yourself, in custom and contrib modules:
grep -rnE "getSession\(\)->get\([^)]*\)->" web/modules/custom
It isn’t urgent for Drupal 12, but it’s exactly the kind of code that breaks quietly the day Drupal moves to Symfony 9.
3. Serializer: only if you denormalize into your own objects
Several Serializer 8.2 changes are about ObjectNormalizer and denormalizing into typed PHP classes:
- denormalizing a JSON object with non-sequential keys into a
list<...>-typed property is deprecated (an exception in 9.0); - collections of union types (
list<CardPayment|BankTransfer>) are now actually denormalized, and an element that matches no member of the union throws instead of being returned as-is; #[SerializedName]now applies to properties like$isActivewith anisActive()accessor.
Drupal’s entity normalizers (REST, JSON:API) aren’t affected. But if you have an integration module that does $serializer->deserialize($json, PartnerDto::class, 'json') to consume an external API, review your DTOs and run your tests. The announced Serializer performance gains (14 to 24% on list normalization) are on that ObjectNormalizer path too, not on Drupal’s entity normalizers: don’t expect a faster JSON:API.
4. Small deprecations worth noting
- Filesystem: passing an empty string as the base path to
Path::isBasePath()is deprecated; pass"/". - DependencyInjection:
AsDecorator::$priorityandAsEventListener::$prioritybecome?int(defaultnull). This only matters for code that reads those attributes through reflection. - DependencyInjection: the
Symfony\Component\EventDispatcher\EventDispatcherInterfaceautowiring alias is deprecated in favour ofSymfony\Contracts\EventDispatcher\EventDispatcherInterface. Drupal declares its own aliases incore.services.yml, so you won’t get the deprecation. Still, for a service that only dispatches, type-hinting theContractsinterface is the right choice.
What you can ignore
These features are headlining the Symfony blog, but they don’t touch a Drupal site:
- Splitting FrameworkBundle into bundles shipped by each component: Drupal doesn’t use FrameworkBundle.
- The
CompiledEventDispatcher: it’s the framework’sevent_dispatcherservice that changes. Drupal’s staysSymfony\Component\EventDispatcher\EventDispatcheron the12.0.xbranch, fed by the classicRegisterListenersPass. Your subscribers don’t change (see Event API). - Container performance gains (debug container dump,
XmlDumper): Drupal uses its own dumper. - Routing changes such as
router.strict_requirements: that’s a framework option. - Messenger (Inbox, signed transports, MongoDB, cross-application messaging): Drupal core doesn’t use Messenger. The only exception is if you use the contrib module Symfony Messenger, which integrates it into Drupal.
- Form, Security, AssetMapper, Translation, ExpressionLanguage: Drupal has its own systems.
Worth watching: the JsonSchema component
One new feature is worth following even if it doesn’t concern you yet: symfony/json-schema. It generates JSON Schema or OpenAPI 3.1 schemas from PHP types and, more interestingly, with generateForParameters(), the input schema of an AI agent tool from a PHP method’s parameters.
That’s exactly what modules exposing Drupal actions to LLMs or MCP servers need to produce. According to the announcement, the component requires PHP 8.2 and works with Symfony 7.4 components, so it could be tried as early as Drupal 11, as long as you check the dependencies it pulls in (TypeInfo, PropertyInfo). Nothing to do today, but it’s the kind of building block Drupal’s AI ecosystem could adopt.
8.2 deprecations are preparing Drupal 13
One simple rule: what’s deprecated in Symfony 8.x is removed in Symfony 9.0, and it’s the next Drupal major after 12 that will move to Symfony 9.
Some of those deprecations are static (a method or class marked @deprecated): PHPStan with phpstan-deprecation-rules, or Upgrade Status, will catch them when the time comes. Others are runtime behaviour changes, like the session or list denormalization: no static analysis tool will see them. Only your tests, and a targeted review, will find them.
What to do now
On a Drupal 11 site:
- nothing to do for Symfony 8.2;
- plan the move to 11.4 at least, ideally 11.5: that’s the prerequisite for upgrading to Drupal 12 (see Drupal 12 alpha1).
On a Drupal 12 project (or one preparing for it):
- check whether you depend on
drupal/core-recommendedor ondrupal/coreonly; - audit Drush workers started by systemd, supervisord or Kubernetes, and add
SuccessExitStatus=143(or the equivalent) where needed; - look for objects changed in the session without
set(); - if you denormalize into DTOs, run your integration tests;
- to test early,
symfony/*8.2.0-BETA1 is available: on a test branch only, withdrupal/coreinstead ofdrupal/core-recommended, runcomposer config minimum-stability betathencomposer update "symfony/*" -W.
To follow what comes next:
- the Symfony 8.2 page for the exact release date;
- the Drupal release schedule for Drupal 12.0.0 and 11.5.0;
- the Drupal core issue queue for the update to Symfony 8.2.
Symfony 8.2 is a non-event for a Drupal 11 site, and a routine update for Drupal 12. But two things deserve ten minutes right now: your workers’ exit codes and the objects you keep in the session. They’re the only ones that can break without warning.
