A radically simple, zero-dependency PHP framework for PostgreSQL purists.
Your framework has more dependencies than your app has users.
Falt Leap is an opinionated MVC framework that throws out the complexity of modern PHP development and gets back to basics. No Composer. No bloated dependencies. No framework-imposed abstractions between you and your database. Just clean, fast PHP that embraces PostgreSQL's power.
Version 0.3 introduces a full error handling system with a rich debug page, interactive console, and production-safe error screens — on top of v0.2's query builder, middleware, and autoloading. All in ~3,200 lines of core code.
- Quick Start
- Feature Comparison
- What's Different? (Show, Don't Tell)
- Built for Modern PHP, Not Around Legacy PHP
- Why Falt Leap?
- What's New in Version 0.3?
- What Makes This Opinionated?
- Architecture
- Model Generation
- Who Is This For?
- Project Structure
- Philosophy
- Documentation
- Real Talk: Why Another Framework?
- Performance
- Contributing
- License
The fastest way from zero to running app:
git clone https://github.com/GECKOSTUDIOS/faltleap myapp
cd myapp
./run.sh
# Done. Visit http://localhost:8090That's it. The Docker setup handles PHP, nginx, and everything else. No composer install. No npm install. No build step.
If you'd rather run it on your own PHP + nginx/Apache stack:
# 1. Clone
git clone https://github.com/GECKOSTUDIOS/faltleap myapp
cd myapp
# 2. Create your .env
cat > .env <<'EOF'
DB_HOST=localhost
DB_USERNAME=postgres
DB_PASSWORD=yourpassword
DB_DATABASE=yourdb
DB_SCHEMA=public
APP_DEBUG=true
EOF
# 3. Generate models from your existing PostgreSQL schema
php gen.php all public
# 4. Point your web server's document root to /public/
# (nginx: root /path/to/myapp/public; | Apache: DocumentRoot /path/to/myapp/public)Set APP_DEBUG=false in production. Errors will log to storage/logs/error.log and users see a clean error page instead of stack traces.
| Feature | Falt Leap | Laravel 11 | Symfony 7 |
|---|---|---|---|
| Lines of Code | ~3,200 | ~500,000+ | ~800,000+ |
| Dependencies | 0 | 30+ direct, 100+ total | 50+ direct, 200+ total |
| Vendor Folder Size | 0 bytes | ~274 MB | ~350 MB |
| Fresh Install Time | < 1 second | 2-5 minutes | 3-7 minutes |
| Routing | ✅ Array-based | ✅ Attribute/File-based | ✅ YAML/Annotation |
| Query Builder | ✅ With joins & aggregates | ✅ Full Eloquent | ✅ Doctrine |
| Middleware | ✅ Simple pipelines | ✅ Complex pipelines | ✅ Complex pipelines |
| Autoloading | ✅ PSR-4 | ✅ Composer | ✅ Composer |
| Database Support | PostgreSQL only | MySQL, Postgres, SQLite | Any with Doctrine |
| ORM | Active Record | Eloquent (Active Record) | Doctrine (Data Mapper) |
| Template Engine | Built-in (PHP) | Blade | Twig |
| Auto-Escaping | ✅ Safe by default | ✅ Blade {{ }} |
✅ Twig {{ }} |
| Zero Config Setup | ✅ Yes | ❌ No | ❌ No |
| Error Handling | ✅ Debug page + console | ✅ Ignition | ✅ Profiler |
| Code You Can Read | ✅ In one afternoon | ❌ Months | ❌ Never |
| Breaking Changes | Rare | Every major version | Every major version |
| Learning Curve | 1 day | 2 weeks | 1 month |
Not shown: The peace of mind from owning your entire stack.
Laravel:
// routes/web.php
Route::get('/users/{id}', [UserController::class, 'show'])->middleware(['auth', 'verified']);
Route::resource('posts', PostController::class);
// Plus routes/api.php, routes/channels.php, RouteServiceProvider, etc.Falt Leap:
// conf/router.config.php
$routes = [
"/users/{id}" => ["UsersController@show", ["auth"]],
"/posts" => "PostsController@index"
];That's it. One array. No service providers. No route caching. No magic.
Laravel:
// app/Models/User.php - 40+ lines of boilerplate
class User extends Model {
protected $fillable = ['name', 'email', 'password'];
protected $hidden = ['password', 'remember_token'];
protected $casts = ['email_verified_at' => 'datetime'];
// ... and hope it matches your migration
}
// database/migrations/2024_01_create_users_table.php - another 30 lines
// Now keep them in sync manually foreverFalt Leap:
// Design your schema in PostgreSQL (where it belongs)
CREATE TABLE users (
idusers SERIAL PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100),
created_at TIMESTAMP DEFAULT NOW()
);
// Generate perfect models
$ php gen.php users
// models/Users.model.php - Auto-generated, always in sync
class Users extends LeapModel {
public string $table = 'users';
public array $cols = [/* all metadata from schema */];
}Change your schema? Run php gen.php users again. Always in sync. No drift. No lies.
Laravel Eloquent:
$topCustomers = Order::select('customer_id', DB::raw('SUM(amount) as total'))
->with('customer')
->where('status', 'paid')
->groupBy('customer_id')
->having('total', '>', 1000)
->orderByDesc('total')
->limit(10)
->get();Falt Leap (same query):
$topCustomers = Orders::Query()
->select('customer_id', 'SUM(amount) as total')
->join(Customers::class, 'customer_id')
->where("status = :s", [':s' => 'paid'])
->groupBy('customer_id')
->having('total > :min', [':min' => 1000])
->orderBy('total DESC')
->limit(10)
->get();Similar API, but you can read the LeapQueryBuilder source in 10 minutes and understand exactly what's happening.
Laravel:
config/app.php (200+ lines)
config/database.php (150+ lines)
config/cache.php (100+ lines)
config/queue.php (100+ lines)
config/mail.php (120+ lines)
... 15+ more config files
Falt Leap:
# .env
DB_HOST=localhost
DB_NAME=myapp
DB_USER=postgres
DB_PASS=secret
APP_DEBUG=true
# Done.Most popular frameworks were born in the PHP 5 era. They carry years of abstractions that exist to work around language limitations that no longer exist. Laravel shipped its first version in 2011. Symfony in 2005. The PHP they were designed for didn't have strict types, union types, named arguments, enums, fibers, or even a sane error model.
So what did frameworks do? They built thousands of lines of code to compensate:
| What frameworks built | Why it existed | What PHP 8+ has natively |
|---|---|---|
Illuminate\Support\Str (600+ lines) |
PHP lacked basic string helpers | str_contains(), str_starts_with(), str_ends_with() |
| Doctrine DBAL abstraction layer | PDO was clunky and error-prone | PDO with ERRMODE_EXCEPTION, named params, proper fetch modes |
| Service container with reflection | No way to express dependencies clearly | Typed properties, union types, constructor promotion |
| Collection classes (1,500+ lines) | Arrays were painful to work with | Generators, array_is_list(), spread operator, arrow functions |
| Validation layers and type casting | No type safety at the language level | declare(strict_types=1), union types, mixed, typed properties |
Enum packages (spatie/enum, etc.) |
PHP had no enum support | Native enum (PHP 8.1) |
| Null-handling helpers | Null checks were verbose and error-prone | Nullsafe operator ?->, null coalescing ?? and ??= |
| Template escaping helpers | Easy to forget htmlspecialchars() |
We solve this at the architecture level with auto-escaping data wrappers |
| Macro/mixin systems | Extending framework classes was rigid | When your framework is 3,200 lines, you just change the code |
Falt Leap doesn't carry this baggage. It was written from scratch for PHP 8+ and leans on the language itself instead of reinventing it.
Every file in the framework uses declare(strict_types=1). Types are enforced by PHP itself, not by a validation layer on top.
PDO does the heavy lifting. We don't wrap PDO in an abstraction layer that pretends databases are interchangeable. We use PDO's exception mode, named parameters, and prepared statements directly — because modern PDO is already good:
// This is the entire query method. No DBAL. No query log. No event dispatcher.
$stmt = $this->connection->prepare($sql);
$stmt->execute($params);
return $stmt->fetchAll(PDO::FETCH_ASSOC);Dependency injection is just typed constructors. No service container. No binding configuration. No $this->app->make(). PHP's type system tells us what a class needs:
class UsersController extends LeapController {
// db, request, session, view — injected automatically via typed properties
// No container config. No service provider. No binding.
}Auto-escaping uses PHP's own magic methods — not a custom template syntax with a compiler:
// LeapSafeData wraps your data and escapes strings on property access
// No Blade compiler. No Twig lexer. Just __get() and htmlspecialchars().
<?= $this->data->username ?> <!-- escaped automatically -->The result: features that take thousands of lines in other frameworks take dozens in Falt Leap — because we let PHP 8 do what PHP 8 was designed to do.
You've spent your career dealing with:
- 300MB vendor folders for a CRUD app
- Breaking changes in dependencies you can't control
- Update fatigue from packages you don't even use
- Security alerts from nested dependencies 8 levels deep
- Debugging framework code instead of building features
Falt Leap says: enough.
Modern PHP frameworks come with hundreds of dependencies. Falt Leap has exactly zero. Every line of code is in this repository. The entire framework is ~3,200 lines. You can read and understand it in an afternoon.
# No composer install
# No npm install
# No build process
# No node_modules black hole
# Just clone and codeWhat you get instead:
- Full control over every line of code
- No supply chain vulnerabilities
- Instant deployment (just
git pull) - Zero dependency conflicts
- Framework code you can actually understand
We're not trying to support every database under the sun. Falt Leap is built exclusively for PostgreSQL, which means:
- Native schema support (
SET search_path) - Full embrace of PostgreSQL's type system
- No MySQL compatibility compromises
- Clean, predictable SQL generation
- Introspection that actually works
If you're not using PostgreSQL, this framework isn't for you. And that's okay.
Stop writing models by hand. Stop maintaining duplicated schema information. With Falt Leap:
- Design your database schema in PostgreSQL
- Run
php gen.php all - Get perfect Active Record models with full type information
Models are generated, not written. Change your schema? Regenerate. Add a column? Regenerate. Your models stay perfectly in sync with your database schema.
Routes are a simple array:
$routes = [
"/" => "HomeController@index",
"/users/{id}" => "UsersController@show"
];Controllers get automatic dependency injection:
class UsersController extends LeapController {
public function show($id) {
$user = Users::WhereOne("id = :id", [":id" => $id]);
return $this->view->render("users/show", (object)["user" => $user]);
}
}Models use Active Record with fluent query building:
// Simple queries
$user = Users::Query()->where("username = :u", [":u" => $username])->first();
$user->email = "new@email.com";
$user->save();
// Complex joins (NEW in 0.2!)
$posts = Posts::Query()
->join(Users::class, 'idusers')
->where("posts.status = :status", [":status" => "published"])
->orderBy("posts.created_at DESC")
->limit(10)
->get();
foreach ($posts as $post) {
echo $post->title;
echo $post->users->username; // Joined data auto-hydrated!
}
// Aggregates
$totalRevenue = Orders::Sum('amount', 'status = :s', [':s' => 'completed']);
$activeUsers = Users::Count('last_login > NOW() - INTERVAL \'30 days\'');No repositories. No services. No factories. No abstract factories. No query builder learning curve. Just SQL you already know with objects that make sense.
We don't dictate your frontend stack, but we have opinions:
- Bootstrap 5.3 for UI components and responsive design
- Vanilla JavaScript for interactivity (no React, Vue, Angular bloat)
- No build process required - write code that runs in the browser
- WebSockets built-in for real-time features when you need them
Frontend complexity is optional, not mandatory.
A complete error handling system that replaces bare echo/die() calls with proper exception handling throughout the framework.
Debug mode (APP_DEBUG=true) gives you a rich, self-contained error page:
- Dark-themed UI with no external dependencies
- Exception class, message, and file:line at a glance
- Clickable stack trace sidebar with source code preview (error line highlighted)
- Tabs for Request, Session, and Environment data (passwords auto-masked)
- Interactive PHP console at the bottom for inspecting runtime state
- Syntax errors caught before execution via
php -llint checks on controllers and views
Production mode (APP_DEBUG=false) shows a clean Bootstrap error page with a reference ID. Full details are logged to storage/logs/error.log.
// .env
APP_DEBUG=true // Rich debug page with stack traces and console
APP_DEBUG=false // Clean error page, details in storage/logs/error.logThe debug console is security-restricted to local/private IPs only. Database connection failures, missing routes, missing views, and PHP errors all flow through the same handler.
Build complex queries with joins, aggregates, grouping, and nested conditions:
// Multi-table joins with auto-hydration
$orders = Orders::Query()
->join(Customers::class, 'idcustomers')
->join(Products::class, 'idproducts')
->where("orders.total > :min", [":min" => 100])
->orderBy("orders.created_at DESC")
->get();
// Aggregates: Count, Sum, Avg, Min, Max
$stats = [
'total' => Orders::Sum('amount'),
'avg' => Orders::Avg('amount', 'status = :s', [':s' => 'paid']),
'count' => Orders::Count('created_at > NOW() - INTERVAL \'7 days\'')
];
// GROUP BY and HAVING support
$topCustomers = Orders::Query()
->select('customer_id', 'SUM(amount) as total')
->groupBy('customer_id')
->having('SUM(amount) > :min', [':min' => 1000])
->orderBy('total DESC')
->limit(10)
->get();Composable middleware with automatic dependency injection:
// Define middleware in routes
$routes = [
"/admin/users" => ["UsersController@index", ["auth", "admin"]],
"/api/data" => ["ApiController@data", ["auth", "rate-limit"]]
];
// Create custom middleware
class RateLimitMiddleware extends LeapMiddleware {
public function handle(callable $next): mixed {
if ($this->exceedsLimit()) {
return $this->redirect("/error", "Rate limit exceeded");
}
return $next();
}
}No configuration files. No service providers. Just extend LeapMiddleware and use it.
Proper namespacing with automatic class loading:
namespace App\Controllers;
namespace App\Models;
namespace App\Middleware;
// No manual requires. Ever.Environment-based configuration without external packages:
// .env file
DB_HOST=localhost
DB_NAME=myapp
APP_DEBUG=true
// In code
$debug = LeapEnv::get('APP_DEBUG', false);Every framework file uses declare(strict_types=1). Because it's 2025 and we should know our types.
We're not anti-dependency. We're anti-complexity. Every external package is a potential security risk, maintenance burden, and breaking change waiting to happen. Falt Leap is entirely self-contained.
The entire framework is ~3,200 lines. That's less than a single Laravel controller in some projects.
We don't waste time on database abstraction layers that make every database equally mediocre. We embrace PostgreSQL's features fully:
- Native JSON/JSONB support
- Full-text search capabilities
- Array types
- Advanced indexing
- Schema-aware queries
RETURNINGclause support
If you're not using PostgreSQL, this framework isn't for you. And that's a feature, not a bug.
Hand-written models get out of sync with your database. Generated models don't. We enforce schema-first development.
php gen.php all public
# Generates perfectly typed models from your schema
# Re-run after migrations. Always in sync. Always.The repository pattern adds indirection without adding value for 90% of applications. Active Record is simpler, clearer, and faster to write.
You're building a web app, not a NASA mission control system.
Our "ORM" is a thin wrapper around PDO with schema introspection. You write SQL. We just make it convenient.
// This is fine
$users = Users::Where("age > :age", [":age" => 18]);
// This is also fine
$result = $this->db->query("SELECT * FROM users WHERE created_at > NOW() - INTERVAL '1 day'");We don't try to turn SQL into an object-oriented query language. SQL is already great.
1. Add route in /conf/router.config.php:
$routes = [
"/hello/{name}" => "HelloController@greet"
];2. Create controller in /app/HelloController.php:
<?php
class HelloController extends LeapController {
public function greet($name) {
return $this->view->render("hello", (object)[
"name" => $name,
"title" => "Greetings"
]);
}
}
?>3. Create view in /views/hello.leap.php:
<div class="container mt-5">
<h1>Hello, <?= $this->data->name ?>!</h1>
</div>Done. No service providers to register. No middleware to configure. No build process to run.
Every component is documented, typed, and readable:
- LeapEngine: Application bootstrapper and request dispatcher
- LeapRouter: URL routing with regex pattern matching and middleware support
- LeapController: Base controller with auto-injected dependencies (db, request, session, view)
- LeapModel: Active Record ORM with fluent query builder (~840 lines including joins, aggregates, grouping)
- LeapQueryBuilder: Join builder with auto-hydration and complex query support (~350 lines)
- LeapView: Template engine with layout inheritance, flash messages, and auto-escaping
- LeapSafeData: Auto-escaping wrapper for XSS protection — strings are escaped on access, non-strings pass through
- LeapDB: PostgreSQL PDO wrapper with schema support and prepared statements
- LeapRequest: HTTP request abstraction with type-safe helpers
- LeapSession: Session management with flash message support
- LeapErrorHandler: Global error/exception handler with rich debug page and production error page
- LeapDebugConsole: Interactive PHP console for inspecting runtime state during errors
- LeapHttpException: Base HTTP exception with status code support
- LeapNotFoundException: 404 exception for missing routes, controllers, views
- LeapSyntaxException: Syntax error exception with source file/line context
- LeapWebSocketServer: Built-in WebSocket server for real-time features
- LeapSafeData: Auto-escaping data wrapper for XSS protection (~75 lines)
- LeapAutoloader: PSR-4 compliant autoloader (~145 lines)
- LeapMiddleware: Abstract middleware base class with dependency injection
- LeapMiddlewareStack: Middleware pipeline executor (~115 lines)
- LeapEnv: Zero-dependency .env file parser (~107 lines)
Total framework size: ~3,200 lines across 20 files. You can read it all in one sitting.
HTTP Request
↓
/public/index.php (loads PSR-4 autoloader + .env)
↓
LeapErrorHandler registers (catches all errors/exceptions from here on)
↓
LeapEngine->start($routes)
↓
LeapRouter->getRoute($url) → extracts controller, method, middleware
↓
Lint check on controller (debug mode) → LeapSyntaxException on failure
↓
LeapMiddlewareStack builds pipeline
↓
Middleware chain executes (auth, validation, logging, etc.)
↓
Controller instantiation (auto-injected: db, request, session, view)
↓
Controller method execution
↓
View rendering (lint check + layout + flash messages)
↓
HTTP Response
⚡ Any uncaught exception at any step → LeapErrorHandler
→ Debug mode: Rich error page with stack trace + interactive console
→ Production: Clean error page + logged to storage/logs/error.log
Straightforward. Predictable. You can trace every line of execution.
Models are generated from your database schema, not hand-written:
# Generate all models from schema
php gen.php all [schema_name]
# Generate single model
php gen.php usersGenerated models include:
- All columns with proper types
- Default values from database
- Nullable information
- Primary key detection
- Active Record methods (
save(),delete(),Where(),WhereOne())
Example generated model:
class Users extends LeapModel {
protected static $columns = ["id", "username", "email", "created_at"];
protected static $defaults = ["created_at" => "CURRENT_TIMESTAMP"];
protected static $nullables = ["email"];
protected static $primaries = ["id"];
}Philosophy: Your database schema is the source of truth. Models reflect it automatically.
- ✅ Value simplicity over abstraction - You're tired of 10 layers between you and the database
- ✅ Trust PostgreSQL more than ORMs - You know PostgreSQL can do things Laravel's query builder can't
- ✅ Want to understand your framework - All ~3,200 lines of it
- ✅ Prefer convention over configuration - Routes are arrays, not YAML manifests
- ✅ Think modern frameworks have gotten ridiculous - When did a TODO app need 400 dependencies?
- ✅ Build real applications - CRUD apps, dashboards, internal tools, SaaS backends, APIs
- ✅ Ship fast - No build step, no compile, no webpack. Just deploy.
- ✅ Don't need to support every database - PostgreSQL is enough (and better than MySQL anyway)
- ✅ Are tired of breaking changes - The framework is complete. No surprise v10 rewrite coming.
- ✅ Want to own your code - Not rent it from package maintainers who might abandon it
When you could understand your entire stack. When "upgrading" didn't mean 3 days of fixing breaking changes. When you shipped features instead of fighting your framework.
Falt Leap is that world again.
- ❌ Need MySQL/SQLite/MongoDB support (we're PostgreSQL-only by design)
- ❌ Want a massive ecosystem of plugins (we have 14 files, not 14,000 packages)
- ❌ Prefer repository patterns and service layers (we think those add complexity without value)
- ❌ Need queues, events, notifications out of the box (build what you need, when you need it)
- ❌ Want framework-agnostic code (this is intentionally coupled to PostgreSQL)
- ❌ Love microservices architecture (this is for monoliths and we're proud of it)
- ❌ Think TypeScript is the only way (this is PHP with strict types, not JavaScript cosplay)
/app/ Controllers (suffix: Controller.php)
/conf/ Configuration files
├── db.config.php Database connection
└── router.config.php Route definitions
/lib/ Framework core (20 classes, zero dependencies)
/models/ Generated model classes
/public/ Web root (index.php entry point)
/storage/ Runtime data (gitignored)
├── /logs/ Error logs (error.log)
└── /debug/ Debug console context files
/views/ Templates (.leap.php extension)
└── index.leap.php Master layout
/container/ Docker development environment
.env Environment config (DB credentials, APP_DEBUG)
gen.php Model generator
run.sh Docker dev server launcher
Modern frameworks give you everything. Falt Leap gives you what you actually need:
- Routing - Array-based, regex-powered, dead simple
- Controllers - Automatic dependency injection, no configuration
- Active Record models - With query builder, joins, aggregates
- Middleware - Composable pipelines without complexity
- Template rendering - Layouts, partials, flash messages
- Session management - Built-in, secure, straightforward
- Error handling - Debug page with stack traces, console, and production-safe error screens
- Database connection - PostgreSQL-native with schema support
- Autoloading - PSR-4 compliant, zero-config
- .env support - Configuration without packages
Total: ~3,200 lines. Including a full error handling system with interactive debug console.
Everything else? That's your code to write, not framework bloat to maintain. Need queues? Write a queue. Need emails? Send emails. You're a developer, not a framework configurator.
Your database schema IS your domain model.
Design it well in PostgreSQL, and Falt Leap reflects it perfectly in code:
- Design tables with proper types, constraints, defaults
- Run
php gen.php all - Get perfectly typed models with all metadata
- Change schema? Regenerate. Always in sync.
No schema drift. No model divergence. No @ORM annotations trying to recreate what your database already knows. Just truth.
We use technology that will still work in 10 years:
- PHP 8+ - The language that runs 80% of the web (yes, still)
- PostgreSQL - The database that's been rock-solid for 30 years
- PDO - PHP's standard database interface
- Bootstrap 5 - The CSS framework that needs no introduction
- Vanilla JavaScript - The only frontend dependency that won't have a breaking change next week
No bleeding edge. No "revolutionary" architecture. No framework rewrites every 18 months.
Just proven, boring technology that works.
Every dependency is a liability:
- Security vulnerabilities you didn't write
- Breaking changes you didn't ask for
- Maintenance burden you can't control
- Abandoned packages that break your build
Falt Leap has zero dependencies. You own every line. You control every update. You decide when things change.
No one can break your code except you.
- Framework Guide: See
/CLAUDE.mdfor detailed component documentation - Model Generation: Run
php gen.phpfor usage - Docker Development: Run
./run.shfor instant dev environment
Because we're tired.
Tired of spending more time configuring than coding. Tired of frameworks that need frameworks. Tired of "simple" examples that require 50 lines of boilerplate. Tired of upgrade guides longer than the features they add.
The Modern Framework Tax:
# Laravel 11 - Fresh install
$ composer create-project laravel/laravel myapp
$ du -sh myapp/vendor
274M myapp/vendor
$ find myapp/vendor -name "*.php" | wc -l
32,847 filesFalt Leap:
$ git clone faltleap myapp
$ du -sh myapp/lib
152K myapp/lib
$ find myapp/lib -name "*.php" | wc -l
20 files274MB vs 152KB. 32,847 files vs 20 files.
And you know what? The Falt Leap version will still be working in 5 years. No breaking changes. No deprecated APIs. No surprise rewrites.
We're not trying to be everything to everyone. We're trying to be exactly what you need for PostgreSQL web applications.
- Want to add Redis? Just use Redis. It's PHP.
- Need queues? Write a queue table and a worker script.
- Want GraphQL? Add a library. Or don't. Up to you.
You're in control. Not your framework's roadmap.
You've used:
- Laravel (too much magic)
- Symfony (too much configuration)
- Slim (too little structure)
- CodeIgniter (dated patterns)
- Raw PHP (too much reinventing)
Falt Leap is the Goldilocks framework.
Just enough structure. Just enough features. Just enough code to read in one sitting.
And when something goes wrong? You can actually debug it because you understand every component.
Fast. PostgreSQL is fast. PDO is fast. PHP 8 is fast. No ORM overhead. No middleware bloat. No service container reflection magic.
Typical request cycle: < 5ms (excluding database queries).
And because there's no Composer autoloader scanning thousands of files, cold starts are instant.
Falt Leap is intentionally minimal. We're not trying to compete with Laravel or Symfony. We're building a focused tool for a specific philosophy.
What we'll accept:
- Bug fixes in core components
- Better PostgreSQL integration
- Documentation improvements
- Performance optimizations
- Security fixes
What we won't accept:
- MySQL/SQLite/MongoDB support
- Composer dependencies
- Complex abstractions
- Enterprise features for the sake of checkboxes
- Breaking changes without extremely good reason
Code contributions must:
- Use
declare(strict_types=1) - Be fully typed
- Include clear documentation
- Not break backward compatibility
- Stay true to the framework philosophy
BSD License - Use it, fork it, learn from it, build with it.
No strings attached. No corporate ownership. No surprise relicensing.
If you're a burned-out senior developer who clicked on this README thinking "finally, someone gets it" — you're right.
This framework exists because we felt the same way.
We were tired of explaining to junior developers why we need 47 config files for a CRUD app. Tired of Stack Overflow answers that just say "use this package." Tired of pretending that complexity equals professionalism. The whole webstack is so broken, that we need AI to make something half decent - when we actually don't need it at all.
Simple is professional. Boring is reliable. Small is beautiful.
If that resonates with you, give Falt Leap a try. Read the code. Understand it. Own it.
And then build something great.
Built with conviction. Powered by PostgreSQL. Zero dependencies, zero regrets.
Version 0.3 • ~3,200 lines • 20 files • ∞ possibilities