scenic-bpy 0.6.0__tar.gz

scenic_bpy-0.6.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+      - name: Run spec tests (no Blender required)
+        run: uv run --python ${{ matrix.python-version }} --extra dev pytest -q
+
+  bpy-smoke:
+    # End-to-end against the real bpy wheel: compile the examples headless.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+      - name: Build examples to .blend and .glb
+        run: |
+          uv run --python 3.11 --extra blender scenic build examples/hero_shot.py -o /tmp/hero.blend
+          uv run --python 3.11 --extra blender scenic build examples/meadow.py -o /tmp/meadow.glb
+          uv run --python 3.11 --extra blender scenic build examples/arm.py -o /tmp/arm.blend
+          uv run --python 3.11 --extra blender scenic docs examples/orbit.py --json > /tmp/catalog.json
+          test -s /tmp/hero.blend && test -s /tmp/meadow.glb && test -s /tmp/catalog.json

scenic_bpy-0.6.0/.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: Publish to PyPI
+
+# Publishes on version tags (v0.6.0, ...). Uses PyPI Trusted Publishing — one-time
+# setup at pypi.org: Account > Publishing > add GitHub publisher for
+# satyam-fp/scenic-bpy, workflow publish.yml, environment pypi.
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Build sdist and wheel
+        run: uv build
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

scenic_bpy-0.6.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+dist/
+out/
+*.blend
+*.blend1
+uv.lock

scenic_bpy-0.6.0/DESIGN.md

