Slim is a PHP micro framework that helps you quickly write simple yet powerful web applications and APIs.

Overview

Slim Framework

Build Status Coverage Status Total Downloads License

Slim is a PHP micro-framework that helps you quickly write simple yet powerful web applications and APIs.

Installation

It's recommended that you use Composer to install Slim.

$ composer require slim/slim:^4.0

This will install Slim and all required dependencies. Slim requires PHP 7.2 or newer.

Choose a PSR-7 Implementation & ServerRequest Creator

Before you can get up and running with Slim you will need to choose a PSR-7 implementation that best fits your application. A few notable ones:

Slim-Http Decorators

Slim-Http is a set of decorators for any PSR-7 implementation that we recommend is used with Slim Framework. To install the Slim-Http library simply run the following command:

composer require slim/http

The ServerRequest and Response object decorators are automatically detected and applied by the internal factories. If you have installed Slim-Http and wish to turn off automatic object decoration then you can use the following statements:

<?php

use Slim\Factory\AppFactory;
use Slim\Factory\ServerRequestCreatorFactory;

AppFactory::setSlimHttpDecoratorsAutomaticDetection(false);
ServerRequestCreatorFactory::setSlimHttpDecoratorsAutomaticDetection(false);

$app = AppFactory::create();

// ...

Hello World using AppFactory with PSR-7 auto-detection

In order for auto-detection to work and enable you to use AppFactory::create() and App::run() without having to manually create a ServerRequest you need to install one of the following implementations:

Then create file public/index.php.

<?php
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/../vendor/autoload.php';

// Instantiate App
$app = AppFactory::create();

// Add error middleware
$app->addErrorMiddleware(true, true, true);

// Add routes
$app->get('/', function (Request $request, Response $response) {
    $response->getBody()->write('<a href="/hello/world">Try /hello/world</a>');
    return $response;
});

$app->get('/hello/{name}', function (Request $request, Response $response, $args) {
    $name = $args['name'];
    $response->getBody()->write("Hello, $name");
    return $response;
});

$app->run();

You may quickly test this using the built-in PHP server:

$ php -S localhost:8000 -t public

Going to http://localhost:8000/hello/world will now display "Hello, world".

For more information on how to configure your web server, see the Documentation.

Tests

To execute the test suite, you'll need to install all development dependencies.

$ git clone https://github.com/slimphp/Slim
$ composer install
$ composer test

Contributing

Please see CONTRIBUTING for details.

Learn More

Learn more at these links:

Security

If you discover security related issues, please email [email protected] instead of using the issue tracker.

For enterprise

Available as part of the Tidelift Subscription.

The maintainers of Slim and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Contributors

Code Contributors

This project exists thanks to all the people who contribute. Contribute.

Financial Contributors

Become a financial contributor and help us sustain our community. Contribute

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. Contribute

License

The Slim Framework is licensed under the MIT license. See License File for more information.

