neith library

Documentation system (TS, ~15K LOC): developer, user, and api doc modules exported as namespaces from @neith/docs. Tagged layer:docs.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.