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

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.

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
01. Domain (DDD) Pure Purity
Layer: Architecture & Modeling

Bounded contexts, validated DTOs, single-purpose Actions, and CQRS queries.

Package: obelaw/framework
02. IUM Core Agnostic Core
Layer: Domain Gateway

Unified fluent API (ium()->...) across domains with zero UI ties.

Package: obelaw/framework
03. Twist Platform Filament Native
Layer: Admin & Presentation

Modular Filament addon architecture, dynamic navigation, and multi-tenancy.

Package: obelaw/twist
04. Packages Composable
Layer: Workbench Utilities

Standalone tools for dynamic EAV (Attrify), audit trails (Trail), configs, and scheduler.

Package: obelaw/attrify, trail...
Full Harmony

How The 4 Pillars Connect Together

Domain logic stays pure and decoupled at the core, while IUM bridges entrypoints, and Twist + Laravel packages provide first-class UI and tools for Laravel.

// 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 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 Licensed
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.

FAQ

Frequently Asked Questions

Common architectural and technical questions about Obelaw, Domain-Driven Design, and Laravel integration.

What is Obelaw and how does it fit into the Laravel ecosystem?

Obelaw is an open-source decoupled architecture platform designed around Domain-Driven Design (DDD). It isolates business logic from framework infrastructure while treating Laravel as its primary, first-class implementation ecosystem.

What are the 4 core pillars of the Obelaw architecture?

The 4 pillars are: 1) Domain (DDD) for pure bounded contexts and business invariants; 2) IUM for a fluent orchestration API; 3) Twist for modular Filament admin panels; and 4) curated open-source Laravel packages like Attrify, Runner, and Trail.

How does Obelaw implement Domain-Driven Design (DDD) in Laravel?

Obelaw organizes code into self-contained domain folders with aggregate roots, value objects, domain events, transactional outbox relays, and CQRS actions/queries, preventing monolithic models and tight coupling.

What is IUM (Interactive Ubiquitous Model)?

IUM is the fluent developer gateway connecting decoupled domains to delivery layers (HTTP, CLI, queues) through a clean, chainable API without exposing internal models.

Can I adopt Obelaw incrementally in an existing Laravel application?

Yes. You can install obelaw/framework or individual packages like Attrify, Runner, or Trail via Composer into an existing Laravel codebase without rewriting your application.

What vertical solutions are powered by Obelaw?

Obelaw powers vertical solutions such as Obelaw Dental Practice Management, featuring interactive odontograms, periodontal charting, and 2-way clinical-to-invoice synchronization with Intuit QuickBooks.

Connect

Let's Talk Architecture

Have questions about structuring your domain boundaries, developing Twist addons, or integrating Obelaw packages into your Laravel project? We're here to help.

Direct architectural advisory • Replies within 24h