Download the PHP package nixphp/framework without Composer

NixPHP

"As simple as possible, as flexible as necessary."

NixPHP is a modern, lightweight PHP microframework designed for real-world projects:
fast, minimal, extendable, and now fully embracing modern PHP standards like PSR-3, PSR-4, PSR-7, PSR-11, and PSR-18.

It builds on native PHP features and lets you stay in control:
Use only what you need, and extend freely when you want.

🧩 NixPHP provides a minimal core with a clean plugin architecture.
Everything beyond routing and dispatching, such as sessions, views, forms, or database, is handled by optional plugins.
You get full control over what your app includes, and nothing more.

✨ Philosophy

• Minimalist Core: Only essential components by default.
• PSR-First: Native support for key PHP standards (PSR-3, PSR-4, PSR-7, PSR-11, PSR-18).
• Extendable: Easily plug in external libraries — Blade, Twig, Eloquent, Middleware, etc.
• Transparent by Design: No hidden magic, no complicated abstractions.
• Native PHP Power: PDO database, clean routing, lightweight templating.
• Secure and Clear Structure: Safe public directory (public/) separated from your app code.

Core Features

• Plugin System: Add reusable features via Composer
• Lightweight Routing: Define routes with [Controller::class, 'method']
• Smart Dispatcher: Automatic parameter and controller resolution
• Dependency Container (PSR-11): Service registry with built-in autowiring
• PSR-3 Logging (lightweight logger ready to use)
• PSR-4 Autoloading (Composer)
• PSR-7 Request/Response Handling
• PSR-18 HTTP Client (via nixphp/client)
• Minimalist View System: Block-based templating (via nixphp/view)
• PDO Database Connection (via nixphp/database)
• Session Handling (via nixphp/session)
• Form Memory Helpers (via nixphp/form)
• JSON Response Helper (for easy API responses)
• Composer-Ready: Easy installation and dependency management

PSR Compliance Overview

❓ Why not just use Laravel or Symfony?

Frameworks like Laravel and Symfony are fantastic, but they often come with a heavy stack of features, conventions, and dependencies you may not always need.

NixPHP offers a different approach:

• No hidden complexity: You see exactly what happens.
• No forced patterns: Use only what you need, when you need it.
• No unnecessary overhead: Keep performance and flexibility under your control.
• Real extendability: Bring your favorite libraries if needed — but stay light if you don't.

If you want full control without fighting against a "big framework" structure,
NixPHP might be the perfect starting point for you.

📢 Installation

Install via Composer

This installs the NixPHP core, a minimal routing and dispatch layer.
For additional features like views, forms, or sessions, just install the corresponding plugins.

Set up your project structure

NixPHP leaves the project organization completely up to you.
A typical structure could look like this:

• Plural names for app folders
• public/ as webroot for higher security
• bootstrap.php for autoloading and bootstrapping services, registering events, and so on...

Creating your App

You typically...

• Create a bootstrap.php to initialize NixPHP
• Set up your routes.php
• Create a public/index.php as your web entry point (which includes bootstrap.php)

1. Fill bootstrap.php

2. Create a route

3. Create a controller

4. Create a view

5. Access your page

Visit:

You should see:

🔧 Dependency Injection & Autowiring

NixPHP includes a PSR-11 compliant container with automatic dependency resolution built-in.
No configuration needed, it just works.

Registering Services

Register your core services (interfaces, databases, loggers) in the container:

Automatic Dependency Resolution

Controllers and services automatically receive their dependencies:

How It Works

NixPHP's autowiring follows these basic rules:

1. Interfaces must be registered: tell the container which implementation to use
2. Concrete classes are auto-built: no registration needed
3. Dependencies are resolved recursively: the entire dependency tree is handled

Building Instances Manually

Sometimes you need to build instances directly (e.g., Commands):

Features

• Zero configuration: autowiring works out of the box
• Concrete classes auto-resolve: less boilerplate
• Circular dependency detection: prevents infinite loops
• Nullable dependencies: handled gracefully
• Optional parameters: with default values supported
• Custom parameters: pass explicit values when needed

Best Practices

🔌 Plugin Support

NixPHP includes a clean plugin system that allows you to extend your app modularly — without configuration.

Just install a plugin via Composer (e.g. composer require vendor/my-plugin) and it is automatically detected if it uses the correct package type:

A typical plugin might look like this:

• config.php is automatically merged.
• views/ are added to the view search path.
• bootstrap.php runs automatically to register routes, events, etc.

Layout conventions

Wherever a resource is looked up, both the app/ and the src/ spelling are accepted. Views may additionally live in a top-level views/ directory, which keeps template files out of your PSR-4 source root.

Which resources exist differs between a plugin and your application:

bootstrap.php is the one exception to the two spellings: it is always read from the package root, never from app/ or src/.

The first existing candidate wins and the rest are ignored, so a package should never ship two of them at once. Resources that do not exist are not registered at all — getViewPaths() and friends only ever return real paths.

Application view paths are resolved by nixphp/view and are configurable via view.paths; the other application resources are loaded by the core.

Plugin availability checks

Use app()->hasPlugin('vendor/name') to gate functionality on optional plugins. Version hints like vendor/name:>=0.1.2 or vendor/name:<0.2.0 are also supported — the constraint is compared against the plugin version that Composer registers when the plugin loads. This makes it easy to only enable code when a specific plugin version is present, without having to interrogate InstalledVersions manually.

You can build plugins exactly like you build an app, with full access to routing, events, and controllers.

For plugin examples, see the Plugin Documentation

License

MIT License.