The PHP ecosystem has witnessed countless frameworks over the years, each promising to solve the complexities of web development. However, Tempest emerges as a game-changer with its core philosophy: developers should write as little framework-related code as possible, focusing instead on application logic.

What Makes Tempest Different?

The Zero-Config Philosophy

Unlike traditional PHP frameworks that require extensive configuration files, routing definitions, and service container setup, Tempest operates on a “zero config, zero overhead” principle. This approach eliminates the cognitive load of framework-specific boilerplate, allowing developers to concentrate on solving business problems.

Attribute-Driven Architecture

Tempest leverages PHP 8’s attribute feature extensively, making code more readable and self-documenting. Here’s a simple controller example

<?php

final class BookController
{
    #[Get('/books/{book}')]
    public function show(Book $book): Response
    {
        return new Ok($book);
    }

    #[Post('/books')]
    public function store(CreateBookRequest $request): Response
    {
        $book = map($request)->to(Book::class)->save();
        return new Redirect([self::class, 'show'], book: $book->id);
    }
}

This approach eliminates the need for separate routing files while keeping the code intuitive and maintainable.

Core Features That Set Tempest Apart

1. Automatic Discovery

Tempest automatically scans all project and package code, discovering any files the framework needs to know about without requiring manual configuration. This includes controllers, console commands, event handlers, and more.

2. Built-in Dependency Injection

The framework provides seamless dependency injection through constructor parameters, eliminating the need for complex service container configurations

final class MigrateUpCommand
{
    public function __construct(
        private Console $console,
        private MigrationManager $migrationManager,
    ) {}

    #[ConsoleCommand(
        name: 'migrate:up',
        description: 'Run all new migrations',
        middleware: [ForceMiddleware::class, CautionMiddleware::class],
    )]
    public function __invoke(): void
    {
        $this->migrationManager->up();
        $this->console->success("Everything migrated");
    }
}

3. Event-Driven Architecture

Tempest supports event handling out of the box, making it easy to build decoupled applications

#[EventHandler]
public function onMigrationMigrated(MigrationMigrated $migrationMigrated): void
{
    $this->console->writeln("- {$migrationMigrated->name}");
}

4. Console Commands with Middleware

The framework provides a robust console command system with middleware support, making CLI applications as powerful as web applications.

Getting Started with Tempest

Installation

Creating a new Tempest project is straightforward

composer create-project tempest/app:1.0-alpha.5 my-project

For existing projects, simply add Tempest as a dependency

composer require tempest/framework:1.0-alpha.5

Project Structure Freedom

One of Tempest’s standout features is that it won’t impose any specific file structure on your project. The framework’s discovery mechanism adapts to your preferred organization, whether you prefer domain-driven design, layered architecture, or any other approach.

Performance and Developer Experience

Minimal Overhead

The zero-configuration approach doesn’t just improve developer experience—it also reduces runtime overhead. Without complex configuration parsing and service container warm-up, applications start faster and consume fewer resources.

Modern PHP Standards

Tempest fully embraces modern PHP features:

• PHP 8+ attributes for metadata
• Strong typing throughout
• Readonly properties
• Constructor property promotion
• Match expressions

Community Reception

The developer community has responded positively to Tempest, with experienced PHP developers noting that it represents how web development should look in 2024. Early adopters appreciate the framework’s clean approach and its focus on reducing ceremony.

When to Choose Tempest

Ideal Use Cases

• Rapid Prototyping: Zero configuration means faster time-to-market
• Microservices: Lightweight footprint perfect for containerized applications
• API Development: Clean attribute-based routing ideal for REST APIs
• Small to Medium Applications: Excellent balance of simplicity and functionality

Considerations

As Tempest is currently in alpha (version 1.0-alpha.5), it’s important to consider:

• Limited ecosystem compared to mature frameworks
• Potential breaking changes before stable release
• Smaller community for troubleshooting

Comparing Tempest to Established Frameworks

Feature	Tempest	Laravel	Symfony
Configuration	Zero	Extensive	Moderate
Learning Curve	Gentle	Moderate	Steep
Attribute Support	Native	Limited	Growing
Auto-Discovery	Full	Partial	Manual
Performance	High	Good	Excellent

The Future of PHP Development

Tempest represents a shift in PHP framework philosophy. By prioritizing developer experience and reducing framework-specific code, it addresses many pain points developers face with traditional frameworks. The framework’s approach aligns with modern development practices and the direction PHP is heading.

Conclusion

Tempest PHP Framework offers a refreshing take on web development by eliminating configuration overhead and focusing on what matters most: your application code. While still in alpha, it shows tremendous promise for developers seeking a modern, efficient framework that gets out of their way.

The combination of zero configuration, attribute-driven development, and automatic discovery makes Tempest an compelling choice for new projects. As the framework matures and its ecosystem grows, it could very well become the go-to choice for PHP developers who value simplicity without sacrificing functionality.

Ready to try Tempest? Check out the official documentation and join the growing community of developers who are building the future of PHP development.