v0.21

a fully integrated javascript application framework built around elegance by default.

build status

about dframework

dframework is an opinionated framework that enforces architectural consistency and deterministic behavior. it controls the complete application lifecycle including routing, rendering, components, styling, assets, state management, compilation, transport, and native runtime integration.

plugin ecosystems, adapter layers, and competing architectural patterns are intentionally rejected. dframework is designed to be used as a complete framework without partial adoption.

who dframework is for

dframework targets developers who value integrated tooling, enforced conventions, architectural consistency, and minimal configuration. it provides deterministic application structure, long term maintainability, and framework controlled optimizations.

it may not suit developers who prefer custom stacks, plugin ecosystems, interchangeable tooling, progressive adoption, or extensive runtime customization.

developing with dframework

dframework removes architectural decision making, allowing developers to focus on application logic rather than tooling assembly.

routes are defined declaratively:

1Route.get('/', 'HomeController@index');
2Route.post('/users', 'UserController@store').name('users.store');

controllers handle request logic:

1export default class UserController extends Controller {
2  async store(req) {
3    const validation = validate(req.body, {
4      email: 'required|email',
5      password: 'required|min:8'
6    });
7 
8    if (validation.fails()) {
9      return abort(422).withErrors(validation.errors());
10    }
11 
12    const user = await User.create({
13      email: req.body.email,
14      password: req.body.password
15    });
16 
17    return json({ user });
18  }
19}

views use a compiled templating system:

1@extends('layouts.app')
2 
3@section('content')
4  <div d-live="users" d-live-filter="active:1">
5    @foreach(await User.where({ active: 1 }) as user)
6      <div class="flex-row gap-05">
7        {{ user.email }}
8        <d-hold-button
9          d-wire="user:destroy"
10          d-wire-data="id:{{ user.id }}">delete</d-hold-button>
11      </div>
12    @endforeach
13  </div>
14@endsection

native application workflows:

1dstrn simulate --ios
2dstrn build --ios

quick start

1npm install -g dframework
2dstrn init my-app
3cd my-app
4dstrn serve

philosophy

dframework follows core principles that shape its architecture:

architectural consistency

applications should not require extensive architectural decisions. directory structure, lifecycle behavior, rendering flow, and framework conventions are intentionally enforced to ensure structural consistency across all dframework applications.

closed world architecture

dframework assumes complete ownership of the application runtime. routing, rendering, styling, state management, compilation, and transport form a single coherent system without support for partial adoption.

performance through coherence

performance emerges from architectural coherence and assumption density. by controlling the full lifecycle, the framework aggressively optimizes routing, middleware dispatch, rendering, serialization, hydration, template compilation, and memory allocation as a unified runtime rather than a collection of interchangeable libraries.

convention over configuration

configuration is intentionally minimal. directory structure, lifecycle patterns, and architectural conventions are enforced by the framework, with configurations provided only when they reinforce this philosophy.

forward evolution

legacy compatibility layers are intentionally avoided. when architectural improvements require breaking changes, applications are expected to migrate forward, prioritizing internal consistency over long term backward compatibility.

non goals

the framework intentionally excludes:

these restrictions are fundamental to maintaining architectural integrity.

why dframework

modern development increasingly relies on fragmented tooling, layered abstractions, and interchangeable architectures, leading to configuration fatigue, dependency instability, architectural inconsistency, runtime overhead, and unpredictable application structure.

dframework takes an opposing approach by prioritizing coherence, predictability, deterministic architecture, integrated tooling, runtime efficiency, and long term maintainability.

constraints in dframework exist to strengthen system integrity rather than limit developers arbitrarily.

features

dframework provides:

performance

dframework achieves performance through its closed world runtime architecture with strong assumptions. by controlling the complete lifecycle, the framework optimizes across subsystem boundaries rather than relying on interchangeable abstractions.

benchmark results and methodology:

documentation

fundamentals

data management

frontend development

asynchronous processing

tooling

security

native applications

contributing

before contributing, understand that dframework is intentionally opinionated.

features that weaken architectural consistency, introduce alternate paradigms, or reduce framework control over the runtime will be rejected.

all contributions must align with the framework philosophy.

license

mit