Comments
  • Slim 4 Release Feedback

    Slim 4 Release Feedback

    Slim 4 Release See the full release notes.

    Before doing anything read the docs I just finished the first draft of the docs for Slim 4 which are available here. I need feedback please: https://www.slimframework.com/docs/v4

    Download the 4.0.0 release composer require slim/slim:^4.0

    Install a PSR-7 Implementation You will also need to install a PSR-7 implementation and ServerRequestCreator combo. You can use Slim's PSR-7 Implementation or choose one of the ones described on the 4.x branch README: https://github.com/slimphp/Slim/blob/4.x/README.md composer require slim/psr7

    You can also use the Slim 4 DDD API Skeleton to create a new project composer create-project slim/slim-skeleton [my-app-name]

    If you have any questions don't hesitate to ping me on Slack or ask questions in this thread directly, I'm available to help!

    Slim 4 
    opened by l0gicgate 83
  • SLIM FRAMEWORK! Working fine in Localhost, but not in web hosting.

    SLIM FRAMEWORK! Working fine in Localhost, but not in web hosting.

    I was half way on my project. And I tried to put it on live hosting. And now, I encountered a problem that when I use my login page, and submit the form.. It didn`t redirect to any page, instead it returned me the same routing page with a blank content/page.

    I have a scenaro.. error

    opened by konskript 62
  • PHP Object Injection Vulnerability in SessionCookie.php

    PHP Object Injection Vulnerability in SessionCookie.php

    https://github.com/slimphp/Slim/blob/master/Slim/Middleware/SessionCookie.php#L127

    Generally, it's a bad idea to blindly unserialize() user-controllable input.

    https://www.owasp.org/index.php/PHP_Object_Injection

    EDIT - for people who don't want to read the whole thread:

    The SessionCookie class is not used by default, you have to actually write your application to use it. So this means that the unserialize() -> RCE possibility is only for the select few apps that explicitly use this feature. The default is the native session driver, which is of course not vulnerable.

    opened by sarciszewski 62
  • Routing is incompatible with embedded PHP server and default nginx settings

    Routing is incompatible with embedded PHP server and default nginx settings

    The default Nginx value of SCRIPT_NAME parameter sent to PHP-FPM is: fastcgi_param SCRIPT_NAME $fastcgi_script_name; https://github.com/nginx/nginx/blob/master/conf/fastcgi_params#L7

    The default value of $fastcgi_script_name is a request URI. http://nginx.org/en/docs/http/ngx_http_fastcgi_module.html#variables

    In the same time Slim sets the BasePath setting to $_SERVER['SCRIPT_NAME'] here: https://github.com/slimphp/Slim/blob/3.x/Slim/Http/Uri.php#L209

    A router substracts the basepath from the URL https://github.com/slimphp/Slim/blob/3.x/Slim/Http/Uri.php#L216 The router receives "/" as the URI for any request, and so it misses all routes except of "/".

    discussion Slim 3 
    opened by grikdotnet 54
  • Slim 4 and PHP versions

    Slim 4 and PHP versions

    More of a question than an issue, but what versions of PHP are to be supported by Slim 4? Has dropping PHP 5 support in the new major version been considered?

    Slim 4 
    opened by Sam-Burns 53
  • Slim 4 Alpha Release Feedback

    Slim 4 Alpha Release Feedback

    Slim 4 Alpha Release See the full release notes

    Before doing anything read the docs I just finished the first draft of the docs for Slim 4 which are available here. I need feedback please: http://dev.slimframework.com/docs/v4

    Download an test the 4.0.0-alpha release You may also play around with the 4.x branch and create a simple app with it to test things out. composer require slim/slim:4.0.0-alpha

    Install a PSR-7 Implementation You will also need to install a PSR-7 implementation and ServerRequestCreator combo. You can use Slim's PSR-7 Implementation or choose one of the ones described on the 4.x branch README: https://github.com/slimphp/Slim/blob/4.x/README.md composer require slim/psr7:dev-master

    Slim 4 DDD API Skeleton Prototype I also just created a Slim4 Skeleton with a DDD style directory structure with example files and test coverage for everything. I'm not sure if it's the right fit yet as it may be a bit too opinionated but I'd love some feedback:

    git clone https://github.com/l0gicgate/Slim-Skeleton
    git checkout 4.x
    

    If you have any questions don't hesitate to ping me on Slack or ask questions in this thread directly, I'm available to help!

    discussion Slim 4 
    opened by l0gicgate 50
  • Slim instance as parameter in controller constructor

    Slim instance as parameter in controller constructor

    This PR addresses issue #748 by passing the \Slim\Slim application object to the controller constructor.

    Just add something like the following to your controller class and \Slim\Slim object will be available within your controllers.

    /**
     * Constructor
     * @param \Slim\Slim $application The Slim application
     */
    public function __construct(\Slim\Slim $application)
    {
        $this->app = $application;
    }
    
    opened by ciaranmaher 44
  • Should Slim 4's middleware be LIFO or FIFO?

    Should Slim 4's middleware be LIFO or FIFO?

    Slim 3 currently uses a Last In, First Out (LIFO) model for middleware.

    That is:

    $app->add('middleware3');
    $app->add('middleware2');
    $app->add('middleware1');
    

    will execute the middleware in the order:

    1. middleware1
    2. middleware2
    3. middleware3

    This works if you imagine middleware as layers of an onion and adding a new middleware adds a new layer to the outside of the onion.

    An alternative, would be to use First In, First Out (FIFO) model.

    This is, the same PHP code would execute the middleware in this order:

    1. middleware3
    2. middleware2
    3. middleware1

    This works if you imagine middleware as a pipleline going from top to bottom where the first one you add is the first one that's executed, then the second one added is executed, etc.

    Should Slim 4 change to the FIFO model?

    discussion question Slim 4 
    opened by akrabat 43
  • Slim 4.0 Road Map

    Slim 4.0 Road Map

    Here are some intiial thoughts:

    • [BC break] Extract Slim\Http into separate PSR-7 component (ONLY PSR-7 methods)
    • [BC break] Create custom decorator classes to hold Slim-specific additions to PSR-7
    • Accommodate additional media type parsers in request
    • Address issues reported by Phan
    • Improve test coverage

    Additional ideas:

    • [BC break] Remove Request, Response and Env from container (@akrabat)
    • [BC break] Don't set content-length by default. Provide a middleware for people to use if they want to. (@akrabat)
    • Make it faster (or at least don't slow it down!) (@Cyrille37)
    • [BC break] Removing Method-Override and providing a middleware (@geggleto)
    • [BC break] Decide if we need subRequest at all (@codeguy/@silentworks/@geggleto)
    • Lazy resolve route middlewares (#1635) We already do this with route callable(only resolve the matched one). (@mathmarques)
    • Look at __invoke and run on App and see if we can consolidate functionality and make them easier to unit test. (@geggleto)
    • [BC break] Consolidate error handlers for exceptions and PHP 7 errors (@akrabat)
    • Can we avoid statics in Slim\Http? See #1850 (@Raistlfiren)
    • [BC break] Look at pathFor()'s parameters? see #1800 (@akrabat)
    • [BC break] Do something about basePath from Request. Maybe middleware solution instead? (@akrabat)
    • [BC break] Remove determineRouteBeforeDispatch and make routing a middleware that can be placed where you want it to be. If you don't add it yourself, we would add it immediately before dispatch. (@akrabat)
    • Use getallheaders() to get the Authorisation header. (irc channel)
    • Move documentation into main repo and publish to website on each new release. That way we can insist on documentation with the PR.
    • [BC break] Either rename Slim\Exception\SlimException or remove it.

    Please add additional thoughts below.

    discussion Slim 4 
    opened by codeguy 43
  • 4.x Error Handling

    4.x Error Handling

    Description As discussed on issue #2170 I feel that the error handling has always been a bit clunky and very tightly coupled to the rendering of the error. This PR eliminates all native error handlers and replaces it with ErrorHandler which handles all errors. You can create a handler for any exception in these ways:

    /*
     * Via Shortcut Method
     * Notice that the callable also gets passed $displayErrorDetails optionally from the App settings
     * You can either pass a callback or a resolvable callable as the second parameter
     * My implementation uses CallableResolver when 
     */
    $handler = function ($req, $res, $exception, $displayErrorDetails) {
        return $response;
    };
    $app->setErrorHandler(\Your\Namespaced\Exception::class, $handler);
    
    /*
     * Via Named Shortcut Methods Currently NotFound and NotAllowed only
     */
    $app->setNotFoundHandler(function ($request, $response, $exception) {
        return $response;
    });
    
    /*
     * Via App Settings
     */
    $app = new \Slim\App([
         /*
          * The default error handler can be set using this variable
          * or the $app->setDefaultErrorHandler() method
          * All exceptions are caught by this handler by default which is an instance of ErrorHandler
          */
        'defaultErrorHandler' => function ($req, $res, $exception, $displayErrorDetails) {
           return $res->withJson(['Oops...']);
        },
    
         /*
          * You can also set multiple error handlers via the settings object
          * by passing an associative array with 'Namespace\Exception' => function () {}
          * You can also pass a resolvable callable since this PR implements CallableResolver
          */
        'errorHandlers' => [
           \Slim\Exceptions\HttpNotFoundException::class => function (...) {...},
           \Your\Namespaced\Exception::class => ResolvableCallable::class
        ]
    ]);
    

    Error Handling/Rendering The rendering is finally decoupled from the handling. Everything still works the way it previously did. It will still detect the content-type and render things appropriately with the help of ErrorRenderers. The core ErrorHandler extends the AbstractErrorHandler class which has been completely refactored. By default it will call the appropriate ErrorRenderer for the supported content types. Someone can now provide their custom error renderer by extending the AbstractErrorHandler class and overloading the protected renderer variable from the parent.

    class MyCustomErrorRenderer extends \Slim\Handlers\AbstractErrorRenderer
    {
        public function render()
        {
            return 'My awesome format';
        }
    }
    
    class MyCustomErrorHandler extends \Slim\Handlers\AbstractErrorHandler
    {
        protected $renderer = MyCustomErrorRenderer::class;
    }
    

    HTTP Exceptions I just think it makes sense to throw HTTP based exceptions within the application. These exceptions works with nicely with the proposed native renderers. They can each have a description and title attribute as well to provide a bit more insight when the native HTML renderer is invoked.

    The base class HttpException extends Exception and comes with the following sub classes :

    • HttpBadGatewayException
    • HttpBadRequestException
    • HttpForbiddenException
    • HttpInternalServerErrorException
    • HttpNotAllowedException
    • HttpNotFoundException
    • HttpNotImplementedException
    • HttpUnauthorizedException

    The developer can extend the HttpException class if they need any other response codes that we decide not to provide with the base repository. Example if you wanted a 504 gateway timeout exception that behaves like the native ones you would do the following: I

    class HttpForbiddenException extends HttpException
    {
        protected $code = 504;
        protected $message = 'Gateway Timeout.';
        protected $title = '504 Gateway Timeout';
        protected $description = 'Timed out before receiving response from the upstream server.';
    }
    

    Status

    • [x] Build Passing
    • [x] Unit Tests (Coverage Increased +2.03%)
    • [ ] Discussion and Code Review.
    Slim 4 
    opened by l0gicgate 40
  • Regression fix for Route Group

    Regression fix for Route Group

    These are the cases covered:

    Single routes:

    | Route URI | Final pattern registered with router | | --- | --- | | '/foo' | /foo | | '/foo/' | /foo/ | | 'foo' | /foo | | '/' | / | | '' | / |

    Route groups:

    | Group 1 | Group 2 (if exists) | Route URI | Final pattern registered with router | | --- | --- | --- | --- | | '/foo' | | '/bar' | /foo/bar | | '/foo' | | '/bar/' | /foo/bar/ | | '/foo' | | '/' | /foo | | '/foo' | | '' | /foo | | '/foo' | '/baz' | '/' | /foo/baz | | '/foo' | '/baz' | '' | /foo/baz | | '/foo' | '/baz' | '/bar' | /foo/baz/bar | | '/foo' | '/baz' | '/bar/' | /foo/baz/bar/ | | '/foo' | '/' | '/bar' | /foo/bar | | '/foo' | '/' | 'bar' | /foo/bar | | '/foo' | '' | '/bar' | /foo/bar | | '/foo' | '' | 'bar' | /foo/bar | | '/' | | '/bar' | /bar | | '/' | | '/bar/' | /bar/ | | '/' | | '/' | / | | '/' | | '' | / | | '/' | '/baz' | '/' | /baz | | '/' | '/baz' | '' | /baz | | '/' | '/baz' | '/bar' | /baz/bar | | '/' | '/baz' | '/bar/' | /baz/bar/ | | '/' | '/' | '/bar' | /bar | | '/' | '/' | 'bar' | /bar | | '/' | '' | '/bar' | /bar | | '/' | '' | 'bar' | /bar | | '' | | '/bar' | /bar | | '' | | '/bar/' | /bar/ | | '' | | '/' | / | | '' | | '' | / | | '' | '/baz' | '/' | /baz | | '' | '/baz' | '' | /baz | | '' | '/baz' | '/bar' | /baz/bar | | '' | '/baz' | '/bar/' | /baz/bar/ | | '' | '/' | '/bar' | /bar | | '' | '/' | 'bar' | /bar | | '' | '' | '/bar' | /bar | | '' | '' | 'bar' | /bar |

    Routes and Route Groups are expected to always start with a slash /.

    Related to #1578

    Feedback welcome @akrabat @designermonkey @geggleto @dopesong

    bug Slim 3 
    opened by silentworks 40
  • phpspec/prophecy is now explicitely needed for tests

    phpspec/prophecy is now explicitely needed for tests

    Bug Report

    Since PHPUnit dropped phpspec/prophecy from its dependencies (https://github.com/sebastianbergmann/phpunit/issues/5033), the following errors are triggered when running the testsuite with latest PHPUnit.

    There were 2 errors:
    
    1) Slim\Tests\Http\RequestTest::testGetRequestTargetWithSlimPsr7Uri
    PHPUnit\Framework\Exception: This test uses TestCase::prophesize(), but phpspec/prophecy is not installed. Please run "composer require --dev phpspec/prophecy".
    
    /tmp/autopkgtest-lxc._6y23c80/downtmp/build.jLX/src/tests/Http/RequestTest.php:458
    /usr/bin/phpunit:73
    
    2) Slim\Tests\Http\RequestTest::testGetRequestTargetWithNonSlimPsr7Uri
    PHPUnit\Framework\Exception: This test uses TestCase::prophesize(), but phpspec/prophecy is not installed. Please run "composer require --dev phpspec/prophecy".
    
    /tmp/autopkgtest-lxc._6y23c80/downtmp/build.jLX/src/tests/Http/RequestTest.php:477
    /usr/bin/phpunit:73
    

    Regards

    David

    opened by DavidPrevot 1
  • Route arguments get decoded twice

    Route arguments get decoded twice

    Hi!

    The arguments get decoded twice, in:

    • \Slim\Routing\RoutingResults::getRouteArguments
    • \Slim\Routing\RouteResolver::computeRoutingResults

    That's a problem if the argument contains a "decodable" combination of characters.

    Let's say I have an article with id 9%65. The route to retrieve it is /articles/{id}.

    If I rawurlencode the article id (i.e. /articles/9%2565), since it gets decoded twice, the argument returned is 9e instead of 9%65.

    In order to get the proper argument, I'd need to rawurlencode the article id twice (i.e. /articles/9%252565)

    Please advise

    opened by assertio-dani 4
  • Variable App not available in routes

    Variable App not available in routes

    I just need some tips on to fix this, i've read a bit of the documentation and downloaded some demos and there is some problem in the routes (i'm just troubleshooting to move to another server and testing on my dev. env.)

    Undefined variable: app in C:\wamp64\www\portal\app\routes.php on line 12

    Routes.php $this->group('/access/{id}', function() use ($app) {

    I manage to make it run using the routes that don't use the app var.

    I have a virtual host set and mod rewrite on Apache (Wampp server)

    Index.php $app = new Slim\App(["settings" => $config]);

    $container = $app->getContainer();

    $container['view'] = new \Slim\Views\PhpRenderer("resources/views/");

    require 'app/routes.php';

    $app->run();

    If i do a var_dump on $app in the routes files, i get the dependecy container.

    object(Slim\App)[3]

    Any tips?

    opened by EzequielGv83 3
  • RequestResponseNamedArgs and Typed Parameters

    RequestResponseNamedArgs and Typed Parameters

    I was in the process of migrating my web application to use the Slim RequestResponseNamedArgs controller invoker in favor of the previous PHP-DI/Invoker-based one I was using, and I had expected that the transition would be a fairly straightforward one, but I'm running into one big issue: if you type a parameter in a controller action, for example as an int, it can never coerce into that value:

    <?
    $app->get('/test', function($request, $response, int $id) {
        // This will fail with RequestResponseNamedArgs
    });
    

    The reason this fails is because, at least per my own research, there's no way to specify that a route parameter should be cast as an integer, even if it only accepts numeric values per its FastRoute config. Because declare(strict_types=1) is set on the RequestResponseNamedArgs class, it won't coerce the always-string values for parameters to fit the typed argument in the action.

    I'm not sure what the elegant solution to this is. You could remove the strict typing from that single class, since any type strictness originates from the calling file and this would allow type coercion...or somehow let FastRoute know that it should be parsing some parameters as integers.

    I'm not even sure that it's something you'd want to fix on the framework side at all, instead choosing to say that every passed parameter will be a string because, well, URLs are strings. That's certainly what my immediate resolution will be, just to re-type all of those action arguments as strings and parse them down the line.

    opened by BusterNeece 4
Releases(3.12.4)
Owner
Slim Framework
Slim is a PHP micro framework that helps you quickly write simple yet powerful web applications and APIs.
Slim Framework
Simple PHP framework that helps you quickly understand and write simple APIs.

Lightweight PHP Framework For Web and APIs PHP framework that helps you write quickly simple but powerful web apps and APIs Installation Use the packa

Youssef Hajjari 24 Jul 22, 2022
Leaf is a PHP framework that helps you create clean, simple but powerful web apps and APIs quickly and easily.

Leaf is a PHP framework that helps you create clean, simple but powerful web apps and APIs quickly and easily. Leaf introduces a cleaner and much simpler structure to the PHP language while maintaining it's flexibility. With a simple structure and a shallow learning curve, it's an excellent way to rapidly build powerful and high performant web apps and APIs.

Leaf Framework 654 Sep 27, 2022
A powerful yet easy-to-use PHP micro-framework designed to help you build dynamic and robust Web applications - fast!

A powerful yet easy-to-use PHP micro-framework designed to help you build dynamic and robust Web applications - fast! Condensed in a single ~65KB file

Bong Cosca 2.6k Sep 25, 2022
A tiny, yet powerful, PHP micro-framework.

Equip Framework A tiny and powerful PHP micro-framework created and maintained by the engineering team at When I Work. Attempts to be PSR-1, PSR-2, PS

Equip 118 Jun 24, 2022
Framework X – the simple and fast micro framework for building reactive web applications that run anywhere.

Framework X Framework X – the simple and fast micro framework for building reactive web applications that run anywhere. Quickstart Documentation Tests

Christian Lück 568 Sep 20, 2022
A curated list of awesome tutorials and other resources for the Slim micro framework

Awesome Slim A curated list of awesome tutorials and other resources for the Slim micro framework Table of Contents Essentials Tutorials Packages and

Sawyer Charles 466 Sep 14, 2022
The Slim PHP micro framework paired with Laravel's Illuminate Database toolkit.

Slim & Eloquent The Slim PHP micro framework paired with Laravel's Illuminate Database toolkit. Getting started # Download composer curl -s https://ge

Kyle Ladd 111 Jul 23, 2022
TrailLamp is a lightweight, easy-to-use Php MVC framework that can be used to build web applications and REST APIs.

TrailLamp Introduction TrailLamp is a lightweight, easy-to-use Php MVC framework that can be used to build web applications and REST APIs. Installatio

Etorojah Okon 14 Jun 10, 2022
Plates Template Integration for Slim micro framework 3

Plates Template Integration for Slim micro framework 3 Render your Slim 3 application views using Plates template engine. Install Via Composer $ compo

Projek XYZ 26 Feb 5, 2022
PhpBoot is an easy and powerful PHP framework for building RESTful/Microservices APIs.

?? tiny & fast PHP framework for building Microservices/RESTful APIs, with useful features: IOC, Hook, ORM, RPC, Swagger, Annotation, Parameters binding, Validation, etc.

tknet 653 Aug 7, 2022
REST APIs using Slim framework. Implemented all CRUD operations on the MySql database

PHP REST API using slim framework and CRUD operations ?? Hi there, this is a simple REST API built using the Slim framework. And this is for the folks

Hanoak 2 Jun 1, 2022
Framework X is a simple and fast micro framework based on PHP

Framework X is a simple and fast micro framework based on PHP. I've created a simple CRUD application to understand how it works. I used twig and I created a custom middleware to handle PUT, DELETE methods.

Mahmut Bayri 5 Aug 13, 2022
FlyCubePHP is an MVC Web Framework developed in PHP and repeating the ideology and principles of building WEB applications, embedded in Ruby on Rails.

FlyCubePHP FlyCubePHP is an MVC Web Framework developed in PHP and repeating the ideology and principles of building WEB applications, embedded in Rub

Anton 1 Dec 21, 2021
Sunhill Framework is a simple, fast, and powerful PHP App Development Framework

Sunhill Framework is a simple, fast, and powerful PHP App Development Framework that enables you to develop more modern applications by using MVC (Model - View - Controller) pattern.

Mehmet Selcuk Batal 2 Aug 6, 2022
Woski is a fast and simple lightweight PHP Framework for building applications in the realm of the web.

Woski is a simple fast PHP framework for the Realm The Project Installation Clone the repository $ composer create-project clintonnzedimma/woski myApp

Clinton Nzedimma 19 Aug 15, 2022
An extensible micro-framework for PHP

What is Flight? Flight is a fast, simple, extensible framework for PHP. Flight enables you to quickly and easily build RESTful web applications. requi

Mike Cao 2.5k Sep 12, 2022
A resource-oriented micro PHP framework

Bullet Bullet is a resource-oriented micro PHP framework built around HTTP URIs. Bullet takes a unique functional-style approach to URL routing by par

Vance Lucas 410 Jul 17, 2022
a micro mvc framework for php

micro-mvc-php a micro mvc framework for php Config your Web url in .env . lifecycle All request proccess by index.php Autoload files include in bootst

Amiranbari 6 Jul 9, 2022