@@ -0,0 +1,258 @@
+# Scenic (working title) — a FastAPI-style framework for bpy
+
+One-liner: **declare typed, composable scene components; the framework compiles them into a
+.blend.** You write pure Python functions with type hints; Scenic handles everything that makes
+raw bpy miserable.
+
+## Why FastAPI is the right model
+
+FastAPI's magic is not HTTP — it's the shape:
+
+| FastAPI | Scenic |
+|---|---|
+| `@app.get("/x")` registers a route | `@app.asset()` / `@app.material()` / `@app.scene()` registers a component |
+| Pydantic validates request params | Pydantic validates component params before any bpy call runs |
+| `Depends()` injects shared resources | `Depends()` injects other components (materials into objects, rigs into characters) |
+| Starlette does the ugly ASGI work | The bpy backend does the ugly context/selection/mode work |
+| Auto-generated OpenAPI docs | Auto-generated component catalog + JSON Schemas (also = LLM tool definitions) |
+| `uvicorn --reload` | `scenic watch` — edit script, scene rebuilds incrementally |
+
+## What raw bpy gets wrong (the framework's job is to absorb all of this)
+
+- **Global mutable state**: active object, selection, mode. Operators silently fail or hit the
+  wrong object. Scenic saves/restores state around every builder; builder code never touches it.
+- **`bpy.ops` context fragility**: Scenic prefers `bpy.data` construction internally; when an
+  operator is unavoidable it runs under a correct `temp_override`.
+- **Naming collisions & orphan datablocks**: Scenic owns naming (stable IDs) and lifecycle
+  (garbage-collects datablocks it created that are no longer referenced).
+- **Node trees are graph plumbing**: 40 lines of `links.new(...)` for a simple material. Scenic
+  gives a socket-piping DSL.
+- **No validation**: errors surface deep inside a 500-line script. Scenic validates every
+  parameter and every cross-reference before compiling anything.
+- **Non-reproducibility**: same script, different results depending on the open file. Scenic
+  builds are deterministic functions of (code, params, seed).
+
+## Core architecture: spec layer vs. compiler
+
+The single most important decision. Builders do **not** call bpy. They return **specs** — plain
+Pydantic models describing what should exist:
+
+```
+user code (builders)  →  SpecGraph (pure data, no bpy)  →  Compiler (bpy backend)  →  .blend
+```
+
+Why split:
+
+1. **Testable without Blender** — unit tests over specs run in milliseconds, no bpy import.
+2. **Validatable before execution** — a bad param never half-mutates a scene.
+3. **Serializable** — a scene spec is JSON. Diff it, cache it, send it over the wire, have an
+   LLM emit it directly against the schema.
+4. **Reconcilable** — the compiler can diff desired spec vs. what's tagged in the open file and
+   rebuild only what changed (see Incremental builds).
+
+The compiler is the *only* module that imports bpy. Everything above it is a normal Python
+library.
+
+**Escape hatch** (non-negotiable — no spec layer covers all of Blender): a builder can request
+raw access. It runs inside a managed context that snapshots/restores selection/mode/active and
+tags whatever datablocks it creates:
+
+```python
+@app.asset(raw=True)
+def weird_thing(ctx: BpyContext, twist: float = 1.0):
+    obj = ctx.new_mesh_object("weird")     # tagged + tracked automatically
+    # ... arbitrary bpy against ctx ...
+    return obj
+```
+
+## The API, sketched
+
+```python
+from scenic import Scenic, Depends, Field
+from scenic.geometry import Cube, Bevel, Array
+from scenic.shading import PrincipledBSDF, NoiseTexture, ColorRamp, Mix
+
+app = Scenic()
+
+@app.material()
+def rust_metal(rust: float = Field(0.4, ge=0, le=1), scale: float = 8.0):
+    base = PrincipledBSDF(metallic=1.0, roughness=0.35)
+    mask = NoiseTexture(scale=scale).fac >> ColorRamp(stops=[(0.4, "black"), (0.6, "white")])
+    rusty = PrincipledBSDF(base_color=(0.35, 0.13, 0.05, 1), roughness=0.9)
+    return Mix(fac=mask * rust, a=base, b=rusty)   # sockets pipe with >> and arithmetic ops
+
+@app.asset()
+def crate(size: float = 1.0, mat=Depends(rust_metal)):
+    return (
+        Cube(size=size)
+        .modify(Bevel(width=0.02, segments=3))
+        .shade(mat)
+    )
+
+@app.asset()
+def crate_stack(rows: int = Field(3, ge=1, le=20), jitter: float = 0.05, seed: int = 0):
+    rng = app.rng(seed)                     # seeded randomness, injected → reproducible
+    return Group(
+        crate(size=1.0).at(pos + rng.uniform(-jitter, jitter, 3))
+        for pos in grid(rows)
+    )
+
+@app.scene()
+def hero_shot(stack=Depends(crate_stack)):
+    return Scene(
+        objects=[stack],
+        camera=Camera(pos=(6, -6, 4), look_at=stack.center, lens=50),
+        lights=[Sun(energy=3, rotation=(45, 0, 30))],
+        world=HDRI("studio.exr", strength=1.2),
+        render=Render(engine="CYCLES", resolution=(1920, 1080), samples=128),
+    )
+```
+
+Everything is a function of typed params → components compose like ordinary code. `Depends`
+gives you the DAG for free: build order, datablock reuse (two objects depending on
+`rust_metal(rust=0.4)` share one material), and cache keys.
+
+### Animation
+
+Two entry points, both compiling to fcurves:
+
+```python
+@app.animation()
+def crate_drop(target: ObjectRef, height: float = 5.0):
+    with timeline(fps=24) as t:
+        t.at(0).of(target).loc(z=height)
+        t.at(30).of(target).loc(z=0).ease("BOUNCE", "EASE_OUT")
+        t.at(30).of(target).scale(1, 1, 0.8)   # squash
+        t.at(36).of(target).scale(1, 1, 1)
+```
+
+Plus declarative `Track`/`Key` models for programmatic generation (LLMs, mocap import), and
+`Driver(expr="...", vars=...)` as a first-class spec.
+
+### Rigging
+
+Declarative skeleton spec — bones, constraints, IK chains, and weight strategy:
+
+```python
+@app.rig()
+def simple_arm():
+    return Rig(
+        bones=chain("upper", "fore", "hand", lengths=[0.35, 0.30, 0.1]),
+        ik=[IK(target_bone="hand", chain_len=2, pole="elbow_pole")],
+        controls=[Control("hand_ctrl", drives="hand", shape="cube")],
+    )
+```
+
+Humanoid preset (`HumanoidRig(proportions=...)`) later; the primitive layer
+(Bone/Constraint/IK/Driver specs) comes first.
+
+## Incremental builds (the `--reload` moment)
+
+Every datablock the compiler creates is tagged with a component ID and a hash of the resolved
+params (custom properties: `scenic_id`, `scenic_hash`). On rebuild:
+
+1. Resolve the spec graph (cheap, pure Python).
+2. Diff against tags in the open file.
+3. Rebuild only dirty nodes; relink dependents; GC orphans Scenic owns.
+
+That makes `scenic watch` feel like hot reload — edit a material param, only that material
+recompiles, viewport updates in place. Untagged (user-made) datablocks are never touched.
+
+## Runtime & CLI
+
+Two execution homes, same code:
+
+- **Headless**: `pip install scenic bpy` → runs anywhere Python runs (CI, render farm, server).
+- **In-Blender**: thin addon that hosts the watch loop so you get live viewport feedback while
+  editing scripts in your editor.
+
+```
+scenic build scenes.py -t hero_shot -p rows=5 -o hero.blend
+scenic render scenes.py -t hero_shot -o hero.png
+scenic watch scenes.py -t hero_shot          # rebuild on save (headless or into a live Blender)
+scenic docs  scenes.py                       # catalog: every component + its JSON Schema
+scenic serve scenes.py --port 8000           # literally a FastAPI app: POST params → .blend/.glb/PNG
+```
+
+`serve` is the punchline: because components are typed and validated, wrapping them in real
+FastAPI endpoints is nearly free — a scene-generation microservice from the same file.
+
+`docs` doubles as **LLM tool schemas**: every component already has a name, description
+(docstring), and JSON Schema. An agent can discover and call the whole catalog with validated
+arguments instead of emitting freehand bpy.
+
+## Libraries (the APIRouter analog)
+
+```python
+# scenic_scifi/  (a pip package)
+lib = Library(name="scifi", prefix="scifi")
+
+@lib.asset()
+def corridor(...): ...
+
+# user code
+app.include(lib)
+```
+
+Asset packs become versioned pip dependencies. This is how an ecosystem forms.
+
+## Module layout
+
+```
+scenic/
+  core/        # Scenic app, registry, Depends resolution, Pydantic base specs, hashing, rng
+  geometry/    # primitives, mesh-from-data, modifier stack, geometry-nodes wrapper
+  shading/     # node DSL, material/texture specs
+  animation/   # timeline DSL, tracks, drivers, NLA
+  rigging/     # bones, constraints, IK, controls, skinning
+  staging/     # scene, camera, lights, world, render settings, compositor (later)
+  compile/     # THE ONLY bpy importer: compiler, reconciler, context guard, naming, GC
+  cli/         # build/render/watch/docs/serve
+```
+
+## Prior art (and the open slot)
+
+- **Infinigen** (Princeton): huge procedural bpy codebase — proof this works at scale, but it's
+  a research monolith, not a reusable typed framework.
+- **Geometry Script**: lovely, but geometry-nodes-only.
+- **bpy wheel**: makes headless distribution trivial — the enabler, not a competitor.
+- Nothing occupies "typed, composable, validated app framework over bpy." That's the slot.
+
+## Risks / honest costs
+
+- **API surface is enormous.** Mitigation: the spec layer is deliberately partial; `raw=True`
+  is the pressure valve from day one. Coverage grows by demand, not completionism.
+- **Blender version drift** (4.x renames enums/sockets regularly). Mitigation: compiler is the
+  only bpy-touching module; version shims live there; CI matrix over bpy wheels.
+- **Reconciler correctness** is the hardest subsystem. Ship v1 as "wipe managed collection +
+  full rebuild" (still fast headless); make it incremental in v2.
+
+## MVP roadmap
+
+1. ✅ **v0.1 — the spine**: `Scenic` app, `@asset/@material/@scene`, Pydantic specs, `Depends`,
+   compiler for meshes/primitives/modifiers/Principled materials, `scenic build/render`,
+   full-rebuild semantics, seeded rng.
+2. ✅ **v0.2 — the feel**: shading node DSL with socket piping, `scenic watch` + in-Blender
+   addon, `scenic docs`. (Geometry nodes wrapper deferred to v0.3.)
+3. ✅ **v0.3 — motion**: timeline DSL (`.at().loc().ease()`), animation components, slotted
+   actions (bpy 5.0) with 4.2 legacy fallback; incremental reconciler with mesh/material
+   dedup by content hash. (Drivers, NLA, geometry nodes deferred to v0.4.)
+4. ✅ **v0.4 — ecosystem**: drivers (scripted expressions + cross-object variables),
+   `Library`/`include`, `scenic serve` (FastAPI over components; PNG/blend/glb responses),
+   glTF export. (Rigging, NLA, geometry nodes deferred to v0.5.)
+5. ✅ **v0.5 — bodies**: rigging primitives (bones, chains, IK/constraints, auto-weight
+   skinning via `.skinned()`), pose-bone Timeline keys (`t.at(f).bone("ctrl").loc(...)`),
+   NLA strips via `.play()`. (Geometry nodes, humanoid preset deferred to v0.6.)
+6. ✅ **v0.6 — procedural**: geometry nodes wrapper (scatter/instancing DSL attached via
+   the GeoNodes modifier), humanoid rig preset (19-bone biped, 4 IK chains).
+
+The original roadmap is complete. Beyond it: node-tree exposure of modifier inputs,
+cross-object driver/constraint targets, physics specs, USD export, `scenic diff`.
+
+## Open questions
+
+- Name. (`scenic` is a placeholder — `scenic` on PyPI may be taken.)
+- Is LLM-facing schema export a first-class goal from v0.1? (Given Mixar, probably yes — it
+  changes how much effort goes into docstrings/descriptions early.)
+- Minimum Blender/bpy version to target (bpy wheel requires Python 3.11 for 4.x — pinning to
+  4.2 LTS is the safe floor).

