The first time I attended a PHP meetup, someone handed me a sticker that just said, 'Heat.' Maybe it was the room, maybe it was the new release buzz—but from that point on, I knew the PHP world did things a little differently. Fast-forward to today: with PHP 8.5 out, the community’s still just as fervent, divided, and, dare I say it, oddly charming. In this post, I’ll share what’s genuinely exciting (and occasionally confusing) in PHP 8.5, plus a few not-so-official tales from the trenches.
PHP 8.5 Features I Didn’t See Coming (And Why They Matter)
Static Closures in Attributes: Cleaner, Smarter, and Long Overdue
When I first saw the PHP 8.5 features list, the ability to use static closures in attributes and constant expressions immediately caught my eye. For years, I’ve wanted a way to define logic in attributes without awkward workarounds. Now, with PHP 8.5, you can do this:
#[MyAttribute(static fn() => 'hello')]
It’s cleaner, more expressive, and finally brings PHP attributes up to par with what developers expect from modern languages. Honestly, I’m still wondering why it took so long, but I’m just glad it’s here. This update means less boilerplate and more readable code, especially for frameworks and libraries that rely on attributes for configuration.
Pipe Operator: Slick Syntax, But Not Prime Time (Yet)
The pipe operator (|>) is probably the most debated of all PHP 8.5 new features. It promises a more functional style of programming, letting you chain operations in a clear, readable way. Here’s a quick example:
$result = $data
|> array_filter($$)
|> array_map(fn($x) => $x * 2, $$);
But let’s be real: the current implementation feels a bit half-baked. As I said on launch day,
"The pipe operator combined with the improvements that will be made on it for PHP 8.6 will become good. I don't think the pipe operator is any good at the moment, but it will be very good on the next version of PHP."
The community is split—some love the direction, others want to see more polish. For now, it’s a taste of what’s coming, and I’m excited to see it mature in PHP 8.6.
Clone With Syntax & Array Functions: Less Boilerplate, More Expressive
Two more PHP 8.5 updates that made my daily coding smoother: the new clone with syntax and the introduction of array_first() and array_last(). The clone with lets you copy objects with modifications in a single line, and the new array functions mean no more custom helpers just to grab the first or last element:
$first = array_first($array);
$last = array_last($array);
It’s a small change, but it adds up to cleaner, more readable code.
URI Extension: Out-of-the-Box Parsing, Finally
One of the most practical PHP 8.5 features is the new URI extension. PHP finally gives us a built-in way to parse and manipulate URIs without relying on external libraries or fragile regex. This is a huge win for anyone building APIs or web apps that need to handle URLs reliably.
With the URI extension, parsing, modifying, and validating URLs is now first-class and consistent. It’s one of those features that makes you wonder how we ever lived without it.
- Release date: November 20, 2025
- Key features: Static closures in attributes, pipe operator (partial), array_first(), array_last(), URI extension
- Community quirks: Ongoing debates about the pipe operator’s readiness
The Laravel Divide: Tall Stack, Inertia, and My Weekend Coding Adventure
Within the Laravel community, there’s a clear divide when it comes to building modern web apps: the tall stack (Laravel, Livewire, Alpine.js, Tailwind) for solo and freelance projects, versus Inertia.js and React frontend for company-driven work. As a PHP developer who’s lived both sides, I’ve seen how these choices shape our daily experience and even the culture of our teams.
Lightning-Fast Solo Builds: Why I Love the Tall Stack
Let me confess: when I’m working on my own projects, the tall stack is my go-to. It’s just fast. I can whip up a prototype or even a full product in a fraction of the time it would take with a full-blown SPA setup. Case in point: I built pinky.com, a social media platform, over a single weekend using the tall stack. The speed comes from the tight integration of Laravel, Livewire, and Alpine.js—no context switching, no API headaches, just pure productivity.
"If you are a Laravel developer and you basically already mastered a tall stack, it's probably the best way of making stuff happen, you know."
Many solo devs and freelancers in the Laravel community echo this sentiment. The tall stack feels like the “GOAT” for personal projects—fast, familiar, and incredibly efficient for those who’ve mastered it.
Company Gigs: Inertia.js & React Rule the Roost
But when I step into a company setting, the reality shifts. Most organizations default to Inertia.js with a React frontend. Why? It’s simple: the frontend talent pool is saturated with React developers. If you want to hire or collaborate with skilled frontend engineers, React is the lingua franca. Even if I personally move faster with the tall stack, market realities mean that Inertia and React are often non-negotiable in team environments.
- Hiring ease: React devs are everywhere; Livewire/Alpine experts are rare.
- Team familiarity: Most frontend teams already know React, not Livewire.
- Long-term maintenance: Companies want tech that’s easy to staff and scale.
This split is a recurring theme in the Laravel ecosystem: solo devs gravitate to the tall stack for speed, while companies lean on Inertia and React to tap into the broader frontend market.
Framework Mashups: Filament vs Nova (And Why It Feels Awkward)
Mixing multiple frontend frameworks—say, React with Filament or Nova—can feel like inviting too many DJs to one party. The result? A legacy vibe and added complexity. Each framework brings its own conventions, tooling, and quirks. In my experience, this mashup often slows down development and muddies the PHP developer experience, especially when you’re juggling Livewire, Alpine.js, and React in the same codebase.
Ultimately, the Laravel community is split: the tall stack shines for rapid solo builds, while Inertia.js and React dominate in company settings. The choice isn’t just technical—it’s about speed, hiring, and the realities of modern PHP development.
Beyond Code: Events, Sponsors, And Life in the PHP Lane
If you think being part of the PHP community is just about writing code, think again. The real magic happens beyond the IDE—at events, in group chats, and yes, even during those legendary after-event pub crawls. Take PHP Lisbon for example. On the surface, it looked like a modest gathering, but behind the scenes, we had about 40 passionate developers in the room and over 100 more tuning in live from Twitch, YouTube, Twitter, and TikTok. The energy was palpable, and the conversations—both technical and casual—reminded me why I love this community.
"PHP Portugal for the win. Another event for the books."
Events like PHP Lisbon are more than just talks and workshops. They’re where the PHP community comes alive, where new friendships are forged, and where ideas bounce from laptops to napkins and back again. Even if you couldn’t make it in person, the live streams and recordings meant you were still part of the action. This is the new normal: meetups that blend offline and online, making sure no one is left out, no matter where they code from.
But let’s be real—none of this would be possible without our sponsors. A huge shout-out to JetBrains (the minds behind PHPStorm), Redberry International, Devon AI, Code Rabbit, and Lotas.com. Their support keeps the lights on, the coffee flowing, and the swag bags full. Good tools matter, and so do the people and companies who believe in the PHP ecosystem enough to back it with resources. Whether it’s a license for the best editor in the world or a free t-shirt, these sponsors help make our community gatherings possible and memorable.
Of course, the PHP community isn’t without its quirks. Someone recently asked about the gender ratio at our meetups, and it’s a fair question. The truth is, like much of the tech world, PHP events still skew male. We do our best to encourage gender diversity in tech, but there’s more work to be done. It’s a conversation we need to keep having, and it’s on all of us to make our spaces more welcoming and inclusive. The more perspectives we bring in, the stronger our community becomes.
So, what’s life really like in the PHP lane? It’s a blend of code sprints, late-night debugging, and shared laughter over pizza. It’s the thrill of a new PHP 8.5 release, the camaraderie of a well-run meetup, and the satisfaction of seeing your work help someone else. As we look ahead, let’s keep showing up—online and offline, for each other and for the language we love. The PHP community is more than just code; it’s a place to belong.
Hats off to nunomaduro for the valuable content! Be sure to check it out here: https://www.youtube.com/watch?v=EfIujHUXIwI.