EXPERIMENTAL RUNTIME PROPOSAL

DOM++

A browser-native mutation runtime exploring deterministic DOM updates, optional reactivity, fine-grained signals, and progressive enhancement without virtual DOM reconciliation.

Explore Examples Architecture Docs GitHub

Philosophy

DOMPP extends native DOM prototypes with small chainable setters while preserving direct access to browser APIs.

No virtual DOM. No hidden reconciliation. No compiler required.

Direct DOM Mutation

DOMPP mutates native DOM nodes directly without virtual DOM diffing or reconciliation layers.

Optional Reactivity

Choose between local stateful runtime or optional fine-grained signals.

Existing DOM Enhancement

Enhance existing server-rendered HTML without subtree recreation or hydration engines.

What DOMPP Is Not

DOMPP intentionally avoids several common framework abstractions.

No Virtual DOM

DOMPP mutates native DOM nodes directly without tree diffing or reconciliation passes.

No Compiler

DOMPP does not require JSX, template compilation, or build-time transforms.

No Hidden Runtime Ownership

State remains attached directly to DOM elements and follows explicit mutation flow.

Runtime Architecture

DOMPP is designed around explicit mutation flow and native DOM mental models.

Runtime Architecture

Runtime Semantics

DOMPP examples also document runtime behavior and mutation semantics.

Stateful Mutation

Explore how local state reruns reactive setters and propagates mutation through the DOM.

Fine-Grained Signals

Understand direct signal subscriptions and isolated setter-level reactivity.

Identity Preservation

Learn how DOMPP handles node reuse, child replacement, and runtime ownership.

Examples

DOMPP examples are designed as runtime learning blocks.

Each example progressively explores: deterministic mutation, reactive ownership, DOM identity preservation, fine-grained updates, and browser-native runtime semantics.

Foundations

01 — Basic Text Simplest chainable text mutation using native DOM nodes. 02 — Basic Styles Inline style mutation using partial style updates. 03 — Basic Attributes Unified attribute mutation including boolean attributes. 04 — Basic Children Declarative child tree composition without virtual DOM diffing. 05 — Basic Events Chainable event listeners with deterministic replacement.

Mutation Semantics

06 — Mutation Consistency Deterministic setter behavior and predictable mutation flow. 07 — children vs childNodes Structural differences between element-only and full node traversal. 08 — Fragment Support Native DocumentFragment support without unnecessary wrappers.

Reactive Runtime

09 — Reactive Counter Reactive setters driven by local element state. 10 — Reactive Children Declarative reactive child trees rebuilt from state. 11 — Reusable Stateful Elements Component-like reusable factories using native DOM nodes. 12 — Cross Element State External mutation of element state through DOM references. 13 — Existing DOM Enhancement Enhance server-rendered DOM without subtree recreation. 14 — Fine-Grained Signals Optional signal-based reactivity with isolated setter reruns. 15 — Enhancement + Signals Combine existing DOM enhancement with fine-grained subscriptions.

Runtime Semantics

16 — State Equality Behavior Explore rerender behavior when mutating identical state values. 17 — Nested Stateful Elements Parent-child runtime ownership and nested state behavior. 18 — Keyed List Behavior DOM identity preservation through reused node references. 19 — DOM Identity Preservation Runtime ownership attached directly to DOM node identity. 20 — Reactive Feed Prepend and append feed mutation with editable stateful posts. 21 — JSX Integration Use JSX syntax with a tiny custom pragma factory powered by Babel (or your bundler).

Native Runtime Exploration

Architecture & Runtime Docs Explore runtime flow, mutation architecture, signals, enhancement semantics, and browser-native runtime proposals.

Experimental Runtime Proposal

DOMPP explores the idea that browser-native mutation APIs could evolve into a richer runtime layer capable of supporting higher-level frameworks and compilers.

Rather than replacing the DOM, DOMPP investigates how the DOM itself might become the runtime infrastructure.