The most visible removal: Doctrine annotations. @Route, @ORM\Column, @Assert - gone. Native PHP attributes have been the recommended approach since Symfony 5.2. 7.0 just makes it official.

Attributes everywhere

The migration from annotations to attributes is mostly mechanical: syntax changes from @ to #[], and the class references move from Doctrine annotation classes to PHP attribute classes:

// before
/** @Route('/users', methods={"GET"}) */

// after
#[Route('/users', methods: ['GET'])]

The real win isn’t just the syntax: attributes are validated by the PHP engine, not a docblock parser. IDEs can resolve them without custom plugins. Static analysis tools understand them natively. No more “it fails silently at runtime because of a typo in a comment.”

Workflow with PHP attributes

Workflow event listeners and guards can now be registered via attributes:

#[AsGuard(workflow: 'order', transition: 'ship')]
public function canShip(Event $event): void
{
    if (!$event->getSubject()->isPaymentConfirmed()) {
        $event->setBlocked(true);
    }
}

The workflow profiler, a dedicated panel showing the current marking and available transitions, is a genuinely useful debugging tool if you’re working with complex state machines.

:clock1: DatePoint in the Clock component

DatePoint, the immutable DateTime with strict error handling introduced in 6.4, is now the recommended way to work with dates. Combine it with PHP 8.2’s readonly properties and date value objects in domain code become almost trivially clean:

readonly class Order {
    public function __construct(
        public DatePoint $createdAt,
        public ?DatePoint $shippedAt = null,
    ) {}
}

What 7.0 removes

The full removal list: Doctrine annotations support, the Templating component bridge, ProxyManager bridge, the Monolog bridge for versions below 3.0, and the Sendinblue transport (replaced by Brevo). PHP 8.0 and 8.1 support also ends. 8.2 is the floor now.

Upgrade from 6.4 with all deprecation notices fixed, and 7.0 is smooth. Skip that step and you’re in for a bad time.

Scheduler and AssetMapper graduate

Two components that shipped as experimental in 6.3 are now stable: Scheduler and AssetMapper. Stable means locked APIs, no more @experimental caveats, and they show up properly in the upgrade guide. You can actually rely on them now.

Scheduler gets #[AsCronTask] and #[AsPeriodicTask] for attribute-based task registration, runtime schedule modification with heap recalculation, FailureEvent, and a --date option on schedule:debug. AssetMapper adds CSS file support in importmap, an outdated command, an audit command, and automatic preloading via WebLink.

#[AsCronTask('0 2 * * *')]
class NightlyReportMessage {}

#[AsPeriodicTask(frequency: '1 hour')]
class HourlyCleanupMessage {}

Service wiring gets two new attributes

#[AutowireLocator] and #[AutowireIterator] landed in 6.4 and graduate to stable in 7.0. They replace the verbose XML/YAML tagged service locator config with something you can just put directly in PHP:

class HandlerRegistry
{
    public function __construct(
        #[AutowireLocator('app.handler', indexAttribute: 'key')]
        private ContainerInterface $handlers,
    ) {}
}

#[Target] also gets smarter: when a service has a named autowiring alias like invoice.lock.factory, you can now write #[Target('invoice')] instead of the full alias name. Less noise when the type already tells you what you want.

Messenger gets more precise failure handling

RejectRedeliveredMessageException tells the worker to not retry a message, which is handy when a message arrives twice because of a transport ack timeout and you need exactly-once semantics. messenger:failed:remove --all clears the entire failure transport in one shot, no loop required. Failed retries can also go directly to the failure transport, bypassing the retry queue entirely.

Multiple Redis Sentinel hosts are now supported in the DSN:

redis-sentinel://host1:26379,host2:26379,host3:26379/mymaster

Console gets signal names and command profiling

SignalMap maps signal integers to their POSIX names. When a worker catches SIGTERM, the log now says SIGTERM instead of 15. Small thing, real improvement. ConsoleTerminateEvent is dispatched even when the process exits via signal, which wasn’t the case before 7.0.

Command profiling lands too: pass --profile to bin/console and the collected data goes straight into the Symfony profiler, browsable from the web UI.

Form: small things that add up

ChoiceType gets a duplicate_preferred_choices option. Set it to false and you stop showing the same option twice when preferred choices overlap with the full list. FormEvent::setData() is deprecated for events where the data is already locked at that point in the lifecycle. The self-closing slash on <input> elements is also gone: <input> is a void element in HTML5 and the slash was technically invalid.

Enum support in forms is a nice one: ChoiceType renders backed enums directly, and translatable enums get their labels through the translator without any custom wiring.

HttpFoundation: small but useful

Response::send() gets a $flush parameter. Pass false to buffer the output without flushing to the client, useful when chaining middleware that needs to inspect the response before it leaves the process.

UriSigner moves from HttpKernel to HttpFoundation, where it belongs semantically. Same class name, different namespace.

Cookies get CHIPS support (Cookies Having Independent Partitioned State), the browser mechanism for cross-site cookies in a first-party partition. Only matters if you build embeddable widgets, but good to know it’s there.