scenic_bpy-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Satyam Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

scenic_bpy-0.6.0/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: scenic-bpy
+Version: 0.6.0
+Summary: A FastAPI-style framework for building Blender scenes from typed, composable components.
+Project-URL: Repository, https://github.com/satyam-fp/scenic-bpy
+Author: Satyam Kumar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3d,blender,bpy,procedural,scene-generation
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.5
+Provides-Extra: blender
+Requires-Dist: bpy>=4.2; extra == 'blender'
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: serve
+Requires-Dist: fastapi>=0.110; extra == 'serve'
+Requires-Dist: uvicorn>=0.29; extra == 'serve'
+Description-Content-Type: text/markdown
+
+# scenic
+
+A FastAPI-style framework for building Blender scenes with `bpy`: declare typed, composable
+components; scenic compiles them into a `.blend`. No UI, no clicks — just Python.
+
+| Procedural rust (shader DSL) | Geometry-node scatter |
+|---|---|
+| ![rust crates](docs/images/rust_crates.jpg) | ![meadow](docs/images/meadow.jpg) |
+
+| Driver-powered orbit | IK arm + auto-skinning |
+|---|---|
+| ![orbit](docs/images/orbit.jpg) | ![arm wave](docs/images/arm.gif) |
+
+Every image above is the output of a spec file in [`examples/`](examples), rendered headless
+with `scenic render` — no Blender UI was opened.
+
+```python
+from scenic import Scenic, Depends, Field
+from scenic.geometry import Cube, Bevel
+from scenic.shading import PrincipledBSDF
+from scenic.staging import Scene, Camera, Sun
+
+app = Scenic()
+
+@app.material()
+def steel(roughness: float = Field(0.3, ge=0, le=1)):
+    return PrincipledBSDF(metallic=1.0, roughness=roughness)
+
+@app.asset()
+def crate(size: float = 1.0, mat=Depends(steel)):
+    return Cube(size=size).modify(Bevel(width=0.03, segments=3)).shade(mat)
+
+@app.scene()
+def main(box=Depends(crate)):
+    return Scene(
+        objects=[box],
+        camera=Camera(location=(4, -4, 3), look_at=(0, 0, 0)),
+        lights=[Sun(energy=3, rotation=(50, 0, 30))],
+    )
+```
+
+```bash
+scenic build  scenes.py -o out/main.blend          # compile to a .blend
+scenic render scenes.py -o out/main.png -p size=2  # render a still, override params
+scenic docs   scenes.py --json                     # component catalog as JSON Schemas
+```
+
+## How it works
+
+Builders never call bpy. They return **specs** — immutable Pydantic models. The compiler
+(`scenic.compile`, the only module that imports bpy) realizes specs into datablocks. That split
+means params are validated before anything mutates a scene, tests run without Blender, scenes
+serialize to JSON, and equal specs dedup to shared datablocks (two crates with the same `steel`
+share one material).
+
+See [DESIGN.md](DESIGN.md) for the full architecture and roadmap.
+
+## Install
+
+```bash
+pip install -e ".[dev]"        # framework + tests (no Blender needed)
+pip install -e ".[blender]"    # + the bpy wheel for headless build/render
+```
+
+Requires Python 3.11+. Runs headless via the `bpy` wheel or inside Blender 4.2+.
+
+## Shader node DSL
+
+Materials are node graphs written as expressions — sockets pipe with `>>`, scalar arithmetic
+becomes Math nodes, and the whole graph is still an immutable, JSON-serializable spec:
+
+```python
+from scenic.shading import Bump, ColorRamp, Mix, NoiseTexture, PrincipledBSDF
+
+@app.material()
+def rust_metal(rust: float = Field(0.5, ge=0, le=1)):
+    steel = PrincipledBSDF(base_color=(0.55, 0.56, 0.58), metallic=1.0, roughness=0.35)
+    corrosion = PrincipledBSDF(
+        base_color=NoiseTexture(scale=24).fac >> ColorRamp(stops=((0.3, (0.22, 0.06, 0.02)), (0.7, (0.45, 0.18, 0.06)))),
+        roughness=0.85,
+        normal=NoiseTexture(scale=30, detail=8).fac >> Bump(strength=0.4),
+    )
+    mask = NoiseTexture(scale=6, detail=6).fac >> ColorRamp(stops=((0.35, "black"), (0.65, "white")))
+    return Mix(fac=mask * rust, a=steel, b=corrosion)
+```
+
+## Animation
+
+Keyframes are authored on a `Timeline` and attached to objects with `.animate()`.
+`.ease()` shapes the motion *into* the keys you just set — what animators mean:
+
+```python
+from scenic.animation import Timeline
+
+@app.animation()
+def drop_and_squash(height: float = 4.0, land: int = 18):
+    t = Timeline()
+    t.at(1).loc(z=height)
+    t.at(land).loc(z=0.5).ease("BOUNCE", "EASE_OUT")   # arrive with a bounce
+    t.at(land + 3).scale(1.2, 1.2, 0.6)                # squash
+    t.at(land + 9).scale(1, 1, 1).ease("BACK", "EASE_OUT")
+    return t
+
+ball = Sphere(radius=0.5).animate(drop_and_squash(height=6))
+```
+
+```bash
+scenic render examples/bounce.py -o out/bounce.mp4    # full frame range
+```
+
+Rotations are authored in degrees. The compiler targets Blender 5.0's slotted
+actions with a 4.2 legacy fallback. The pip `bpy` wheel can't encode video, so
+`.mp4` output renders PNG frames and assembles them with system ffmpeg.
+
+## Live reload
+
+```bash
+scenic watch scenes.py -o out/main.blend    # rebuilds on every save
+```
+
+Builds are **incremental**: every managed datablock carries a content-hash key, and
+rebuilds only create/remove what changed (a no-op rebuild of a 30-object scene is ~4 ms;
+identical geometry and materials are shared datablocks).
+
+For a live viewport inside Blender, install `scenic/addon.py` (requires
+`pip install scenic-bpy` into Blender's Python): a **Scenic** tab appears in the
+3D-viewport sidebar with *Build Once* and *Watch* — only the managed "Scenic"
+collection is ever touched.
+
+## Libraries
+
+`Library` is the `APIRouter` analog — a mountable pack of components, distributable as a
+pip package:
+
+```python
+from scenic import Library
+
+parts = Library("scifi")
+
+@parts.asset()
+def corridor(...): ...
+
+app.include(parts)          # available as "scifi.corridor"
+```
+
+## Drivers
+
+Scripted expressions on any channel; variables reference other objects by name:
+
+```python
+moon = IcoSphere(radius=0.2).named("moon").drive("location", "cos(frame / 24) * 3", index=0)
+sat = Sphere(radius=0.1).drive("location", "moon_z + 2", index=2,
+                               variables=(Var("moon_z", target="moon", transform="LOC_Z"),))
+```
+
+## Serving scenes over HTTP
+
+```bash
+pip install "scenic-bpy[serve]"
+scenic serve scenes.py --port 8000
+```
+
+Every `@app.scene()` becomes `POST /scenes/{name}/render` (PNG) and
+`POST /scenes/{name}/build?format=blend|glb`, with request validation and OpenAPI
+docs generated from the same schemas the CLI uses. `scenic build -o scene.glb`
+exports glTF directly too.
+
+## Rigging
+
+Declarative bones, IK, and constraints; meshes bind to a parent armature with
+automatic weights:
+
+```python
+from scenic.rigging import Armature, Bone, IK, Rig, chain
+
+@app.rig()
+def arm_rig():
+    upper = Bone("upper", head=(0, 0, 0), tail=(0, 0.06, 0.5))
+    fore = Bone("fore", head=(0, 0.06, 0.5), tail=(0, 0, 0.95), parent="upper", connected=True)
+    ctrl = Bone("ctrl", head=(0, 0, 0.95), tail=(0, 0.22, 0.95), deform=False)
+    return Rig(bones=(upper, fore, ctrl),
+               constraints=(IK(bone="fore", target="ctrl", chain_count=2),))
+
+armature = Armature(arm_rig()).animate(wave()).with_children(
+    tube().skinned()          # ARMATURE_AUTO weights
+)
+```
+
+Pose bones key through the same Timeline: `t.at(16).bone("ctrl").loc(x=0.45)`.
+`chain("upper", "fore", lengths=(0.5, 0.45))` lays connected runs head-to-tail.
+
+## NLA
+
+Layer or sequence clips instead of baking one action:
+
+```python
+obj.play(walk_cycle(), at=1, repeat=4).play(blink(), at=10, track="face", blend="ADD")
+```
+
+## Geometry nodes
+
+Procedural scattering and instancing with the same piping DSL, attached as a modifier:
+
+```python
+from scenic.geometry import GeoNodes
+from scenic.geonodes import (DistributePoints, IcoSphereMesh, InputGeometry,
+                             InstanceOnPoints, RandomVector, SetMaterial)
+
+rocks = (
+    InputGeometry()
+    >> DistributePoints(density=0.8, seed=3)
+    >> InstanceOnPoints(
+        instance=IcoSphereMesh(radius=0.14, subdivisions=1) >> SetMaterial(material=rock_mat()),
+        scale=RandomVector(min=(0.4, 0.4, 0.3), max=(1.6, 1.6, 1.0)).value,
+    )
+)
+field = Plane(size=14).modify(GeoNodes(rocks))
+```
+
+`humanoid(height=1.8)` from `scenic.rigging` gives a ready 19-bone biped with IK
+arms/legs and hand/foot controls.
+
+## Status (v0.6)
+
+| Area | State |
+|---|---|
+| Typed components, `Depends`, validation | ✅ |
+| Primitives, modifiers, camera/lights/world/render | ✅ |
+| Shader node DSL (`>>` piping, textures, ramps, mix, bump) | ✅ |
+| Timeline animation DSL, animation components, mp4 render | ✅ |
+| Incremental reconciler, shared mesh/material datablocks | ✅ |
+| Drivers, `Library`/`include`, `scenic serve`, glTF export | ✅ |
+| Rigging (bones, chains, IK/constraints, auto-skinning), NLA | ✅ |
+| Geometry nodes (scatter/instance DSL), humanoid preset | ✅ |
+| `scenic build / render / docs / watch / serve`, in-Blender addon | ✅ |
+
+The original DESIGN.md roadmap is complete. Works on Blender/bpy 4.2 through 5.0
+(socket renames and the slotted-action API are handled with fallbacks).