orkid: Skill for Claude Code

HyperSyn — Reality Synthesizer

HyperSyn is orkid's unified authoring stack for procedural content. It layers a Python expression DSL on top of the existing ork::dataflow graph runtime to let users compose particles, procedural textures (2D and 3D), mesh/SDF operations, and — eventually — audio and sequencer graphs from compact, declarative Python. Each authored graph traces into a dflow::graphdata_ptr_t, is validated in a subprocess (the editor must never be brought down by a bad graph), then materializes into a typed runtime artifact (PBRMaterial, Texture, Mesh, SDF grid, GraphInst).

The naming: HyperSyn because the long-term target is a single composable hypergraph — modeled on Farbrausch's werkkzeug and Houdini's multi-context model — that synthesizes an entire realtime experience (textures, meshes, particles, sound, sequencing) from a compact procedural description.

This skill is the contract — the API surface, the authoring pattern, the materializer outputs, the runtime modes. Implementation status, milestone roadmap, M0 hardening checklist, and team-review-driven design corrections live in the sibling file PLAN.md. When you are using HyperSyn (authoring graphs, asking how a family works, looking up materializer outputs), this skill is the source of truth. When you are building HyperSyn (deciding what to commit next, tracking what's done), consult PLAN.md.

Core concepts

Trace-then-materialize

A HyperSyn graph is authored as a Python class that subclasses a family base. __init__ builds an in-memory expression tree using DSL operations. self.surface(...) / self.texture(...) / self.mesh(...) / self.render(...) records the output bindings. generatedflow() walks the tree and emits a typed dflow::graphdata_ptr_t (a family-specific subclass of GraphData). The graph is then validated and materialized.

Subclass(FamilyBase).__init__()      build DSL tree (each call returns a DslNode)
                .surface/...(...)    declare output bindings (channel name → DslNode)
                .generatedflow()     materialize tree into dflow::graphdata_ptr_t

dflow.validate(graph)                spawn subprocess: deserialize + DgSorter + link + stage + activate + compute
                                     return {ok: bool, errors: [(module, plug, msg)], warnings: [...]}

family.materialize(graph, ctx)       per-family final artifact build (also in subprocess for codegen)
                                     → dict[str, Artifact]  (multi-sink, see "Multi-sink materializer outputs")
                                       or None on failure (whole-graph failure)