Translation: Phrase provider and tree output

Phrase joins Crowdin and Lokalise as a supported translation provider. Configure it in config/packages/translation.yaml and the translation:push / translation:pull commands handle the sync.

translation:pull gets an --as-tree option that writes translation files in nested YAML rather than flat dot-notation keys. Whether that’s actually better depends entirely on your team.

LocaleSwitcher::runWithLocale() now passes the current locale as an argument to the callback, saving you a getLocale() call inside:

$switcher->runWithLocale('fr', function (string $locale) use ($mailer) {
    $mailer->send($this->buildEmail($locale));
});

A few things in Serializer and DomCrawler

The Serializer’s Context attribute can now target specific classes, so a single DTO can behave differently during (de)serialization depending on which class holds the context. TranslatableNormalizer lands for normalizing objects that implement TranslatableInterface: the translator is called during normalization, not before.

Crawler::attr() gains a $default parameter. Instead of null-checking the return value, pass a fallback:

$src = $crawler->attr('src', '/placeholder.png');

assertAnySelectorText() and assertAnySelectorTextContains() join the DomCrawler assertion set. They pass if at least one matching element satisfies the condition, rather than requiring all of them to match.

HttpClient: HAR responses for testing

MockResponse now accepts HAR (HTTP Archive) files. Record real HTTP interactions in your browser or with a proxy, drop the .har file in your test fixtures, and replay them:

$client = new MockHttpClient(HarFileResponseFactory::createFromFile(__DIR__.'/fixtures/api.har'));

Much better than writing response stubs by hand when you’re dealing with a complex API.

JIT

The Just-In-Time compiler was the headline announcement. The reality in production is more nuanced: for typical web apps (database queries, HTTP calls, template rendering) the gains are modest, because those workloads are I/O bound, not compute bound. Where JIT actually shines is CPU-intensive code: image manipulation, data transformation, mathematical computation.

For most web apps, the performance improvement comes from the overall engine work in 8.0, not JIT specifically. Still worth enabling though: it costs nothing on I/O-bound work.

Match expressions

switch has three problems: it uses loose comparison, it falls through by default, and it can’t be used as an expression. match fixes all three:

$result = match($status) {
    'active', 'pending' => 'processing',
    'done'             => 'finished',
    default            => throw new \UnexpectedValueException($status),
};

Strict comparison. No fall-through. Expression that returns a value. Non-exhaustive match throws. After one week with match I stopped writing switch.

Named arguments

array_slice(array: $users, offset: 0, length: 10, preserve_keys: true);

Named arguments let you pass arguments in any order and skip optional ones. The obvious win is readability on functions with multiple boolean flags. The less obvious win: named arguments survive PHP version upgrades even when parameter order changes, because you’re naming what you mean.

Attributes

Out with docblock annotations (the @Route, @ORM\Column style that frameworks have relied on for years), in with first-class PHP syntax:

#[Route('/users', methods: ['GET'])]
#[IsGranted('ROLE_ADMIN')]
public function list(): Response { ... }

Attributes are validated by the engine, not parsed from strings. IDE support just works, no plugin magic needed. For Symfony and Doctrine users, this is the real daily win of PHP 8.0.

Constructor promotion

class User {
    public function __construct(
        public readonly int $id,
        public string $name,
        private ?string $email = null,
    ) {}
}

Properties declared and assigned in one line in the constructor signature. The most immediate refactoring win in 8.0: every data class I’ve touched since upgrading is half the lines it used to be.

Nullsafe operator

$city = $user?->getAddress()?->getCity()?->getName();

null at any point in the chain short-circuits the rest and returns null. The alternative was nested null checks or a chain of early returns. This composes naturally.

Union types

Named arguments make function signatures more explicit at the call site. Union types make them more honest at the declaration site:

function processInput(int|float|string $value): string|int
{
    if (is_string($value)) {
        return strlen($value);
    }
    return (int) round($value);
}

The union int|float|string is a literal OR. The engine enforces it on entry and exit. Before 8.0, “this parameter accepts int or float” lived in a docblock that nothing enforced. There’s also null as a type component: ?string is just syntactic sugar for string|null, both are valid.

One special case: false. PHP has a bunch of built-in functions that return a typed value on success and false on failure. The 8.0 type system accommodates that: array|false, string|false. It’s an honest acknowledgment that the codebase can’t be rewritten overnight.

static return type

static as a return type was possible informally through docblocks, but 8.0 makes it official. The distinction between self and static matters in inheritance:

class Builder {
    protected array $config = [];

    public function set(string $key, mixed $value): static {
        $this->config[$key] = $value;
        return $this;
    }
}

class SpecialBuilder extends Builder {}

$result = (new SpecialBuilder())->set('foo', 'bar');
// $result is SpecialBuilder, not Builder

With self as the return type, that chain would return Builder, breaking fluent interfaces in subclasses. static makes fluent APIs work correctly across inheritance hierarchies without manual overrides.

mixed type

mixed was a docblock convention for years. 8.0 makes it a real type that shows up in signatures:

function debug(mixed $value): void {
    var_dump($value);
}

