If you built websites on the LAMP stack between roughly 2005 and 2015, there's a decent chance ExpressionEngine was the tool you reached for when a project actually mattered. Not the quick blog, not the brochure site, the real one, the one where the client had actual content requirements and actual editorial workflows and actually cared how the thing worked once it launched. EE was the CMS for developers who had outgrown everything else and weren't quite ready to write their own.
It was genuinely excellent. It was also, for reasons we're about to explore with great affection, frequently its own worst enemy.
The thing about ExpressionEngine is that it didn't generate release notes. It generated lore. Every long-time EE developer has stories: stories about conferences, stories about licensing, stories about Reactor, stories about CodeIgniter, stories about that one keynote where everyone left with more questions than answers, stories about Dildogate. God help us, Dildogate...
This is the lore. It is told with love.
Why We Cared
Derek Jones (2004–2018)
If Rick Ellis built ExpressionEngine, Derek Jones was often the person the community actually interacted with. As EllisLab's Lead Developer and public technical voice for many years, Derek occupied the unenviable position of standing between a passionate developer community and the realities of product development. He answered questions, explained decisions, gave conference presentations, participated in forum discussions, and became one of the most recognizable figures associated with the platform. That role is harder than it sounds.
Developers wanted roadmaps. Clients wanted certainty. Add-on authors wanted stability. Agencies wanted timelines. The answers were not always available, and Derek frequently found himself delivering news he didn't necessarily control. Despite that, he remained a consistent and generally respected presence throughout some of the platform's most turbulent years.
The affection many longtime EE developers carry for Derek Jones says something important about the community. People rarely remember corporate structures; they remember people. They remember who answered questions, who showed up to conferences, who treated developers with respect when the platform news was not encouraging. For a generation of ExpressionEngine users, Derek Jones was that person.
The Conferences (2009 Onward)
The EECI conferences were where the EE community became a community in the fullest sense, and that matters more than any awkward keynote ever could.
The 2009 event in Leiden was the first major gathering, and the energy of it, developers who had known each other online finally in the same room, sharing approaches and opinions and genuine enthusiasm for a tool they had chosen deliberately, set a standard for what the EE conference experience could be at its best. (From what I've been told; I wasn't able to attend.) The 2011 event is remembered for the gap between the clarity the community was hoping for and what was delivered, and for the announcement that EllisLab was stepping back from active CodeIgniter development, which landed with more abruptness than ceremony. EEConf 2012 in Austin quietly closed the Reactor chapter. These moments are part of the record.
The afterparties, across Amsterdam, Leiden, Brooklyn, Austin, and elsewhere, are remembered with uncomplicated affection. The community that formed around EE was genuinely good company, and the conferences were where that became undeniable. The ratio of memorable conversations to forgettable sessions was excellent. That is the honest summary.
LG Addons and the Utilities Everybody Installed (2006–2015)
No history of ExpressionEngine's ecosystem feels complete without mentioning Leevi Graham and LG Addons.
Before Composer packages, before modern package managers, and before today's expectations around reusable libraries, there were community developers solving practical problems one add-on at a time. Few were as prolific or as widely installed as Leevi Graham. LG Better Workflow LG Variables, LG Cache: if you used ExpressionEngine, you probably had at least one of them installed. Most of us had several.
They weren't flashy. They solved annoyances, filled gaps, and streamlined common development tasks, which is precisely why so many developers depended on them. Leevi's contributions reflected one of ExpressionEngine's genuine strengths: developers weren't waiting for EllisLab to solve every problem. They were building solutions and sharing them with the community, and the result was an ecosystem where practical innovation often happened faster than official releases. Many EE veterans could probably reconstruct portions of their old sites simply by remembering which LG Addons were installed. That's the kind of influence that rarely makes headlines but quietly shapes an entire platform.
The Add-On Economy and Its Discontents (2010s)
The EE add-on ecosystem was one of the platform's genuine strengths and, depending on the conversation, one of its most reliable frustrations. The quality of what developers built was high. The cost of assembling a complete toolkit for a serious project added up in ways that were increasingly hard to justify against a WordPress ecosystem where equivalent functionality was often free.
An agency building a typical client site might need a form builder, a membership system, extended field types, an e-commerce layer, and assorted utilities. Each was a separate commercial purchase, often in the $100–$300 range, licensed per site. The math wasn't impossible; it simply required a level of belief in EE that not every client shared. "EE doesn't have a plugin for that; it has a $99 add-on" was funny because it was accurate.
Solspace became essential infrastructure for serious EE projects. Pixel & Tonic produced some of the most admired add-ons in the ecosystem before eventually creating Craft CMS. Ryan Masuga built devot:ee into the add-on directory developers actually used. Ryan Irelan built EE Insider into the community's primary source of news, education, and tutorials. Ryan Battles contributed articles, conference talks, and practical knowledge that helped countless developers build better sites. The ExpressionEngine community, it turns out, ran substantially on Ryans in those days. Companies like Solspace, Pixel & Tonic, and yeah, me, alongside dozens of independent contributors, spent years building tools, writing tutorials, speaking at events, and helping new developers get started.
The ExpressionEngine community also had, as small technical communities sometimes do, a minor talent for producing people who later became famous for entirely unrelated reasons. Brad Parscale ran an EE agency (Giles-Parscale) and helped organize EE conferences before becoming Donald Trump's digital campaign strategist and one of the more recognizable figures of the 2020 election cycle. In our circles he was simply another well-regarded shop owner who understood the platform and got things done. The broader world eventually formed its own opinions about him through a completely different lens. We had him first, and what he was worth to us at the time was "good agency owner, decent conference organizer, sharp dresser." History added the rest of the context.
ExpressionEngine's success was never solely EllisLab's accomplishment. It was the product of an unusually active and unusually generous community, and that community investment is precisely what made the frustrating parts so frustrating. Nobody gets angry about software they don't care about. Nobody spends years arguing about licensing, roadmaps, communication strategies, or repository moderation unless they're emotionally invested in the outcome. ExpressionEngine developers were invested. Which is why the next part of this story exists at all.
Why We Complained
The Cease-and-Desist Years (Mid-2000s Onward)
EllisLab was protective of its intellectual property throughout its history, sometimes necessarily and sometimes in ways that created friction it didn't need.
The trademark enforcement activity is the chapter that aged least well. EllisLab sent cease-and-desist letters to developers using "EE" or "ExpressionEngine" in product names, and the recipients were, overwhelmingly, people who had spent years building on the platform and actively promoting it. That's the part people remember. The legal position was defensible. The optics were catastrophic. It is difficult to build community goodwill while simultaneously mailing legal warnings to some of the people creating that goodwill, and the community relations cost was real, paid by exactly the wrong people.
Licensing Drama (2006–2013)
ExpressionEngine was commercial software in a market that was rapidly becoming open source, and EllisLab navigated this transition with the confidence of a company that had not quite noticed the tide had turned.
Licenses were per-site rather than per-developer, which meant an agency managing fifty client installations was managing fifty separate licenses with fifty separate renewal timelines and fifty separate maintenance contracts. The terms around what constituted a compliant use case were not always clearly spelled out, producing what developers came to call "EllisLab licensing bingo," a guessing game nobody wanted to play, especially when the client was already asking why this CMS cost more than WordPress. Essentially, EllisLab's licensing model dictated their customer's contract model; and customers fucking hate that with the fury of a thousand suns.
When EllisLab eventually introduced a free core version, it arrived without some of the features that made EE worth using in the first place, including relationships, one of the platform's defining capabilities. The community understood the commercial logic; it did not stop them from feeling like the free tier had been designed to participate in the open-source conversation without actually committing to it. Basically, it was masturbation disguised as community benefit.
None of this made EE worse as software. It made it harder to recommend, harder to sell, harder to onboard. And those problems compound.
EllisLab's Communication Style (Throughout)
If there's a single thread connecting most of the controversies in this essay, it's communication. Rick Ellis built something that mattered to a lot of people, and the sincerity of that deserves acknowledgment. But EllisLab's communication style was a recurring source of community anxiety throughout the platform's commercial life.
The company had a pattern of extended quiet followed by announcements that were either significant without sufficient context, or carefully worded in ways that answered less than they appeared to. Forum questions about roadmap and licensing sometimes received responses; sometimes they received silence. The gap between the community's need for clarity and EllisLab's comfort with providing it was a defining characteristic of the relationship for most of the platform's history.
The running joke was that EllisLab released fewer words than lines of code. The joke persisted because it felt true. And once you understand that dynamic, a lot of what follows starts making more sense.
The Weird Years
EE 2.0 and the Art of the Eternal Beta (2009–2010)
ExpressionEngine 2.0 was a substantial rewrite, moving off the original CodeIgniter base and modernizing a codebase that was beginning to show its age. The ambition was real and the eventual result was an improvement. Getting there, however, required a patience the community supplied in remarkable quantities.
The 2009 EECI conference in Leiden featured another look at EE 2.0 in progress, without a firm ship date. Developers who had been following along since the early previews were into their second year of waiting. "Forever beta" entered the vocabulary, delivered with the affectionate exasperation you reserve for a friend who keeps renovating their kitchen and never quite finishes.
When EE 2.0 finally shipped, the upgrade path from EE 1.x was painful enough that many agencies stayed on the old version longer than planned, which meant running parallel installations, which meant additional maintenance overhead, which meant eventually sitting down and performing the migration out of equal parts determination and alcohol. The community absorbed it. We always did.
MojoMotor and the Side Quest Nobody Asked For (2009–2013)
Every platform eventually develops the urge to build something adjacent to the thing people actually use. For EllisLab, that urge became MojoMotor: a lightweight publishing platform aimed at bloggers and smaller sites that occupied an awkward space between WordPress and ExpressionEngine.
The problem wasn't that MojoMotor was bad. The problem was that nobody could quite figure out why it existed. The community reaction wasn't hostility; hostility requires emotional investment. This was closer to confusion, and specifically the kind of confusion that sets in when you've been staring at an EE wishlist for eighteen months and you watch company resources flow toward a product nobody requested and few people seemed eager to adopt. The collective response was less "this is bad" and more "why is this happening to us?"
MojoMotor eventually became symbolic of a recurring tension within EllisLab: the desire to pursue new opportunities while the community remained focused on the platform they'd already invested in. It was retired by 2013 without much ceremony, which was appropriate given the amount of ceremony it had generated on its way in.
The CodeIgniter Divorce (2011–2014)
For years, ExpressionEngine and CodeIgniter existed in a kind of unofficial partnership. They were separate products, but they shared technical DNA, overlapping communities, and many of the same developers. Then EllisLab announced it was stepping away from active CodeIgniter development.
The reaction wasn't outrage. It was bewilderment. CodeIgniter was one of the most widely used PHP frameworks in the world at the time, and many developers had assumed EllisLab would continue supporting it indefinitely. Instead, the framework's future suddenly felt uncertain. For developers invested in both ecosystems, it felt less like a product announcement and more like hearing that two longtime friends had quietly filed for divorce. CodeIgniter eventually transferred to the British Columbia Institute of Technology in 2014, which proved a thoughtful stewardship arrangement, but the path there was more abrupt than the community had expected.
The Reactor Program (2011–2012)
EllisLab announced the Reactor program as a structured way for community developers to help shape ExpressionEngine's future. The pitch landed well; the community was exactly the kind of community that wanted to be involved.
The execution proved more complicated. Reactor members had more visibility than the broader community but less influence over roadmap decisions than many had expected or was promised. Communication between the Reactor group and the rest of the community generated more speculation than clarity. By 2012 the program was quietly winding down, and its retirement was mentioned at EEConf in Austin with approximately the same level of ceremony normally reserved for reminding attendees where the bathrooms were located.
For a program that had been positioned as a meaningful bridge between EllisLab and the community, the ending felt surprisingly casual. Many Reactor members had invested real time and effort into the initiative. I was, to use the precise technical terminology, fucking pissed.
Dildogate (Early 2010s)
I'm including this one because the community always includes this one, usually after the second drink, usually as an introduction to someone who wasn't around for it.
An add-on submitted to the official repository contained a promotional screenshot with an unmistakable dildo visible in the background. The repository moderators missed it. The internet did not. The add-on was removed. The screenshots lived forever. The phrase "Dildogate" was coined almost immediately and stuck with the gleeful permanence that only truly absurd incidents achieve.
In isolation it was a harmless mistake. In context it became community shorthand for a larger truth: EllisLab's official infrastructure often moved slower than the ecosystem it was supposed to be supporting. Nobody was malicious; things just slipped through. This one happened to slip through in spectacular fashion. The community told the story for years, the way you tell a story about a friend who locked themselves out of their own house: with warmth, because it's funny, and because you've been there too.
The Rebuild
EE 3.0 and the Reboot That Was Complicated (2015)
EE 3.0 was positioned as the fresh start: modern architecture, modern interface, modern direction. The launch broke add-ons. The redesign divided opinion. Long-established workflows suddenly required rethinking. The roadmap was ambitious; the delivery was uneven.
The community's response was the familiar mixture of frustration, adaptation, and eventual acceptance that had characterized most major EE releases. The jokes about waiting for 3.x to fix 3.0 started almost immediately, which was, oddly enough, a sign of health. People don't joke about platforms they've already abandoned. EE developers had a high tolerance for growing pains because they understood, from experience, that the platform on the other side of the friction was worth it.
The Ownership Transition (2018–2019)
In 2018, EllisLab sold ExpressionEngine to Digital Locations, a company whose core business was elsewhere. ExpressionEngine was open-sourced as part of the transition, which the community received with genuine appreciation and only modest commentary about timing.
Digital Locations proved transitional rather than permanent. In 2019, Packet Tide acquired ExpressionEngine, and the platform landed where, in retrospect, it probably belonged all along: with a team that had spent years building on it, building for it, and demonstrating through their work that they understood what made it worth caring about. The community's reaction was warm in the specific way warmth arrives when something you care about finally ends up in good hands.
What the Lore Actually Means
Every story in this piece is a story told by people who stayed. That's the thing worth remembering when you read through the list of missteps and frustrations and missed opportunities.
EllisLab made decisions that were commercially cautious when boldness might have served better. Communication was sometimes opaque when transparency was needed. Licensing and legal choices created friction that the community absorbed, mostly, and occasionally didn't. Those observations are fair, and the people who lived through them are allowed to make them.
What they don't change is the fact that ExpressionEngine attracted and retained a community of developers who were serious, opinionated, talented, and genuinely invested in their craft. The controversies are community folklore because the community was real enough to have folklore. Platforms that people don't care about don't generate lore; they just fade.
ExpressionEngine didn't fade. It changed hands, went open source, landed with people who cared deeply about its future, and continues to be the tool a particular kind of developer reaches for when a project actually matters. The stories we tell about the rough years are the stories of something that survived them, maintained by a community that decided it was worth the trouble.
It was.
It is.
The lore is just proof of that.