Decoupled Architecture • Laravel Main Ecosystem

Architect Clean Applications with 4 Open Pillars

Obelaw provides pure architectural patterns and composable tooling: isolate domain logic with Domain (DDD), reach your domains through IUM’s unified fluent API, build modular admin interfaces with Twist, and accelerate delivery with curated Laravel packages. While built with framework-independent clean architecture principles, Obelaw supports Laravel as its main ecosystem.

4
Open Pillars

Domain, IUM, Twist, Packages

100%
Open Source

MIT licensed on GitHub

Main
Laravel Ecosystem

First-class Laravel & Filament tools

Decoupled
Zero Lock-In

Pure domain logic & zero bloat

Core Architecture

The 4 Open Pillars of Obelaw

Engineered to keep core business logic pure, testable, and decoupled — while providing first-class, seamless tooling for Laravel as our main ecosystem.

Pillar 01 Core Model

Domain (DDD)

Isolate business rules into clean bounded contexts, DTOs, and single-purpose actions.

Pillar 02 Gateway

IUM Core

Expose every domain through a unified fluent entrypoint with zero UI dependencies.

Pillar 03 Presentation

Twist Platform

Mount modular, multi-tenant Filament admin addons and dynamic panel navigation.

Pillar 04 Workbench

Laravel Packages

Enhance models with dynamic EAV (Attrify), audit trails (Trail), and background runners.

01
Pillar 01 • Architecture

Domain (DDD)

Clean Domain Boundaries & Domain-Driven Design

Bring strict Domain-Driven Design to your application. Partition application complexity into explicit bounded contexts with validated Data Transfer Objects (DTOs), single-purpose Actions for writes, and fluid Queries for reads — keeping business logic independent with native Laravel scaffolding.

Bounded Contexts Typed DTOs Single-Purpose Actions CQRS Queries
$ composer require obelaw/framework
// Run mutation via single-purpose Domain Action
$order = CreateOrderAction::run(
OrderData::from($request->validated())
);
02
Pillar 02 • Gateway

IUM Core

Decoupled Business Domain Builder

Expose all your decoupled business domains through one expressive, compile-checked fluent API. Eliminate tangled controllers, brittle service contracts, and presentation dependencies. Runs anywhere in modern PHP with native gateway support for Laravel.

Unified Fluent API Zero UI Dependencies Domain Autodiscovery Strict Contracts
$ composer require obelaw/framework
// Reach any domain via one unified fluent API
$inventory = ium()->inventory()->stock()->available($sku);
$invoice = ium()->billing()->invoice()->generate($payload);
03
Pillar 03 • UI & Addons

Twist Platform

Modular Filament Addon Platform

Build scalable, multi-tenant Filament applications with a plug-and-play addon architecture. Twist powers the UI tier of our Laravel ecosystem, allowing teams to package admin panels, navigation clusters, forms, and tables into composable modules.

Modular Addons Multi-Tenancy Filament v3+ Native Dynamic Panels
$ composer require obelaw/twist
// Modular Twist Addon Registration
Twist::addon('inventory')
->resources([StockResource::class])
->navigationGroup('Operations');
04
Pillar 04 • Open Source Tools

Laravel Packages

Precision Standalone Tools for Artisans

A curated collection of standalone, MIT-licensed packages crafted specifically for the Laravel ecosystem to solve targeted problems with zero dead weight. Drop them into any standard Laravel project immediately.

$ composer require obelaw/attrify obelaw/trail
// Standalone dropped into any Eloquent model
class Product extends Model {
use HasDynamicAttributes;
}

The 4 Pillars at a Glance

How each pillar fits into your architecture and application lifecycle.

Architecture Matrix
Swipe horizontally to view full matrix
Pillar Role & Layer Core Responsibility Decoupling Level Package Command
Domain (DDD) Architecture & Modeling Bounded contexts, validated DTOs, single-purpose Actions, and CQRS queries. Pure Domain Purity obelaw/framework
IUM Core Domain Gateway Unified fluent API (ium()->...) across domains with zero UI ties. Framework-Agnostic Core obelaw/framework
Twist Platform Admin & Presentation Modular Filament addon architecture, dynamic navigation, and multi-tenancy. Laravel / Filament Native obelaw/twist
Laravel Packages Workbench Utilities Standalone tools for dynamic EAV (Attrify), audit trails (Trail), configs, and scheduler. Standalone & Composable obelaw/attrify, trail...
Full Harmony

How The 4 Pillars Work Together

Domain logic stays pure and decoupled at the core, while Twist and Laravel packages provide first-class integration into Laravel applications.

// app/Domains/Inventory/Actions/AdjustStockAction.php
namespace App\Domains\Inventory\Actions;

use App\Domains\Inventory\Data\StockAdjustmentData;
use App\Domains\Inventory\Events\StockAdjustedEvent;

final class AdjustStockAction
{
    public static function run(StockAdjustmentData $data): StockRecord
    {
        // Enforce domain invariants
        $stock = StockRecord::findOrFail($data->skuId);
        $stock->mutateQuantity($data->quantity);
        
        // Emit decoupled domain event
        StockAdjustedEvent::dispatch($stock);
        
        return $stock;
    }
}
The Obelaw Law

Architectural Rules We Never Break

Every package and domain is engineered against a strict set of principles. No monolithic traps, no bloat, and no shortcuts.

Decoupled Domain Logic

Core business logic lives purely in the domain layer, completely independent of any web framework runtime, HTTP routers, and presentation views.

Zero Bloat Policy

Deploy exactly what you need. Small footprints keep your applications fast, auditable, and free of dead vendor dependencies.

Strict Domain Invariants

State mutations must pass through validated DTOs and single-purpose Actions. Prevent architectural drift across large teams.

Event-Driven Architecture

Hook into any lifecycle event with isolated listeners. Extend behavior without mutating core domain files.

Laravel as Main Ecosystem

While domain logic remains framework-independent, Obelaw provides first-class native support, service providers, and Filament UI tools for Laravel as its primary ecosystem.

100% Open Source

MIT-licensed and community-driven. You can audit every line of code, fork freely, and integrate without licensing worries.

Laravel is Our Main Ecosystem

Obelaw’s core architectural principles are built on pure PHP and decoupled domain design, with first-class native tools, providers, and packages crafted primarily for the Laravel and Filament ecosystems.

PHP 8.2+ Core
Laravel 11/12
Filament v3+
MIT Open Source
Latest Updates

From The Blog

Insights on Domain-Driven Design, decoupled development, Twist addons, and Laravel package engineering.

Get Started

Ready to Build Decoupled Applications?

Adopt pure Domain (DDD), IUM fluent orchestration, Twist modular Filament addons, and precision Laravel packages.

Connect

Let's Talk Architecture

Have questions about structuring your domain boundaries, developing Twist addons, or integrating Obelaw packages into your project?