PARALLEL ENERGETIC RUNTIME · v0.1.2

Keep the web.
Give it a Universe.

Quetzalcoatl Core creates a demand-driven energetic Universe alongside the DOM. The DOM remains the semantic plane, Rust/WASM resolves energy and relationships, and WebGL2 materializes the response through the GPU.

Not preset animations.
Not a permanent render loop.
The world changes. The runtime responds.

Experience the rocio Effect$npm install quetzalcoatl-core
v0.1.2 · OPEN SOURCE · APACHE 2.0DOM · RUST / WASM · CRYSTAL · WEBGL2
WHY QUETZALCOATL CORE

Keep the DOM.
Give it a parallel Universe.

THE PROBLEM

The semantic plane. Content, structure, accessibility, native behavior and geometric reference remain in the web you already have, coordinated through the browser’s CPU-driven layout and painting pipeline.

As interfaces become more spatial, continuous and computationally dynamic, that pipeline becomes a constraint. Not on what we can show — but on how visual behavior can evolve.

A DIFFERENT MODEL

Two planes.
One web.

01DOM
SEMANTIC PLANE

Content, structure, accessibility, native behavior and geometric reference remain in the web you already have.

02UNIVERSE
PARALLEL RUNTIME

Participating elements gain identity, relationships, energy and dynamic state, with visual response materialized through the GPU.

THE SHIFT

The DOM defines the plane.
The Universe defines the space.

A DIFFERENT PROGRAMMING MODEL

From animation logic
to relational physics.

Quetzalcoatl Core introduces a relational physics runtime beside the DOM. Participating elements become runtime entities whose behavior can emerge from energy, mass, tension, deformation, motion and relationships.

ARCHITECTURAL COMPARISONExplore how the model differs
AREACONVENTIONAL APPROACHQUETZALCOATL CORE
UI motion

Properties are commonly interpolated between predefined visual states: position, scale, opacity or transforms.

Motion can emerge from relational physical state: mass, energy, tension, deformation and relationships between Nahuales.

State model

Application state usually represents values directly: coordinates, visibility, progress or animation state.

The Universe maintains a relational physical state where energy, mass, coupling, tension, deformation, motion and equilibrium can evolve.

Interaction

Input is commonly mapped directly to state changes or visual properties.

Input can enter the Universe as a Ray — an interaction perturbation that propagates through energetic state and relationships between Nahuales.

GPU graphics

Canvas-based engines commonly maintain an independent scene, geometry and coordinate system.

Crystal projects resolved Universe state while the DOM remains the semantic and geometric plane.

Runtime

Interactive graphical systems often maintain a render loop while the experience is active.

The Universe evolves toward equilibrium. QC can stop requesting its own frames once meaningful energetic activity has settled.

WHY A UNIVERSE?

Inspired by a universe
of interacting states.

Quetzalcoatl is conceptually inspired by the idea of a universe composed of interacting states rather than isolated visual properties.

It is not a quantum physics simulation. The inspiration is architectural: entities carry state, relationships connect them, perturbations affect the system and the runtime resolves how that state evolves.

UNIVERSE STATEExplore the internal state model
MASSinertia
ENERGYactivity
TENSIONresistance
DEFORMATIONresponse
RELATIONSHIPScoupling
EQUILIBRIUMrest
RELATIONAL PHYSICS

Interaction perturbs the runtime state.
The Universe resolves how that state evolves.

THE CORE

Change enters.
The Universe responds.

Quetzalcoatl Core maintains a parallel runtime beside the DOM. Participating elements become Nahuales, interactions perturb the Universe through Rays, Rust/WASM resolves energy and relationships, and Crystal materializes the resulting visual response through WebGL2 on the GPU.

CHANGEInteraction · DOM · Geometry · State
RAY
RAYAn interaction signal that perturbs the Universe.

A Ray carries change into the runtime with an origin, direction and intensity.

NAHUALThe runtime counterpart of a participating element.

A Nahual gives a participating DOM element identity, energy, state, hierarchy and relationships inside the Universe.

A
SEMANTIC PLANE

DOM

HTMLCSSSemanticsNative behaviorGeometry

The DOM remains the source of semantics, native behavior and geometric truth. QC extends the web without replacing it.

B
PARALLEL RUNTIME

Universe

NahualesParticipationEnergyRelationshipsHierarchy

The Universe maintains the runtime identity, energy, hierarchy and relationships of participating elements.

C
STATE RESOLUTION

Rust / WASM

EnergyCouplingResonanceMotionEquilibrium

Rust/WASM evolves the Universe, resolving energy, relationships and motion until the active state approaches equilibrium.

D
MATERIALIZATION

Crystal

ProjectionSurfacesDisplacementGPU

Crystal projects resolved runtime state into visible GPU materialization through WebGL2 alongside the native DOM.

Explore the Architecture Spec
DEMAND-DRIVEN RUNTIME

Quiet by default.
Active on demand.

Change wakes the runtime. Quetzalcoatl Core evolves while active energy or pending change remains, resolves the response, updates its visual manifestation, and returns to a quiet state once equilibrium is reached.

RUNTIME ACTIVITYQUIET → ACTIVE → QUIET
ACTIVE
01QUIETNo active frame processing
02CHANGEInput or state changes
03WAKERuntime activates
04EVOLVEUniverse state resolves
05MATERIALIZEGPU output updates
06EQUILIBRIUMReturn to quiet
QUIET UNIVERSENo permanent render loop.
THE ROCIO EFFECT

Disturb the Universe.
Watch it respond.

This is not a preset animation.Your pointer introduces a Ray into the Universe. Rust/WASM resolves the resulting state, and Crystal materializes the visual response through WebGL2 on the GPU.
MOVE YOUR POINTER OR TAP TO PERTURB THE UNIVERSE
ROCIO INTENSITY0.90
subtlefull
05 / QUICK START

Enter the
Universe.

Start with the web stack you already use. Select your environment to see how Quetzalcoatl Core enters the application, how elements participate and how Rocio is manifested.

INSTALL
$npm install quetzalcoatl-core
CHOOSE YOUR STACKUse the React integration to wrap an application or subtree and control participation directly from JSX.
IMPLEMENTATION GUIDEREACT
01
IMPORTREACT INTEGRATION
import {
    Quetzalcoatl
} from "quetzalcoatl-core/react";
React applications use the Quetzalcoatl integration exported by the package.
02
ENTER THE UNIVERSEPARTICIPATION: ALL
export default function App() {
    return (
        <Quetzalcoatl participation="all">
            <main>
                <Interface />
            </main>
        </Quetzalcoatl>
    );
}
In all mode, supported elements participate by default.
03
PARTICIPATE EXPLICITLYPARTICIPATION: EXPLICIT
<Quetzalcoatl participation="explicit">
    <main>
        <NativeContent />

        <section qc>
            <InteractiveExperience />
        </section>
    </main>
</Quetzalcoatl>
In explicit mode, content stays native until qc enables participation.
04
MANIFEST ROCIOVISUAL RESPONSE
export function Card() {
    return (
        <article qc rocio>
            <h2>
                Universe active.
            </h2>
        </article>
    );
}
qc enables participation. rocio requests the visual energetic manifestation.
CORE ATTRIBUTES
qcenables participation
noqckeeps content native
rocioenables visual manifestation