Green started as a small experiment. 🌱
I didn't have a big roadmap.
I just wanted to build a PHP framework myself and understand more of what happens underneath the frameworks I use every day.
The first version was simple. I wasn't trying to build something that could compete with existing frameworks. I was mainly interested in the process of building one.
Some parts were there from the beginning. Others came later. But almost everything has evolved and improved along the way.
From the Basics
Routing and database access were part of Green from the early versions.
Then the framework started growing around them.
- Middleware
- Authentication
- APIs
- Sessions
- Caching
- Testing
- Localization
- Validation
- Service Providers
- Exception Handling
- Relations & Pagination
- Admin Features
And many other smaller pieces.
But adding features wasn't the only part of the journey.
A big part of it was going back to things I had already built and asking:
- Can this be simpler?
- Does this belong here?
- Is this really the responsibility of this class?
Refactoring Became Part of the Process
One example is the router.
At some point, the router was doing too much.
Instead of continuing to add more code to it, I split its responsibilities into smaller components such as:
RouteRegistrarRouteRegistryRouteMatcherMatchedRouteDispatcherRouteInvoker
FastRoute is still used underneath, but the routing API belongs to Green.
That kind of refactoring happened in other parts of the framework too.
The goal wasn't to make Green bigger.
It was to make it easier to understand and maintain.
From v1 to v2
The early versions were mostly about getting the foundation working.
As Green moved toward v2, more attention went into the architecture and developer experience.
Some of the things that evolved along the way:
- Service Providers became a native part of the framework
- Database and relation handling evolved
- Exception handling became more consistent
- Routing became more structured
- Testing increased
- Session handling became safer
- Session IDs are regenerated after login
- Sessions can be invalidated where needed
They came from actually working on the framework and finding things that needed to change.
22 Releases Later
Today, Green has 22 releases since April 2026.
That's roughly one release every week.
The number itself isn't the most important thing for me.
What I like about looking back at the releases is seeing how much changed between the first version and the current one.
A small experiment turned into a framework with its own structure, conventions, and ideas.
Getting Started
Starting a new Green project is straightforward.
composer create-project yasser-elgammal/green my-app
You can also check the source code and documentation on GitHub:
Green Framework on GitHub
Using Green in a Real Environment
One of the best parts of this journey was getting the chance to use Green in a real production environment.
Using Green in a real application gave me a different perspective.
Some things that looked good while building them needed to be simplified.
Some assumptions had to be reconsidered.
And some parts became much more valuable when they were actually used.
That's probably one of the biggest differences between building something as an experiment and building something that has to work for a real application.
Still Building
Green is far from finished.
There are still things I want to improve, features I want to build, and architectural decisions I want to revisit.
But looking back from v1 to the current release, I'm happy with how far the project has come.
It started as a small experiment.
Now it's a framework I'm continuing to build, use, and learn from.
Still building. 🌱
