The simple and fast micro framework for building reactive web applications with PHP. Supports async and non-blocking execution for maximum performance. Runs anywhere, from shared hosting to your own servers. Get started in minutes and scale to the next level with Framework X!
Big news! We're excited to announce our v0.16.0 release! Framework X on GitHub
Sneak a peek at the code!
Here’s what using Framework X in code looks like.
<?php
require __DIR__ . '/../vendor/autoload.php';
$app = new FrameworkX\App();
$app->get('/', function () {
return React\Http\Message\Response::plaintext(
"Hello wörld!\n"
);
});
$app->get('/users/{name}', function (Psr\Http\Message\ServerRequestInterface $request) {
return React\Http\Message\Response::plaintext(
"Hello " . $request->getAttribute('name') . "!\n"
);
});
$app->run();
But that’s not all! Take a look at our documentation to get a deep understanding of how everything works and how to build most common use-cases.
Framework X combines years of experience from existing real-world projects.
Building web APIs should be simple, lightweight and efficient. That’s what Framework X is all about. No matter if you’re building a RESTful or JSON-based HTTP API or the next big cat rating platform, we’ve got you covered. Framework X doesn’t get in your way, it paves your way.
$app->get('/users', function () {
$users = [['name' => 'Alice'], ['name' => 'Bob']];
return React\Http\Message\Response::json(
$users
);
});
Framework X is super efficient. It’s a micro framework that is optimized for you as human (to build fast) and the computer (to run fast). Because Framework X is so efficient, it makes it much easier to scale.
$ ab -n100000 -c50 -k http://localhost:8080/
…
Concurrency Level: 50
Time taken for tests: 5.508 seconds
Complete requests: 100000
Failed requests: 0
Keep-Alive requests: 100000
Total transferred: 13300000 bytes
HTML transferred: 1300000 bytes
Requests per second: 18155.95 [#/sec] (mean)
Time per request: 2.754 [ms] (mean)
Time per request: 0.055 [ms] (mean, across all concurrent requests)
Transfer rate: 2358.15 [Kbytes/sec] received
Thanks to async programming, Framework X allows you to do multiple things at once. On top of this, its built-in web server also utilizes the async execution model to process multiple incoming connections at once. We support fibers, coroutines, and promises. Your choice!
$app->get('/book/{isbn}', function (Psr\Http\Message\ServerRequestInterface $request) use ($db) {
$isbn = $request->getAttribute('isbn');
$result = await($db->query(
'SELECT title FROM book WHERE isbn = ?',
[$isbn]
));
assert($result instanceof React\MySQL\QueryResult);
$data = $result->resultRows[0]['title'];
return React\Http\Message\Response::plaintext(
$data
);
});
Framework X has built-in support for reactive applications that are responsive, resilient, elastic and message-driven. It enables streaming protocols to transport structured and binary data over HTTP.
EventSource API allows you to receive live updates in real-time as they happen on the server side.
Because it uses standard HTTP requests, it works well on most stacks.
When using the built-in web server, you can utilize efficient, long-lived connections.
WebSocket API allows bidirectional real-time communication of structured live data between client and server.
This is supported thanks to the efficient, event-driven nature of Framework X’s built-in web server.
$app->get('/users', function () use ($redis) {
// stream messages received from Redis PubSub channel
$stream = new React\Stream\ThroughStream();
$redis->on('message', function ($message) use ($stream) {
$stream->write("data: $message\n\n");
});
return new React\Http\Message\Response(
React\Http\Message\Response::STATUS_OK,
[
'Content-Type' => 'text/event-stream'
],
$stream
);
});
Framework X is scalable from the ground up. We provide a simple API that is easy to get started with for the smallest of projects, yet allow to grow to complex, production-ready setups. We're ready for PHP 8.3+, but also support PHP 7.1+ with no extensions required!
$ php -S localhost:8081 examples/index.php
PHP Development Server (http://localhost:8081) started
$ php examples/index.php
Listening on http://127.0.0.1:8080
$ curl http://localhost:8081/
Hello world!
$ curl http://localhost:8080/
Hello world!
Framework X is so much more than yet another framework, it is the way to introduce asynchronous programming to the broader PHP community. We believe it's essential to involve the whole community in all our processes and provide you with the opportunity to bring up your awesome ideas.
Share your question with the community on Twitter or introduce your awesome project you created with Framework X. Just drop in, get in touch and connect with our community on Twitter.
We are where the open-source community is. GitHub discussions and the public issue tracker are a great way to keep track of discussions and follow the project progress and upcoming enhancements.
You need help to include Framework X in your project or want to create a new awesome project? Get professional support for your dev team by clue·engineering, the company behind Framework X.
Get started in seconds
We can start by taking a look at a simple example application.
You can use this example to get started by creating a new public/ directory with an index.php file inside:
<?php
require __DIR__ . '/../vendor/autoload.php';
$app = new FrameworkX\App();
$app->get('/', function () {
return React\Http\Message\Response::plaintext(
"Hello wörld!\n"
);
});
$app->get('/users/{name}', function (Psr\Http\Message\ServerRequestInterface $request) {
return React\Http\Message\Response::plaintext(
"Hello " . $request->getAttribute('name') . "!\n"
);
});
$app->run();
Next, simply install Framework X with a single command:
$ composer require clue/framework-x:^0.16
That's it already! You can now run the above example using any existing web server – or even more impressive: using the built-in web server like this:
$ php public/index.php
And that’s all it takes! X will now listen for incoming requests using its efficient built-in web server. Can’t wait to try it out?
We love open source! ❤️
Framework X is released as open-source under the permissive MIT license. This means it is free as in free speech and as in free beer.
We believe in open source and made a conscious decision to take this path. Being open-source means we can foster a community to focus on building the best possible framework together. Framework X builds on top of existing open-source projects and we want to give back to this community of awesome engineers and developers. Being open to outside contributions means we can guarantee interoperability with a vivid ecosystem and ensure the longevity of the project.
I love open-source! ❤️ Open-source software ensures we can overcome market constraints and build software systems based on trust and mutual cooperations instead.
Here are some numbers!
What you can expect
We ensure a long maintenance of the project with regular updates. This is an elementary part of our philosophy and is accompanied by our high quality standards for our projects.
We speak plainly, nothing happens behind closed doors. Framework X creates a high level of transparency about the current project status and its progress.
We use Framework X ourselves on a daily basis. Our firsthand experience ensures we have an interest in making sure everything works smoothly.
We are software engineers at heart. Framework X is not only a hobby project, it is our biggest project to solve problems and perhaps have a lasting impact on the larger PHP ecosystem.
We provide ways to allow users of Framework X to easily exchange information and ideas with each other. We offer a discussion and chat platform to provide direct community support.
Framework X is released under the permissive MIT license. You can have an impact on the further development of Framework X at any time. Join in, tell us about your ideas and leave your fingerprint.
Let’s get in touch!
We are always interested in mutual cooperations that generate win-win situations for both sides. Think we have a match? Just approach us!