01 PHP 8.5+ · Zero dependencies

Bare by design.

Barephrame is a PHP framework built for fast, dependency-free API development. Compiled routes and its own ORM. Nothing you didn't ask for, nothing hidden underneath.

View on GitHub Read the documentation

0runtime dependencies
3database engines
4iterations of this idea

FIG. 1 — REQUEST LIFECYCLE

01 Request Client hits an endpoint
02 Router Precompiled routes resolve instantly
03 Middleware Auth & validations run first
04 Controller Attributes decoded, method runs
05 Response A typed response object is sent

// philosophy

It shouldn't be required to load thousands of dependencies just to create an API.

That's the whole idea behind Barephrame. The core is small enough to read in an afternoon and simple enough to extend without fighting it — override the parts you need, leave the rest exactly as it is.

02 — Spec sheet

What's in the frame

Four load-bearing decisions the rest of the framework is built around.

Zero dependencies

No package manager required to run the core. What ships is what runs, nothing pulled in behind the scenes.

Its own DB Manager

Connect to Postgres, MySQL, or Firebird through one consistent connection layer.

Fast response times

Routes compile ahead of time via the CLI instead of being resolved fresh on every single request.

Its own ORM

Built specifically for Barephrame, talk to different database engines with a consistent syntax.

03 — Mechanism

Routing lives in attributes

Barephrame reads native PHP attributes to know what an endpoint is, which HTTP method it answers to, and what runs before it. No routing files to keep in sync by hand.

#[Route] required. Marks a method as an endpoint, with optional middleware classes as extra arguments.
#[Method] optional. Defaults to GET when omitted.
#[Version] optional. Prefixes the endpoint with /v{n}.
Dynamic segments a :name in the path is passed to the method, in order, as a typed argument.

Changed a route? Run --compile-routes, or keep --watch running while you build.

App/users/Users.php

// /App/users/Users.php
namespace App\users;

use Barephrame\Attributes\Method;
use Barephrame\Attributes\Route;
use Barephrame\Core\Request\Request;

class Users {

    #[Route('/users')]
    public function ListAllUsers() {}

    #[Method('POST')]
    #[Route('/users')]
    public function CreateUser() {}

    #[Route('/users/:code')]
    public function GetUserData(
        Request $request,
        string $code
    ) {}
}

04 — Documentation

Three sheets, start to finish

The documentation is small on purpose. Here's the short version of each sheet — the full set lives in the repository.

04 Other docs

Routing & Attributes

Every endpoint is a plain method carrying a #[Route] attribute. Nothing is discovered until it's compiled — that's what keeps response times down.

#[Route('/path')] is required; without it, the method is invisible to the router.
#[Method('POST'|'PUT'|'PATCH'|...)] overrides the default of GET.
#[Version(n)] prefixes the route with /v{n}.
A middleware chain can be passed as extra arguments to #[Route]; the controller only runs once every middleware returns a 200.
The Request object is always available as the first parameter, but it's optional to type-hint it.

Read the full Endpoints.md →

Route with middleware

// requires all middlewares to validate correctly before the controller runs
#[Route('/users/:code', JWTMiddleware::class, RoleMiddleware::class)]
#[Version(3)]
public function GetUserData(Request $req, int $code) {}
// resolves to GET /v3/users/:code

Database

Connections run through PDO under a single DatabaseTypes enum, so switching engines never means changing connections.

Supported engines: Postgres, MySQL, and Firebird.
Multiple connections can be open at once, and they don't need to share an engine — a Postgres main connection alongside a MySQL secondary works fine.
Connections::mainConnection() reads straight from the [Database] block in app.ini.
Connections::use($keyname) retrieves an already-open connection by name from anywhere in the app.
Every query returns a DatabaseResult; call close() once you're done with it.

Read the full Database.md →

Query with parameters

$connection = Connections::mainConnection(DatabaseTypes::POSTGRES);

$sql = $connection->statement('SELECT * FROM users WHERE id > :ID');
$sql->parameters->ID = 1000;
$result = $sql->execute();
$sql->close();

CLI Tools

Everything routine goes through Barephrame/cli/tools.php. Flags chain together, so there's rarely a reason to run two commands separately.

--init scaffolds the initial project structure without touching files that already exist.
--compile-routes precompiles every discovered endpoint once.
--watch checks every second for changed endpoints and recompiles automatically — development only.
By default, no routes are known even if they exist in the project, until they're compiled at least once.

Read the full CLI.md →

Terminal

# scaffold, then keep routes compiled while you work
php ./Barephrame/cli/tools.php --init
php ./Barephrame/cli/tools.php --watch

05 — Revision history

This isn't the first draft

Barephrame V2 is the fourth revision of the same idea, not a fresh start. Every prior version was rebuilt — sometimes renamed entirely — as I learned more about what a framework like this should actually do.

Rev Name Status Notes

A Gravity Superseded The original prototype — where the idea of a lean, self-contained PHP framework started. B Gravity V2 Superseded A second pass at the same architecture, correcting decisions made too early the first time. C Barephrame Superseded A rename and a rebuild around a leaner core — the direct ancestor of what exists today. D Barephrame V2 Current PHP 8.5+, attribute-based routing, compiled routes, middlewares, and its own ORM.

Get the frame up

terminal

# clone, scaffold, and compile routes
git clone https://github.com/Angel-del-dev/barephrame-V2.git my-api
cd my-api
php ./Barephrame/cli/tools.php --init --watch

Star it on GitHub Read the contributing guide