Aperture 3D engine for the agentic age.

About

What Aperture is.

Aperture is a WebGPU-only, ECS-native 3D runtime built around a simple architecture: ECS is authoritative, rendering is derived from snapshots, simulation can live in a worker, and coding agents are treated as first-class contributors. These are the concrete pieces that matter to the assumptions below.

npx @aperture-engine/cli create my-app

ECS is authoritative

Implemented

Gameplay state lives in ECS. Rendering, input, physics, and tooling read from that data boundary instead of a renderer-owned scene graph.

  • Entities, transforms, hierarchy, resources, and gameplay state are ECS data.
  • Rendering is derived from extracted snapshots.
  • The renderer does not own authoritative game objects.

Worker-first runtime

Implemented

The default browser shape keeps simulation portable to a worker while the main thread owns the canvas, WebGPU, input, and UI.

  • Simulation and extraction can run off the main thread.
  • Render snapshots are structured data passed across the boundary.
  • The split makes deterministic stepping and inspection easier.

WebGPU-only renderer

Implemented

Aperture targets the modern browser GPU stack directly, including materials, shadows, post effects, readback, and diagnostics.

  • No WebGL fallback in the core renderer.
  • Examples exercise cameras, lighting, materials, physics, particles, and UI.
  • Showcase apps prove the path beyond small demos.

Agent-readable tooling

Active thesis

The engine is built around structured diagnostics, generated API references, runtime inspection, and reproducible routes.

  • Errors should explain what failed and what to inspect next.
  • Examples and showcases double as verification surfaces.
  • Reference search gives agents and humans the same indexed corpus.

Assumptions

The bets being tested.

Aperture began as research, so these are intentionally short working hypotheses, not launch claims. Some of them may be wrong.

  1. 01 Validated

    Building a 3D engine is becoming a one-person job

    Agents can carry enough implementation, migration, and verification work that a single developer can own engine-scale scope. The open question is how far that holds under production pressure.

  2. 02 Active thesis

    Agent-native structure can beat training-data familiarity

    For hard iterative work, inspectable state, deterministic checks, and machine-readable diagnostics may matter more than ecosystem popularity.

  3. 03 Active thesis

    Web 3D should be worker-first by default

    Keeping simulation off the main thread improves responsiveness and gives tools a clean data boundary to step, diff, and replay.

  4. 04 Active thesis

    Agentic 3D work moves toward headless validation

    Agents should be able to change ECS systems and validate state before paying the cost of browser and GPU rendering.

  5. 05 Active thesis

    The ecosystem moat may weaken

    If agents can study and port ideas quickly, engine architecture may matter more, though mature ecosystems still matter a lot today.

Search

The reference index is part of the experiment: humans and agents can search the same generated docs, public APIs, examples, diagnostics, and curated source chunks.

Enter a question or capability and rank matches with the pinned local embedding contract.

3,374 chunksjinaai/jina-embeddings-v2-base-code

Ready