It accepts everything: null, objects, resources, scalars, arrays. Semantically it’s the same as having no type declaration, but it’s explicit rather than absent. The difference between “this parameter is untyped” and “this parameter intentionally accepts anything.” Worth using when you’re writing a general-purpose utility that would be dishonest with a narrower type.

throw as expression

Before 8.0, throw was a statement. Sounds like a pedantic distinction until you hit the places where you actually want an expression:

// In a ternary:
$value = $input ?? throw new \InvalidArgumentException('input required');

// In an arrow function:
$getId = fn(User $u) => $u->id ?? throw new \RuntimeException('no id');

// In a match arm (which is already an expression):
$status = match($code) {
    200     => 'ok',
    404     => 'not found',
    default => throw new \UnexpectedValueException("unknown code: $code"),
};

The last one is particularly useful: match without a default will throw UnhandledMatchError automatically, but sometimes you want to control the exception type and message.

catch without a variable

Small quality-of-life fix. When you catch an exception but don’t actually use the object, 8.0 lets you omit the variable:

try {
    $result = $cache->get($key);
} catch (CacheMissException) {
    $result = $this->compute($key);
}

Before 8.0, you had to write catch (CacheMissException $e) and then either use $e or live with the IDE warning about an unused variable. Neither was satisfying.

String functions that should have existed years ago

Three functions that every PHP developer has written manually at least once:

str_contains('hello world', 'world');  // true
str_starts_with('hello world', 'hell'); // true
str_ends_with('hello world', 'world'); // true

Before 8.0, the go-to approaches were strpos() !== false, strncmp(), or substr() ===, all of which require stopping to remember the semantics. These new functions are just direct and readable. No regex, no offset arithmetic.

Stable sort

PHP’s sorting functions weren’t stable before 8.0. “Not stable” means elements that compare as equal could end up in any order relative to each other. In practice this caused subtle bugs in UI code that needed consistent ordering, pagination that shifted between loads, and tests that only passed by luck.

8.0 guarantees stability across all sorting functions: sort(), usort(), array_multisort(), and the rest. Equal elements keep their original relative position. This is the behavior most people assumed was already there.

WeakMap

7.4 brought WeakReference for single objects. 8.0 brings WeakMap: a map where both the keys (objects) and their associated data can be garbage collected when no other reference to the key object exists:

class RequestCache {
    private WeakMap $cache;

    public function __construct() {
        $this->cache = new WeakMap();
    }

    public function get(Request $request): Response {
        return $this->cache[$request] ??= $this->compute($request);
    }
}

The moment $request is no longer referenced anywhere else, the entry disappears from the map. No manual cleanup needed. It’s the right pattern for memoization and computed property caches where you don’t want to be the sole reason an object stays alive.

New exception types

ValueError is thrown when a function gets the right type but an invalid value, as opposed to TypeError which fires on wrong types:

array_chunk([], -5); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0

Before 8.0, many of these were warnings that returned false or null. Now they throw. The engine is stricter, which means you catch problems earlier instead of getting weird results somewhere downstream.

get_debug_type() and fdiv()

Two utility functions worth knowing.

get_debug_type() returns a normalized string representation of any value, handy for error messages:

get_debug_type(1);          // "int"
get_debug_type(1.0);        // "float"
get_debug_type(null);       // "null"
get_debug_type(new Foo());  // "Foo" (not "object")
get_debug_type([]);         // "array"

The difference from gettype(): it returns class names for objects and uses normalized names ("int" not "integer"). Exactly what you want when building an exception message that says what you got versus what you expected.

fdiv() performs floating-point division following IEEE 754, meaning division by zero returns INF, -INF, or NAN instead of a warning:

fdiv(10, 0);   // INF
fdiv(-10, 0);  // -INF
fdiv(0, 0);    // NAN

The changes that break things

8.0 also ships a few changes that aren’t features, they’re corrections.

The big one: 0 == "foo" is now false. In PHP 7, comparing an integer to a non-numeric string would cast the string to 0, so 0 == "anything-non-numeric" evaluated to true. That was a persistent source of bugs and security headaches. PHP 8 flips it: the integer gets cast to a string instead:

var_dump(0 == "foo");  // bool(false) in 8.0, bool(true) in 7.x
var_dump(0 == "");     // bool(false) in 8.0, bool(true) in 7.x
var_dump(0 == "0");    // bool(true) in both ("0" is numeric)

If you relied on this intentionally, you already knew it was sketchy. If you didn’t know you relied on it, 8.0 will find those code paths for you.

Several functions that used to return resources now return proper objects: curl_init() returns a CurlHandle, imagecreate() returns a GdImage, xml_parser_create() returns an XMLParser. Code that checks is_resource($curl) will break, because is_resource() returns false for these objects. The fix is to check against false (the return value on failure) rather than checking the type of the success case.

PHP 8.0 is the kind of release where the features reinforce each other. Attributes play well with constructor promotion. Match pairs naturally with union types. The string functions cut noise that was hiding intent. The corrections are occasionally breaking, but they push the language toward consistency it should have had years ago.