The
libs/neith/area: 312 Nx projects that make up Neith, Oshun's from-scratch ("sovereign") creative-technology stack — a runtime kernel, a professional DAW + plug-in hosting layer, a real-time 3D/game engine, DCC tools, engine-service planes (audio, GI, GPU compute, online services, profiling, VFX, digital humans, virtual production, LiveOps, marketplace, spatial), and the infra/integration libraries that wire them into the rest of the platform. This page is the entity-catalog view of the area.
What this area is#
"Neith" is the codename for Oshun's effort to own its creative toolchain end to end rather than depend on proprietary engines and DAWs. Almost every node here carries the word "sovereign" in its crate docs: the explicit goal is to replace Unreal/Unity (engine), Blender/Houdini/DaVinci (DCC), Ableton/Logic/Pro Tools (DAW), VST/AU/LV2/CLAP vendors (plug-in hosting), and even the OS layer (a NixOS-based creative-workstation distro). The work is tracked under TODOS phases 41–46 (runtime, HAL, engine, DCC, OS, browser), 48 (domain integrations), 53 (state-of-the-art AI/procedural), and the long 132–174 sweep (audio/DAW, Forge 2D, VFX/post, platform services, CI/identity/security planes, colorist/DJ/ match-move suites, EEVEE-class raster, hair, Grease-Pencil-class 2D-in-3D, fluids, VSE, online subsystem, profiler, GPU VFX, digital humans, virtual production, LiveOps, marketplace, spatial runtime, engine audio, GI, GPU compute, sculpting/NPR, and the UE/Blender final-parity families).
The area is polyglot but Rust-dominant. The performance-critical surface —
audio DSP, the renderer, physics, procedural generation, the OS — is Rust, laid
out as Cargo workspaces under <entity>/crates/neith-*/, each crate a focused
module set (src/*.rs). A minority of nodes are TypeScript
(<entity>/src/ index.ts barrels) and cover infra and orchestration concerns
where TS is the right tool: cloud/k8s config, observability, security, QA,
release, docs, training, and the six domain-integration bridges. A handful of
nodes are "dual" — a Rust Cargo workspace wrapped by an Nx package.json (e.g.
@neith/ core, @neith/scene, @neith/procgen, @neith/particles,
@neith/linux) so the cargo build participates in the Nx graph.
The nodes are not flat; they form layered sub-systems that build on each other:
- Runtime & platform foundation —
@neith/core(async executor, allocators, events, serde, reflection),@neith/hal(audio/gpu/input/sensor/camera/net/ storage abstraction),@neith/crypto,@neith/net,@neith/transport,@neith/net-audio, plus the TS infra libs (@neith/cloud,observability,security,qa,release,testing,docs,training) and@neith/linux, the OS the whole stack targets. - Audio / DAW ("Composer", phases 132–133) — the real-time audio runtime and graph, file I/O, telemetry, MIDI, the four plug-in hosts (VST3/AU/LV2/CLAP) with a sandbox and validator, control surfaces, and the deep creative tools (mastering, restoration, pitch, notation, session view, comping, modular, patch-lab, advanced synthesis, live-coding, scoring, DJ, foley, ADR).
- 3D / game engine & DCC (phases 42–44, 53) —
@neith/renderer,@neith/scene,@neith/particles,@neith/animator,@neith/ai-runtime,@neith/assets, and the DCC suites@neith/sculptor(Blender),@neith/weaver(Houdini),@neith/cutter(DaVinci), plus@neith/procgenand the SOTA procedural/material crates. - Domain integrations (phase 48) —
neith-integration-*libraries that let existing Oshun domains (Bellona, Hathor, Isis, Maya, Sophia, Yemaya) consume Neith instead of their previous external engines/DCC/AI providers.
How it fits the wider system#
Neith sits at the bottom of the creative stack: it is the engine/runtime
that higher Oshun domains target. The relationship is expressed through the six
neith-integration-* libraries — each one is the adapter a specific domain
imports to drive Neith (e.g. neith-integration-maya migrates Maya's
Unreal-based metaverse onto the Neith engine; neith-integration-yemaya maps
Yemaya's creative studio onto the Sculptor/Weaver/Composer/Cutter DCC tools).
Within the area, the audio tools all stand on @neith/audio-runtime +
@neith/audio-graph; the engine/DCC tools stand on @neith/core and
@neith/hal; and the TS infra libs (cloud/observability/security/release) are
operational concerns the deployable surfaces consume. Walk the dependency edges
on any node below to see exactly who builds on it.
Since the sections above were written, the area has grown a large set of newer sovereign Rust crate families (phases 135–172), each documented node-by-node in the entity reference below:
audio-*(phase 167) — engine-audio runtime: bus graph, sources, spatial, mixer, dialogue, adaptive music, voice chat, tooling, conformance.broadcast/delivery/dit/foundry/hdr/matchmove/motion/shotops/silhouette/storyboard/subs/virtualprod(phase 135) — film/broadcast post singles: node compositor, roto/tracking, motion graphics, matchmove, DIT/dailies, DCP/IMF delivery, HDR mastering, subtitles/dubbing, shot tracking, storyboarding, LED-volume/moco, live broadcast.compute-*(phase 169) — GPU-compute framework: backend abstraction, shader compiler, resource/dispatch/wave/memory models, ML/sim/render kernels as deterministic CPU references, debug layer, SDK, conformance (physical-GPU gates stay fail-loud).dcc-*,engine-*,parity171-testing(phases 171–172) — UE/Blender named-feature parity: Verse-class scripting, LWC, MegaLights, RVT, modeling, smart objects, choosers, pose search, state trees, motion design, enhanced input, GN fields/zones/tools, metaballs, NURBS, 3D text, preferences, plus the cross-crate validation suite.dh-*(phase 162) — MetaHuman-class digital humans: creator, skin, eyes, face/body rigs, flesh sim, clothing, capture animator, voice (neural TTS behind a fail-loud seam), retarget, ethics/consent, SDK, testing.forge-*— creative-app primitives (whiteboard, fonts, generative-imaging workflow, icons, interactive motion, photo catalog, publishing) as large single-file model+operations crates.gi-*(phase 168) — dynamic global illumination: core abstraction, SDFGI, voxel GI, probes/DDGI, Lumen-class tracing, shadows, lightmapper, AO, volumetrics, emissive, sky, conformance.gpen-*(phase 156) — Grease-Pencil-class 2D-in-3D suite: data model, tools, animation, modifiers, line art, shading, rigging, VR drawing, storyboard, testing.hair-*(phase 155) — curves-based hair: data model, grooming, guides, nodes, simulation, shading, rendering, presets, transfer, validation.liveops-*(phase 164) — monetisation/liveops: IAP, ads, analytics, remote config, experiments, economy, cloud save, attribution, CRM, support, compliance, portal, conformance.market-*(phase 165) — creator marketplace: catalog, creator onboarding, licensing, commerce, delivery, discovery, reviews, moderation, buyer portal, seller analytics, SDK, conformance.npr-*(phase 170) — non-photoreal rendering: Freestyle-class lines, cel/toon shading, inking/hatching.oss-*(phase 159) — Online Subsystem and replication: abstraction, identity, matchmaking, sessions, Iris-class replication, RPC, prediction, transport, voice, presence, replay, pixel streaming, anti-cheat, observability, testing.profiler-*(phase 160) — frame profiler and diagnostics: capture, timing, GPU debugger, memory, net, stat HUD, sampling, shader, physics, audio, asset/cook, UI models, crash analysis, testing.sculpt-*(phase 170) — ZBrush/Blender-class sculpting: core, topology, layers, brushes, face sets, masking, polypaint, retopo, export, testing.sim-*(phase 157) — Mantaflow/Houdini-class offline simulation: core, liquid, gas, MPM, particles, cloth, rigid, ocean, surface meshing, forces, reference rendering, game baking, farm planning, validation.spatial-*(phase 166) — MR/visionOS-class spatial runtime: core scene understanding, volumes, input, avatars, render, physics, audio, SDK, collaborative anchors, OS shell, conformance.vfx-*(phase 161) — Niagara-class GPU-VFX authoring: asset model, spawn, attributes, modules, renderers, sim stages, data interfaces, editor model, perf/LOD, preset library, testing.vp-*(phase 163) — on-set virtual production: core, render cluster, LED wall, camera tracking, ICVFX frustum, colour, scene pipeline, MR keying, operator control, record, broadcast studio, editorial handoff, testing.vse-*(phase 158) — DCC-embedded video sequence editor: timeline core, ingest, transitions, effects, audio, playback, render, review, conform, storyboard, testing.
Across all of these, each family's conformance/testing crate exercises the real sibling crates, and genuinely external boundaries (GPU drivers, ffmpeg, native Opus, neural models, tracker/encoder hardware) are represented as fail-loud seams rather than fabricated results.
Entity reference#
@neith/core#
The sovereign runtime kernel (core/crates/): a from-scratch async executor
(neith-runtime — work-stealing scheduler, fibers, mpmc/mpsc/broadcast
channels, timers, backpressure), purpose-built allocators (neith-alloc —
arena/slab/buddy/tlsf/mmap/huge-page), plus neith-events, neith-serde,
neith-reflect, and neith-log. This is the foundation the rest of Neith's
Rust stands on; substantial and real.
@neith/hal#
The hardware abstraction layer (hal/crates/): seven crates —
neith-audio-hal (device enum + PCM via cpal: ALSA/PulseAudio/PipeWire/
CoreAudio), neith-gpu, neith-input, neith-sensor, neith-camera,
neith-net-hal, and neith-storage (virtual paths, ZIP, S3, keystore). It
gives the engine and tools one portable surface over real OS backends.
@neith/crypto#
Sovereign cryptography (crypto/crates/): neith-sym (full AES-256-GCM with
real S-box/MixColumns + ChaCha20-Poly1305), neith-asym (Ed25519/X25519 field
arithmetic), neith-hash (SHA-2/BLAKE3/HMAC/Merkle/Argon2id/HKDF), neith-rand
(ChaCha20 CSPRNG, RDRAND, fork-safe), and neith-tls (TLS 1.3
session/handshake/cert validation). Domain-specific implementations, not
wrappers.
@neith/net#
General networking (net/crates/): neith-http (HTTP/1.1/2/3 codec, pooling,
caching), neith-transport (reliable UDP with congestion control + NAT
traversal), neith-webrtc (DataChannel/ICE/SDP/DTLS/SRTP/SCTP), and
neith-game-net (authoritative server, prediction/reconciliation, snapshot
interpolation, lag compensation, anti-cheat).
@neith/transport#
The audio transport, clock, and synchronization core (phase 132.11,
transport/crates/neith-transport): the project-wide transport state machine
plus chase-lock / drift-correction infrastructure every audio-producing surface
shares. Distinct from @neith/net's neith-transport (which is UDP).
@neith/net-audio#
Network-audio crate (net-audio/crates/neith-net-audio, ~27.6K LOC): the
streaming-audio-over-network layer for the DAW/engine. Substantial single crate.
@neith/audio-runtime#
The sovereign cross-platform audio HAL (phase 132.1, ~74K LOC): defines the
AudioDriver/AudioStream traits every backend (CoreAudio, ASIO, WASAPI, JACK,
PipeWire, ALSA, AAudio, OpenSL ES) implements. The driver-level foundation the
real-time graph runs its callback on.
@neith/audio-graph#
The real-time audio graph (phase 132.2, ~21K LOC): hosts the driver callback
and routes audio/MIDI/CV between tracks, buses, sends, plugins, and outputs.
Rich scheduler subtree (scheduler/ — SPSC, sub-block, RT-priority/asserts,
parallel exec, denormal handling, watchdog, CPU meter) plus PDC (plugin delay
compensation), sidechain, feedback, and multichannel modules.
@neith/audio-fileio#
Sovereign audio file I/O (phase 132.12, ~80K LOC, 212 files): one reader +
writer per container (WAV/AIFF/FLAC/etc.) feeding the audio graph and receiving
offline bounces from @neith/transport, behind a uniform FileIoError funnel
and shared sample primitives. One of the largest crates in the area.
@neith/audio-telemetry#
Audio metering / loudness / analysis (phase 132.14): per-block/per-frame Peak/RMS/VU/PPM/K-meters plus EBU R128 / ATSC A/85 / ITU-R BS.1770-5 loudness — the analysers every audio surface in Oshun consumes.
@neith/midi-io#
Cross-platform MIDI I/O (phase 132.8): one MidiBackend trait with a
per-platform implementation, the foundational MIDI surface Composer, Euterpe,
Uzume, dialogue, and spatial all depend on (~23K LOC).
@neith/vst3-host#
Sovereign VST3 plug-in host (phase 132.3, ~24K LOC, 77 files): implements Steinberg's VST3 SDK host interfaces from Rust — discovery/loading, processing, component/edit-controller model. Real host stack.
@neith/au-host#
Sovereign Audio Unit (AU) host (phase 132.4): hosts both AUv2 (the legacy
AudioComponentFindNext component model) and AUv3 (NSExtension) plug-ins.
macOS/iOS-only by design — other platforms get a structured NotSupported error
rather than a link failure (an honest fail-loud seam).
neith-clap-host#
Sovereign CLAP plug-in host (phase 132.6, ~34K LOC): discovers .clap
bundles by walking the platform search path, dlopens them, resolves the
clap_entry symbol, and hosts modern CLAP plug-ins. Note the bare project name
neith-clap-host (tags scope:neith, lang:rust).
@neith/lv2-host#
Sovereign LV2 plug-in host (phase 132.5): discovers .lv2/ bundles via
LV2_PATH, parses the Turtle (manifest.ttl) RDF, and loads the bundle's
shared libraries. Real bundle/RDF parsing, not a stub.
neith-plugin-sandbox#
Out-of-process plug-in sandbox (phase 132.7, ~15K LOC): isolates third-party
VST3/AU/LV2/CLAP code from the host so a crashing/hanging/malicious plug-in
can't take down the DAW. Bare project name neith-plugin-sandbox.
@neith/plugin-validator#
Plug-in validator (phase 132.13, ~840 LOC, 5 files — the smallest host-layer crate): a uniform validation framework that runs against any plug-in the host can load (across all four host crates). Real but intentionally compact.
@neith/controllers#
Hardware control-surface integration (phase 132.10, ~35K LOC): Mackie Control Universal, HUI, EuCon, OSC, custom Lua/WASM scripts, and generic HID — each protocol a pure-Rust codec + state machine in its own module.
@neith/composer#
The DAW core as a 5-crate workspace (composer/crates/): neith-daw-core
(timeline/recording/audio-ops/analysis), neith-mixer (channels/metering/
automation/routing), neith-midi (piano-roll/CC-routing/theory), neith-synth
(sampler/subtractive/FM/wavetable/granular), and neith-spatial-audio
(panner/environment/game-audio). The Ardour-class assembly point for the audio
tools.
@neith/mastering#
Ozone-class mastering suite + Neutron-class mix assistant (phase 133.5, ~19K LOC): mastering modules, an assistant/reference engine, and stem-focus / diffusion-mastering SOTA work, each task as a focused module.
@neith/restoration#
iZotope-RX-class audio restoration (phase 133.3, ~42K LOC): spectral repair and the dialogue/audio restoration toolkit. Large, substantial single crate.
@neith/pitch#
Melodyne-class polyphonic pitch & time editing (phase 133.4, ~13K LOC): polyphonic note detection plus formant-preserving pitch/time manipulation.
@neith/notation#
Dorico-class music-notation engraving (phase 133.1, ~51K LOC, 65 files): provides the hierarchical score model and engraving foundation — the layout, beaming, and music-symbol rendering on which the rest of the Neith notation stack builds. One of the larger creative crates.
@neith/session-view#
Ableton-class clip launcher / Session View (phase 133.2, ~18K LOC): the non-linear clip-grid performance surface that complements the DAW's linear arrangement.
@neith/comping#
Comping, track stacks, folder tracks (phase 133.14): take-folder data model with parent clip, ordered takes, active-take pointer, and per-take metadata — the session-management tools for multi-take recording (~8K LOC).
@neith/modular#
VCV-Rack-class modular synth environment (phase 133.6, ~42K LOC, single crate): a sovereign modular-synthesis patching environment for the Composer DAW.
@neith/patch-lab#
Max/MSP / Pure-Data-class visual patching (phase 133.7, ~18K LOC): a sovereign visual dataflow patching environment.
@neith/synth-advanced#
Advanced-synthesis library (phase 133.9, ~17K LOC): additive, spectral,
modal, physical-modeling, neural, scanned, waveguide, and vector synthesis —
each engine its own module behind a shared SynthEngine trait.
@neith/live-code#
Embedded live-coding runtime (phase 133.8, ~20K LOC): a small scripting language (lexer/parser/runtime) whose source is hot-reloaded against a running audio session — TidalCycles/Sonic-Pi-class.
@neith/scoring#
Scoring-to-picture toolkit (phase 133.10, ~12K LOC): frame-accurate scrubbing, spotting notes, streamers/punches, and tempo/hit-point maps for film/TV/game composers — beyond a generic DAW+video-sync.
@neith/dj#
Sovereign DJ deck toolkit (phase 133.12, ~24K LOC): Serato/Traktor/ Rekordbox-class — 2/4-deck transport, beat-grid + key detection, master tempo, hot cues, loops, slicer, real-time stem separation, FX rack, sampler, automix, and CloudDirectPlay streaming.
@neith/foley#
Generative Foley / video-conditioned SFX (phase 133.16, ~9.6K LOC): maps text prompts and video frames to typed SFX templates and synthesises real PCM via additive+noise+envelope DSP, then refines with a published DDIM sampler. Deterministic, no external neural model — an honest documented approximation.
@neith/adr-foley#
ADR + Foley post-production toolkit (phase 133.11, ~10K LOC): cue lists, streamers/beeps, take management, looping playback, VocAlign-class auto-alignment, EQ/reverb match, foley library, mic-perspective routing, and walla — the data + operations a post sound team needs.
@neith/realtime-assist#
Real-time AI mixing/mastering collaboration (phase 133.15, ~8.3K LOC): an on-device assistant that watches a session live and emits structured suggestions for balance, EQ, gain-staging, panning, masking, and chain-building.
@neith/sample-content#
Sample-library tooling (phase 133.13, ~39K LOC): recording session specs and the sovereign sample-library authoring/management surface.
@neith/sound-propagation#
Geometry-aware acoustic propagation
(sound-propagation/crates/ neith-acoustics, single ~1.8K-LOC crate):
octave-band sound energy through scene geometry, acoustic materials, probe
grids, diffraction edges, and portals — deterministic so cook servers/CI
reproduce impulse responses byte-for-byte.
@neith/renderer#
The real-time 3D engine renderer (phase 42, ~96K LOC, 193 files, 16 crates —
the largest entity): neith-render-graph (frame graph), neith-pbr,
neith-material-graph, neith-gpu-driven, neith-virt-geom (Nanite-class
clustered geometry), neith-gi, neith-shadows, neith-lighting,
neith-atmosphere (Bruneton sky), neith-postfx, neith-gaussian-splatting
(3DGS), plus neith-ecs, neith-physics, neith-animation, neith-audio, and
neith-scripting. A genuine engine, not a façade.
@neith/scene#
Scene composition (phase 43.3, scene/crates/): neith-scene-graph
(hierarchical node graph), neith-level-stream (streaming zones, distance-based
load/unload), and neith-world (grid-based world partitioning + collaboration).
Smaller (~4K LOC) but real.
@neith/particles#
GPU particle system + VFX graph (phase 43.4, particles/crates/):
neith-particle-core (#[repr(C)] CPU-side sim layout for GPU staging-buffer
upload) and neith-vfx-graph (node-based VFX editor/compiler).
@neith/animator#
Animation authoring (phase, animator/crates/, ~23K LOC): neith-motion
(pose-search DB for motion matching), neith-mocap (import/solving/retarget/
editing), neith-rig (armature/constraints/control-rig), neith-facial
(eye-jaw/lip-sync/facial-rig), and neith-timeline (curve editor/dope sheet).
@neith/ai-runtime#
Game-AI + ML runtime (phase 43.1 + 53.2, ~51K LOC, 8 crates):
neith- navigation (Recast-style NavMesh, A*/HPA*/flow-field),
neith-behavior-tree, neith-ai-fsm (HSM/pushdown), neith-perception
(sight/hearing/touch/smell), neith-crowd (ORCA + flow fields),
neith-ml-inference (ONNX runtime, LRU model cache, quantization), neith-npc
(personality/backstory/goals), and neith-llm (a normalized
OpenAI/Anthropic/Ollama integration layer).
@neith/assets#
Asset pipeline (phase 43.2, assets/crates/): neith-asset-format (the
.nba binary container — header/chunks/dependencies/versioning), plus
neith-asset-import, neith-asset-proc, neith-asset-stream, and
neith-asset-registry.
@neith/sculptor#
Blender-class DCC (phase 44.1, sculptor/crates/): neith-mesh-edit
(selection/editing), neith-sculpt (brushes, dyntopo, multires, masking),
neith-uv (LSCM/ABF unwrap, UDIM), neith-tex-paint (channels/layers/
projection paint/baking), and neith-sculptor-render (viewport + path tracer +
render passes).
@neith/weaver#
Houdini-class procedural DCC (weaver/crates/, ~54K LOC):
neith-node-graph (execution graph), neith-geo-nodes
(attributes/distribution/primitives), neith-terrain (biome-aware generation,
GIS import, GPU sculpting), neith-building (procedural buildings/cities), and
neith-copernicus (GPU/WebGPU-compute texture synthesis with CPU parity).
@neith/cutter#
DaVinci-Resolve-class video editor (cutter/crates/, ~48K LOC):
neith-video-timeline (multi-track NLE — clips, ripple/roll, snapping,
multicam, nested sequences, proxy), neith-color-grade, neith-vfx, and
neith-export.
@neith/procgen#
Procedural-generation systems (phase 53, procgen/crates/, ~52K LOC, 12
crates): a differentiable-procgen substrate (neith-diff-procgen), inverse
modeling (neith-inverse-procgen, differential evolution), neith-jfa,
neith-nca (neural cellular automata),
neith-neural-flora/neith-neuro-facade (neuro-symbolic L-systems/facades),
neith-physarum, neith-scene-agent (LLM-or-deterministic scene programs),
neith-terrain-ml, neith-texture-synth (Heitz-Neyret histogram-preserving),
neith-tiling (Wang tiles), and neith-wave-noise (Guehl 2025 wave-noise).
Real named algorithms, CPU parity.
@neith/fabric-gen#
Procedural fabric generation (fabric-gen/crates/neith-fabric, single ~2K
crate): authors weaving drafts, generates yarn-level geometry with sliding/
flyaway irregularity, evaluates an anisotropic fiber BSDF, bakes PBR maps, and
estimates drape. Deterministic textile-prompt → weave-recipe.
@neith/pbr-material-synth#
Physically-based material synthesis
(pbr-material-synth/crates/ neith-mat-phys, single ~1.8K crate): turns
measured/physical material properties (spectral IORs, absorption, scattering,
microstructure, weathering, layered stacks) into renderer-facing PBR parameters
— deterministic and serializable.
@neith/topology-opt#
SIMP topology optimization (topology-opt/crates/neith-topopt, single ~2.3K
crate): 8-node hexahedral grid, sparse stiffness assembly, conjugate-gradient
displacement solves, sensitivity filtering, and optimality-criteria density
updates for procedural structural geometry. Includes a GPU dispatch-plan type.
@neith/forge-core#
Forge 2D shared foundation (forge-core/crates/forge-doc-graph): currently
the hierarchical Forge document node graph (134.1.1.1) — doc.rs, layer.rs,
transform.rs. The package description scopes Forge to "document graph, canvas,
color, and plugin host," but the present, implemented crate is the document
graph (~4K LOC); the broader canvas/color/plugin-host pieces are not yet in
this entity.
@neith/ui#
UI toolkit (ui/crates/, ~14.6K LOC): neith-layout (flexbox + CSS grid +
positioning + virtualized lists), neith-render2d (paths/gradients/blend/
compositing), neith-text (shaping/glyph cache/rich text/IME), neith-widgets
(Button…DataGrid…Modal), neith-theme (design tokens), and neith-animation
(springs/keyframes/transitions). A from-scratch retained-mode UI stack.
@neith/linux#
Neith Linux (phase 45, linux/crates/, ~78K LOC, 17 crates — a NixOS-based
creative-workstation OS): the Wayland compositor (neith-shell), package
manager (neith-pkg/neith-pkg-manager/neith-overlay-manager), A/B atomic
updater (neith-update-agent), kernel builder + neith-workload-tuner, and
full neith-audio (PipeWire), neith-graphics (DRM/KMS), neith-network,
neith-storage (Btrfs/LUKS), neith-security (SELinux/AppArmor/TPM),
neith-services (systemd), neith-settings, neith-installer, and
neith-creative subsystems. The OS the whole stack targets.
@neith/cloud#
Cloud-infrastructure config (TS, ~23K LOC, 66 files): dependency-free
factory builders for compute (k8s deployments/autoscaling/GPU workloads),
gpu (node pools, MIG, time-slicing), storage (PVCs, backup/DR, lifecycle),
and network (VPC, CDN, WAF, DDoS). Tagged layer:infra.
@neith/observability#
Observability infra (TS, ~17K LOC): metrics, logging, and tracing
(distributed) building blocks for the deployable Neith surfaces. Tagged
layer:infra.
@neith/security#
Security infra (TS, ~13.7K LOC): iam (identity & access), secrets
(secret management), and compliance modules. Tagged layer:infra.
@neith/qa#
Quality-assurance infra (TS, ~22.3K LOC): code-quality analysis and
doc-quality tooling. Tagged layer:infra.
@neith/release#
Release & distribution (TS, ~16.7K LOC): pipeline, distribution,
performance, and platform/* publishers for thirteen targets (Linux, Windows,
macOS, iOS, Android, Steam, Epic, Xbox, PlayStation, Nintendo, Meta Quest, web)
plus an enterprise software-catalog publisher (ServiceNow/Coupa/SAP-Ariba). Has
a 163-line README.
@neith/testing#
Test infrastructure (TS, ~28.7K LOC — the largest TS entity): unit,
integration, e2e, and performance utilities spanning TypeScript/Vitest,
Rust/cargo-nextest, and C++/GTest/Catch2, exported as namespaces from the
barrel.
@neith/docs#
Documentation system (TS, ~15K LOC): developer, user, and api doc
modules exported as namespaces from @neith/docs. Tagged layer:docs.
@neith/training#
Training & education (TS, ~11.4K LOC): developer courses, user onboarding,
certifications, and community resources for the Neith engine. Tagged
layer:training.
neith-integration-bellona#
Bellona (Build & Engine) ↔ Neith bridge (TS, ~6.8K LOC): native build tools,
deployment automation, and observability — build-system/ and
deployment-system/ modules. Bare project name; tags scope:neith,
scope:bellona, type:integration.
neith-integration-hathor#
Hathor (Worldbuilding) ↔ Neith bridge (TS, ~9.4K LOC): world simulation,
procedural generation, and content-creation tooling tied into the Neith engine
and Nous AI (world-simulation/, content-creation/).
neith-integration-isis#
Isis (Generative AI Factory) ↔ Nous bridge (TS, ~6.2K LOC): replaces
external AI-provider APIs with the in-house Nous LLM — nous-streaming.ts (with
a spec), ai-replacement/, and generation-pipeline/.
neith-integration-maya#
Maya (game engine / metaverse) ↔ Neith bridge (TS, ~14.6K LOC): engine
replacement (Unreal → Neith migration, 48.1.1) and metaverse-platform hosting
(VR OS, avatars, economy, AI NPCs, 48.1.2) — engine-replacement/,
metaverse-platform/.
neith-integration-sophia#
Sophia (Knowledge) ↔ Neith bridge (TS, ~5.5K LOC): knowledge-system/ and
research-tools/ modules connecting Sophia's knowledge surface to Neith.
neith-integration-yemaya#
Yemaya (Creative Studio) ↔ Neith DCC bridge (TS, ~5.6K LOC): maps Yemaya
onto the Neith DCC tools — Sculptor (Blender), Weaver (Houdini), Composer
(Ardour), Cutter (DaVinci) — plus a unified creative pipeline (project format,
VCS, render farm, review, asset library, Nous-assisted creation). dcc-tools/,
creative-pipeline/.
@neith/audio-accessibility#
Game-audio accessibility runtime (Rust, libs/neith/audio-accessibility, phase
167.12): mix (mono down-mix + L/R balance), speech (dialogue-clarity and
hearing-aid EQ), haptics sound substitution, timed captions, and a
protection volume-ceiling hearing protector — targeting the Xbox/PlayStation
accessibility guidelines for engine audio.
@neith/audio-bus-graph#
Runtime audio routing plane (Rust, libs/neith/audio-bus-graph, phase 167.1):
directed source→bus→group→output routing with glitch-free runtime mutation,
sample-accurate event schedule, mix snapshots, per-bus resample, and
hotreload of graph assets. Distinct from the phase-132 DAW graph
@neith/audio-graph — this is the graph a shipped game renders every audio
callback.
@neith/audio-conformance#
Cross-crate conformance suite for the phase-167 engine-audio stack
(libs/neith/audio-conformance) — a testing crate, not a runtime feature. Real
gates (voice_count_stress, latency_p99, atmos_render_determinism,
loudness_compliance) exercise the sibling crates end-to-end and return
GateResults. The dogfood gate binds the real Phase-42 audio engine and
Phase-27 Project Obsidian roots, renders a Phase-42 procedural footstep through
the phase-167 HRTF path, and validates the franchise audio contract. The
external module retains fail-loud seams for the listening-panel ABX and
live-device 24-hour soak.
@neith/audio-dialogue#
Game dialogue system (Rust, libs/neith/audio-dialogue, phase 167.6): line
database with voice banks and per-locale fallback, condition-driven
selection with bark cooldowns, branching conversation flow, phoneme/viseme
lipsync export, and radio/walkie voice FX — the Wwise-dialogue-event /
FMOD-programmer-sound layer.
@neith/audio-environment#
Acoustics and environmental FX (Rust, libs/neith/audio-environment, phase
167.4): reverb (partitioned convolution + FDN/Schroeder), occlusion ray
casting over geom primitives, morphing reverb zones, ambience beds, and
baked/ray-traced acoustics probe fields — Steam Audio / Project
Acoustics-class features rebuilt from first principles.
@neith/audio-mix#
Master-mix plane above the bus graph (Rust, libs/neith/audio-mix, phase
167.5): dB-domain snapshot interpolation, sidechain ducking, a per-bus
dsp_chain (RBJ EQ / compressor / lookahead limiter / saturator), a truepeak
4x-oversampled ISP limiter, and ITU-R BS.1770-4 loudness metering with EBU
R128 normalize — all f64 DSP implemented in-crate with no external audio
dependencies.
@neith/audio-music#
Adaptive/interactive music runtime (Rust, libs/neith/audio-music, phase
167.7): vertical/horizontal layers with tension coupling, bar/beat-quantised
transitions and stingers, a mood-graph state machine, a tempo/key
transport with Ableton-Link-style clock sync, and a euterpe generative-stems
hook.
@neith/audio-profiler#
Audio instrumentation plane (Rust, libs/neith/audio-profiler, phase 167.10):
voices count and stem accounting, per-bus DSP budgets, underrun/asset-hitch
events logs, a mix-graph flamegraph, and trigger-to-ear latency metering —
Wwise/FMOD-Profiler-class diagnostics, separate from the engine-wide profiler-*
family.
@neith/audio-source#
Voice-generator library for the bus graph (Rust, libs/neith/audio-source,
phase 167.2): every generator implements the AudioSource trait — sample and
stream voices, band-limited oscillators, physical Karplus-Strong/modal
models, granular clouds, random/switch/sequence/layer containers, and WSOLA
time-stretch.
@neith/audio-spatial#
3D audio spatialisation (Rust, libs/neith/audio-spatial, phase 167.3):
distance attenuation curves, directional emitter cones, doppler,
spherical-head hrtf binaural with HRIR interpolation, higher-order ambisonic
decode, and atmos bed+object rendering with VBAP panning to 5.1 through
9.1.6 layouts.
@neith/audio-synth#
Procedural SFX synthesis (Rust, libs/neith/audio-synth, phase 167.8): modal
impact/breakage mode banks, material/weight footsteps, layered weapon shots,
additive+granular vehicle engines, swept-noise wind, bubble-model water,
and source-filter creature vocals — every effect computed from a physical or
signal model rather than a sample.
@neith/audio-tooling#
Sound-designer authoring plane (Rust, libs/neith/audio-tooling, phase 167.11):
events designer with state/switch/RTPC editing, a MetaSounds-class timeline
action graph, soundbank banks packaging with offline bake, a waveform asset
browser, a localization coverage matrix, and a live-connect session
command model.
@neith/audio-voice#
Multiplayer voice-chat and microphone pipeline (Rust, libs/neith/audio-voice,
phase 167.9): 20 ms Opus-frame codec packetisation with jitter buffer and loss
concealment, spectral-subtraction denoise, NLMS aec, envelope agc, a WSOLA
voice changer, proximity/team channels routing, and moderation hooks.
The Opus bitstream itself lives in the phase-159 OSS stack.
@neith/broadcast#
Live-broadcast plane (Rust, libs/neith/broadcast, phase 135.12): a 36-module
crate covering the switcher (buses, transitions, stinger, keyers, PiP),
multiviewer, lower_third/ticker/scoreboard graphics, and captioning plus
loudness. The sdi/ndi/smpte2110/blackmagic modules are typed
protocol/control models, not hardware driver bindings.
@neith/compute-abstraction#
Front door of the phase-169 GPU-compute framework (Rust,
libs/neith/compute-abstraction): a single backend API shaped over
Vulkan/Metal/D3D12/WebGPU/CUDA/HIP/SYCL with capability flags, device
enumeration and a best-device heuristic, multi_gpu peer topology, and a real
deterministic cpu_backend reference. Native APIs attach through a versioned,
backend-bound executable-provider protocol. Manifest discovery, probe,
enumeration and dispatch are real; nonce/identity, device metadata, artifact
format, dispatch limits, read-only buffers, output shape, and timing are
validated fail closed before provider output enters the runtime.
@neith/compute-conformance#
Khronos-CTS-style conformance suite for the compute stack
(libs/neith/compute-conformance): bit-reproducible correctness checks
against the CPU reference backend, a suballocator leak_burnin, a
determinism_regression sweep, and typed fail-closed evidence graders plus the
compute-validate operator CLI for CUDA/HIP parity, browser WebGPU, 24-hour
soak, multi-GPU scaling, dogfood, and console gates. Synthetic evidence can
exercise decisions but can never certify a release.
@neith/compute-debug#
GPU-compute debug and validation layer (Rust, libs/neith/compute-debug, phase
169.10): resource-binding validation, a happens-before race detector,
bounds and nan checkers, a shader assert/printf shader_debug runtime, and
a shadow-memory sanitizer — ASan/TSan-style tooling operating on recorded
compute state.
@neith/compute-dispatch#
Dispatch model of the compute framework (Rust, libs/neith/compute-dispatch,
phase 169.4): direct/indirect/mesh/RT dispatch with validation, async-compute
and copy queue topology, pipeline barriers with hazard classification,
fence/event sync, and dispatch batching — the command-buffer/queue/barrier
surface, modelled and tested in-crate rather than driver-bound.
@neith/compute-lang#
Sovereign shader compiler (Rust, libs/neith/compute-lang, phase 169.2): an
SSA-form ir, recursive-descent lexer/parser for a shared WGSL/HLSL/GLSL
compute grammar, real opt passes (constant folding, DCE, CSE, loop unrolling),
pipeline reflection, five text targets plus MSL/Slang transpile, and an AMD
ISA occupancy diagnoser — pure std and fully deterministic.
@neith/compute-memory#
GPU memory model and allocators (Rust, libs/neith/compute-memory, phase
169.6): memory heaps with budget alarm, a fence-tracked staging ring,
paged virtual memory with LRU residency, bump and size-class pool
allocators, and a VMA-class free-list suballocator with coalescing and
defragmentation — real placement algorithms over byte offsets.
@neith/compute-ml#
ML inference kernels for the compute stack (Rust, libs/neith/compute-ml, phase
169.7) — deterministic CPU reference implementations, not GPU execution: an
n-dim strided tensor primitive, tiled gemm + Conv2D (im2col), fused
activations (ReLU/GELU/SiLU), LayerNorm/RMSNorm norm, flash-style
attention, quantisation, and a gguf reader, each tested against
known-correct values.
@neith/compute-render#
Compute-shader building blocks of a GPU-driven renderer (Rust,
libs/neith/compute-render, phase 169.9), implemented as CPU-verified
per-element math: frustum culling + hiz occlusion pyramid, meshlet
geometry cone culling, clustered lights froxel lists, bone-palette
skinning, particles, postprocess kernels (Karis bloom, TAA resolve), and a
swrast software rasteriser.
@neith/compute-resources#
Resource model of the compute framework (Rust, libs/neith/compute-resources,
phase 169.3): storage/structured/append/counter buffers, 1D/2D/3D/array/cube
textures with correct mip and subresource indexing, samplers, a bindless
descriptor heap, and spec-exact std140/std430 layout arithmetic — the
Vulkan/D3D12/Metal/WebGPU resource surface as tested layout rules.
@neith/compute-sdk#
Developer SDK for the compute framework (Rust, libs/neith/compute-sdk, phase
169.11): bindings signature emission for C/C++/Rust/Swift/Python/TS, a
kernel-authoring dsl, runnable examples (matmul/raymarch/fluid/FFT) with
reference outputs, a bench harness computing real mean/median/percentile/CoV
statistics with IQR outlier detection, plus stress, compat, and docs
tooling.
@neith/compute-sim#
Simulation kernels for the compute stack (Rust, libs/neith/compute-sim, phase
169.8) — deterministic f64 CPU reference implementations that GPU backends are
diffed against: direct + Barnes-Hut nbody, SPH/PIC/FLIP/APIC particles
transfer, PCG/multigrid pressure Poisson solvers, xpbd constraint
projection, radix-2 Cooley-Tukey fft, plus scan/sort/bvh primitives.
@neith/compute-wave#
Wave/subgroup operations (Rust, libs/neith/compute-wave, phase 169.5) — a
deterministic CPU model of the SIMD lane group (warp/wavefront/subgroup): vote
(all/any/ballot), broadcast, reduce, inclusive/exclusive scan,
shuffle/swizzle, and coopmat cooperative-matrix multiply-accumulate over
FP8/FP16/BF16/INT8 tiles — the HLSL SM6 / CUDA-warp intrinsic surface as a
testable model.
@neith/dcc-bsurfaces#
Retopology and quad-remesh toolbox (Rust, libs/neith/dcc-bsurfaces, phase
171.24): grease-pencil-stroke bsurfaces surface fill, a quad-flow retopo
brush with symmetry and shrinkwrap, auto-quad remesh, curvature edge-loop
extraction, hole patching, and high-to-low displacement/normal bake — the
sovereign BSurfaces + QuadriFlow + bake equivalent, integrating the phase-170
sculpt crates.
@neith/dcc-data#
Data-block linking and library overrides (Rust, libs/neith/dcc-data, phase
171.25): library link/append of external data-blocks, overrides that edit
linked data without breaking the link (scope, propagation on re-link, per-
property and animation overrides), an orphan cleaner with fake-user retention,
and an outliner override diff view — Blender's linking system as a sovereign
model.
@neith/dcc-freestyle-extensions#
Deep NPR line-render controls (Rust, libs/neith/dcc-freestyle-extensions,
phase 171.26) extending the phase-170 Freestyle core: a multi lineset manager,
edgetype include/exclude matrix, parametric line style expressions along the
stroke, colour/alpha/thickness + geometry modifiers stacks, svg export, a
compositor bridge, and temporal stroke coherence.
@neith/dcc-gn-fields#
Geometry-Nodes fields system (Rust, libs/neith/dcc-gn-fields, phase 171.20): a
lazy, domain-dependent field evaluator with position/normal/attribute inputs,
noise/voronoi generators and math operators, capture-attribute persistence
with accumulate/scan/sort, cross-domain sample, a viewport visualizer, and a
gpu compilation fastpath — Blender's GN fields as a sovereign evaluator.
@neith/dcc-gn-repeatzones#
Geometry-Nodes repeat and for-each zones (Rust, libs/neith/dcc-gn-repeatzones,
phase 171.22): a repeat zone with accumulator sockets, break conditions,
index/total exposure and nesting, an order-independent parallel-safe foreach
element zone, and a gpu unroll fastpath for affine recurrences.
@neith/dcc-gn-simzones#
Geometry-Nodes simulation zones (Rust, libs/neith/dcc-gn-simzones, phase
171.21): a zone input/output pair carrying per-frame state with substepping
and reset/retime, RAM+disk cache/bake with upstream hash invalidation, a
deterministic per-zone rng, nested zones with a profiler, and built-in
blocks (advection, boids, PBD cloth, soft body).
@neith/dcc-gn-tools#
Geometry-node asset tools (Rust, libs/neith/dcc-gn-tools, phase 171.23): node
groups exposed as operators — tool + inputs parameter-UI descriptors,
shelf install and drag-drop apply, mode auto-switch with undo integration,
and a publish path (presets, share, marketplace certification checks) —
Blender 4.0+ node-group tools as a sovereign model.
@neith/dcc-metaballs#
Metaball primitive (Rust, libs/neith/dcc-metaballs, phase 171.16):
ball/tube/plane/cube/ellipsoid elements with stiffness/radius and negative
(subtractive) energy, a summed implicit field with iso threshold,
marching-tetrahedra mesh conversion, per-object resolution, and animation
with parent constraints.
@neith/dcc-nurbs#
NURBS curves and surfaces (Rust, libs/neith/dcc-nurbs, phase 171.17):
Cox-de-Boor basis with knot insertion, rational curves (open/closed, order
N, weights), surface patches with tessellation, trim curves,
loft/revolve/sweep/bevel operations, continuity constraint editing, and an
IGES/STEP import path plus hair-guide NURBS.
@neith/dcc-preferences#
Preferences and keymap system (Rust, libs/neith/dcc-preferences, phase
171.19): a searchable prefs model, a keymap editor with conflict detection,
presets (Blender/Maya/Max/industry-compatible), viewport and gizmo defaults,
auto-save/recent/startup files handling, addons enablement, per-project
overrides, and portable preference bundles.
@neith/dcc-text3d#
3D text object (Rust, libs/neith/dcc-text3d, phase 171.18): font model with
kerning and OpenType feature tags, paragraph layout
(kerning/tracking/leading/alignment), bidi script detection with RTL
reordering, variable-font axes, glyph-outline extrude with bevel/taper,
text-oncurve, and ear-clip triangulated glyphs for text-to-mesh.
@neith/delivery#
Cinema/broadcast delivery and QC core (Rust, libs/neith/delivery, phase
135.7): a 41-module crate spanning DCP mastering (jpeg2000, mxf, cpl,
kdm), IMF (imf_documents, supplemental packages, Photon-style validator),
Dolby Vision/HDR10+ metadata, Atmos/adm_bwf audio delivery, ABR/cmaf
streaming presets, and automated QC (signal_qc, pse_qc, loudness, cadence,
subtitles).
@neith/dh-animator#
Digital-human performance-capture animator (Rust, libs/neith/dh-animator,
phase 162.8), built on neith-dh-core: monocular/HMC/depth face_solve with
marker hybrid, audio viseme_solve, body_retarget and finger solving,
tongue_teeth and breath inference, motionmatch, gaze conditioning,
clean-up filters, a keyframe editor, and farm batch processing.
@neith/dh-bodyrig#
Digital-human body rig and deformation (Rust, libs/neith/dh-bodyrig, phase
162.5): biped/quadruped skeletons, LBS/DQS skinning, muscle-bulge
blendshapes, jiggle joints, volume preservation, two-bone/FABRIK/CCD ik
plus full-body fbik, foot placement, spine ribbon, breathing, 25-bone hands,
space switching, and a rig variants library.
@neith/dh-clothing#
Digital garment system (Rust, libs/neith/dh-clothing, phase 162.7): seven
garment presets, a 2D cut-pattern model with ASCII-DXF import (the Marvelous
binary format is a fail-loud seam), stitch/seam authoring, a fabric library,
drape simulation, fit-to-body, layering order, and cloth lod cards —
deterministic geometry and physics on neith-dh-core types.
@neith/dh-core#
Shared spine of the phase-162 MetaHuman-class digital-human pipeline (Rust,
libs/neith/dh-core): dependency-free math (Vec/Quat/Mat4), triangle mesh
with UDIM UVs, skeleton bind-pose evaluation, sparse blendshape stacks,
LBS/DQS skinning, and the facs/viseme descriptor vocabulary every other
dh-* crate builds on.
@neith/dh-creator#
Character creator (Rust, libs/neith/dh-creator, phase 162.1): parametric
face/body morph dials with calibrated ageing/dimorphism curves, a
Beer-Lambert melanin/haemoglobin skin-tone model with CIELAB/ITA
classification, Perlin-style micro-geometry, a least-squares landmark
photofit, an OBJ importscan path, and a UDIM uvlayout auto-packer — all
seeded and deterministic.
@neith/dh-ethics#
Likeness, consent, and provenance governance for digital humans (Rust,
libs/neith/dh-ethics, phase 162.12): signed actor consent forms, a
hash-chained tamper-evident ledger with fail-closed queries and revocation, an
LSB-steganography likeness watermark with checksum-validated detection, an
append-only usage log, agegate and synthetic-only flags, and a royalty
split model.
@neith/dh-eyes#
Ocular system (Rust, libs/neith/dh-eyes, phase 162.3): parametric
cornea/iris/sclera geometry with dual-layer shading, Snell's-law refraction
through the cornea, iris parallax, wet-line meniscus and tears, pupil
dilation, saccade jitter, vergence, and a blink library — real ocular
geometry and oculomotor dynamics, CPU-deterministic.
@neith/dh-facerig#
Facial rig (Rust, libs/neith/dh-facerig, phase 162.4): FACS 48-action-unit
blendshapes library, a hybrid joint+blendshape rig with correctives, a
rom range-of-motion harness, wrinkle maps, visemes, tongue/jaw/neck
kinematics, control curves, a pose library, and runtime stripping with a
sub-millisecond solver budget.
@neith/dh-retarget#
Animation retarget and library plane (Rust, libs/neith/dh-retarget, phase
162.10): skeleton bonemapping with twist hints, clip retarget with IK foot
lock, proportion retarget, posespace interpolation, Mixamo/HumanIK
convention import and Mannequin/MetaHuman maps, foot-slide fixup, a rig
switcher, and runtime baking.
@neith/dh-sdk#
Runtime SDK and game integration for digital humans (Rust, libs/neith/dh-sdk,
phase 162.11): a streaming asset loader, lod chain with impostors,
gpu_skin/morph packing descriptors, groom/garment bind, a runtime
facerig_solver, memory budget, crowd instancing, and pixel_stream plus
Unreal/Unity/Godot plugin descriptors (descriptor models, not engine-linked
plugins).
@neith/dh-sim#
Ziva-class flesh simulation (Rust, libs/neith/dh-sim, phase 162.6):
tetrahedral co-rotational fem muscle, fat soft body, sliding skin, an
anatomy library, activation maps, contact deformation, a learned skinning
deformer, sim cache/replay, and LOD/realtime hero options — all CPU
physics on neith-dh-core types, fully deterministic.
@neith/dh-skin#
Physically-based skin material (Rust, libs/neith/dh-skin, phase 162.2):
Burley + sum-of-Gaussians sss with measured per-channel scatter distances,
Cook-Torrance/GGX specular with mesoscopic per-pore roughness, procedural
pores normal maps, wetness/bloodflow/goosebumps dynamics, and
birthmark/tattoo/makeup layers — CPU-evaluable shading math, no GPU dependency.
@neith/dh-testing#
Testing and validation suite for the digital-human stack (Rust,
libs/neith/dh-testing, phase 162.13) — a validation crate, not a runtime
feature: image_metrics (MSE/PSNR/SSIM) against references, facs_coverage
checks, lipsync timing offsets, solver_budget gates, foot_slide RMS,
MetaHuman-import and cross_engine export conformance, and a consent_ledger
audit.
@neith/dh-voice#
Voice and speech bridge (Rust, libs/neith/dh-voice, phase 162.9):
per-character voice models, a consent-gated + watermarked cloning path,
emotion prosody parameters, a forced phoneme aligner, viseme_mapping with
coarticulation, and dtw-based dubbing auto-alignment. Neural TTS and
voice-clone models are honestly external behind the SynthBackend seam, which
reports NotConfigured until a backend is bound.
@neith/dit#
DIT, dailies, and on-set media pipeline core (Rust, libs/neith/dit, phase
135.6): a 24-module crate covering card_ingest with mhl/hash verification,
cdl handling and cdl_authoring, dailies and proxy generation models,
camera_report/sound_report/dit_report paperwork, ltfs archive, and
review/preview_link delivery.
@neith/engine-anim-insights#
Animation debugging and insights (Rust, libs/neith/engine-anim-insights, phase
171.14): per-frame anim-graph record dumps, posecache evolution series,
montage/notify trails with slot-weight history, a real FABRIK ik iteration
breakdown, retarget deltas, a gauntlet-style auto-test harness, cross-build
diff, and statistical regression alerting — Unreal Animation Insights +
Rewind Debugger territory.
@neith/engine-chooser#
Chooser tables and data-driven selection (Rust, libs/neith/engine-chooser,
phase 171.10): a table asset of if-context-then-pick rows with composite
conditions (tag/bool/range), first-match, weighted and chained evaluation with
a debug trace, hotreload, CSV/JSON import, and StateTree/BT integration
adapters — Unreal's Chooser Table plugin as a sovereign model.
@neith/engine-input#
Enhanced-input system (Rust, libs/neith/engine-input, phase 172.1): input
action assets and mapping contexts with priority stacking in subsystem, a
modifiers pipeline (dead-zone/smooth/swizzle/response-curve), a triggers
pipeline (tap/hold/chord/pulse), device keys models, runtime rebinding,
accessibility options, and input record/replay.
@neith/engine-level-instances#
Level instances and packed level actors (Rust,
libs/neith/engine-level-instances, phase 171.3): reusable sub-level
instances with per-instance overrides, packed static-mesh baking into
instanced batches, nested instances with override propagation,
worldpartition streaming-cell assignment, hlod proxy generation, and
datalayer gating.
@neith/engine-lights#
Area and photometric lights (Rust, libs/neith/engine-lights, phase 171.6):
rect/disc/tube area emitters with solid-angle sampling, mesh-emissive light
sampling, ies profile loading with polar preview, gobo projection,
barndoor/spot masks, falloff editing, and pathtrace importance sampling
with MIS, plus a light-mixer console model.
@neith/engine-lwc#
Large-world coordinates (Rust, libs/neith/engine-lwc, phase 171.2): an f64
world substrate — dvec vectors with f32 parity, f64 TRS transforms with
split-precision upload, floating-origin rebasing near the camera, an f64
symplectic physics path, camera_relative translation for the f32 renderer,
and quantised netcompress delta compression of 64-bit coordinates.
@neith/engine-mdf#
Mesh distance fields and global distance field (Rust, libs/neith/engine-mdf,
phase 171.8): mesh-to-SDF generate baking, a composited global scene field
with sphere tracing, landscape heightfield SDFs, cone-traced ao and penumbra
soft shadows, VFX particle collision, and SDF streaming/LOD — the
software-raytracing substrate of the renderer.
@neith/engine-megalights#
MegaLights-class many-light renderer (Rust, libs/neith/engine-megalights,
phase 171.4): a ReSTIR direct-illumination integrator (restir) with
weighted-reservoir RIS and temporal/spatial reuse, per-light importance
scoring with CDFs, point/spot/rect/disc/tube light sampling, ies profiles,
and skin/hair/translucent materials BSDFs — validated against a reference
estimator.
@neith/engine-modeling#
In-editor modeling mode and geometry script (Rust, libs/neith/engine-modeling,
phase 171.7): an editable indexed mesh with an extrude/inset/bevel/knife
toolkit, polyedit selection and transforms, SDF-voxel mesh booleans,
shrinkwrap retopo, planar/box/cylindrical uv unwrap with shelf packing, and
a headless composable geoscript surface. Its stable node_library exposes
more than 200 unique primitive, selection, topology, Boolean, deform, retopo,
UV, attribute, bake, and query nodes; named invocations lower into the same cook
IR used by visual and text scripting, and the parity corpus executes every node.
@neith/engine-motion-design#
Cinema4D-MoGraph-class motion-design toolkit (Rust,
libs/neith/engine-motion-design, phase 171.12): grid/linear/radial cloners,
plain/random/step/noise effectors modulated by fields, animated Catmull-Rom
spline paths, spawner/sequencer time integration, text-on-path kinetic
typography, a templates library, and a broadcast-output bridge.
@neith/engine-pose-search#
Pose search / motion matching (Rust, libs/neith/engine-pose-search, phase
171.11): a pose database of motion feature vectors with channel-weighted
K-NN cost, a kdtree ANN index, spring-damper trajectory prediction,
inertialization blend-out with overshoot control, and a motion-warp layer —
Unreal's Pose Search plugin as a sovereign runtime.
@neith/engine-rvt#
Runtime virtual textures (Rust, libs/neith/engine-rvt, phase 171.5): a virtual
page table and physical atlas with GPU-style feedback and LRU cache
paging, disk streaming with neighbour prefetch, multi-layer RVT tile types
(colour/normal/height/mask), landscape terrain blend, and decal/weather
accumulate writers.
@neith/engine-scale#
Open-world scale systems (Rust, libs/neith/engine-scale, phase 171.15):
foliage volumes with per-instance LOD and HISM clustering, grass density
painting, spline-driven landmass edits over a shared heightfield, water
bodies with gerstner wave displacement, shoreline foam, underwater
post-processing, and hydraulic erosion.
@neith/engine-smart-objects#
Smart objects and gameplay interactions (Rust,
libs/neith/engine-smart-objects, phase 171.9): smart-object assets with
interaction slots, a claim/perform/release interaction lifecycle with
occupancy tracking, hierarchical gameplay tags with query, utility-AI
scoring, an ai selection loop, and a runtime registry plus replication
hooks.
@neith/engine-state-tree#
StateTree/BehaviorTree convergence (Rust, libs/neith/engine-state-tree, phase
171.13): a hierarchical FSM + utility + BT runtime — selector/sequence/
parallel/task/condition nodes, a global/local scoped blackboard, events
listeners, EQS and smart-object integration hooks, live-editable tree
instances, profiling, and a behaviour templates library.
@neith/engine-verse#
Verse-class scripting stack (Rust, libs/neith/engine-verse, phase 171.1): a
strongly-typed, concurrent, failure-aware language — lexer/parser/check
front-end, ir compilation, a sandboxed transactional vm with resource
quotas, hotreload with state migration, a live repl, a Blueprint-class
visual scripting surface targeting the same IR, and a static-analysis
distribution gate.
@neith/forge-board#
Whiteboard and diagramming primitives (Rust, libs/neith/forge-board) — a
single-file ~11K-line crate (233 pub fns, 105 tests) of typed board operations:
BoardRect/CanvasTileCoord geometry, sticky notes (StickyNoteColor), and
CaptureExport region/format export planning.
@neith/forge-fonts#
Font-editor primitives (Rust, libs/neith/forge-fonts) — a single-file
~10.7K-line crate modelling glyph outlines (Glyph, GlyphContour,
GlyphNode), FontMetrics and guides, and auto-hinting (AutoHintOptions,
stem-hint orientation) with per-operation tests.
@neith/forge-genimaging#
Generative-imaging workflow primitives (Rust, libs/neith/forge-genimaging,
~3.7K lines): typed models and operations for text-to-image canvases
(TextToImagePrompt, GenerationSettings, DiffusionSampler), masked
GenerativeFillRequests, reference images, and canvas expansion — the workflow
layer only; diffusion model inference is not in this crate.
@neith/forge-icon#
Icon and brand-asset primitives (Rust, libs/neith/forge-icon, ~2.2K lines):
PixelGrid icon templates across standard IconSizes, SVG optimisation
(SvgOptimizeOptions), icon-font builds (IconFontBuild), and multi-density
raster export planning (RasterExportPlan).
@neith/forge-motion#
Interactive motion-graphics primitives (Rust, libs/neith/forge-motion, ~3.2K
lines): keyframed VectorTimelines with Easing, animated-property tracks, and
a Rive-style interactive StateMachine with StateInputs and condition-guarded
StateTransitions.
@neith/forge-photo#
Photography catalog and RAW workflow primitives (Rust, libs/neith/forge-photo)
— a single-file ~12.6K-line crate (202 pub fns, 120 tests):
ImportSource/PhotoAsset catalog operations plus USB and Wi-Fi tethering
session/capture models (UsbTetherSession, WifiTetherProtocol) — typed
workflow state, not camera device drivers.
@neith/forge-publisher#
Long-document publishing primitives (Rust, libs/neith/forge-publisher, ~12.2K
lines): PrintPageSetup page geometry with edge insets and PrintMarks, and
PDF/X export planning (PdfXStandard, PdfOutputIntent, PdfXExportOptions)
for print production.
@neith/foundry#
Nuke-class node-compositor core (Rust, libs/neith/foundry, phase 135.1): an
80-module crate composing the shared Neith DAG with image-specific nodes —
keying (keylight, primatte, ibk), roto/paint_stroke, cryptomatte and
deep compositing, ocio/ACES colour, 2D/planar/camera tracking,
scanline_render/ray_render 3D, and Python/Lua/Tcl API surfaces. Host
boundaries like image decode/encode stay explicit and deterministic.
@neith/gi-ao#
Ambient-occlusion suite (Rust, libs/neith/gi-ao, phase 168.8): horizon-based
gtao (XeGTAO-class) with bent normals, ray-traced rtao, Jimenez
multibounce energy recovery, distance-field dfao cone tracing, analytic
capsule_ao for characters, thickness-map transmission, and a contribution
stage applying AO to indirect light only.
@neith/gi-conformance#
Cross-crate conformance suite for the phase-168 GI pipeline
(libs/neith/gi-conformance) — a validation crate: canonical scenes built in
every technique's representation, reference-vs-realtime rmse, temporal
stability and moving-object robustness checks, a shadow_corpus, per-profile
memory budgets, and fail-loud external gates for cross-GPU parity and
mobile/console frame-rate targets that need real hardware.
@neith/gi-core#
Unified GI abstraction and render graph (Rust, libs/neith/gi-core, phase
168.1): implements no single GI algorithm itself — it defines the
diffuse/specular/shadow interface the technique crates satisfy, quality
profile tiers, a capability-driven fallback chain (HW-RT → SW-RT → SDFGI →
probes), render-graph scheduling, budgets, and a path-traced reference for
validation.
@neith/gi-emissive#
Emissive light injection (Rust, libs/neith/gi-emissive, phase 168.10):
emissive triangles become area lights via mesh_light with per-triangle
sampling, froxel cluster_injection, one-bounce gi_contribution, luminance
importance sampling, incremental moving-object updates, distance lod
cutoff, and HDR bloom feed — sprites and VFX emit too.
@neith/gi-lightmap#
Progressive/baked lightmapping (Rust, libs/neith/gi-lightmap, phase 168.7):
UV-chart atlas generation and packing, a path-traced baker with a
progressive-radiosity fallback, a tiled gpu-style bake scheduler,
directional dominant-direction lightmaps, mixed static+dynamic lighting with
stationary subtractive support, and a seam-aware denoiser — Unity Progressive
Lightmapper / Lightmass territory.
@neith/gi-lumen#
Lumen-class software + hardware ray-trace GI (Rust, libs/neith/gi-lumen, phase
168.5): a SAH bvh with Möller–Trumbore traversal, hardware and software
trace paths, an on-mesh surface_cache and world radiance_cache,
screen_probe final gather, restir (ReSTIR-GI) spatiotemporal reservoir
resampling, and SVGF denoise. Also serves as the pipeline's path-traced
reference.
@neith/gi-probe#
Irradiance and reflection probe system (Rust, libs/neith/gi-probe, phase
168.4): order-2 sh irradiance probes, a ddgi dynamic diffuse grid with
octahedral encoding and Chebyshev visibility, prefiltered cubemap
reflection_probes and planar_probes, auto-placement with inside-geometry
relocation, and runtime/offline bake plus streaming.
@neith/gi-sdfgi#
Signed-distance-field GI (Rust, libs/neith/gi-sdfgi, phase 168.2): scene
meshes baked to an sdf grid by exact point-to-triangle distance,
camera-centred cascade clipmaps with incremental scrolling and dirty regions,
per-voxel albedo+emission, hemisphere cone_trace diffuse and sharp specular,
sky fallback, and a denoise pass — Godot-SDFGI / Brixelizer-class, no
lightmaps.
@neith/gi-shadow#
Unified shadow pipeline (Rust, libs/neith/gi-shadow, phase 168.6): vsm
virtual shadow maps with a sparse page table, csm cascades with soft
transitions, raytraced and stochastic PCSS soft shadows, screen-space
contact shadows, hair strand and translucent shadows, and a distance
lod + per-light budget — a ShadowPipeline selects the technique and
answers the gi-core ShadowGi query.
@neith/gi-sky#
Sky, atmosphere, and time-of-day (Rust, libs/neith/gi-sky, phase 168.11): a
Bruneton-style Rayleigh/Mie atmosphere with aerial perspective, celestial
sun/moon/star ephemeris with eclipse and aurora events, weather-driven
parameters, a sky-to-cubemap-to-SH bake feeding sky_gi, dynamic cloud
shadows, and a keyframed timeofday timeline composed by the Sky type.
@neith/gi-volumetric#
Volumetric lighting (Rust, libs/neith/gi-volumetric, phase 168.9): a froxel
frustum-voxel scattering integrator over HG/Rayleigh phase functions,
analytic + heterogeneous VDB-style density fields, volumetric
self-shadowing, godrays, sun-lit ray-marched clouds, in-volume caustics
approximation, and a volumetric denoiser.
@neith/gi-voxel#
Voxel GI (Rust, libs/neith/gi-voxel, phase 168.3): a sparse voxel octree
with surface voxelisation, anisotropic six-face radiance with emissive
injection, a front-to-back mipmap pyramid, cone_trace lookup for diffuse and
specular GI, an irradiance_cache, per-light voxel shadow, and region
streaming — SVOGI/VXGI-class, fully dynamic.
@neith/gpen-anim#
Grease-pencil 2D animation workflow (Rust, libs/neith/gpen-anim, phase 156.3),
built on the neith-gpen-object data model: onion-skin ghosting, cubic stroke
inbetween tweens driven by an fcurve, a dopesheet and xsheet,
cycles/walkcycle looping, lipsync mouth charts, and animatic timing.
@neith/gpen-lineart#
Line art from 3D (Rust, libs/neith/gpen-lineart, phase 156.5): views a
triangle mesh through a camera and emits grease-pencil strokes for silhouettes
(contour), creases, material boundaries and intersections, chained into
editable polylines with occlusion culling, material-driven style, and
noise roughening — Blender Line Art / Pencil+ territory, with a gpu path.
@neith/gpen-modifier#
Grease-pencil modifier evaluator (Rust, libs/neith/gpen-modifier, phase
156.4): one real deformation algorithm per modifier kind — armature, array,
build, lattice, mirror, noise, smooth, shrinkwrap, dotdash and
more — evaluated over a layer's strokes by a ModifierPipeline threading a
shared ModifierContext; every modifier is a pure, deterministic function of
parameters and context.
@neith/gpen-object#
Foundation data model of the grease-pencil suite (Rust,
libs/neith/gpen-object, phase 156.1): GpObject → layers → sparse frame
lists → strokes of points, plus fills, materials, shapekeys, the math
kernel, and a usd custom-prim/BasisCurves exporter — every other gpen-* crate
builds on this spine.
@neith/gpen-rig#
2D character rigging for grease pencil (Rust, libs/neith/gpen-rig, phase
156.7): armature FK skeletons, envelope auto-weights, linear-blend skin of
strokes, CCD/FABRIK ik, mean-value-coordinate cage deform, blendshape
expression rigs, and an autorig body template — Toon Boom/Moho-class cut-out
puppetry.
@neith/gpen-shade#
Materials and rendering for grease pencil (Rust, libs/neith/gpen-shade, phase
156.6): a software MSAA rasterizer with multi-aov framebuffer,
solid/gradient/texture/pattern shaders with stencil alpha, lit strokes and
shadows in light, layer blend modes, stroke sorting, and a gpu (wgpu)
path.
@neith/gpen-storyboard#
Storyboard and previs (Rust, libs/neith/gpen-storyboard, phase 156.9): a
board panel manager, an Act→Scene→Shot→Board hierarchy with roll-up timing,
a keyframed storyboard camera widget, per-board sidecar metadata, animatic
assembly, and edl/otio/pdf export — Storyboard-Pro territory on the
grease-pencil model.
@neith/gpen-testing#
Cross-crate validation harness for the grease-pencil suite (Rust,
libs/neith/gpen-testing, phase 156.10) — a testing crate that depends on every
gpen-* sibling: 100k-stroke perf scenes, usda round-trip checks, and
integration runs (cross-NPR consistency, an end-to-end animated short, the
phase-141 X-sheet hand-off).
@neith/gpen-tools#
Interaction layer of the grease-pencil suite (Rust, libs/neith/gpen-tools,
phase 156.2): draw with brush presets, pressure curves and a stabilizer,
fill_ops (flood fill via the foundation ear-clipper), sculpt and edit
reshaping, select modes, guides, and surface projection — everything
between pen-down and a finished drawing.
@neith/gpen-vr#
VR/AR spatial drawing (Rust, libs/neith/gpen-vr, phase 156.8): 6DoF controller
input to stroke ingestion via a quat kernel, AR anchor-relative placement,
tube/ribbon/billboard volumetric geometry, gestures, and CRDT-based
collab/sync multi-artist sessions — a Quill/Open-Brush-class layer whose
strokes stay first-class grease-pencil data.
@neith/hair-anim#
Hair animation and rigging for curve grooms (Rust, libs/neith/hair-anim, phase
155.9): rest/dynamic pose blending, bake of simulation to sparse keyframes,
blendshapes with layer blends and correctives, motion-vector computation,
control-curve rigging, lattice FFD deformation, and an animatable wind
driver.
@neith/hair-curve#
Foundation of the phase-155 curves-hair system (Rust, libs/neith/hair-curve):
a first-class Curve strand type with Poly/Bézier/Catmull-Rom/B-Spline bases,
typed columnar attributes, a CurveSet scene object with layered
evaluation, surface anchoring, instances, and lod — the data model every
other hair-* crate mutates.
@neith/hair-groom#
Grooming brushes and tools (Rust, libs/neith/hair-groom, phase 155.2): every
brush consumes a BrushStroke soft radial region and mutates a CurveSet in
place — topology add/remove/density, deform comb and smooth, length
grow/trim, clump with soft core, plus mask and mirror support —
XGen-Interactive/Ornatrix-class sculpting.
@neith/hair-guide#
Guide curves and interpolation (Rust, libs/neith/hair-guide, phase 155.4):
sparse authored guide strands interpolated to a full groom via N-nearest,
Gaussian rbf, and UV-aware interp with priority layering, weight painting,
and feather/bilateral symmetry mirroring.
@neith/hair-nodes#
Geometry-node graph for curves (Rust, libs/neith/hair-nodes, phase 155.3):
procedural nodes transforming a CurveSet — scatter from surface/density map,
generate from guides, edit (trim/resample/set-radius), shape
(turbulence/curl/frizz), braid and clump — composed by a NodeGraph and
wired into looks by presets.
@neith/hair-presets#
Groom preset library (Rust, libs/neith/hair-presets, phase 155.8): 250+
parametric strand grooms — human hair including afro/coily grades, beards,
braids and wigs, creature fur/feathers/scales, stylised looks, and
accessory mesh descriptors — each GroomPreset carrying an Attribution and
able to emit a shaping node graph.
@neith/hair-render#
Hair rendering geometry and LOD (Rust, libs/neith/hair-render, phase 155.7):
strand-to-tube/ribbon mesh generation, raytrace ray-strand intersection,
weighted-blended oit transparency, stochastic alpha-tested shadows,
strand→clump→card distance lod with cross-fade and auto card baking, plus
billboards and motion blur — CPU math, renderer-facing.
@neith/hair-shade#
Hair shading (Rust, libs/neith/hair-shade, phase 155.6): the two production
BSDFs — marschner far-field and chiang near-field — plus kajiya-Kay
stylised shading, melanin-based color, dual_scatter multiple scattering,
aov/Cryptomatte outputs, and LOD-aware billboard shading.
@neith/hair-sim#
Hair simulation and dynamics (Rust, libs/neith/hair-sim, phase 155.5): a CPU
strand solver — der discrete-elastic-rod bending/twist, pbd constraints with
fast_projection inextensibility, self/body collide, gravity/wind forces,
wet-hair materials, sim lod, cache baking, and rig-driven roots.
@neith/hair-transfer#
Cross-mesh groom transfer (Rust, libs/neith/hair-transfer, phase 155.10):
UV-projection transfer with auto-scale, cross-topology and retopo support over
a uv_map triangle lookup, morph-target resync, portable groom-pack
bundles, hair-scalp fit checking, cross-character retargeting, and
partline relocation.
@neith/hair-validation#
Cross-crate validation for the hair suite (Rust, libs/neith/hair-validation,
phase 155.11) — a testing crate with the integration tests in
tests/validation.rs: deterministic simulation stability, afro/coily texture
fidelity, and groom transfer across a synthetic head set. Items needing a
viewport, offline renderer, or external interchange (1M-strand renders,
USD/Alembic round-trips, Arnold comparison) are honestly out of scope here.
@neith/hdr#
HDR mastering core (Rust, libs/neith/hdr, phase 135.9): dolby_xml metadata
and trim levels, hdr10plus, hlg and pq transfer handling, aces colour,
sdr_tonemap and display_mapping preview, colorimetry, and automated_trim
— the mastering/delivery metadata plane for HDR finishing.
@neith/liveops-ads#
Ad mediation and SDK (Rust, libs/neith/liveops-ads, phase 164.2): a sealed-bid
first/second-price auction, per-network mediation adapters,
waterfall/header-bidding allocation, frequency caps and pacing, HMAC
server-side reward verification, COPPA kids-mode and GDPR/ATT consent
gating, click/install fraud guards, and eCPM/fill reporting.
@neith/liveops-analytics#
Game analytics (Rust, libs/neith/liveops-analytics, phase 164.3): an event
envelope with per-platform SDK clients, inactivity-gap sessionization,
funnels, player profiles, economy source-sink flow, DAU/MAU retention,
LTV/ARPU revenue, a cohort builder and boolean segment engine, and NDJSON
warehouse export — deterministic throughout (time is an explicit parameter,
never a wall clock).
@neith/liveops-attribution#
Mobile attribution and growth (Rust, libs/neith/liveops-attribution, phase
164.8): last-touch install attribution, deferred deeplinks, skan
(SKAdNetwork) postbacks with 6-bit conversion values, k-anonymous privacy
aggregation, HMAC partner postbacks, click-fraud detection, cohort ltv
projection, mta multi-touch, and incrementality testing — Adjust/AppsFlyer
territory, wall-clock-free.
@neith/liveops-cloud-save#
Cloud save and inventory sync (Rust, libs/neith/liveops-cloud-save, phase
164.7): a versioned per-slot kv store with crdt (LWW-register + OR-Set)
merge, version history, block-delta sync, ChaCha20 crypto at rest,
offline-first background sync, Steam/Epic/sovereign backend seams, schema
migration, GDPR erasure, and tamper detection.
@neith/liveops-compliance#
Regional regulatory compliance (Rust, libs/neith/liveops-compliance, phase
164.11): each module encodes a real regime as deterministic rules — lootbox
disclosure/legality with a gambling test, age-rating plus COPPA/GDPR-K gates,
China-minor playtime curfew and break notices, rolling spend caps,
data-residency routing, and right-to-erasure automation.
@neith/liveops-conformance#
Cross-crate conformance harnesses for the phase-164 liveops stack (Rust,
libs/neith/liveops-conformance) — a validation crate: receipt_conformance
(Apple/Google/sovereign IAP), ad_benchmark fill/auction correctness,
remote_consistency rollout monotonicity, experiment_srm alarms, and a
fraud_redteam harness, each returning a ConformanceReport. Its load_test
holds one million virtual connections live together and drives two million
remote-config/analytics SDK operations through bounded worker shards; dogfood
binds the real Phase 27 Project Obsidian, Phase 76 Maya Forge and Phase 77 Maya
Nexus/MMO package roots and runs each profile through all twelve liveops
runtime/operator crates.
@neith/liveops-crm#
Player CRM and lifecycle messaging (Rust, libs/neith/liveops-crm, phase
164.9): 360 profiles with RFM, cross-platform push and an in-game inbox,
segment auto-campaigns, churn/reactivation journey orchestration, vip
outreach, consent + frequency governance with quiet-hours, and in-campaign A/B
via experiment — deterministic scheduling over injected time and transport.
@neith/liveops-cs#
Customer-support and agent tooling (Rust, libs/neith/liveops-cs, phase
164.10): privacy-audited player lookup, ban/mute sanctions with an appeal
state machine, audited currency/item grants with daily limits, save
rollback, incident compensation composer, sla dashboards, chargeback
workflow, and account merge/split — all on a tamper-evident SHA-256 audit
hash chain.
@neith/liveops-economy#
Virtual economy (Rust, libs/neith/liveops-economy, phase 164.6): every value
movement conserved through a double-entry ledger — inventory, crafting
recipes, trading/marketplace/auction, pity loot tables with drop-rate
disclosure, exchange caps, dup-fraud detection, an inflation simulator,
and wealth analytics.
@neith/liveops-experiments#
A/B and experimentation platform (Rust, libs/neith/liveops-experiments, phase
164.5): an experiment definition DSL, deterministic hash assignment with
mutual-exclusion layers and holdouts, a metrics registry with guardrails,
self-contained stats (erf/gamma, z/t tests, CUPED, Bayesian, SPRT sequential
early-stop), and SRM checks in analysis — no external numeric dependencies,
fully reproducible.
@neith/liveops-iap#
In-app purchase and storefront (Rust, libs/neith/liveops-iap, phase 164.1):
integer-micros money with banker's rounding, a cross-platform catalog,
StoreKit2/Google/console/Steam receipt validation, idempotent entitlement
grants, refund webhooks, promo codes, FX regional pricing with elasticity
A/B, subscription lifecycle, and VAT/GST tax.
@neith/liveops-portal#
Operator-portal backend (Rust, libs/neith/liveops-portal, phase 164.12) — data
aggregation only, no GUI: KPI dashboard rollups with alert states, a release
scheduler with dependency topo-ordering, unified config/experiment/flag
changesets with approval, a cohort explorer, revenue drill-down,
retention/churn exploration, and a whatif economy simulator.
@neith/liveops-remote#
Remote config and feature flags (Rust, libs/neith/liveops-remote, phase
164.4): namespaced typed values, a targeting rule engine
(segment/country/semver/device), deterministic gradual rollout and
experiment decisions from a stable FNV-1a hash of (user_id, key),
kill-switch flags, an offline-fallback client SDK model, change audit +
versioned release/rollback, and a fetch-latency slo.
@neith/market-buyer-portal#
Buyer-experience layer of the creator marketplace (Rust,
libs/neith/market-buyer-portal, phase 165.9): owned library with receipts,
re-download and install tracking, cart with saved-for-later, wishlist
price-drop alerts, team/org purchase pooling with shared seats and budget, and
child/student gating.
@neith/market-catalog#
Catalog and asset-type layer of the marketplace (Rust,
libs/neith/market-catalog, phase 165.1): an asset taxonomy (3D/2D/audio/
plugin/ML-model/...), a required-field schema with versioned migrations,
preview plans (turntable/playblast/web viewer/audio waveform),
content-addressed ids, engine-semver compat matching, templates,
collections, and curation.
@neith/market-commerce#
Money engine of the marketplace (Rust, libs/neith/market-commerce, phase
165.4): integer-micros money with banker's rounding (no f64 in the pricing
path), auto-fx and ppp purchasing-power tiers, discount/pwyw/
preorder/groupbuy mechanics, a place-of-supply tax engine, a transparent
fees waterfall, multi-currency escrow, chargeback insurance, and
collaborator revenue splits.
@neith/market-conformance#
Cross-crate conformance harnesses for the marketplace (Rust,
libs/neith/market-conformance, phase 165.12) — a validation crate driving the
real market-* crates end-to-end: search_load (BM25 P99 at scale),
commerce_audit (20-cycle payout conservation), security_audit (license-cert
tampering, malware catch-rate), Unity/Fab migration import, an
onboarding_soak, and refund_e2e.
@neith/market-creator#
Creator onboarding (Rust, libs/neith/market-creator, phase 165.2): profile and
portfolio, a KYC/tax-form state machine (W-9/W-8BEN treaty rates), payout
and identity verification with real IBAN/ABA checksums, studio teams with
roles, a submission wizard with version rollback, automated asset lint
(missing maps, non-power-of-two, poly budget), and review-sla tracking.
@neith/market-creator-analytics#
Seller insights (Rust, libs/neith/market-creator-analytics, phase 165.10):
sales dashboards with country splits, view/cart/purchase funnels with refund
rates, anonymised peer-percentile benchmarking, listing seo scoring,
abtests with two-proportion z-test significance, log-log price elasticity
regression, and RFC-4180 CSV plus versioned bounded JSON API export —
closed-form stats, no fabricated numbers.
@neith/market-discover#
Discovery, search, and recommendations (Rust, libs/neith/market-discover,
phase 165.6): bm25 keyword search with facet filtering, cosine semantic
recommendations over embeddings, perceptual-hash visual search, association
rule cross-sell bundles, time-decayed trending ranking, editorial lists,
and a personalised feed — every ranking a real deterministic algorithm.
@neith/market-dl#
Asset delivery and DRM-lite (Rust, libs/neith/market-dl, phase 165.5):
resumable chunked download with per-chunk SHA-256, rsync-style rolling-hash
delta patching, install actions with plugin auto-enable, a fail-closed
per-user entitlement unpack gate, signed offline activation, an optional
per-buyer watermark, and re-download quota accounting — byte plans and state
machines a thin networked shell drives.
@neith/market-licensing#
Licensing and rights engine (Rust, libs/neith/market-licensing, phase 165.3):
tier rights bundles (standard/extended/enterprise), usage metering
(royalty/per-seat/per-title), composable custom terms with conflict detection,
CC and GPL/MIT/Apache templates with an SPDX-style compat checker,
Ed25519-signed proof-of-license certs, auto-attribution NOTICE generation,
and a DMCA takedown/dispute workflow.
@neith/market-moderation#
Trust and safety plane of the marketplace (Rust, libs/neith/market-moderation,
phase 165.8): SHA-256 malware signature scans, static_analysis of plugin
scripts (dangerous-API/obfuscation heuristics), an NSFW/violence classifier,
copyright/deepfake/ trademark guards, a human review queue with SLAs,
appeal due process, regional/agegate availability, an escalating strikes
ledger, and a transparency report — all detectors pure and deterministic.
@neith/market-review#
Ratings, reviews, and QA (Rust, libs/neith/market-review, phase 165.7): star
ratings with verified-purchase weighting, Wilson-score helpful-vote ranking,
creator responses with an edit window, guideline flagging and enforcement,
lexicon sentiment with negation handling, automated qa-bot scene tests, and
per-category refund policy.
@neith/market-sdk#
Integration SDK for the marketplace (Rust, libs/neith/market-sdk, phase
165.11): DCC/engine/PWA surfaces, a neithmarket cli, publish-from-CI
idempotency in publish, Stripe-style HMAC-signed webhooks, oauth
(authorization-code + PKCE S256), licensed-asset verification, inventory sync
diffing, and signed embed-buy widgets — genuine SHA-256/HMAC/PKCE, not mocks.
@neith/matchmove#
Camera tracking and matchmove core (Rust, libs/neith/matchmove, phase 135.4):
a 19-module crate covering 2D tracking and object_tracking, lens solve with
a lens_database, bundle adjustment, survey and nodal solves,
multi_view reconstruction, point_cloud/mesh output with textured export,
gaussian_splat output, and drift diagnostics.
@neith/motion#
After Effects-class motion-graphics composition core (Rust, libs/neith/motion,
phase 135.2): frame-exact nested compositions — shape and text layers, an
expression engine, 3D camera/light/raytrace, particles, graph-editor
curves, time remapping, templates, and dynamic_link — a ~1.2K-line lib.rs
orchestrating 16 modules.
@neith/npr-cel#
Cel/toon shading pipeline (Rust, libs/neith/npr-cel, phase 170.11, built on
neith-sculpt-core): a multi-step diffuse ramp with shadow tiers and stepped
specular, features (skin-tone ramp, anisotropic hair streak, eye card, rim
layer), detail (SDF hard shadows, posture correction, face-normal bake),
layered cel materials, and a shared realtime/offline parity kernel —
Guilty-Gear/Pencil+4 territory.
@neith/npr-inking#
Inking and hatching pipeline (Rust, libs/neith/npr-inking, phase 170.12):
illuminance-driven hatch density with progressive cross-hatch angle ramps and
curvature-aligned direction, rotated-screen halftone dots with a manga
screentone library, pencil/charcoal/ink/etching presets, and paper-texture
composite with unified stylised edges.
@neith/npr-line#
Freestyle-class offline line renderer (Rust, libs/neith/npr-line, phase
170.10): feature-edges detection (silhouette, crease, ridge/valley, suggestive
contour), stroke chaining with prune/sort in stroke, a shader modifier
chain, dash/dot patterns with tapered caps, hand-drawn jitter, occlusion,
and temporal stability — built on neith-sculpt-core.
@neith/oss-abstraction#
Platform-agnostic foundation of the phase-159 online stack (Rust,
libs/neith/oss-abstraction): gameplay code targets one IOnlineSubsystem
trait; backends hold a NullBackend, a first-party SovereignBackend, a
BackendRegistry and external-SDK bridge seams, plus real mdns LAN discovery,
capability flags, hotswap, and compliance checks.
@neith/oss-anti-cheat#
Server-authoritative anti-cheat (Rust, libs/neith/oss-anti-cheat, phase
159.13) — the server never trusts the client: kinematic movement reachability
checks against teleports/speed-hacks, server-side hitreg re-derivation,
packet and ratelimit guards, statistical anomaly models, and a review
pipeline. OS-level code-signing attestation and the trust service are explicit
fail-loud seams.
@neith/oss-identity#
Identity, auth, friends, and presence (Rust, libs/neith/oss-identity, phase
159.2): a sovereign PlayerIdentity aggregating linked platform accounts, a
deterministic SHA-256 stable_id, real oidc ID-token claim validation,
webauthn, friends/presence/moderation state, guest accounts, and
crossplay policy.
@neith/oss-matchmaking#
Matchmaking, lobby, and party (Rust, libs/neith/oss-matchmaking, phase 159.3)
— engine-agnostic policy and math with no network I/O: a lobby directory with
typed attributes and an inverted search index, single-use invite deep-link
tokens, a persistent party service, ready-check countdowns, skill rating
(Glicko-class), hopper/backfill queues, region selection, and smurf
detection.
@neith/oss-observability#
Net telemetry and profiler (Rust, libs/neith/oss-observability, phase 159.14):
per-connection RTT (RFC 6298 SRTT/RTTVAR), RFC 3550 interarrival jitter and
sequence-gap loss, bandwidth attribution with top-N hotspots, capture and
timeseries models, slo tracking, and regression detection — replaying a
recorded packet log yields identical numbers.
@neith/oss-pixel#
Pixel streaming and cloud game output (Rust, libs/neith/oss-pixel, phase
159.12): the protocol/control plane of streaming frames to browsers — WebRTC
negotiate, abr adaptive bitrate, sfu forwarding, latency budgeting,
input transport, rooms, and fleet scaling. The media transport and
hardware encoder are fail-loud NotConfigured seams, not fabricated media.
@neith/oss-prediction#
Client prediction, rollback, and interpolation (Rust,
libs/neith/oss-prediction, phase 159.7): a deterministic fixed-point sim
underpins predict+reconcile (resimulating unacked inputs), GGPO-style
rollback and lockstep, and interpolation with bounded extrapolation and
lag-compensated hitscan — the netcode-feel layer.
@neith/oss-presence#
Presence, stats, leaderboards, and progression (Rust, libs/neith/oss-presence,
phase 159.10): rich presence cards, a typed stats store with aggregation,
leaderboards, achievements and quests, cloudsave and inventory models.
Native trophy push and EOS/Steam/PSN/Xbox federation lookups are fail-loud
NotConfigured seams.
@neith/oss-replay#
Replay and spectator plane (Rust, libs/neith/oss-replay, phase 159.11): a
CRC32-framed on-disk container for the replication stream, keyframe-indexed
playback with reverse/fast-forward, a 6-DOF spectator camera, a director
feed, killcam extraction, and compression — only the cloud upload is an
external fail-loud seam.
@neith/oss-replication#
Iris-class replication graph and protocol (Rust, libs/neith/oss-replication,
phase 159.5): static/dynamic net_id GUIDs, a ReplicationWorld entity model
with authority transfer and dormancy, a build-time property RepLayout with
conditions, delta quantize compression, fast_array serializers, spatial
graph prioritisation, and channel streams — the minimal per-connection byte
stream that keeps clients converged.
@neith/oss-rpc#
RPC plane of the online subsystem (Rust, libs/neith/oss-rpc, phase 159.6):
transport-agnostic descriptors (direction, reliability class, owner scope,
versions), server-authoritative dispatch admission with mandatory validation,
per-caller ratelimit token buckets, call batching and compression, and
metrics.
@neith/oss-session#
Session and game-server lifecycle (Rust, libs/neith/oss-session, phase 159.4):
a session state machine with legal transitions only, a best-fit bin-packing
allocator onto dedicated fleets, an Agones-class fleet autoscaler, host
migration, p2p listen-server support, ban lists, and slots reservation —
network-free policy and math.
@neith/oss-testing#
Cross-crate conformance suite for the fifteen OSS crates (Rust,
libs/neith/oss-testing, phase 159.15) — an integration harness with no mocks
of the systems under test: a 128-player replication soak, cross-region RTT
budgets, 10% packet-loss resilience, a nat connectivity matrix, 100k-tick
rollback determinism, protocol fuzzing, and host-failover/migration
drills.
@neith/oss-transport#
Transport, NAT traversal, and security floor (Rust, libs/neith/oss-transport,
phase 159.8): ENet/Gaffer-style UDP reliability (ack-bitfield, retransmission,
channels), WebRTC/QUIC framing in transports, stun/nat traversal,
congestion control, fec, mtu discovery, pacing/shaping, and packet
security — protocol implementations verified against published test vectors.
@neith/oss-voice#
Voice chat and proximity audio (Rust, libs/neith/oss-voice, phase 159.9):
congestion-aware codec bitrate adaptation and RTP-style packetisation (the
native Opus encode/decode itself is a fail-loud seam), 3D spatial attenuation
with cone directivity, team/party channel routing with mute and block,
hysteretic vad + push-to-talk, and caption/moderation hooks.
@neith/parity171-testing#
Cross-crate validation suite for the 26 phase-171 UE/Blender parity crates
(Rust, libs/neith/parity171-testing) — a testing crate whose integration tests
live in lib.rs/tests: Verse sandbox, LWC planet scale, MegaLights 1000-light
convergence, RVT paging soak, the complete 200+ node Geometry Script corpus, and
motion-matching RMSE. The explicit blender-reference target renders a
canonical scene in headless Blender and grades extended Freestyle output with a
line-aware visual diff. Deterministic Project Obsidian dogfood binds Phase 27
set authoring, Phase 79 landmass/water, Phase 162 hero validation, and Phase 163
content-addressed ordered-shoot grading without claiming live-volume
certification from synthetic evidence.
@neith/profiler-asset#
Asset and cook profiler (Rust, libs/neith/profiler-asset, phase 160.11):
per-asset cook timing statistics, a weighted buildgraph with longest-path
critical-path analysis, a depgraph with three-colour DFS cycle detection, DDC
cache correlation (the remote cache is an UnconfiguredRemoteCache fail-loud
seam), diskio, shader and sizedelta tracking.
@neith/profiler-audio#
Audio-engine profiler (Rust, libs/neith/profiler-audio, phase 160.10):
active-voices tracking with priority stealing, per-bus dsp_bus budget
roll-ups, plugins CPU accounting (the out-of-process plugin host is a
fail-loud trait seam), underrun logs, latency metering, a flamegraph, and
stutter correlateion — Wwise/FMOD Advanced-Profiler territory.
@neith/profiler-capture#
Tracing backend of the frame-profiler stack (Rust,
libs/neith/profiler-capture, phase 160.1): instrumented scopes via a
neith_profile_scope! macro with zero-overhead compile-out, per-thread
lock-free ring buffers, GPU timestamp zones, a monotonic clock, and a
versioned CRC-checked binary format a viewer can open, stream, or replay —
Tracy/Unreal-Insights capture-side parity.
@neith/profiler-crash#
GPU crash / post-mortem analyzer (Rust, libs/neith/profiler-crash, phase
160.13): a minidump model with CRC binary codec (the vendor capture source
is the one external seam), tdr timeout analysis, memguard guard-page fault
classification, deadlock and watchdog hang detection, cmdbuffer culprit
localisation, and an uploadable report bundle — Nsight-Aftermath/DRED
territory, CPU-only.
@neith/profiler-gpu#
GPU frame debugger (Rust, libs/neith/profiler-gpu, phase 160.3): a CPU-only
reimplementation of the RenderDoc/PIX data models — frame capture and replay
of an API-call stream, state/texture/buffer/shader inspection with a
shadervm interpreter, overdraw in pixel/raster, barrier analysis, and
raytracing accel structures. The only external boundary is a live devkit
socket, a fail-loud seam in remote.
@neith/profiler-memory#
Memory profiler (Rust, libs/neith/profiler-memory, phase 160.4): an LLM-style
hierarchical tag_tree, an allocation timeline, a fragmentation model with
first/best-fit allocators, a callstack-hash leak detector, retained-size
analysis, oom_warning projection, and snapshot_diff — the live cook-daemon
socket in pipeline is the only fail-loud seam.
@neith/profiler-net#
Network profiler (Rust, libs/neith/profiler-net, phase 160.5): Unreal Insights
Networking parity in pure Rust — per-connection bandwidth timelines,
replication byte attribution per (actor class, property), rpc frequency/size
stats, packet and ack analysis, congestion and prediction views — all
over caller-supplied deterministic inputs.
@neith/profiler-physics#
Physics-solver profiler (Rust, libs/neith/profiler-physics, phase 160.9):
broad/narrow phases timing with a real sweep-and-prune broad-phase, a
Projected-Gauss-Seidel solver with convergence iteration counts, contacts
timelines with Welford stats, islands and sleeping tracking, substep
accounting, and determinism checks — PhysX-PVD/Chaos-Insights territory.
@neith/profiler-sample#
Sample-based statistical profiler (Rust, libs/neith/profiler-sample, phase
160.7): a continuous sampler building an arena CallTree with self/total
counts, symbolication, cohort/population aggregation across captures,
regression and bootstrap confidence statistics, and trend analysis — the
live kernel tracer is the only fail-loud seam.
@neith/profiler-shader#
Shader profiler and static analyser (Rust, libs/neith/profiler-shader, phase
160.8): a small real shader il in three-address form, a cost analyser with a
per-opcode latency/throughput table, occupancy and registers pressure
modelling, hardware counters aggregation with bottleneck classification,
permutation/variants analysis, and cross- targets diffing —
RGA/Mali-offline-compiler territory.
@neith/profiler-stat#
In-game stat-command and HUD overlay engine (Rust, libs/neith/profiler-stat,
phase 160.6): stat unit/fps/scene frame breakdowns, a scrolling graph,
hitch detection, colour-coded thread bars, a developer-console command
dispatcher, and input key-binding toggles — every overlay produced as data
(draw lists, layout rects); pixel readback is a fail-loud FrameGrabber seam.
@neith/profiler-testing#
Cross-crate validation suite for the profiler stack (Rust,
libs/neith/profiler-testing, phase 160.14) — a testing crate running against
the real crates: instrumentation overhead ≤3%, trace-open fileio throughput,
GPU capture fidelity and shader-stepping accuracy, loopback stream_test, and
a report matrix stating honestly which gates need external hardware or
multi-hour soaks.
@neith/profiler-timing#
Timing/flamegraph analysis (Rust, libs/neith/profiler-timing, phase 160.2):
reads a captured Trace and rebuilds nested zones, thread swim-lane
timelines with ns-to-session zoom, bottom-up/top-down calltree flamegraphs,
frames deltas, task-graph tasks, and concurrency views — the analysis half
of the capture crate.
@neith/profiler-ui#
Profiler UI and workflow layer (Rust, libs/neith/profiler-ui, phase 160.12):
no windowing — every module produces the data a front-end renders: a dock
layout with a real min/weight constraint solver, a web-viewer scene graph to
z-ordered draw lists, a versioned remote-trace stream protocol, capture
compare deltas, query hit-testing, export, and palette/ theme systems.
@neith/sculpt-brushes#
Sculpt brush library (Rust, libs/neith/sculpt-brushes, phase 170.4): the
ZBrush/Blender/Mudbox brush set as real per-vertex deformation and
mesh-generation operators on neith-sculpt-core — base draw/clay/crease/
inflate/pinch family, grab/snake_curve/transpose, claybuildup, cloth
and pose brushes, zsphere armatures, zremesher-style remesh brush,
nanomesh, and stamp/spotlight projection.
@neith/sculpt-core#
Sculpt-mode foundation (Rust, libs/neith/sculpt-core, phase 170.1): the shared
substrate for all sculpt/NPR crates — an editable indexed mesh with adjacency,
a per-object sculpt mode session with per-face hiding, a pressure/tilt
stroke engine with lazy-mouse stabiliser, X/Y/Z + radial symmetry, an
additive/subtractive clay compositor, falloff curves, undo, and vr
input.
@neith/sculpt-export#
Sculpt export engine (Rust, libs/neith/sculpt-export, phase 170.9):
gameready low-poly + normal-map bundles, real text-format writers in formats
(OBJ, PLY, ASCII STL, glTF 2.0 with base64 buffers, ASCII USD, ASCII FBX),
print3d STL/3MF with a ray-cast wall-thickness check, normalspace
conversion, udim splitting, and engine presets — the Alembic Ogawa binary
backend is an honest fail-loud seam in exporter.
@neith/sculpt-face-sets#
Face-sets / poly-groups engine (Rust, libs/neith/sculpt-face-sets, phase
170.5): per-face sets with grow/shrink/invert/isolate over edge adjacency,
auto-assign by normal angle/material/mask/UV island, a paint brush,
inter-set boundary visualisation, face-set↔vertex-mask convert, and per-set
pivots.
@neith/sculpt-layers#
Non-destructive sculpt layers (Rust, libs/neith/sculpt-layers, phase 170.3): a
per-object displacement layer stack with visibility/opacity and
add/multiply/overlay blend modes, per-layer mask painting, sublayers scoped
to a multires level, morph-target export, per-layer version history with
revert, and opacity keyframe animation.
@neith/sculpt-mask#
Sculpt masking engine (Rust, libs/neith/sculpt-mask, phase 170.6): a
per-vertex mask with falloff painting, box/lasso/line shapes, procedural
generate masks by cavity/AO/curvature, projected-image texture masks,
nearest-mirror symmetry, feather/smooth/sharpen filtering, and masked-region
extraction to a new mesh.
@neith/sculpt-polypaint#
Polypaint / vertex-colour engine (Rust, libs/neith/sculpt-polypaint, phase
170.7): per-vertex RGBA paint with pressure and pattern brushes, a picker
eye-dropper, an hsv hue-shift adjustment brush, procedural
colour-by-cavity/AO, and bidirectional vertex-colour↔texture bake over UVs.
@neith/sculpt-retopo#
Retopology engine (Rust, libs/neith/sculpt-retopo, phase 170.8): manual
poly-by-poly retopo with surface snapping via closest-point projection, auto
instant-quad and cross-field flow-guided retopo, mirror-weld symmetric retopo,
uvpack island packing, high-to-low shrinkwrap, and normal/colour/skin-weight
transfer plus a texture baker.
@neith/sculpt-testing#
Testing and validation for the sculpt + NPR pipeline (Rust,
libs/neith/sculpt-testing, phase 170.13) — a validation crate: large-mesh
perf throughput, dyntopo burnin, multires_bake accuracy against an
analytic reference, faceset_roundtrip serialisation, a retopo/map-bake
corpus, Freestyle line_stability across an animated camera, and a fail-loud
.ztl binary-import seam in ztl.
@neith/sculpt-topology#
Dynamic topology and multiresolution (Rust, libs/neith/sculpt-topology, phase
170.2): Sculptris-Pro dyntopo tessellation with a detail-size slider,
quadric-error decimate to a target count, Loop subdiv multires with
per-level displacement, voxel_remesh (DynaMesh-style surface nets),
cross-field_remesh (ZRemesher-style), and crease/snapshot support.
@neith/shotops#
Studio shot tracking and pipeline operations (Rust, libs/neith/shotops, phase
135.11): a 20-module ShotGrid-class core — production hierarchy and workflow
state, a review_player with notes and share_links,
assignment/vendor/turnover management, dependency tracking,
time_tracking/cost/forecast, an api surface, and
dcc/ingest_validator hooks.
@neith/silhouette#
Roto, planar tracking, and paint core (Rust, libs/neith/silhouette, phase
135.3): a 29-module Silhouette/Mocha-class crate — planar tracking with
point_trackers and multi_planar surfaces, roto with feather and
auto_roto, optical_flow, clean_plate/content_fill/wire_remove paint,
screen_replace, stereo workflows, and deflicker/grain finishing.
@neith/sim-cloth#
XPBD cloth and soft-body kernel (Rust, libs/neith/sim-cloth, phase 157.6): an
xpbd distance-constraint solver with per-substep compliance, dihedral
bending, strain-threshold tearing with topology splitting, spatial-hash
self_collision, analytic-SDF body_contact, aerodynamics, garment
assembly with stitch seams, and a co-rotational fem soft-body path.
@neith/sim-core#
Shared foundation of the phase-157 Mantaflow/Houdini-class simulation framework
(Rust, libs/neith/sim-core): math with polar decomposition, a domain box
with nested multi-res, dense grids + staggered MacGrid, a sovereign
VDB-class sparse grid, narrow-band levelsets, seeded rng, and
bake/cache machinery every solver crate reuses.
@neith/sim-farm#
Distributed simulation orchestration (Rust, libs/neith/sim-farm, phase 157.13)
— the planning/scheduling layer, not a live farm: shot decompose across
machines and MPI-rank domain carving, scaling prediction, dependency
schedule ordering, farm submit descriptors, retry policies, proxy review
gating, cost estimation, and byte-budget cache_policy — real cluster
hardware is explicitly out of scope.
@neith/sim-forces#
Force fields and object interaction (Rust, libs/neith/sim-forces, phase
157.10): static/kinematic/deforming obstacles as SDF + cell-type masks with
moving-surface velocity stamping, triangle-mesh-to-SDF in collider, flow
inflow/outflow, curve guide forces, curl noise, and region masks — all on
the shared sim-core grid types.
@neith/sim-games#
Real-time baking for game runtimes (Rust, libs/neith/sim-games, phase 157.12):
bakes solved sims into runtime-samplable assets — flipbook atlases, volume
textures, vat vertex-animation textures, pointcaches, GPU particle_seed
textures, loopbake cycles, and impostors — every baker has a tested decode
inverse within stated tolerance.
@neith/sim-gas#
Eulerian pyro/gas solver (Rust, libs/neith/sim-gas, phase 157.3): a
staggered-grid smoke and fire solver — semi-Lagrangian + MacCormack/BFECC
advection, deflated-PCG pressure projection, vorticity confinement,
two-scale upres, fuel→flame→smoke combustion, and Planck blackbody fire
emission — Houdini-Pyro/EmberGen territory, offline quality.
@neith/sim-liquid#
FLIP/APIC/PIC liquid solver (Rust, libs/neith/sim-liquid, phase 157.2): a
hybrid particle-grid incompressible solver — PIC/FLIP/APIC/MLS transfer,
MIC(0)-preconditioned PCG pressure projection, level-set surface with CSF
tension and adaptive seeding, Newtonian/Herschel-Bulkley rheology,
whitewater, and a pbf quick-preview path.
@neith/sim-mpm#
Material-point-method solver (Rust, libs/neith/sim-mpm, phase 157.4): one
MLS-MPM solver running snow, sand, goo and elastic solids by swapping the
material constitutive law and plastic return-map — signed 3x3 svd, quadratic
B-spline grid transfer, fracture, and solver coupling.
@neith/sim-ocean#
Ocean, waves, and whitecaps (Rust, libs/neith/sim-ocean, phase 157.8): a
Tessendorf Phillips-spectrum fft_ocean with choppiness, Jacobian foam and
seamless tiling, analytic gerstner trochoids, beaufort wind presets,
Green's-law shore shoaling and breaking, shallow_water solve, and boat
wakes.
@neith/sim-particles#
Particle system / POPs solver (Rust, libs/neith/sim-particles, phase 157.5): a
structure-of-arrays particle store, point/surface/volume/curve emitters with
deterministic seeding, forces and collision, boids flocking,
poisson-disk sampling, spatial hashing and a bvh, metaball/mesh
outputs, and a gpu descriptor path — property-tested against conservation laws
and analytic solutions.
@neith/sim-render#
CPU reference volume renderer (Rust, libs/neith/sim-render, phase 157.11) —
deliberately not a GPU pipeline: a physically-based volume ray-marcher serving
as ground truth for the viewport, with aov channel extraction from
dense/staggered/sparse grids, blackbody emission, phase functions,
denoise, and image output.
@neith/sim-rigid#
Rigid-body, constraint, and fracture solver (Rust, libs/neith/sim-rigid, phase
157.7): a sequential-impulse solver with contact manifolds, restitution and
Coulomb friction, hinge/ball/slider/cone-twist constraint joints as real
Jacobian impulses, force-limited motors and CFM/ERP springs, voronoi
pre-fracture by half-space clipping, island sleeping, and building
demolition clustering.
@neith/sim-surface#
Surface reconstruction and meshing (Rust, libs/neith/sim-surface, phase
157.9): Yu-Turk anisotropic kernel fields from particles, canonical 256-case
marching_cubes and QEF dual_contouring, narrowband polygonisation,
smoothing/subdivision/remesh post-passes, uv generation, and
velocity-mapped meshcache output.
@neith/sim-validation#
End-to-end validation benchmarks for the simulation framework (Rust,
libs/neith/sim-validation, phase 157.14) — a testing crate asserting physical
invariants, not screenshots: dambreak vs the Ritter analytic solution, a
rising bubble, Rayleigh-Taylor/Kelvin-Helmholtz instability, an
mpm_snowball, a pyro_corpus, and .bobj/sparse-cache interop round-trips.
@neith/spatial-anchors-collab#
Multi-user collocated sessions (Rust, libs/neith/spatial-anchors-collab, phase
166.9): LAN peer discovery with heartbeat expiry and cloud-relay fallback, a
sequence-ordered shared-anchor protocol with latency budgeting, chunked
roomscan sharing, a last-writer-wins crdt with vector clocks for shared
scene state, and session recording — peer-to-peer, no central authority.
@neith/spatial-audio#
Spatial-audio engine of the spatial runtime (Rust, libs/neith/spatial-audio,
phase 166.7): hrtf binaural rendering via Woodworth ITD + ILD + head-shadow
low-pass, room acoustics from the scene mesh with the Sabine RT60 equation,
occlusion filtering, first-order ambisonics encode/decode/rotate, and a
spatializer — closed-form and deterministic for headless conformance runs.
@neith/spatial-avatars#
Avatar and presence layer (Rust, libs/neith/spatial-avatars, phase 166.4):
persona face+voice signature capture with cosine verification, a
joint-hierarchy rig with stylised variants and slot-conflict wardrobe,
quantised gaze/expression frame streaming, energy+formant mic lip-sync in
audio, two-bone law-of-cosines upper-body IK, and privacy controls.
@neith/spatial-conformance#
Cross-crate conformance for the spatial runtime (Rust,
libs/neith/spatial-conformance, phase 166.11) — a validation crate driving the
real sibling implementations: motion-to-photon latency (≤12 ms after
reprojection), eye-tracking calibration (≤1 degree), hand jitter benchmarks,
room mesh_accuracy across synthetic rooms, thermal throttle monotonicity,
anchor drift bounds, and wcag checks, plus fail-loud external gates for
on-device targets.
@neith/spatial-core#
Session, scene, and world-anchor foundation of the spatial runtime (Rust,
libs/neith/spatial-core, phase 166.1): a cold-start/warm-resume session
state machine, persistent anchors with cloud_anchor relocalisation via
Horn's rigid registration, scene-mesh reconstruction and occlusion, semantic
room segmentation, spherical-harmonic lighting estimation with CCT,
plane/image/object targets, geospatial/vps positioning, and privacy
gating — ARKit/ARCore/Quest-Scene territory.
@neith/spatial-input#
Gaze, hand, voice, and accessibility input (Rust, libs/neith/spatial-input,
phase 166.3): an eye-tracking gaze ray with dwell hover, a 27-joint hands
skeleton with pinch/curl features, gestures (gaze+pinch, two-hand
scale/rotate, pose recognition, custom recognisers), voice wake-word and
command grammar, touch/controller/keyboard paths, and accessibility
input.
@neith/spatial-os#
Spatial-OS integration shell (Rust, libs/neith/spatial-os, phase 166.10): a
3D-volume window_manager with focus, z-order and side-by-side multitasking, a
home launcher grid with app install store, system-vs-app gestures routing,
yaw recentering and space reset with guardian boundary breach fade,
accessibility settings, and a typed 2D↔3D clipboard — integrating with the
phase-45 sovereign OS shell.
@neith/spatial-physics#
Physics-in-passthrough (Rust, libs/neith/spatial-physics, phase 166.6):
virtual rigid bodies colliding with the reconstructed room — sphere-vs-scene
collision with safety-zone clamping, gravity-aligned dynamics with
support-polygon topple detection and hand-push impulses, planar contact
shadows with dynamic occluders, real-light-driven Lambert/Blinn shading, and
surface magnet snapping.
@neith/spatial-render#
Stereoscopic and foveated XR render layer (Rust, libs/neith/spatial-render,
phase 166.5): per-eye stereo view/projection with IPD calibration and depth
late-latching, fixed + eye-tracked foveation with variable-rate shading tiles,
asynchronous timewarp/spacewarp reprojection, power-aware refresh/resolution
downshift, lens distortion, and hdr passthrough compositing.
@neith/spatial-sdk#
Developer SDK and tooling for the spatial runtime (Rust,
libs/neith/spatial-sdk, phase 166.8): C-ABI bindings descriptors with a
generational opaque-handle table, Unity/Unreal/Godot plugins manifests, WebXR
capability translation, an imperative scenegraph with world-transform
composition, Reality-Composer-class authoring, a simulator model,
debug_perf tooling, and deeplinks.
@neith/spatial-volumes#
Volumes and immersive/shared spaces (Rust, libs/neith/spatial-volumes, phase
166.2): bounded volumes with content clipping and auto-resize-to- room,
immersive full-space takeover with a progressive-immersion dial, multi-app
shared_space compositing via guillotine packing, passthrough blend with
privacy masking, portals, and a spectator view.
@neith/storyboard#
Storyboarding and pre-production core (Rust, libs/neith/storyboard, phase
135.10): a 38-module crate spanning panel drawing and timeline animatics,
camera_move and previs_scene with lens and sun_sky, screenwriting
(fountain, fdx, dual dialogue), and production management —
breakdown_sheet, stripboard, shooting_schedule, call_sheet, budget,
and union_payroll.
@neith/subs#
Subtitle, caption, translation, and dubbing core (Rust, libs/neith/subs, phase
135.8): a 34-module crate covering text/XML/legacy formats plus
cea608/cea708, timing QC (reading_speed, line_break, waveform_sync),
sdh and forced narrative, translation_memory and machine_translation
workflow models, and a dubbing plane (lip_sync, rhythmo_band, me_track,
dub_monitor).
@neith/vfx-attribute#
Particle attribute substrate of the phase-161 Niagara-class VFX stack (Rust,
libs/neith/vfx-attribute): structure-of-arrays storage with std430 layout
sizing, half/unorm8/snorm8 compression codecs, typed attributes with spawn
defaults and persistence policy, stable builtin semantics for addressing
streams by role, material bindings, and a runtime inspector.
@neith/vfx-core#
Effect asset model of the VFX stack (Rust, libs/neith/vfx-core, phase 161.1):
an EffectSystem of emitters with ordered module_stacks, behaviour authored
as a typed dataflow graph that compiles to both a CPU interpreter and a WGSL
compute module, a gameplay-bindable blackboard, a timeline of triggers, a
versioned schema envelope, and hot-reload dependency tracking.
@neith/vfx-data-interfaces#
External data plug-ins for VFX graphs (Rust, libs/neith/vfx-data-interfaces,
phase 161.7): per-particle samplers over injected data — mesh/skeletal
surface sampling, sdf, texture, physics, navmesh, audio FFT and
beat, gbuffer depth/normal, curve LUTs, and neural — all behind the
DataInterface contract with an honest Availability seam that reports
unavailable rather than feeding zeros.
@neith/vfx-editor#
Authoring-editor model layer (Rust, libs/neith/vfx-editor, phase 161.8) — data
structures a UI binds to, no pixels of its own: a graph_editor with validated
edits, a reflected property_panel, a keyframe timeline with real curve
evaluation, a preview transport, debounced recompile, a debug hud with
breakpoints and a particle inspector, undo/redo history, and a
vector-clock CRDT collab layer.
@neith/vfx-library#
Shipped VFX preset catalogue (Rust, libs/neith/vfx-library, phase 161.10):
every preset is a real builder composing a validate()-passing EffectSystem —
combat (muzzle flashes as sub-frame emissive cone bursts), magic, weather
(8192-particle box-volume rain), environment, vehicle, scifi, horror,
npr, and educational categories in a registry.
@neith/vfx-modules#
Behaviour-module library (Rust, libs/neith/vfx-modules, phase 161.4): each
Module is a pure deterministic transform over a particle pool for one timestep
— motion (symplectic integration, inverse-square fields, analytic curl
noise), appearance, collision/environment response, and event
recording onto an EventBus — real domain maths, not data plumbing.
@neith/vfx-perf#
Performance, LOD, and budgeting governor (Rust, libs/neith/vfx-perf, phase
161.9): piecewise-linear lod curves, frustum and occlusion culling, a
global GPU-ms/VRAM budget with priorities, particle pooling, warmup
pre-simulation, async_graph compute hooks, multigpu splitting, and platform
profile clamping of real effect systems.
@neith/vfx-renderers#
Render primitives of the VFX stack (Rust, libs/neith/vfx-renderers, phase
161.5): turns live particle pools into GPU-ready geometry with the real WGSL a
wgpu pipeline would bind — billboard sprites, mesh_instance TRS buffers,
Catmull-Rom ribbons and strands, beams, light parameters, oriented
decal projectors, view-aligned volume slices, and marching-cubes
metaballs.
@neith/vfx-sim#
Advanced simulation stages (Rust, libs/neith/vfx-sim, phase 161.6): correct
CPU references of the compute-shader building blocks, with real WGSL emitted
alongside — a topologically-scheduled stage_graph with barrier checking, grid
fluid and dynamic sdf field generators, neighbour hash-grid search,
sort/scan primitives, indirect dispatch, pingpong buffers, and ml
inference.
@neith/vfx-spawn#
Spawn rules and emission (Rust, libs/neith/vfx-spawn, phase 161.2):
burst/rate/shape/skeletal/beam/curve/event/GPU-readback emitters
producing SpawnRequests written into the particle pool, seeded PCG32 streams
for bit-reproducible effects, spawn budgets and throttles, and typed
SpawnError refusal of invalid geometry or budgets.
@neith/vfx-testing#
Validation harnesses for the VFX stack (Rust, libs/neith/vfx-testing, phase
161.11) — a testing crate driving the real sibling crates: a stress CPU
sim-throughput harness for the 1M@60/5M@30 targets (the GPU frame-rate
acceptance itself is hardware-gated and reported honestly as CPU throughput),
cross-run determinism, lod_smoothness, and budget_cap enforcement.
@neith/virtualprod#
LED volume, camera tracking, ICVFX, and motion control (Rust,
libs/neith/virtualprod, phase 135.13): a 36-module crate spanning
render_cluster/genlock/timecode sync, frustum and tracked_camera
ICVFX, tracker protocol models (mosys, redspy, optitrack, freed),
lens_encoder metadata, light_card/color_matching wall tools, and
rig_control motion-control playback with take_repeatability.
@neith/vp-broadcast#
Broadcast virtual studio (Rust, libs/neith/vp-broadcast, phase 163.9):
real-time graphics lower-thirds, a virtual setlib with camera presets, the
phase-162 talent-avatar binding (a fail-loud rig seam), ar_bridge
depth-ordered AR-over-key compositing, datagraphics, a multi-camera
director, instant-replay speed ramps, and an NDI/SDI/ST-2110 output model
— Vizrt/Brainstorm territory.
@neith/vp-camera#
Camera tracking and metadata (Rust, libs/neith/vp-camera, phase 163.3):
timestamped confidence-weighted TrackerSamples, ingest normalisation for
RedSpy/Ncam/StarTracker/OptiTrack conventions (the live tracker is a fail-loud
TrackerSource seam), lens_encoder calibration, imu fusion,
freed/rttrpm/osc parsers, prediction/smoothing, and timecode-aligned
recording.
@neith/vp-cluster#
Multi-node render cluster (Rust, libs/neith/vp-cluster, phase 163.1): the
nDisplay/RenderStream-class brain keeping N nodes in lockstep — leader
election, config-driven topology, genlock swaplock frame sync, a PTP
deadline scheduler, timecode_sync, heartbeat/failover and crash restart
— all deterministic in-process logic; the OSC/gRPC wire is an honest Transport
seam that fails loud until bound.
@neith/vp-color#
On-set colour pipeline (Rust, libs/neith/vp-color, phase 163.5): an OCIO-
class graph, aces IDT/RRT/ODT chain, per-panel panel_calibration,
camera_log inversion (ARRI LogC, S-Log3, Log3G10, PQ, HLG — published curves),
wall→camera roundtrip verification with CIEDE2000, cdl/lut grading,
colorchecker auto-match, metamerism alerts, and per-setup signoff.
@neith/vp-control#
Operator control surface (Rust, libs/neith/vp-control, phase 163.8) — a
deliberately GUI-free headless state model a web/tablet client and hardware
panel both drive: a serialisable surface aggregate, scene/shot/take
selectors, live parameter dials, a cue engine with fades, role dashboards
in roles, emergency wall-black safety, and snapshot autosave with
rehearsal/record/playback modes.
@neith/vp-core#
Shared spine of the phase-163 virtual-production stack (Rust,
libs/neith/vp-core): dependency-free math (Vec/Mat/Quat, Ray/Plane/
Frustum), drop-frame-correct SMPTE timecode with PTP and genlock phase,
color science (CIE chromaticity, Lab, ΔE76/ΔE2000), a camera
intrinsics/extrinsics/distortion model, and typed ids — every vp-* crate
builds on this vocabulary.
@neith/vp-frustum#
Inner/outer frustum rendering (Rust, libs/neith/vp-frustum, phase 163.4): the
ICVFX heart — a generalized Kooima off-axis perspective through the LED
screen, the camera-accurate inner parallax window with overshoot margin,
outer ambient fill with set-extension bypass, soft-edge blend and
multi-camera crossfade, colormatch, a latency meter, and hero-frame
extraction.
@neith/vp-mr#
In-camera VFX, green screen, and mixed reality (Rust, libs/neith/vp-mr, phase
163.7): colour-difference and chroma-distance keyers, premultiplied
Porter-Duff composite with depth test, despill, set extension, occluder
masking, LiDAR depth compositing, reflection/lighting matching, a shadow
catcher, and roto assist — real signal/compositing maths on the vp-core
primitives.
@neith/vp-pipeline#
Editorial and VFX handoff (Rust, libs/neith/vp-pipeline, phase 163.11):
CMX3600 edl + OTIO export, per-take usd (USDA) scene publish, a
timecode-keyed camera_path, EXR+JSON plate packages (clean vs graded), ASC
cdl persistence, proxy-geometry OBJ handoff, a post-rebuild manifest, and
a bidirectional DCC livelink.
@neith/vp-record#
Capture, recording, and playback (Rust, libs/neith/vp-record, phase 163.10):
raw plate capture with codec-modelled byte accounting, a timecode-keyed FreeD
tracking recorder with interpolated pose queries, a synchronised
multi-cam+audio timeline with out-of-sync flagging, a Take recorder state
machine, retake-less re-render, dailies packaging, and a shotops publish
hook.
@neith/vp-scene#
Virtual scene content pipeline (Rust, libs/neith/vp-scene, phase 163.6): a
SceneAsset/SceneGraph model with a real gltf 2.0 JSON parser (binary
containers fail loud via an ExternalDecoderSeam), spatial-grid streaming
with hysteresis, incremental dcc_update live-link edits, sky/time-of-day and
hdri domes, weather/atmospherics hooks, splats, and take history with
asset bundle shipment.
@neith/vp-testing#
Virtual-production validation harness (Rust, libs/neith/vp-testing, phase
163.12) — a testing crate grading traces against acceptance criteria: genlock
jitter ≤1 scan line, motion-to-photon latency ≤1.5 frames at 24 fps, color
round-trip ≤ΔE 1, per-node throughput (4K/120), multi-stage isolation,
mid-take smoothness, retake determinism, and lens_compat checks.
@neith/vp-wall#
LED volume geometry and mapping (Rust, libs/neith/vp-wall, phase 163.2): a
panel spec catalog, flat/curve/cylinder/ceiling/floor wall geometry, wall-UV
to panel pixel mapping with geometry-preserving bezel compensation, warp +
soft-edge blend, scan-based calibration, moire mitigation, hdr luminance
calibration, panel health monitoring, and a Brompton/Novastar/ROE processor
bridge model.
@neith/vse-audio#
Audio DSP layer of the embedded Video Sequence Editor (Rust,
libs/neith/vse-audio, phase 158.5): per-strip gain_pan with constant-power
pan, a bus mixer, RBJ EQ/compressor/limiter dynamics, BS.1770-4 loudness
metering with true peak, sidechain ducking under dialogue, spectral-flux
beatgrid tempo snapping, and waveform caching — the VST3/AU/LV2/CLAP
plugin_host scan is a fail-loud seam.
@neith/vse-conform#
Editorial conform and interchange (Rust, libs/neith/vse-conform, phase 158.9):
otio JSON import/export, an aaf object model with binary MS-CFB/OLE2
round-trip, fcpxml and Premiere xmeml round-trips, CMX-3600 edl, Resolve
XML, sendto handoffs to the compositor/colorist/2D-animation phases, and
auto-conform from an editorial cut with version-up.
@neith/vse-core#
Timeline and strip model of the VSE (Rust, libs/neith/vse-core, phase 158.1):
exact rational time with cross-rate rescale and SMPTE drop-frame timecode,
strip primitives with lock/mute/solo and meta-strips, animatable keyframe
property tracks, edit operations, markers, snap, and shuttle — the
foundation every other vse-* crate composes.
@neith/vse-effects#
Per-strip video effects (Rust, libs/neith/vse-effects, phase 158.4): every
operator implements the Effect trait over linear f32 RGBA images in an
ordered EffectStack/graph — color levels/curves/balance, Reinhard/ACES
tonemap (with an OCIO view seam), chroma key, masks, retime,
stabilise, blur/grain/lut, and subtitles/text keyed off the shared
rational clock.
@neith/vse-ingest#
Media ingest and proxy (Rust, libs/neith/vse-ingest, phase 158.2): probes
containers into timeline-ready strips — media and metadata (timecode,
reels), proxy encode command specs, imageseq and renderlayer detection,
waveform/proxy caches, and VFR conform to a constant edit rate. Running
ffmpeg and debayering camera raw are typed fail-loud seams
(ExecUnavailable/RawDecodeUnavailable).
@neith/vse-playback#
Real-time playback engine of the VSE (Rust, libs/neith/vse-playback, phase
158.6): a byte-budgeted RAM+disk LRU frame cache keyed by (strip, frame,
quality), a look-ahead prefetch scheduler with a real worker thread, adaptive
quality under load, frame/field-exact scrubbing, and a transport —
hardware decode, SDI output and pro-audio backends are honest fail-loud
seams.
@neith/vse-render#
Render queue and output (Rust, libs/neith/vse-render, phase 158.7): turns a
timeline into shipped files — a JSON-persistable preset registry, a
codec/pixfmt model with ffmpeg encoder-arg builders, range and stem
selection, a render queue and farm model, burnin/caption/hdr handling,
and upload/reingest — live ffmpeg exec, farm schedulers and CDN endpoints
sit behind fail-loud seams.
@neith/vse-review#
Dailies and frame review (Rust, libs/neith/vse-review, phase 158.8):
timecode-anchored notes with drawable annotations, voice memos and CSV/PDF
export, reviewer roles and capabilities, a guarded per-shot approval state
machine with audit history, version compare with an A/B wipe slider, and
shotops/live-session sync payloads behind fail-loud transport seams.
@neith/vse-storyboard#
Storyboard/animatic mode for the VSE (Rust, libs/neith/vse-storyboard, phase
158.10): a board deck of still panels with per-panel timing and a script
column laid onto a core timeline, scratch-track beat alignment of panel
boundaries, auto-slate shot numbering, and promote handoffs into the
grease-pencil, storyboarding, and previs pipelines.
@neith/vse-testing#
Cross-crate validation suite for the VSE (Rust, libs/neith/vse-testing, phase
158.11) — a testing crate covering the locally-actionable slices of the
phase-158 matrix: roundtrip interchange fidelity (OTIO/AAF/FCPXML/EDL/
Premiere), hdr metadata preservation, sample-accurate audio_phase mixing, a
deterministic edit-storm soak, and render_determinism frame hashing.
@neith/vse-transitions#
Transitions and effects maths for the VSE (Rust, libs/neith/vse-transitions,
phase 158.3): dissolve blend curves, wipe patterns, motion pushes,
landmark-based morph cuts, audio cross-fades, procedural glitches,
transform3d flips, and automatic cut detection — all on normalised
resolution-independent inputs; the compositor feeds samples through these
functions.
@neith/dcc-annotations#
Editor annotation tool (Rust, libs/neith/dcc-annotations, phase 172.19):
freehand + text markup in any editor — 2D-screen and 3D-world annotation
layers with per-layer colour/thickness and leader-line TextAnnotations, snap
to object/face/vertex, an integration module with Grease-Pencil conversion,
author-tagged layer merge and a dailies ReviewSession note workflow, and
SVG/PNG-raster/PDF export.
@neith/dcc-color-attrs#
Colour / vertex attributes, post-3.2 model (Rust, libs/neith/dcc-color-attrs,
phase 172.18): float4/byte4 ColorAttributes on point/corner domains with
active-render/edit selectors on Mesh, a bake module (ray-traced AO,
Laplacian curvature, material), masked vertex paint with gradient/fill and
geometry-node field sampling, and export to glTF COLOR_0 / USD primvars /
Alembic plus legacy tessface migration.
@neith/dcc-drivers#
Driver system and relationship depth (Rust, libs/neith/dcc-drivers, phase
172.23): drivers bind typed DriverVariables (single-property, rotational
difference, distance, transform channel) and reduce them via a sandboxed
recursive-descent expr evaluator; around that sit a DriverGraph with
dependency-cycle detection, batch retarget, a copy/paste library with
corrective-shape-key and face-rig presets, a debug value-watch + profiler +
errors panel, and a global KillSwitch.
@neith/dcc-graph-editor#
Graph Editor / F-curve depth (Rust, libs/neith/dcc-graph-editor, phase
172.22): bezier de Casteljau evaluation with an X-to-t inverse solver,
Auto/Vector/Free/Aligned/Auto-Clamped handles, the full Penner easing set in
interp, a modifiers stack (Noise/Cycle/Generator/Envelope/Limit/Stepped),
RDP-decimate/smooth/sample/bake cleanup, multi-channel selection with
normalised + proportional editing, key clipboard, snapping, and an euler
filter with quaternion dual-cover fix.
@neith/dcc-multi-edit#
Multi-object edit mode (Rust, libs/neith/dcc-multi-edit, phase 172.24): a
MultiEditSession over several EditObjects with unified vertex selection,
world-space transforms distributed through per-object local frames, per-object
pivot and mirror, ops propagation (extrude/inset/bevel and multi-object UV
unwrap), cross-object snap, and a combined atomic UndoStack boundary.
@neith/dcc-outliner#
Outliner + view layers + render passes (Rust, libs/neith/dcc-outliner, phase
172.20): a SceneTree collection/object arena flattened into filterable
Outliner rows with tree modes and isolate/solo, a VisibilityTable resolving
viewport/render/select/holdout through the hierarchy, drag-drop and batch-rename
collection_ops with orphan/fake-user purge, ViewLayer include/exclude with
material/light overrides, passes with exact channel layouts plus LPE and AOV
custom passes, and a compositor routing surface.
@neith/dcc-pose#
Pose-mode depth (Rust, libs/neith/dcc-pose, phase 172.26): Armature posing
with bone collections, a PoseLibrary with copy/paste, snap-to-rest and
cross-frame propagation, a quaternion-slerp blend pose blender and
breakdowner, mirror / paste-flipped via .L/.R name flipping, and FABRIK
auto-ik on bone chains.
@neith/dcc-proportional#
Proportional editing (Rust, libs/neith/dcc-proportional, phase 172.25): the
O-key smooth-falloff transform — eight Falloff shapes (Smooth/Sphere/Root/
Inverse-Square/Sharp/Linear/Random/Constant), connected-only mode via Dijkstra
graph_distances over the mesh graph, radius-controlled apply_translation,
domains application to UV/animation-channel/weight data, and a RadiusOverlay
visualisation circle.
@neith/dcc-texture-paint#
Texture-paint mode (Rust, libs/neith/dcc-texture-paint, phase 172.17):
painting onto UV-mapped texture Canvases with UDIM tile routing in UdimSet,
falloff Brush dabs with tablet pressure/tilt (Stylus), mask and symmetry,
camera-view projection painting with stencil and clone brushes, smear/softener
filters plus cross-seam dilation, an OCIO-managed LayerStack with polypaint
baking, and DirtyRegion batching for GPU upload.
@neith/dcc-timeline-markers#
Timeline + pose + camera markers (Rust, libs/neith/dcc-timeline-markers, phase
172.21): coloured/labelled Markers on a MarkerTrack with camera-marker
playback auto-switch and in-action PoseMarkers, ops for
drag/duplicate/group, filtering/search and cross-scene sync, snap with
BPM-to-frame beat grids, audio-beat import and BPM estimation, and
OpenTimelineIO marker export_otio.
@neith/engine-cameras#
Gameplay + cinematic cameras (Rust, libs/neith/engine-cameras, phase 172.5): a
physical CineLens (focal/aperture/filmback to FOV plus hyperfocal DOF) with a
LensDatabase, autofocus + rack-focus keyframes, rig behaviours
(follow/orbit/boom/POV/dolly), critically-damped smooth_damp + leash
damping, soft collision pull-back, thirds/headroom/look-room composition
with aim-assist, a ShakeMixer oscillator library, a multi-camera
CameraDirector with eased cut/blend, and a Cinemachine-class CameraBrain
vcam with a LiveLinkFeed bridge.
@neith/engine-commonui#
Common-UI depth (Rust, libs/neith/engine-commonui, phase 172.12): a
gamepad-first UI framework — D-pad/stick spatial FocusRouter over Widget
rects with gamepad/mouse/touch parity, a ScreenStack activation stack with
back-stack + breadcrumb, a platform input-PromptLibrary and virtual keyboard,
a localised ActionBar over LocTables, hot-reloadable Themes with
high-contrast/large-text Accessibility modes, pillarbox/safe-zone layout,
and modal/toast/drawer OverlayManager with screen-reader annotations.
@neith/engine-concert#
Concert multi-user editing (Rust, libs/neith/engine-concert, phase 172.7):
collaborative scene editing on convergent CRDTs — a Lamport Clock,
LwwRegister + add-wins OrSet, a transaction-based Document, a Session in
client-server or peer-to-peer topology, presence
(cursor/camera-follow/selection/ping/VR pose), roles + Permissions, a
ChangeLog with blame, persistence and replay, and a ConflictDetector. All
in-process models: the chat/voice ChatBridge is a message log + membership set
(no audio transport), and the RemoteBridge DCC/engine bridge is a
host-provided-transport seam that fails loud when disconnected.
@neith/engine-data-registry#
Data registry + data-driven CVars (Rust, libs/neith/engine-data-registry,
phase 172.13): a DataRegistry federating LocalTable/RemoteFeed/
ComputeSource data sources with CompoundKey lookup, an LRU + TTL
RegistryCache with revision invalidation, an AsyncFetch state machine, and a
CVarSystem of data-driven console variables with explorer search, a change
audit log and hot-reload. The remote feed is snapshot-fed from the LiveOps plane
and fails loud (NotConfigured) until a snapshot is applied — no network fetch
of its own.
@neith/engine-dmx#
DMX / Art-Net / sACN lighting control (Rust, libs/neith/engine-dmx, phase
172.6): a headless model + codec crate — a 512-channel DmxUniverse with
overlap-guarded patching, a FixtureDefinition library with 8/16-bit channels,
byte-exact ArtDmx/ArtPoll and SacnDataPacket E1.31 codecs, MIDI-to-DMX and
OSC bridges, a timecode-locked CueList sequencer, delta-compressed
DmxRecorder playback, previs fixture-state decoding, lighting-board show
import, and strobe/chase/sine patterns. It encodes and decodes the wire
protocols but does no live network output, and GDTF/MVR import is a fail-loud
archive seam.
@neith/engine-gameplay-tags#
GameplayTags hierarchical taxonomy (Rust, libs/neith/engine-gameplay-tags,
phase 172.2): dotted GameplayTags with partial hierarchical matching in a
validated table with ref-counting and per-tag source tracking, .ini +
data-table sources, a TagContainer with an Any/All/None/Exact + And/Or/Not
TagQuery DSL, a block/cancel RelationshipMap, a fuzzy-ranked editor
picker, rename RedirectMap migration, localised TagMeta, replication
TagDeltas over a TagDictionary, and Smart-Object/StateTree/Chooser
integration hooks.
@neith/engine-gas#
Gameplay Ability System depth (Rust, libs/neith/engine-gas, phase 172.3): an
AttributeSet with base/current-value aggregate (add/multiply/divide/
override), GameplayEffects with instant/duration/infinite/periodic policies,
stacking and scalable-curve/set-by-caller/custom-execution Magnitudes, a
CueRouter binding gameplay cues to FX/audio with local/replicated scope,
Ability chains gated by cooldown/cost with activation-failure tags, a
PredictiveAsc for client prediction with server rollback, level-scaling
Curves, a GasSnapshot debugger overlay, and AscSaveState persistence
across levels.
@neith/engine-landscape#
Landscape-editor depth (Rust, libs/neith/engine-landscape, phase 172.16): a
metres-valued Heightfield substrate with sculpt brushes
(raise/lower/smooth/flatten/ramp/noise), thermal-talus + hydraulic-droplet
erosion simulation, weight-layers painting, 16-bit .r16 heightmap I/O,
Catmull-Rom terrain-carving splines, LOD decimate with RMS error, streaming
proxy tiles, screen-error nanite tessellation, dominant-layer physical
materials, mask-gated grass scatter, slope/altitude masks, and copy/paste
editops with hero-hand-edit over a procedural base.
@neith/engine-livecoding#
Hot reload / live coding / editor scripting (Rust,
libs/neith/engine-livecoding, phase 172.15): a FileWatcher (hash + mtime
diff), a LiveCoding session that models the native patch table and call stack
— refusing to patch symbols with live frames (PatchError::OnStack), the Unreal
Live Coding safety constraint — plus a ReloadGraph cascading
Blueprint/Verse/shader reloads through dependency invalidation, a ScriptHost
command registry with UtilityWidgets, and a scripted batch Pipeline. Honest
scope: it models patch lifecycle and safety, it does not rewrite real machine
code.
@neith/engine-mrq#
Movie Render Queue + Movie Render Graph (Rust, libs/neith/engine-mrq, phase
172.4): a serde-scriptable RenderJob queue with shots/ranges/versioning, a
RenderSettings stack with preset library, temporal + spatial Accumulator
sampling with Halton sequences, shutter-angle motion blur and warm-up frames,
OCIO/ACES ColorPipeline transforms, MurmurHash3 cryptomatte_id + ID/AOV
passes with denoise + composite_over, filename-token NameTemplate output
versioning, a resume-failed-frame executor with farm distribute, and a
node-based RenderGraph with per-shot branching and variable inputs.
@neith/engine-pcg-biome#
PCG biome core (Rust, libs/neith/engine-pcg-biome, phase 172.11):
ecologically-plausible scatter from a declarative description —
BiomeDefinitions keyed on climate/elevation/slope/moisture with fuzzy
suitability, a SpeciesLibrary with per-species per-biome DensityCurves,
water/path/building ExclusionMask geometry, normalised blend_weights between
biomes, canopy-dominance competition culling, deterministic SplitMix64
streaming-partitioned ScatterScene with seasonal/time-of-day hooks, and an
editable PaintMask.
@neith/engine-remote#
Remote Control preset + web remote (Rust, libs/neith/engine-remote, phase
172.9): a RemoteControlPreset exposing properties with typed PropMeta
(ranges/steps/groups), a RemoteEndpoint dispatching get/set/batch
Request/Response commands through role-based Acl and an AuditLog,
bidirectional OSC + 7-bit-scaled MIDI BindingRouter, auto-generated web-UI
Layout widgets, and preset export/import. The REST/WebSocket transport is
host-provided — this crate models the message layer and is testable without a
socket.
@neith/engine-switchboard#
Switchboard + stage monitor (Rust, libs/neith/engine-switchboard, phase
172.8): VP-cluster orchestration — a per-ClusterNode lifecycle state machine
(Offline/Launching/Online/Stopping/Error) rejecting illegal transitions,
GPU/CPU/RAM/thermal Telemetry with health scoring and cluster_rollup, a
per-frustum/per-panel StageMonitor, camera-tracking TrackingStream health
(jitter/dropout/latency) with a LogAggregator, a unified TakeRecorder, and a
Preflight checklist evaluator. Launch/kill commands drive the state machine;
no real remote processes are spawned.
@neith/engine-testing#
Gauntlet-class automation framework (Rust, libs/neith/engine-testing, phase
172.14) — the engine's test framework, not a conformance suite: a tiered
TestHarness (smoke/integration/e2e) with functional-test Assertions,
golden-Image PSNR/MSE compare, PerfCapture frame-time percentiles vs budget
baselines, a DetRng + LockedClock + Replay determinism mode, a shrinking
property/fuzz harness with ChaosCluster network-partition testing,
content-validation rules with gameplay-tag coverage, and a TriageReport
aggregator with FlakinessTracker and JUnit export.
@neith/engine-vr-scout#
Virtual scouting + Live Link XR (Rust, libs/neith/engine-vr-scout, phase
172.10): a ScoutCamera with walk/fly/teleport Locomotion, snap-turn and
GridOverlay snapping, in-VR Measurement/Annotation/Markup, a ScoutTake
recorder with storyboard-frame extraction and tolerance-reduced Sequencer
keyframe export, and a LiveLinkXr ingest model for Vive/OptiTrack/generic
TrackerSamples with timecode, prop tracking, and full-body BodyPose joint
streaming.
@neith/dcc-file-browser#
Sovereign File Browser + asset-path management (phase 172.28,
libs/neith/dcc-file-browser): entry (file entries, filters, previews,
thumbnail regeneration), paths (relative/absolute conversion, remap-on-move,
recents/bookmarks), library (library path manager + missing-file finder), and
datablocks (blend-data browser, drag-drop import, pack/unpack) — the Blender
File Browser / path-management equivalent as a pure headless model.
@neith/dcc-python-console#
Sovereign Python/Script/Info editor workspace (phase 172.27,
libs/neith/dcc-python-console): a REPL, script editor with run-script,
operator-history info log, template library, API-symbol autocomplete/browser,
and a statement-level step debugger built around a small sovereign expression
language — deliberately no embedded CPython, so everything is real and testable
in pure Rust.
@neith/parity172-testing#
Cross-crate validation suite for the phase-172 UE/Blender second-parity sweep
(phase 172.29, libs/neith/parity172-testing) — integration and determinism
tests spanning the phase's engine-*/dcc-* crates. Includes an executable MRQ
comparison against the Phase-138 path-tracer transport and a checked-in
texture-paint reference image. The full Phase-27 shoot remains an external
production acceptance gate while its prerequisite filming and virtual-production
artifacts are unfinished.
@neith/engine-asset-manager#
Sovereign Asset Manager & Primary Data Asset system (phase 173.1,
libs/neith/engine-asset-manager) — the UAssetManager/
FStreamableManager/Asset Audit equivalent with deterministic, tick-driven
streaming: primary_asset (Type:Name ids, soft-object paths), streamable
handles with priority-queue ordering, per-type budget tracking, bundles
chunk composition with platform overrides, a dependency graph with
unreferenced/orphan/cycle audit, and the registry load/tick/evict runtime plus
an editor outliner facade.