Part 1: Introduction & Getting Started

Imagine you want to build a simple web app — maybe a contact form, a blog, or a small API. You search for "PHP framework" and find Laravel or Symfony. You read the docs, and suddenly you're looking at artisan commands, service providers, middleware pipelines, and a dozen folders to learn before you write a single line of code.

What if there was another way? A framework that lets you write Hello, world in 5 lines — not 5 files?

That's Fat Free Framework. And this blog series will teach you how to use it.

What is Fat Free Framework?

Fat Free Framework (F3) is a PHP micro-framework that weighs in at just ~90 kilobytes. It's small enough to fit in your pocket, but has every tool you actually need to build real web applications.

Think of it like a Swiss Army knife. A full-size kitchen knife (Laravel) is great for professional chefs building large restaurants. But if you just need to slice an apple, the Swiss Army knife gets the job done — and you can carry it anywhere. F3's smaller footprint also means cheaper hosting: shared hosting with limited resources can run F3 apps that would choke on Laravel's memory requirements.

What Can You Build with F3?

F3 isn't just for "Hello World" demos. It ships with a full toolkit that handles real work:

People have built: REST APIs, content management systems, e-commerce sites, URL shorteners, image galleries, and internal business tools.

Why Choose a Micro-framework?

A micro-framework gives you the essentials and gets out of your way. Here's what that means in practice:

• Fast to learn — You can be productive in hours, not weeks. No need to memorize dozens of framework-specific CLI commands or config file formats.
• Fast to install — One composer require and you're done. No php artisan key:generate, no .env setup, no config files.
• Fast to run — ~90kb loads instantly. For context: framework boot time (~50-100ms for Laravel) is rarely the bottleneck in real apps. F3's advantage is a simpler mental model and less memory overhead, not measurably faster TTFB.
• No boilerplate — Write only the code your app needs. Delete what you don't use.
• Flexible — Use native PHP, Twig, Smarty, or F3's own template engine. Your choice.

Installation

F3 has exactly one requirement: PHP 8.0 or later (for version 3.9). No Apache modules required. No vendor lock-in.

Note: F3 doesn't bundle database drivers — you'll still need PHP extensions like pdo_mysql or pdo_sqlite installed if your app uses a database. Check with php -m | grep pdo.

Option A: Composer (Recommended)

Composer is PHP's package manager. If you don't have it, install it first.

# Create your project folder
mkdir my-app && cd my-app

# Install F3
composer require bcosca/fatfree-core

This creates a vendor/ folder and sets up autoloading automatically. When you need F3, just require the autoloader:

require 'vendor/autoload.php';

Option B: Manual Download (No Composer)

If you prefer not to use Composer, download the framework directly:

• Go to github.com/bcosca/fatfree-core
• Click the green "Code" button → "Download ZIP"
• Extract the ZIP and find base.php
• Copy base.php into your project folder

Hello World in 5 Lines

Create a file called index.php and paste this:

<?php
$f3 = \Base::instance();

$f3->route('GET /', function() {
    echo 'Hello, world!';
});

$f3->run();

How a Request Flows Through F3

When you visit a URL, here's what happens inside F3:

         Your Browser
              │
              ▼
    ┌─────────────────┐
    │   HTTP Request   │   GET http://localhost:8000/
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │   index.php      │   PHP script starts
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │ Base::instance() │   Create F3 singleton
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │  $f3->route()    │   Register route (store in array)
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │  $f3->run()      │   Start the framework
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │  Match route?    │   GET /  →  Yes, match found
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │  Run callback    │   echo "Hello, world!"
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │  Send response   │   HTTP 200 + "Hello, world!"
    └────────┬────────┘
             │
             ▼
         Your Browser
         sees the page

Project Structure: Start Simple, Grow Later

For now, one index.php file is all you need. But as your app grows, here's a structure that works well:

my-app/
├── index.php              # Entry point - all routes here
├── vendor/                # Composer packages
├── src/
│   ├── controllers/       # Route handlers (later)
│   └── models/            # Database classes (later)
├── views/                 # HTML templates (later)
└── public/                # CSS, JS, images

Don't create all these folders now. Start with index.php. When complexity grows — multiple route handlers, shared logic, or the file becomes hard to navigate — split routes into a controllers/ folder. For experienced devs: refactor based on complexity and coupling, not just line count.

System Requirements

F3 is intentionally minimal. Here's everything you need:

You can run F3 with PHP's built-in development server — no Apache or Nginx needed for development:

# Run on port 8000 (default)
php -S localhost:8000

# Run on a different port
php -S localhost:3000

# Run on all interfaces (development only!)
php -S 0.0.0.0:8000

Troubleshooting

Running into issues? Here are the most common problems:

What's Next?

You now have F3 running. In Part 2: Routing & Controllers, we'll go deeper:

• Route parameters — /user/42 and capturing values
• HTTP methods — GET, POST, PUT, DELETE
• Route groups — shared prefixes and filters
• Controllers — organizing code into classes
• Before/after filters — authentication, logging

The best way to learn is to do. You've already built your first F3 app. Now let's build something real.