# Neith Domain — Features

> **Neith** (`libs/neith/`) is the sovereign runtime kernel domain of the Oshun
> monorepo — a large polyglot, Rust-heavy domain providing the lowest-level
> systems that all performance-critical applications build on. Named after the
> ancient Egyptian creator goddess who wove the world into existence, Neith
> provides the fabric beneath everything: async execution, memory management,
> cryptography, hardware abstraction, custom networking, real-time rendering,
> physics, audio, UI, game AI, creative tools, and ultimately a sovereign
> operating system and browser. The goal is complete technology sovereignty:
> replacing external runtimes (Unity, Unreal Engine, macOS, Windows) with
> custom-built, Oshun-owned equivalents written in Rust. Neith is organized as
> roughly sixty Cargo workspaces under `libs/neith/` (plus fourteen standalone
> TypeScript packages); the six **foundational engine workspaces** (`core`,
> `crypto`, `hal`, `net`, `renderer`, `ui`) are documented in full below, each
> containing multiple focused crates.

---

## What Neith Is and Who Uses It

Neith exists to answer a fundamental question: why depend on Unity, Unreal
Engine, or an operating system you do not control when you can own the entire
stack yourself? Every Oshun domain that needs high-performance computation —
Maya for the game engine, Aphrodite for VR streaming, Nyx for the star map —
builds directly on Neith instead of on a third-party runtime.

The domain is organized as approximately sixty Rust Cargo workspaces under
`libs/neith/`. Each workspace is a cohesive group of related crates: for
example, `core/` bundles the async executor, memory allocators, serialization,
reflection, event bus, and diagnostics, while `renderer/` bundles sixteen crates
covering every aspect of a modern game rendering pipeline. A small set of
standalone TypeScript packages (observability, cloud infrastructure, domain
integration adapters) also live under `libs/neith/`; these are not Rust code but
infrastructure glue.

Crucially, Neith has no upstream dependencies within the monorepo. Maya,
Bellona, Aphrodite, and Nyx all consume Neith — but Neith depends on none of
them. This hard invariant means every Neith crate can be compiled, tested, and
embedded independently, even outside the Oshun monorepo entirely. Maya owns the
virtual-world and gameplay product layer; Bellona owns external engine export
bridges. Neith owns the sovereign low-level runtime, engine, browser,
operating-system, and graphics stack those domains build upon.

---

## `@neith/core` — Sovereign Runtime Kernel

The foundational layer every other Neith crate depends on. `@neith/core`
provides async execution, memory management, serialization, reflection, event
dispatch, and diagnostics — entirely without dependency on Tokio, serde, or
other third-party runtimes. This self-containment makes it embeddable in game
loops, WebAssembly, and embedded environments where external runtimes are
impractical.

The workspace contains six crates, each addressing a distinct infrastructure
concern: `neith-runtime` (async executor), `neith-alloc` (memory management),
`neith-serde` (serialization), `neith-reflect` (runtime type metadata),
`neith-events` (typed event bus), and `neith-log` (structured diagnostics).

### Async Runtime (`neith-runtime`)

A custom work-stealing async executor designed for game engines and real-time
systems that Tokio's general-purpose design cannot serve.

- **Work-Stealing Task Scheduler** — Multiple worker threads dynamically steal
  tasks from each other's queues when idle, achieving high CPU utilization
  without manual thread affinity management. Each worker runs independently;
  stealing minimizes cross-thread synchronization.
- **Priority-Based Task Scheduling** — Tasks carry a priority level. Game
  systems (physics tick, rendering) are dispatched before background I/O without
  blocking the frame.
- **Fiber/Coroutine System** — Cooperative multitasking via fibers allows
  suspending mid-execution without OS thread context switches, reducing overhead
  in tight game loops where thousands of coroutines run per frame.
- **Async I/O Layer** — Uses `io_uring` on Linux and IOCP on Windows for
  kernel-bypass I/O, delivering maximum throughput with minimal CPU overhead.
- **Timer Wheel** — O(1) amortized timeout management for thousands of
  concurrent timers. Used by game loop timers, network retries, and animation
  controllers.
- **Cancellation Tokens** — Structured cancellation that propagates through
  async task trees, enabling clean shutdown without resource leaks.
- **Task-Local Storage** — Async equivalent of thread-local storage for carrying
  context (request ID, trace ID, game frame ID) without explicit parameter
  threading.
- **Async Primitives** — `AsyncMutex`, `AsyncRwLock`, `AsyncSemaphore`,
  `AsyncBarrier`, `AsyncLatch`. Non-blocking synchronization that yields rather
  than spinning.
- **Channel Primitives** — mpsc, mpmc, and broadcast channels with configurable
  backpressure for task coordination and inter-system communication.
- **Runtime Metrics** — Per-executor task count, queue depth, steal rate, and
  task duration histograms for diagnosing scheduler pathologies.

### Memory Management (`neith-alloc`)

Custom allocators for performance-sensitive subsystems. General-purpose
allocators like jemalloc add latency and fragmentation that game engines cannot
tolerate.

- **Arena Allocator** — Bump allocator serving a frame's temporary allocations
  (particle spawning, collision broadphase) from a single pre-allocated block,
  then resets at frame end. Zero per-allocation overhead during the frame.
- **Pool Allocator** — Fixed-size object pool for game entities, events, and
  particles. O(1) allocation and deallocation with no GC pressure.
- **Slab Allocator** — Used by ECS component storage. Groups same-type objects
  in contiguous memory slabs for cache-line-friendly iteration.
- **TLSF (Two-Level Segregated Fit)** — General-purpose real-time allocator with
  O(1) amortized allocation, suitable for subsystems requiring predictable
  latency.
- **Memory Budget System** — Per-subsystem memory limits with pressure
  callbacks. When a subsystem approaches its budget, it receives a signal to
  reduce quality (lower LOD, drop audio voices, shrink particle pools).
- **Virtual Memory Management** — Reserve/commit/decommit utilities for managing
  large virtual address spaces and lazy-mapping memory-mapped files.
- **Memory-Mapped Files** — Direct address-space mapping for large assets
  (heightmaps, lightmaps) without heap buffering.
- **Out-of-Memory Handling** — Configurable OOM strategies: abort, graceful
  degradation (drop non-critical allocations), or recovery callbacks.

### Serialization (`neith-serde`)

A unified serialization framework with multiple wire formats, zero-copy fast
paths, schema versioning, and streaming support. Serialization is prerequisite
for networking, save games, asset pipelines, and undo/redo.

- **Neith Binary Format (NBF)** — Custom compact binary format with zero-copy
  deserialization: the in-memory layout matches the wire format, enabling direct
  memory mapping of serialized data without parsing.
- **Schema Evolution and Versioning** — Forward and backward compatibility with
  migrations. Old save files load correctly in new engine versions; new fields
  are defaulted when loading old data.
- **JSON, MessagePack, CBOR** — Human-readable JSON with streaming; compact
  MessagePack for Neith-to-JavaScript interop; CBOR for constrained
  environments. All formats share the same schema definition.
- **Protocol Buffers Compatibility Layer** — Read and write proto-wire-format
  messages, enabling Neith services to participate in existing gRPC
  infrastructure.
- **Custom Derive Macros** — `#[derive(NbfSerialize, NbfDeserialize)]` generates
  serialization code for any Rust struct or enum at compile time.
- **Partial Serialization for Deltas** — Serialize only changed fields in an
  object, dramatically reducing bandwidth for network state replication.
- **Compression Integration** — LZ4 (fast, for real-time streaming) and Zstd
  (high ratio, for asset storage) integrated transparently.

### Reflection System (`neith-reflect`)

Runtime type metadata enabling editor property grids, scripting language
bindings, automated serialization, and diff/patch without hand-written glue
code.

- **Runtime Type Information (RTTI)** — Every registered type has a unique
  compile-time `TypeId` and runtime metadata including fields, methods, and
  attributes.
- **Type Registry** — Global registry mapping `TypeId` to metadata. Enables
  dynamic creation, inspection, and mutation of any registered type — essential
  for editor tools and scripting.
- **Field Metadata** — Each field carries name, type, byte offset, size, and
  attached attributes. Fields are accessed by name at runtime, enabling generic
  editor property panels.
- **Attribute/Annotation System** — Attributes on types and fields (e.g.
  `#[reflect(range = 0.0..1.0, tooltip = "Opacity")]`) are read by editors to
  generate appropriate UI controls automatically.
- **Reflection-Based Diff and Patch** — Compare two instances by their reflected
  fields and produce a minimal patch. Used for undo/redo and network delta
  synchronization.
- **Validation via Attributes** — Range checks, non-null constraints, and custom
  validators declared as attributes are enforced during deserialization and
  editor input.

### Event System (`neith-events`)

A high-performance typed event bus for in-process communication between engine
subsystems, supporting multiple dispatch models and cross-thread delivery.

- **Typed Event Channels** — Events are typed at the channel level; publishing
  the wrong type is a compile error, preventing runtime bugs common in
  string-keyed event systems.
- **Synchronous and Async Dispatch** — Immediate delivery within the current
  call frame for input events and physics callbacks; configurable async delivery
  with ordering guarantees for less-latency-sensitive events.
- **Event Batching** — Accumulate high-frequency events (particle collisions,
  per-frame inputs) and deliver as a batch to amortize dispatch overhead.
- **Event Replay for Debugging** — Record all events and replay them
  deterministically, reproducing bugs that only manifest under specific event
  sequences.
- **Event Sourcing Patterns** — Event-sourced state machines where state is
  derived entirely from event history, enabling complete undo and time-travel
  debugging.
- **Weak Event References** — Subscribers holding weak references are cleaned up
  automatically when dropped, preventing memory leaks from forgotten
  subscriptions.

### Diagnostics (`neith-log`)

Structured, performance-aware logging and diagnostics for the Rust layer,
bridging to the TypeScript observability stack at domain boundaries.

- **Structured Logging** — All records are structured key-value pairs, not
  formatted strings, enabling aggregation and search without regex parsing.
- **Compile-Time Level Filtering** — Log calls below the configured level are
  compiled out entirely — zero overhead on hot paths in release builds.
- **OpenTelemetry Distributed Tracing** — Spans carry W3C Trace Context,
  enabling correlation with `@oshun/tracing` spans at the TypeScript boundary.
- **Metric Collection** — Counters, gauges, and histograms emitted from Rust
  code and exported to the `@oshun/metrics` Prometheus pipeline.
- **Crash Reporting and Minidumps** — On panic or signal, the process writes a
  minidump and structured crash report including the active span and recent log
  records.

---

## `@neith/crypto` — Cryptographic Primitives

Sovereign cryptographic implementations for all security-sensitive operations.
Owning the cryptographic layer eliminates dependence on system OpenSSL versions
and ensures consistent behavior across all platforms. The workspace contains
five crates: `neith-sym`, `neith-asym`, `neith-hash`, `neith-rand`, `neith-tls`.

### Symmetric Encryption (`neith-sym`)

- **AES-256-GCM** — Industry-standard authenticated encryption. Hardware
  acceleration via AES-NI CPU instructions. Provides both confidentiality and
  integrity in a single primitive.
- **ChaCha20-Poly1305 / XChaCha20-Poly1305** — Preferred for software-only
  environments (mobile, embedded) where AES-NI is unavailable. Constant-time,
  timing-attack resistant. Extended nonce variant eliminates nonce reuse risks
  with random nonces.
- **Streaming Encryption** — Encrypt and decrypt large files in chunks without
  loading the full content into memory.
- **HKDF / PBKDF2 / Argon2** — HMAC-based key derivation from master keys;
  password-based key derivation; memory-hard password hashing resistant to GPU
  brute-force attacks.
- **Secure Memory Wiping** — Key material is securely zeroed on drop, preventing
  keys from lingering in memory dumps.

### Asymmetric Cryptography (`neith-asym`)

- **Ed25519 Signatures** — Fast, compact (64-byte) digital signatures for code
  signing, asset authentication, and cross-service message signing.
- **X25519 Key Exchange** — Elliptic-curve Diffie-Hellman for establishing
  shared secrets without transmitting the secret.
- **RSA-4096 and ECDSA** — For PKI infrastructure, CA compatibility, and JWT
  ES256/ES384 token interoperability.
- **Post-Quantum Hybrid Schemes** — Kyber + X25519 hybrid key exchange:
  quantum-resistant while remaining compatible with classical clients. Secure if
  either primitive remains unbroken.
- **Threshold Signatures** — Multi-party signatures where a message requires M
  of N party signatures, enabling multi-party authorization workflows.
- **X.509 Certificate Parsing and Validation** — Parse, validate, and inspect
  TLS certificates including chain validation, expiry, and OCSP/CRL revocation.

### Hash Functions (`neith-hash`)

- **SHA-2 (SHA-256/512) and SHA-3/Keccak** — Hardware-accelerated via SHA-NI;
  SHA-3 as an alternative with different security assumptions.
- **BLAKE3** — The fastest cryptographic hash, using a Merkle tree structure for
  multi-threaded hashing of large files. Used for content addressing in the
  asset pipeline.
- **HMAC** — HMAC-SHA256 and HMAC-SHA512 for message authentication with a
  shared secret.
- **Merkle Tree Utilities** — Build and verify Merkle trees for large-dataset
  integrity verification and asset deduplication.
- **Incremental and Parallel Hashing** — Hash data streams in chunks; hash large
  files using multiple threads.

### Random Number Generation (`neith-rand`)

- **CSPRNG (OS Entropy)** — Cryptographically secure random bytes from OS
  entropy (`/dev/urandom`, `BCryptGenRandom`, `SecRandomCopyBytes`). Suitable
  for key generation, tokens, nonces.
- **Hardware RNG (RDRAND)** — CPU hardware RNG as an additional entropy source
  on supported Intel/AMD processors.
- **Deterministic RNG** — Seeded ChaCha20-based PRNG for reproducible
  simulations, tests, and procedural generation.
- **UUID v4 and v7 Generation** — UUID v4 for general IDs; UUID v7
  (time-ordered) for database primary keys benefiting from monotonic ordering.
- **Bias-Free Random Selection** — Rejection sampling for truly uniform integers
  without modulo bias.

### TLS and Secure Channels (`neith-tls`)

- **TLS 1.3 (rustls)** — Pure-Rust TLS with no OpenSSL dependency. TLS 1.3 only,
  eliminating classes of historical vulnerabilities.
- **ALPN Protocol Negotiation** — Negotiate higher-level protocols (HTTP/2,
  HTTP/3, custom game protocols) during the TLS handshake.
- **Session Resumption and 0-RTT** — 1-RTT and 0-RTT reconnection to reduce
  handshake latency for reconnecting game clients.
- **Mutual TLS (mTLS)** — Both client and server authenticate with certificates
  for service-to-service authentication.
- **DTLS for UDP** — Datagram TLS for securing UDP game networking traffic.
- **Noise Protocol Framework** — Alternative to TLS for custom secure channels
  with simpler setup and lower overhead for peer-to-peer encrypted
  communication.

---

## `@neith/hal` — Hardware Abstraction Layer

A unified interface to physical hardware across Windows, macOS, Linux, Android,
iOS, and WebAssembly. HAL (Hardware Abstraction Layer) means domain code never
writes platform-conditional code — it calls HAL APIs and Neith routes to the
correct platform backend transparently. This is how the same Maya engine code
runs on an NVIDIA Vulkan GPU on Linux, a Metal GPU on macOS, and a WebGPU
context in a browser without any conditional compilation in Maya itself. The
workspace contains seven crates: `neith-gpu`, `neith-audio-hal`, `neith-input`,
`neith-sensor`, `neith-camera`, `neith-net-hal`, and `neith-storage`.

### GPU Abstraction (`neith-gpu`)

- **Multi-Backend via wgpu** — Single API over Vulkan (Windows/Linux/Android),
  Metal (macOS/iOS), DirectX 12 (Windows), and WebGPU (browsers). The same
  rendering code runs on all platforms.
- **GPU Memory Allocator** — VMA-style GPU memory management with suballocation
  from large heaps, reducing per-allocation overhead and fragmentation.
- **Shader Compilation Pipeline** — WGSL → SPIR-V compilation with offline
  precompilation for production and online compilation for development.
- **Shader Hot-Reloading** — Watch source files and automatically recompile and
  hot-swap shaders without restarting, accelerating graphics iteration.
- **Multi-Queue Support** — Separate graphics, compute, and transfer queues for
  concurrent GPU work. Async compute enables physics simulation on the GPU while
  rendering proceeds.
- **GPU Profiling** — Timestamp queries around GPU work segments to measure
  GPU-side frame time without CPU-GPU synchronization stalls.

### Audio Hardware Abstraction (`neith-audio-hal`)

- **Platform Backends** — WASAPI (Windows), CoreAudio (macOS/iOS),
  ALSA/PulseAudio/PipeWire (Linux), AAudio/OpenSL ES (Android), WebAudio
  (browsers). Low-latency paths on all platforms.
- **Audio Device Enumeration and Hot-Plugging** — List all input/output devices
  with sample rates and formats; detect device connection/disconnection without
  restarting.
- **MIDI Device Abstraction** — Enumerate and communicate with MIDI controllers
  and synthesizers via a unified API.
- **Exclusive Mode** — Request exclusive audio hardware access for
  minimum-latency professional audio production.

### Input Abstraction (`neith-input`)

- **Unified Input Event System** — All input sources (keyboard, mouse, gamepad,
  touch, pen, motion controller, eye tracker, voice) produce events in a single
  typed stream.
- **Mouse Raw Mode** — Unaccelerated, unclamped delta for FPS games;
  OS-processed mode for UI.
- **Gamepad Support** — XInput, DirectInput, and HID with rumble and HD haptic
  feedback.
- **Touch and Gesture** — Multi-touch with gesture recognizer (tap, long press,
  swipe, pinch-zoom, rotate).
- **VR Motion Controllers** — 6DOF tracking data from OpenXR-compatible
  controllers.
- **Input Recording and Playback** — Record all events with timestamps for bug
  reproduction, automated testing, and speedrunning tools.
- **Input Remapping** — Users rebind controls through a serializable input
  mapping layer without touching game code.

### Sensor Abstraction (`neith-sensor`)

- **IMU and Sensor Fusion** — Unified accelerometer, gyroscope, magnetometer
  access. Madgwick and Mahony filters fuse accelerometer and gyroscope data into
  a stable orientation estimate, compensating for gyroscope drift.
- **GPS/GNSS Abstraction** — Location over all platform location APIs with
  accuracy information and coordinate utilities.
- **Kalman Filtering** — Linear and extended Kalman filters for noise reduction
  in position and orientation estimation.
- **Power-Efficient Batching** — Batch sensor samples at lower frequency to
  reduce power consumption on mobile.

### Camera Abstraction (`neith-camera`)

- **Capture Backends** — V4L2 (Linux), AVFoundation (macOS/iOS), MediaFoundation
  (Windows) with unified format negotiation.
- **Camera Controls** — Exposure, focus, white balance, ISO, and zoom through a
  unified API.
- **Depth Camera Support** — Intel RealSense and Microsoft Kinect depth streams
  alongside color.
- **Camera Streaming to GPU Textures** — Zero-copy camera frame upload to GPU
  textures via DMA for minimum-latency AR and video processing.

### Network Hardware Abstraction (`neith-net-hal`)

- **QUIC Protocol (quinn)** — Multiplexed, encrypted, UDP-based transport
  eliminating head-of-line blocking. Better than TCP for game networking and
  HTTP/3.
- **WebSocket Support** — First-class WebSocket client and server for browser
  compatibility and real-time web APIs.
- **DNS Resolution** — Async DNS resolver with caching, retry, and custom DNS
  server support.
- **mDNS/DNS-SD** — Local network service discovery for multiplayer LAN games
  and IoT integration.
- **Bluetooth** — BLE and Classic Bluetooth device discovery and communication.

### Storage Abstraction (`neith-storage`)

- **File System Abstraction** — Cross-platform file I/O with consistent path
  handling, directory watching, and file locking.
- **Directory Watching** — inotify (Linux), FSEvents (macOS),
  ReadDirectoryChanges (Windows) via a unified watch API. Used by the editor for
  live asset reloading.
- **Secure Storage** — Keychain (macOS/iOS), Windows Credential Manager, and
  libsecret (Linux) for storing secrets securely.
- **Key-Value Store** — Embedded key-value store abstraction over SQLite and
  custom B-tree implementations.

---

## `@neith/net` — Custom Networking Stack

Custom networking protocols optimized for game networking and real-time
communication. Generic TCP is inadequate for real-time games because its
head-of-line blocking and congestion control introduce unpredictable latency
spikes. `@neith/net` provides the specialized protocols that real-time games and
streaming applications actually require: reliable UDP for game state, WebRTC for
peer-to-peer media, and a full HTTP stack for service calls. The workspace
contains four crates: `neith-transport`, `neith-game-net`, `neith-webrtc`, and
`neith-http`.

### Transport Layer (`neith-transport`)

- **Reliable UDP Protocol** — Custom protocol over UDP providing reliability
  (acknowledgment, retransmission), ordering (sequenced channels), and
  congestion control without TCP's head-of-line blocking.
- **BBR-Style Congestion Control** — Maximizes throughput without filling
  buffers, avoiding the latency spikes of CUBIC congestion control.
- **Ordered and Unordered Channels** — Separate logical channels with
  independent ordering guarantees. Position updates use unordered unreliable
  channels (newest wins); chat uses ordered reliable channels.
- **NAT Traversal (STUN/TURN/ICE)** — Enables peer-to-peer connections across
  NAT firewalls using STUN for address discovery, ICE for candidate exchange,
  and TURN for relay fallback.
- **Bandwidth Estimation** — Continuously estimate available bandwidth and RTT
  (round-trip time) to adapt data rates and avoid congestion.

### Game Networking (`neith-game-net`)

- **Client-Side Prediction** — Apply player input immediately on the client
  before server confirmation, hiding network latency in player movement and
  actions.
- **Server Reconciliation** — When the server corrects prediction errors,
  smoothly reconcile by replaying unconfirmed inputs from the correction point.
- **Snapshot Interpolation** — Interpolate between received server snapshots to
  produce smooth movement even with 20–30Hz server update rates.
- **Lag Compensation** — Rewind game state on the server to the time a client
  fired a shot, preventing unfair situations where fast-moving targets are
  impossible to hit at high latency.
- **Delta Compression** — Only transmit changed fields in state updates,
  reducing bandwidth by 60–90% for large game worlds.
- **Interest Management (Relevancy)** — Only send each client the entities
  within their area of interest, preventing bandwidth waste for large open-world
  games.
- **RPC System** — Type-safe remote procedure calls for triggering events across
  the client-server boundary (trigger animation, activate ability, show UI).

### WebRTC (`neith-webrtc`)

- **Data Channels** — Bidirectional, multiplexed, reliable and unreliable data
  channels over DTLS/SCTP for browser peer-to-peer communication.
- **Audio/Video Streams** — Capture, encode, transmit, and render real-time
  audio and video with codec negotiation.
- **ICE Candidate Gathering** — Full STUN/TURN ICE implementation for connection
  establishment through NAT.
- **Simulcast** — Multiple quality layers simultaneously so each receiver gets
  the quality their bandwidth supports.
- **Echo Cancellation and Noise Suppression** — Audio processing pipeline for
  voice communication.

### HTTP Stack (`neith-http`)

- **HTTP/1.1, HTTP/2, and HTTP/3** — All three versions in a single unified
  client API. HTTP/3 over QUIC provides better performance on lossy networks.
- **Connection Pooling** — Reuse connections for subsequent requests, avoiding
  handshake overhead for high-frequency API calls.
- **Request Streaming and Compression** — Stream large request bodies;
  transparent gzip, brotli, and Zstd response decompression.

---

## `@neith/renderer` — Real-Time Rendering Pipeline

An industry-leading rendering pipeline targeting the visual fidelity of Unreal
Engine 5. The renderer runs on `@neith/hal`'s GPU abstraction and therefore
supports every platform the HAL does: Windows, macOS, Linux, Android, iOS, and
browsers. The workspace is intentionally broad: it contains **16 crates** — the
ten dedicated rendering crates plus `neith-physics`, `neith-audio`, `neith-ecs`,
`neith-scripting`, `neith-animation`, and `neith-gaussian-splatting` — because
these subsystems are tightly coupled to the render loop and need to share the
same workspace dependency graph. All sixteen are real, substantial workspace
members built in Rust.

- **Render Graph System** (`neith-render-graph`) — Frame graph architecture with
  automatic render pass dependency management, resource lifetime tracking,
  resource aliasing for memory reuse, and async compute integration. Compiled
  and optimized each frame before submission.
- **GPU-Driven Rendering** (`neith-gpu-driven`) — GPU frustum culling, occlusion
  culling, Hi-Z buffer culling, indirect draw calls, GPU-driven LOD selection,
  mesh cluster rendering, and bindless resource management. Reduces CPU draw
  call overhead to near zero.
- **PBR Material System** (`neith-pbr`) — Physically based rendering (PBR —
  materials described by real physical properties rather than artist-tweaked
  values) with metallic-roughness and specular-glossiness workflows. Subsurface
  scattering, anisotropy, clear coat, sheen (cloth), transmission (glass),
  iridescence/thin-film, and material layering.
- **Material Graph Editor** (`neith-material-graph`) — Node-based material
  editor with real-time preview, custom function nodes, and shader variant
  compilation.
- **Global Illumination** (`neith-gi`) — Lumen-class GI (global illumination —
  accurate indirect lighting bouncing off all surfaces) via signed distance
  field ray tracing, surface cache, and infinite diffuse bounces. Hardware RTX
  path for NVIDIA cards.
- **Shadow System** (`neith-shadows`) — Cascaded shadow maps, virtual shadow
  maps, shadow caching, PCSS (contact hardening), ray-traced shadows, and
  per-object shadows.
- **Lighting System** (`neith-lighting`) — Directional, point, spot, and area
  lights. IES light profiles. Clustered forward and deferred rendering paths.
  Volumetric lighting and god rays.
- **Virtualized Geometry** (`neith-virt-geom`) — Nanite-class rendering where
  any triangle-count asset can be placed in a scene without LOD authoring.
  GPU-resident geometry with streaming and software rasterizer for small
  triangles.
- **Post-Processing** (`neith-postfx`) — ACES tone mapping, color grading,
  bloom, bokeh depth of field, motion blur, TAA/FXAA/SMAA anti-aliasing,
  FSR-class upscaling, and GTAO ambient occlusion.
- **Atmospheric Rendering** (`neith-atmosphere`) — Physical sky model with
  Rayleigh and Mie scattering, volumetric clouds, height/volumetric fog,
  time-of-day system, and aerial perspective.
- **Gaussian Splatting** (`neith-gaussian-splatting`) — 3D Gaussian splatting
  renderer for radiance-field scene reconstruction and playback.

### Physics, Audio, ECS, Scripting, and Animation

These are also workspace members of `@neith/renderer`, alongside the rendering
crates above.

- **Multi-Physics Simulation** (`neith-physics`) — Rigid body dynamics,
  character controller, vehicle physics (Pacejka tire model), ragdoll, cloth
  simulation (PBD), soft body physics, fluid simulation (SPH/FLIP), and Voronoi
  fracture destruction. A self-contained physics engine with its own SAP/BVH
  broadphase, GJK/EPA narrowphase, and constraint solver — no external physics
  dependency.
- **Spatial Audio Engine** (`neith-audio`) — HRTF-based binaural rendering
  (Head-Related Transfer Function — positional audio personalized to your ear
  shape), room acoustics with real-time reverb, Doppler effect, sound occlusion,
  procedural audio synthesis, and adaptive music.
- **Entity Component System** (`neith-ecs`) — Archetype-based ECS (a
  data-oriented game object model where entities are IDs and behavior is defined
  by which components they carry) with cache-friendly storage, parallel system
  execution, and type-safe component queries.
- **Multi-Language Scripting** (`neith-scripting`) — Lua, WASM, and visual
  scripting via node graphs. Hot-reload scripts without restarting the engine.
- **Animation System** (`neith-animation`) — Skeletal animation, blend trees,
  animation state machines, IK/FK, procedural locomotion, and facial animation.
  (Distinct from the `neith-animation` crate in the `@neith/ui` workspace, which
  is a separate UI-animation crate.)

---

## `@neith/ui` — GPU-Accelerated UI Toolkit

A cross-platform, GPU-accelerated UI toolkit built on `@neith/hal`'s rendering
layer. The goal is simple: every platform gets the same pixel-perfect UI without
paying the memory, startup, and rendering-fidelity costs of shipping a
web-browser runtime (Electron, WebView) for native interfaces. The six crates
divide responsibility cleanly — `neith-render2d` draws shapes and images,
`neith-text` handles international text shaping, `neith-layout` computes
Flexbox/grid positions, `neith-widgets` provides the standard control library,
`neith-animation` handles UI motion, and `neith-theme` manages design tokens.

### 2D Rendering Core (`neith-render2d`)

- **GPU-Accelerated 2D Renderer** — Vector path rendering (Bézier curves, arcs),
  anti-aliased shapes, gradient fills, image rendering, blend modes, and
  clipping masks — all executed on the GPU.
- **Shadow and Blur** — Box shadows, drop shadows, and Gaussian blur composited
  by the GPU without CPU pixel processing.
- **HiDPI/Retina Support** — Correct device pixel ratio scaling for sharp
  rendering on high-density displays.
- **Color Management** — sRGB and Display P3 wide-gamut support through the
  rendering pipeline.

### Text Rendering (`neith-text`)

Correct, high-quality international text rendering is the hardest part of any UI
toolkit.

- **SDF Font Rasterization** — Signed distance field rendering produces sharp
  glyphs at any scale without re-rasterizing.
- **HarfBuzz Integration** — Correct OpenType text shaping for all scripts:
  Arabic (right-to-left, cursive joining), Devanagari (combining vowel marks),
  CJK, and complex Indic scripts.
- **Bidirectional Text** — Full Unicode Bidirectional Algorithm for correct
  mixed LTR/RTL display.
- **IME Support** — Input Method Editor support for Chinese, Japanese, Korean,
  and other languages requiring composition.
- **Variable Font Support** — Interpolate along font axes (weight, width, slant)
  without loading multiple font files.

### Layout Engine (`neith-layout`)

- **Flexbox and CSS Grid** — Full specification implementations for fluid and
  two-dimensional layout.
- **Virtualized Lists** — Render lists with thousands of items at 60fps by only
  creating nodes for visible items.
- **Constraint-Based Layout** — Cassowary constraint solver for AutoLayout-style
  declarative UI constraints.

### Widget Library (`neith-widgets`)

A complete set of standard UI controls: `Button`, `TextField`, `TextArea`,
`Checkbox`, `Radio`, `Slider`, `RangeSlider`, `Dropdown`, `DatePicker`,
`TimePicker`, `ColorPicker`, `Progress`, `Spinner`, `Tabs`, `TreeView`,
`DataGrid`, `Modal`, `Dialog`, `Tooltip`, `Popover`, `ContextMenu`.

### Animation System (`neith-animation` in UI workspace)

- **Spring Physics Animations** — Natural-feeling animations based on
  spring-damper systems, reacting to interruptions without jarring jumps.
- **Gesture-Driven Animations** — Animations tracking and responding to gesture
  input in real time (drag to dismiss, swipe to navigate).
- **Shared Element Transitions** — Animate an element from one location to
  another across navigation transitions.
- **Lottie Animation Support** — Render Lottie (After Effects exported)
  animation files.

### Theming System (`neith-theme`)

- **Design Token System** — Centralized semantic tokens (`color.primary.500`,
  `spacing.md`) mapping to platform-specific values for consistent cross-domain
  theming.
- **Light/Dark Themes** — Built-in themes with automatic selection based on
  system preference; runtime switching without restart.
- **High Contrast and Reduced Motion Modes** — Accessibility compliance for
  users with low vision or motion sensitivity.

---

## `@neith/ai-runtime` — Game AI and Inference (Phase 43)

Game AI sits at the intersection of real-time constraints and decision-making
complexity. The `ai-runtime/` Cargo workspace bundles eight crates covering
every layer of game AI, from low-level navigation meshes up to on-device
language models for NPC dialogue. Each crate is independently usable: a simple
game might take only `neith-navigation` and `neith-behavior-tree`; a richer
title might add `neith-perception`, `neith-crowd`, and `neith-npc`. The eight
crates are: `neith-navigation`, `neith-behavior-tree`, `neith-ai-fsm`,
`neith-perception`, `neith-crowd`, `neith-ml-inference`, `neith-llm`, and
`neith-npc`.

- **Navigation System** (`neith-navigation`) — NavMesh generation, A\* and
  hierarchical pathfinding, flow field pathfinding, dynamic NavMesh updates,
  local avoidance (RVO), and steering behaviors.
- **Behavior Trees** (`neith-behavior-tree`) — Full node library (sequence,
  selector, parallel, decorator, condition, action), blackboard system, subtree
  references, and visual editor.
- **Hierarchical State Machines** (`neith-ai-fsm`) — Layered state machines,
  global transitions, entry/exit actions, pushdown automata, and visual editor.
- **Perception System** (`neith-perception`) — Sight, hearing, touch, and smell
  perception with memory, decay, line-of-sight queries, and stealth mechanics.
- **Crowd Simulation** (`neith-crowd`) — Large-scale agent crowd movement and
  avoidance.
- **On-Device ML Inference** (`neith-ml-inference`) — ONNX Runtime integration
  (via the `ort` crate) for local neural networks: animation-driven locomotion,
  face animation from audio, and procedural content generation without server
  round-trips.
- **LLM and NPC Runtime** (`neith-llm`, `neith-npc`) — On-device language-model
  inference and agentic NPC behavior.

---

## Creative Tools Suite (Phase 44)

Neith's sovereign creative tools replace Blender, DaVinci Resolve, and similar
professional applications with Rust-native equivalents that integrate directly
into the engine stack. Because the same `neith-render-graph` and `neith-gpu`
primitives power both the game engine and the tool renderers, assets authored in
the tools are immediately usable in the engine without a re-import step.

The creative tools are organized as Cargo workspaces under `libs/neith/` — each
a `[workspace]` manifest with a `crates/` directory, not an npm-style package.

- **3D Modeling Application** (`sculptor/` workspace — crates `neith-mesh-edit`,
  `neith-sculpt`, `neith-uv`, `neith-tex-paint`, `neith-sculptor-render`) —
  Blender-class mesh editing, subdivision surfaces, dynamic topology sculpting,
  UV unwrapping, texture painting, PBR material authoring, and rendering.
- **Animation Application** (`animator/` workspace — crates `neith-motion`,
  `neith-rig`, `neith-timeline`, `neith-mocap`, `neith-facial`) —
  Armature/skeleton creation, IK/FK switching, weight painting, blend trees,
  procedural animation, motion capture, and facial animation tools.
- **Video Editor** (`cutter/` workspace — crates `neith-video-timeline`,
  `neith-vfx`, `neith-color-grade`, `neith-export`) — Non-linear editing, color
  grading (nodes), effects, compositing, real-time GPU preview, and export.
- **Audio Production** (`composer/` workspace — crates `neith-daw-core`,
  `neith-mixer`, `neith-midi`, `neith-synth`, `neith-spatial-audio`) — DAW-style
  timeline, multi-track mixing, MIDI sequencing, synthesis, and spatial audio.
  The broader sovereign-audio plugin and host workspaces are covered in
  Phase 132.
- **Procedural Generation Tools** (`procgen/` workspace, plus the `forge-core/`
  workspace) — Node-based procedural content graphs for terrain, textures,
  foliage, and more, including ML-driven procgen crates (`neith-terrain-ml`,
  `neith-texture-synth`, `neith-neural-flora`, …).

  The Phase 53 SOTA procgen crate set carries specific capability envelopes:
  - `neith-nca` — Neural Cellular Automata growth models for self-organizing
    textures/structures and damage regeneration (§53.12).
  - `neith-jfa` — GPU Jump Flooding Algorithm for real-time distance fields,
    Voronoi diagrams, and SDF generation (§53.13).
  - `neith-tiling` — Wang tiles and aperiodic monotile (einstein/hat) tiling for
    repetition-free surface and level layout (§53.14).
  - `neith-texture-synth` — stochastic/example-based texture synthesis
    (histogram-preserving blending, by-example tiling) (§53.15).
  - `neith-inverse-procgen` — inverse procedural modeling: recovering grammar or
    graph parameters from exemplar assets (§53.17).
  - `neith-diff-procgen` — differentiable procedural pipelines optimizable by
    gradient descent against target imagery or metrics (§53.18).
  - `neith-wave-noise` — multi-dimensional wave/phasor noise fields for
    artifact-free, spectrally-controlled patterns (§53.19).
  - `neith-neuro-facade` — neuro-symbolic facade generation (Pro-DG-style
    grammar + neural detailing) for building exteriors (§53.21).
  - `neith-scene-agent` — LLM-agent scene orchestration turning natural language
    into scene layout and dressing operations (§53.22).
  - `neith-neural-flora` — neural L-systems for learned plant morphology
    (§53.23).
  - `neith-physarum` — Physarum transport-network growth for organic
    road/river/cave networks.
  - `neith-terrain-ml` — ML terrain synthesis and enhancement.

  Phase 53 also plans differentiable physical audio (§53.24) in the `composer`
  workspace's synthesis crates.

- **VFX / Particles** (`particles/` workspace — crates `neith-particle-core`,
  `neith-vfx-graph`) — GPU particle systems and node-based VFX graphs.

---

## Neith Operating System (Phase 45)

A sovereign operating system built on the Neith stack, targeting servers,
embedded devices, and eventually desktop platforms. Owning the OS layer means
Neith can guarantee real-time scheduling priorities, custom kernel modules for
GPU workloads, and a package manager tuned for the creative-tool and game-engine
deployment model.

The work lives in the `linux/` Cargo workspace (17 crates plus `kernel/`,
`modules/`, `iso/`, `packages/`, `partitions/`, and a `flake.nix`). Note that
the OS is not split into separate `@neith/os-kernel`, `@neith/drivers`,
`@neith/fs`, or `@neith/pkg` packages — everything lives within the single
`linux/` workspace.

- **Distro core, kernel builder, and installer** (`neith-distro-core`,
  `neith-kernel-builder`, `neith-installer`) — Linux distribution assembly,
  custom kernel builds, and system installation.
- **Driver-adjacent subsystems** (`neith-graphics`, `neith-storage`,
  `neith-network`, `neith-audio`) — Graphics, storage, networking, and audio
  subsystem crates for the OS.
- **Package management** (`neith-pkg`, `neith-pkg-manager`,
  `neith-overlay-manager`) — Package management, overlay management, and
  content-addressed package storage.
- **Shell, services, and tuning** (`neith-shell`, `neith-services`,
  `neith-settings`, `neith-workload-tuner`, `neith-update-agent`,
  `neith-security`, `neith-creative`) — System shell, service supervision,
  settings, workload tuning, update agent, security, and creative-app
  integration.

---

## Neith Browser (Phase 46)

A Servo-based sovereign web browser with tight integration into the Neith
application platform. Owning the browser closes the last major gap in
sovereignty: Oshun applications can embed web content, run web APIs, and
distribute through the browser channel without depending on Chromium or WebKit.
The browser shares the same `neith-gpu` rendering backend as the rest of the
stack, so it renders web content using the same GPU abstraction as the game
engine.

The work lives in the `browser/` Cargo workspace, which contains ten crates:
`neith-browser-engine`, `neith-browser-rendering`, `neith-browser-layout`,
`neith-browser-script`, `neith-browser-webapi`, `neith-browser-webgl`,
`neith-browser-media`, `neith-browser-net`, `neith-browser-storage`, and
`neith-browser-shell`.

- **Rendering Engine** (`neith-browser-engine`, `neith-browser-rendering`,
  `neith-browser-layout`) — Servo-based engine core with WebRender GPU
  compositing, retained-mode display lists, and HTML/CSS layout.
- **Script Engine** (`neith-browser-script`) — SpiderMonkey engine integration
  with JIT compilation and WebAssembly support (SIMD, threads, GC, exceptions,
  the component model).
- **Web Platform APIs** (`neith-browser-webapi`, `neith-browser-webgl`,
  `neith-browser-media`, `neith-browser-net`, `neith-browser-storage`) — DOM,
  service workers, WebGL 2.0/WebGPU, media, networking, and storage APIs.
- **Browser Shell** (`neith-browser-shell`) — Browser chrome and the user-facing
  application shell.

---

## Domain Integration and Platform Operations (Phases 48–52)

Phases 48–52 carry `@neith/*` package prefixes and are co-owned by Neith with
Oshun/Shared: they take the stack from Phases 41–46 to a platform other Oshun
domains run on.

- **Domain Integration (Phase 48)** — `@neith/integration-maya`, `-yemaya`,
  `-isis`, `-sophia`, `-hathor`, and `-bellona`: migration layers that move each
  domain onto the Neith engine, renderer, physics, audio, ECS, and scripting
  stack, plus the Neith-hosted metaverse platform that Maya worlds deploy onto.
  Each integration package owns the adapter surface between the domain's
  existing runtime and the Neith equivalents so domains migrate
  subsystem-by-subsystem rather than in one cutover.
- **Infrastructure and DevOps (Phase 49)** — `@neith/cloud` (Kubernetes deploy
  configs, GPU node pools, autoscaling, service mesh), `@neith/observability`
  (metrics, tracing, log pipelines for Neith services), and `@neith/security`
  (security infrastructure: secrets, network policy, supply-chain scanning) for
  the Neith-stack deployment story, complementing the `@oshun/*` cross-cutting
  libraries owned by Shared.
- **Testing and QA (Phase 50)** — `@neith/testing` (unit/integration/E2E/
  performance frameworks per language of the stack, coverage gates,
  mutation/property/fuzz/snapshot testing) and `@neith/qa` (QA processes,
  release-quality checklists, bug triage workflows).
- **Documentation and Training (Phase 51)** — `@neith/docs` (developer and user
  documentation system, tutorials, cookbooks, migration guides) and
  `@neith/training` (onboarding curricula and certification courses for
  engineers building on the stack).
- **Release and Distribution (Phase 52)** — `@neith/release`: release pipeline,
  branching/versioning policy, release candidates, staged rollouts, feature
  gates, LTS/EOL policy, and download/distribution infrastructure and channels
  for engine, OS, browser, and tool artifacts.

---

## Industrial Engine Services (Phase 72)

Phase 72 closes industrial-grade gaps versus commercial engines. Four of its
`@neith/*` workspaces are present in `libs/neith/`:

- **`@neith/sound-propagation`** — geometric/wave acoustic simulation:
  occlusion, diffraction, reverb zones, and material-aware propagation for game
  audio (72.31).
- **`@neith/topology-opt`** — topology optimization for generated structures and
  parts (72.32).
- **`@neith/fabric-gen`** — procedural fabric/garment generation (72.33).
- **`@neith/pbr-material-synth`** — PBR material synthesis from exemplars and
  text prompts (72.34).

The remaining Phase 72 envelope is planned across Neith and Maya:
neural-rendering specifics (neural radiance caching and cooperative-vector
inference in the render loop, 72.1), dedicated game-server infrastructure and
fleet orchestration (72.2), a distributed build system and content-cooking
pipeline (72.3), DRM and anti-tamper beyond storefront DRM-lite (72.4),
binary-asset version control strategy (72.20), shader compilation and variant
management (72.30), a cinematic sequencer/timeline editor (72.15), gameplay
camera systems (72.16/72.23), NPC scheduling and daily routines (72.17), and
automated playtesting / AI bot frameworks (72.19). Game-system envelopes that
already exist in Maya (quests, inventory, dialogue via Hathor) are documented in
`DOMAINS/maya/features.md` and `DOMAINS/hathor/features.md`.

---

## Sovereignty Closure Roadmap (Phases 132–135, 137–174)

The closure roadmap extends Neith from a runtime, engine, OS, browser, and
creative-tools foundation into a complete sovereign replacement for external
audio stacks, DCC tools, post-production suites, live-service backends, office
software, cloud-gaming platforms, CI/CD, identity, security operations, and the
remaining Unreal/Blender parity gaps. Phase 136 is owned by Athena because it
introduces the CAD/EDA/CAM/GIS kernel, but Neith remains the shared runtime and
rendering substrate for it.

Each phase below corresponds to a TODO milestone. The phases are ordered by
priority and dependency, not just by number. **Most of this roadmap is now
present in source**: Phases 132–134 and the full Phase 156–170 closure families
(`gpen-*`, `sim-*`, `vse-*`, `oss-*`, `profiler-*`, `vfx-*`, `dh-*`, `vp-*`,
`liveops-*`, `market-*`, `spatial-*`, `audio-*`, `gi-*`, `compute-*`,
`sculpt-*`, `npr-*`) exist as Cargo workspaces under `libs/neith/`, along with a
shipped subset of the Phase 171 `engine-*` workspaces (see the "Closure
workspace families" inventory in `specifications.md`). Several mid-range
sovereign-product phases (135, 137–152) and the remainder of the Unreal/Blender
parity sweep (rest of 171 and all of 172–174) are still planned and do not yet
have directories.

> **On the `@neith/...` names below.** These identifiers name **Cargo crate
> workspaces**, not published npm packages — the Rust convention in
> `libs/neith/` is a directory (e.g. `audio-runtime/`) carrying a `[workspace]`
> `Cargo.toml` and a `crates/` directory. The audio-suite workspaces of Phases
> 132–133 (`audio-runtime/`, `audio-graph/`, `vst3-host/`, `clap-host/`,
> `notation/`, `session-view/`, `restoration/`, `pitch/`, `mastering/`, and
> others) are present in source as Cargo workspaces. Many later-phase items
> (Phases 135 onward — e.g. `foundry`, `metron-core`, `idp-core`, `ci-dsl`,
> `vault-crypto`) have **no directory yet** and are planned. Treat every name
> below as a workspace identifier; consult `specifications.md` for the
> authoritative inventory of which workspaces exist in source.

### Phase 132: Sovereign Audio Runtime and Plugin Platform

Phase 132 replaces CoreAudio, ASIO, WASAPI, and JACK with a single sovereign
audio runtime, and replaces the VST3/AU/CLAP plugin ecosystems with sovereign
hosts and validators. The goal is a professional-grade audio stack that gives
Oshun complete control over latency, driver negotiation, and plugin sandboxing
without depending on any platform audio API beyond a thin kernel driver.

- `@neith/audio-runtime`: cross-platform driver HAL with device enumeration,
  capability negotiation, sample formats, interleaved/planar buffers, channel
  mapping, hot-plug handling, exclusive/shared modes, duplex streaming,
  aggregate devices, xrun recovery, sample-rate drift correction, diagnostics,
  and driver capability reports.
- Driver backends: CoreAudio and AVAudioSession on Apple platforms; ASIO and
  WASAPI on Windows; JACK, PipeWire, PulseAudio, and ALSA on Linux and pro-audio
  setups; AAudio, Oboe, OpenSL ES, USB audio, Bluetooth, spatial audio, focus,
  and JNI bridging on Android.
- `@neith/audio-graph`: deterministic low-latency graph with typed audio, MIDI,
  and CV ports; DAG validation; send/receive routing; sidechains; matrix mixing;
  atomic graph swaps; RT-safe scheduling; lock-free queues; RT allocation;
  watchdogs; SIMD loops; deterministic offline renders; plugin delay
  compensation; oversampling; and sample-rate conversion.
- Plugin hosts: VST3, AudioUnit, LV2, and CLAP discovery, sandboxing, lifecycle,
  processing, MIDI/event routing, parameter automation, state persistence,
  editor embedding, validation-suite conformance, crash isolation, and bridge
  layers for external plugin ecosystems.
- MIDI and hardware: MIDI 1.0 and MIDI 2.0 I/O, MPE, clock and transport sync,
  MIDI learn, SysEx, virtual ports, control surfaces, Mackie/HUI style
  controllers, Ableton Link, MTC, SMPTE/LTC, network audio, NDI/AVB/Dante-class
  routing, and file I/O for WAV/AIFF/FLAC/MP3/AAC/OGG/Opus and broadcast WAV.

### Phase 133: Composer DAW SOTA Expansion

Phase 133 brings the Composer DAW to state-of-the-art parity with Dorico,
Ableton Live, and iZotope RX. The three new crates below extend the `composer/`
workspace with notation engraving, a clip-launcher session view, and
professional restoration/mastering processing — the features that separate a
capable DAW from a professional one.

- `@neith/notation`: Dorico-class notation with a rich score model, engraving
  engine, dynamics, articulations, ornaments, lyrics, text, chord symbols,
  linked parts, layouts, playback, export, and print-grade output.
- `@neith/session-view`: Ableton-class clip launcher with session grid, scenes,
  clips, follow actions, quantization, live recording, performance workflows,
  and controller-driven triggering.
- `@neith/restoration`, `@neith/pitch`, and `@neith/mastering`: iZotope RX-class
  noise/artifact removal, dialogue isolation, spectral editing, Melodyne-class
  pitch and timing, Ozone-class mastering modules, Neutron-class mix assist,
  analysis, presets, and assistant workflows.
- Music creation depth: instrument racks, sampler/synth engines, modulation,
  automation, comping, take lanes, groove, tempo maps, score-to-audio,
  audio-to-MIDI, surround/immersive mixes, deliverables, stems, collaboration,
  and AI-assisted composition/mixing/mastering.
- `@neith/modular` and `@neith/patch-lab`: VCV Rack-class modular synthesis and
  Max/MSP / Pure Data-class visual patching environments.
- `@neith/live-code` and `@neith/synth-advanced`: SuperCollider / TidalCycles /
  Sonic Pi-class live coding, plus additive, physical-modeling, spectral, and
  neural synthesis engines.
- `@neith/scoring` and `@neith/adr-foley`: scoring-to-picture film workflows and
  ADR/Foley/production-sound recording pipelines.
- `@neith/dj`, `@neith/sample-content`, `@neith/realtime-assist`, and
  `@neith/foley`: in-DAW DJ decks with stem separation, the sovereign
  sample-library content strategy, real-time performance assistance, and
  generative/video-conditioned sound effects.

### Phase 134: Forge 2D Sovereign Creative Suite

Phase 134 builds the 2D counterpart to the 3D creative tools. Where the 3D tools
(Sculptor, Animator, Cutter) target Blender/Maya/Resolve workflows, the Forge
suite targets Illustrator, Procreate, and Photoshop workflows for vector
illustration, raster painting, and photo editing. All Forge tools share the
`forge-core` document model and GPU renderer so assets move freely between
applications.

- `@neith/forge-core`: shared document model, canvas/render backend, color
  management, plugin host, history, selection, layers, masks, assets, and
  interchange for the 2D suite.
- `@neith/forge-vector`: Illustrator/Inkscape-class vector illustration with
  path drawing, Boolean path operations, stroke/fill systems, live effects,
  vector text, type-on-path, symbols, swatches, import/export, and print/web
  output.
- `@neith/forge-paint`: Procreate/Clip Studio/Krita-class raster painting with
  brush engine, pen input, stabilization, canvas gestures, layer/mask stacks,
  comic/manga tools, texture painting, reference layers, and time-lapse export.
- Additional 2D applications: photo editing, layout/publishing, typography,
  asset libraries, design-system tooling, icon/UI workflows, batch processing,
  OCR, generative assist, print production, and accessibility.
- `@neith/forge-board`: Miro/FigJam/Lucidchart/draw.io-class whiteboarding and
  diagramming with infinite canvas, connectors, shape libraries, and live
  multi-user boards.
- `@neith/forge-motion`: Rive/Lottie/Spline-class interactive motion graphics —
  state machines, runtime-playable animation formats, and web/app export.

### Phase 135: VFX, Post-Production, Delivery, and Virtual Production

Phase 135 targets the VFX and post-production pipeline — the workflow between a
finished rendering and a delivered broadcast or cinema package. These tools
replace Nuke (compositing), After Effects (motion graphics), SilhouetteFX
(roto), and the OTIO-based editorial conform pipeline, while also covering the
virtual production LED volume workflow that is increasingly standard on
high-budget productions.

- `@neith/foundry`: Nuke-class node compositor with image operations, grading,
  keying, roto, planar tracking, paint/clean-plate, 3D compositing, scripting,
  expressions, deep compositing, OCIO/ACES, multi-channel EXR, and render-farm
  execution.
- `@neith/motion`, `@neith/silhouette`, and `@neith/matchmove`: After
  Effects-class motion graphics, Silhouette/Mocha-class roto and tracking,
  camera/object matchmove, stabilization, retiming, clean-up, and export.
- `@neith/conform` and delivery stack: OTIO/AAF/EDL/XML/FCPXML round trips,
  editorial conform, review, dailies, IMF/DCP/ProRes/DNx/EXR output, HDR/SDR
  trims, broadcast QC, caption/subtitle support, archival packaging, and media
  verification.
- Virtual production depth: LED volume content preparation, frustum workflows,
  camera tracking, color pipelines, stage monitoring, live compositing, capture,
  playback, and pipeline handoff to Yemaya and Bellona.
- `@neith/storyboard`: Storyboard Pro / Final Draft-class storyboarding, previs,
  and screenwriting with panels, animatics, script breakdown, and shot-list
  handoff.
- `@neith/shotops`: ShotGrid/ftrack/Flow-class VFX and production management —
  shots, tasks, versions, reviews, approvals, and pipeline event hooks.
- `@neith/broadcast`: vMix/OBS/Wirecast/Vizrt-class live broadcast switching and
  graphics — program/preview switching, keyed graphics, playout, and streaming
  outputs.

### Phase 137: Platform and Live-Service Sovereignty

- `@neith/platform-hal`: common services for storage, achievements,
  entitlements, overlays, input, presence, networking, platform conformance,
  certification, save data, social surfaces, parental controls, and crash
  policy.
- Platform integrations: PlayStation, Xbox, Nintendo, Steam/Steam Deck,
  Epic-style PC stores, iOS, Android, web, cloud, handheld PCs, and dedicated
  server targets with per-platform packaging and compliance.
- Live-service backends: cross-platform identity, matchmaking, lobbies, parties,
  server fleets, rollback netcode, deterministic simulation, transport,
  telemetry, anti-cheat hooks, backend entitlement validation, and account
  linking.
- `@neith/live-ops` and `@neith/commerce`: seasons, battle passes, live events,
  and remote config; storefronts, IAP, virtual currency, and marketplace
  commerce (the Phase 137 platform-level counterparts of the engine-level Phase
  164/165 workspaces).
- `@neith/patching-cdn`: build distribution, delta patching, binary diffing, and
  CDN management.
- `@neith/accessibility-compliance` and `@neith/moderation`: accessibility
  standards, age ratings, store compliance; and trust/safety content moderation
  for live platforms.

### Phase 138: DCC and Rendering Depth Parity

- `@neith/sculptor-pro`: ZBrush-depth sculpting with ZSpheres/ZSketch,
  ZRemesher/ZModeler, Transpose/Pose tools, masks, morph targets, layers,
  DynaMesh/Sculptris Pro/NanoMesh style workflows, brushes, polypaint,
  projection, retopology, and export.
- `@neith/weaver-pro`: Houdini-depth procedural FX with SOPs, DOPs, solvers,
  VEX/VOP/HDAs, PDG/TOPs, Solaris/USD/Karma-style scene workflows, volumes,
  particles, crowds, destruction, procedural terrain, and pipeline automation.
- `@neith/substance-pro`, `@neith/mari-pro`, and `@neith/clothsmith`: Substance
  Designer/Painter graph and layer workflows, UDIM painting, baked maps, smart
  materials, procedural materials, garment authoring, pattern drafting, cloth
  simulation, avatar fitting, grading, and manufacturing data.
- `@neith/pathtracer`: Arnold/RenderMan/V-Ray-class production path tracer with
  light path expressions, Cryptomatte, deep output, AOVs, adaptive sampling, and
  denoising.
- `@neith/usd-studio` and `@neith/interchange`: USD authoring with Hydra
  delegates, layer/variant workflows, and standards round-trip
  (USD/glTF/FBX/Alembic) interchange.
- `@neith/render-farm`: Deadline/Tractor-class render-farm management — job
  submission, scheduling, pools, licensing, and artist-facing monitors.
- `@neith/mocap-ingest` and `@neith/asset-library`: optical/inertial/facial
  mocap ingest, cleanup, and retarget; and a Megascans/Poly Haven-class
  sovereign asset library with scanning and publishing pipelines.

### Phase 139: Sovereign Office, Scholarly Authoring, and Collaboration

- `@neith/docs-core`: shared document/collaboration substrate with structured
  document models, CRDT/OT collaboration, storage, sync, comments, tracked
  changes, permissions, offline mode, and audit history.
- `@neith/writer`, `@neith/sheets`, and `@neith/slides`: Word/Pages/Google Docs
  style writing, Scrivener/Ulysses long-form authoring, Excel/Numbers/Sheets
  spreadsheet grids and formulas, Airtable-style tables, PowerPoint/Keynote
  slide building, charts, animations, templates, and exports.
- Scholarly and team apps: Zotero/EndNote-class references, LaTeX/Markdown
  publishing, whiteboards, forms, wikis, project/task boards, chat, meetings,
  comments, review workflows, versioning, templates, and governance.
- `@neith/notes`: Notion/Obsidian/Roam-class personal knowledge management —
  block editor, backlinks, graph view, databases, and local-first sync.
- `@neith/mail` and `@neith/calendar-contacts`: sovereign mail client (and
  server pairing) with Outlook/Gmail/Thunderbird-class triage, plus calendar,
  contacts, and task surfaces with invites and scheduling.
- `@neith/pdf-tools`: Acrobat-class PDF reading, editing, forms, annotation,
  redaction, and digital signatures.
- `@neith/knowledge-ai`: the sovereign AI knowledge worker — retrieval over the
  office suite's documents, drafting, summarization, and meeting/task assistance
  grounded in workspace content.

### Phase 140: Sovereign Cloud Gaming Platform

- `@neith/stream-encoder`: hardware encoder HAL, H.264/H.265/AV1/VP9 support,
  rate control, pre/post processing, HDR, low-latency tuning, and GPU capture.
- `@neith/stream-transport`: WebRTC/QUIC/RTP-style transport, adaptive bitrate,
  congestion control, FEC, packet recovery, jitter buffers, regional routing,
  relay fallback, and bandwidth estimation.
- `@neith/stream-input`, `@neith/stream-session`, and `@neith/stream-client`:
  input capture/injection, prediction, fleet orchestration, GPU allocation,
  title images, save persistence, thin-client SDKs, controller support,
  browser/mobile/TV clients, entitlement checks, and session telemetry.
- `@neith/stream-commerce` and `@neith/stream-security`: subscription tiers,
  bring-your-own-game entitlement, and spectator monetization; plus anti-abuse,
  session privacy, and content-protection controls.

### Phase 141: Sovereign 2D Animation Suite

- `@neith/anim2d-core`: timing, exposure sheets, dope sheets, scene model,
  layers, cameras, sound, keyframes, holds, and production-ready project
  organization.
- `@neith/anim2d-draw`, `@neith/anim2d-rig`, and `@neith/anim2d-lipsync`:
  TVPaint/OpenToonz-class frame-by-frame drawing, onion skinning, cleanup,
  ink/paint, Moho/Harmony-class rigged puppets, bones, deformers, meshes,
  character libraries, auto-motion, phoneme detection, lip-sync, and audio
  timing.
- `@neith/anim2d-color`, `@neith/anim2d-camera`, and production tools: palettes,
  ink-and-paint, multiplane cameras, compositing, effects, render queues,
  collaboration, review, versioning, and delivery.
- `@neith/anim2d-procedural` and `@neith/anim2d-pipeline`: Cavalry-class
  procedural motion design, and the storyboard → animatic → final production
  pipeline with X-sheet handoff and shot management.

### Phase 142: Sovereign Product Analytics and Experimentation

- `@neith/metron-core`: event schema, SDKs, ingestion, validation, pipeline,
  consent capture, replayable streams, and high-volume event normalization.
- `@neith/metron-identity`, `@neith/metron-warehouse`, and
  `@neith/metron-insights`: account stitching, identity graphs, columnar
  storage, query APIs, funnels, cohorts, retention, paths, dashboards, alerts,
  and product-health reports.
- `@neith/metron-replay`, `@neith/metron-experiment`, and
  `@neith/metron-destinations`: session replay, heatmaps, feature flags,
  experiments, warehouse sync, reverse ETL, privacy, governance, deletion, and
  regulatory compliance.
- `@neith/metron-mobile-attrib` and `@neith/metron-surveys`:
  AppsFlyer/Adjust/Branch-class mobile attribution and deep-link measurement,
  plus in-app surveys, NPS, and feedback collection.

### Phase 143: DCC Competitor Depth Parity

- `@neith/mograph` and `@neith/c4d-scene-nodes`: Cinema 4D MoGraph-class
  cloners, effectors, fields, motion typography, scene-node runtime, procedural
  object graphs, caching, and animation workflows.
- `@neith/modo-modeling`, `@neith/modo-shader-tree`, and
  `@neith/lightwave-bridge`: Modo-class polygon modeling, MeshFusion-style
  Booleans, layered shader trees, LightWave-style authoring, and bridge/export
  workflows.
- `@neith/clarisse` and `@neith/katana-standalone`: massive scene assembly,
  lookdev, lighting, renderer integration, progressive preview, USD scene
  graphs, shot variants, and standalone lighting pipeline tools.

### Phase 144: Sovereign Real-Time Visualization Renderers

- `@neith/viz-core`: Twinmotion/Enscape/Lumion/D5-class real-time renderer with
  hybrid raster/path tracing, material systems, camera, tone mapping, image
  controls, and high-quality viewport interaction.
- `@neith/viz-livelink`, `@neith/viz-environment`, and `@neith/viz-ecosystem`:
  CAD/BIM/DCC live sync, weather, time of day, atmosphere, scatter, vegetation,
  crowds, traffic, people, vehicles, and asset placement.
- `@neith/viz-presentation`, `@neith/viz-hero`, and `@neith/viz-vantage`:
  walkthroughs, panoramas, VR, animations, presenter UI, Marmoset-style hero
  asset presentation, V-Ray/Chaos Vantage-class path-trace preview, and
  client-facing deliverables.
- `@neith/viz-asset`, `@neith/viz-keyshot`, and `@neith/viz-auto`: the
  visualization asset library; KeyShot-class product/industrial rendering
  workflows; and VRED-class automotive visualization (paint/materials,
  configuration variants, studio lighting).

### Phase 145: Sovereign CI/CD and Supply Chain

- `@neith/ci-dsl`, `@neith/ci-runner`, and `@neith/ci-actions`: pipeline
  language, reusable actions, expressions, templating, managed and self-hosted
  runners, worker protocols, orchestration, marketplace, and local execution.
- `@neith/ci-cache`, `@neith/ci-artifact`, `@neith/ci-secrets`, and
  `@neith/ci-env`: build/test/dependency caches, artifacts, package registry,
  secret and variable store, environments, approvals, deployment gates, and
  promotion workflows.
- `@neith/ci-triggers`, `@neith/ci-insights`, `@neith/ci-security`,
  `@neith/ci-testing`, and `@neith/ci-governance`: event triggers, schedules,
  DORA metrics, quality telemetry, SBOMs, provenance, signing, SLSA/Sigstore
  hardening, test orchestration, org policy, compliance, and auditing.
- `@neith/ci-ide`: developer experience surfaces — editor integration, local
  pipeline runs, and PR/merge-request status UX.

### Phase 146: Sovereign Identity Provider

- `@neith/idp-core`, `@neith/idp-authn`, and `@neith/idp-authz`: directory
  schema, account storage, credentials, passkeys, passwordless auth, OAuth2,
  OIDC, SAML, WebAuthn, RBAC, ABAC, policy models, and decision runtime.
- Federation and lifecycle: external IdP federation, SCIM 2.0 provisioning, user
  lifecycle automation, MFA, adaptive risk, CIAM, social login, consent,
  machine/service identity, workload credentials, token exchange, and
  privileged-access management.
- Enterprise operations: tenant/org management, audit logs, compliance, branded
  login, identity governance, access reviews, break-glass access, and
  self-hosted deployment.
- `@neith/idp-sdk`: relying-party SDKs and integration kits for services that
  authenticate against the IdP.

### Phase 147: Sovereign Specialist Colorist Suite

- `@neith/colorist-core`, `@neith/colorist-raw`, and `@neith/colorist-graph`:
  color-managed project/timeline model, camera RAW debayer, node graph, layer
  stack, Baselight/Nucoda-style grade tree, ACES/OCIO, scopes, and conform.
- `@neith/colorist-primary`, `@neith/colorist-secondary`, and
  `@neith/colorist-effects`: primary controls, curves, HDR wheels, qualifiers,
  keyers, windows, tracking, texture, film emulation, grain, halation, and FX.
- `@neith/colorist-denoise`, `@neith/colorist-hdr`, and `@neith/colorist-panel`:
  restoration, denoise, HDR mastering, trims, Dolby Vision/HDR10+ style
  metadata, control-surface integration, livegrade, review, exports, and
  workstation UX.
- `@neith/colorist-gallery`, `@neith/colorist-remote`, and
  `@neith/colorist-deliver`: stills gallery with look comparison and shot
  matching; remote/collaborative grading sessions; and deliverable rendering
  with per-destination trims.

### Phase 148: Sovereign DJ Workstation

- `@neith/dj-core`, `@neith/dj-mixer`, and `@neith/dj-timecode`: deck engine,
  transport, pitch/key/tempo, beat grid, phase, mixer, crossfader, routing,
  timecode vinyl/CDJ control, and low-latency audio.
- Performance modules: hot cues, loops, sample decks, real-time stem isolation,
  FX, library/crates, playlist prep, track analysis, key detection, controller
  maps, HID/MIDI support, session recording, streaming, Ableton Link, MIDI
  clock, show sync, and lighting/stage integration.
- `@neith/dj-vj`, `@neith/dj-perf`, and `@neith/dj-rights`: video/visuals decks
  for VJ sets; tour-grade low-latency resilience (redundant audio paths,
  failover); and rights/metadata management with play reporting.

### Phase 149: Sovereign Crash Analytics and Error Tracking

- `@neith/crash-ingestion`, `@neith/crash-symbolicator`, and
  `@neith/crash-grouping`: SDK ingestion, minidumps, logs, spans, screenshots,
  symbolication, deminification, fingerprinting, grouping, deduplication, and
  issue lifecycle.
- `@neith/crash-storage`, `@neith/crash-releases`, and `@neith/crash-sessions`:
  event storage/query, release health, deploy tracking, session replay, user
  context, breadcrumbs, performance/APM bridge, and regression detection.
- `@neith/crash-alerting`, `@neith/crash-security`, `@neith/crash-intelligence`,
  and `@neith/crash-ui`: alerts, integrations, PII handling, retention,
  compliance, self-hosting, AI triage, summaries, suggested owners, dashboards,
  and reports.

### Phase 150: Sovereign Password Manager and Secrets Vault

- `@neith/vault-crypto`, `@neith/vault-item`, and `@neith/vault-sync`:
  zero-knowledge crypto, envelopes, key derivation, secure sharing, item
  schemas, passwords, secure notes, cards, identities, files, sync, conflict
  resolution, and offline-first storage.
- User-facing vault: TOTP/OTP/passkey generation, password and secret
  generation, browser/OS autofill, sharing, collections, family/team vaults,
  recovery, breach/weakness monitoring, desktop/mobile/web UI, imports, and
  exports.
- Developer/enterprise vault: CLI/SDK, dynamic secrets, leases, rotation,
  transit encryption, PKI/SSH signing, PAM, SSO, SCIM, policy, audit, and admin
  controls.

### Phase 151: Sovereign EDR/XDR Suite

- `@neith/edr-agent` and `@neith/edr-sensor`: endpoint agent, event collection,
  kernel/user-space telemetry, process/file/network/registry events, filtering,
  buffering, tamper resistance, and cross-platform deployment.
- `@neith/edr-detect`, `@neith/edr-respond`, and `@neith/edr-threat`: behavioral
  detection, rules, ML, threat feeds, IOC matching, response, quarantine, kill
  process, isolate host, rollback, and remediation.
- `@neith/edr-forensics`, `@neith/edr-vuln`, `@neith/edr-mav`,
  `@neith/edr-network`, `@neith/edr-identity`, `@neith/edr-xdr`,
  `@neith/edr-compliance`, and `@neith/edr-console`: IR workbench, vulnerability
  posture, malware analysis, NDR, ITDR, cross-domain correlation,
  audit/compliance, and SOC console.

### Phase 152: Sovereign Incident Management and On-Call

- `@neith/incident-core`, `@neith/oncall`, and `@neith/escalation`: incident
  models, severity/lifecycle states, ownership, rotations, overrides, escalation
  policies, routing, calendars, and handoffs.
- `@neith/alert-ingest`, `@neith/notify`, and `@neith/noise`: alert ingestion,
  deduplication, grouping, ML noise reduction, notifications across email, SMS,
  push, voice, chat, webhooks, and acknowledgement flows.
- `@neith/war-room`, `@neith/status`, `@neith/runbook`, `@neith/slo`,
  `@neith/postmortem`, `@neith/intel`, `@neith/customer-incident`, and
  `@neith/gameday`: live response rooms, status pages, stakeholder comms,
  automation, playbooks, SLO/error budgets, retrospectives, reporting, customer
  support bridges, and chaos/game-day drills.

### Phase 153: Sovereign VFX Match-Move and 3D Camera Tracking

- `@neith/matchmove-core`, `@neith/matchmove-ingest`, and
  `@neith/matchmove-features`: project model, media/camera metadata, feature
  tracking, track authoring, constraints, lens distortion, undistort/redistort,
  and shot preparation.
- `@neith/matchmove-solver`, `@neith/matchmove-object`, and
  `@neith/matchmove-scan`: camera solving, object/body tracking, survey data,
  dense reconstruction, set scanning, alignment, solve diagnostics, and QA.
- `@neith/matchmove-stabilize`, `@neith/matchmove-export`,
  `@neith/matchmove-viz`, `@neith/matchmove-ai`, and `@neith/matchmove-script`:
  stabilization, retime, exports, viewer interaction, ML-assisted tracking,
  Python/Rust SDK, and pipeline automation.

### Phase 154: EEVEE-Class Real-Time Rasterizer

- `@neith/raster-core`, `@neith/raster-material`, and `@neith/raster-gi`: render
  graph, forward/deferred/clustered passes, Principled BSDF shader layer,
  real-time GI, screen-space and probe-based lighting, and material preview.
- `@neith/raster-shadows`, `@neith/raster-aa`, `@neith/raster-volume`, and
  `@neith/raster-post`: shadow maps, cascades, virtual shadows, TAA/FXAA/SMAA,
  upscaling, volumes, atmosphere, bloom, depth of field, motion blur, color
  grading, and compositor passes.
- `@neith/raster-npr`, `@neith/raster-hair`, `@neith/raster-viewport`,
  `@neith/raster-aov`, and `@neith/raster-animation`: stylized output,
  strand/groom shading, viewport modes, AOV/passes/Cryptomatte, and playback.

### Phase 155: Curves-Based Hair and Grooming

- `@neith/hair-curve`, `@neith/hair-groom`, and `@neith/hair-nodes`: curve
  primitives, strand data, grooming brushes, comb/cut/clump/frizz/noise tools,
  geometry-node graphs, masks, selections, and modifiers.
- `@neith/hair-guide`, `@neith/hair-sim`, `@neith/hair-shade`,
  `@neith/hair-render`, `@neith/hair-presets`, `@neith/hair-anim`, and
  `@neith/hair-transfer`: guide interpolation, dynamics, collisions, shading,
  LOD, preset libraries, animation/rigging, and cross-mesh transfer.

### Phase 156: Grease Pencil-Class 2D-in-3D Animation

- `@neith/gpen-object`, `@neith/gpen-tools`, and `@neith/gpen-anim`: grease
  pencil object/data model, strokes, fills, materials, draw/fill/sculpt/edit
  modes, onion skinning, keyframes, interpolation, and timeline workflows.
- `@neith/gpen-modifier`, `@neith/gpen-lineart`, `@neith/gpen-shade`,
  `@neith/gpen-rig`, `@neith/gpen-vr`, and `@neith/gpen-storyboard`: modifier
  stack, line art from 3D, materials/rendering, 2D rigging, spatial drawing,
  storyboard, previs, and review.

### Phase 157: Mantaflow-Class Fluid, Smoke, Fire, Pyro, and Particles

- `@neith/sim-core`, `@neith/sim-liquid`, `@neith/sim-gas`, and
  `@neith/sim-mpm`: solver core, domains, FLIP/APIC/PIC liquid, whitewater,
  foam, gas/pyro, smoke/fire, MPM snow/sand/goo, caching, and stability tools.
- `@neith/sim-particles`, `@neith/sim-cloth`, `@neith/sim-rigid`,
  `@neith/sim-ocean`, `@neith/sim-surface`, `@neith/sim-forces`,
  `@neith/sim-render`, `@neith/sim-games`, and `@neith/sim-farm`: particles,
  cloth, soft bodies, rigid/fracture, oceans, meshing, force fields, shading,
  real-time baking, and distributed simulation.

### Phase 158: DCC-Integrated Video Sequence Editor

- `@neith/vse-core`, `@neith/vse-ingest`, and `@neith/vse-transitions`:
  timeline/strip model, media ingest, proxies, conform, transitions, retiming,
  trim tools, edit modes, and timeline navigation.
- `@neith/vse-effects`, `@neith/vse-audio`, `@neith/vse-playback`,
  `@neith/vse-render`, `@neith/vse-review`, `@neith/vse-conform`, and
  `@neith/vse-storyboard`: strip effects, audio tracks, playback engine, render
  queue, dailies, frame review, interchange, and animatic mode.

### Phase 159: Engine Online Subsystem and Replication

- `@neith/oss-abstraction`, `@neith/oss-identity`, `@neith/oss-matchmaking`, and
  `@neith/oss-session`: service abstraction, auth, friends, parties, lobbies,
  matchmaking, session lifecycle, dedicated server orchestration, and fleet
  handoff.
- `@neith/oss-replication`, `@neith/oss-rpc`, `@neith/oss-prediction`,
  `@neith/oss-transport`, `@neith/oss-voice`, `@neith/oss-presence`,
  `@neith/oss-replay`, `@neith/oss-pixel`, `@neith/oss-anti-cheat`, and
  `@neith/oss-observability`: Iris-class replication graph/protocol, RPC, client
  prediction, rollback/interpolation, NAT/security transport, voice, proximity
  audio, stats, achievements, replay, spectator, pixel streaming, anti-cheat,
  and net telemetry.

### Phase 160: Engine Frame Profiler and Diagnostics

- `@neith/profiler-capture`, `@neith/profiler-timing`, and
  `@neith/profiler-gpu`: tracing backend, CPU/GPU timeline, flamegraphs, frame
  captures, GPU event markers, draw/dispatch inspection, and shader debugging.
- `@neith/profiler-memory`, `@neith/profiler-net`, `@neith/profiler-stat`,
  `@neith/profiler-sample`, `@neith/profiler-shader`, `@neith/profiler-physics`,
  `@neith/profiler-audio`, `@neith/profiler-asset`, `@neith/profiler-ui`, and
  `@neith/profiler-crash`: memory tracking, network profiler, stat HUD,
  production sampling, shader analysis, physics/audio/asset/cook profiling,
  workflow UI, and post-mortem diagnostics.

### Phase 161: Niagara-Class GPU VFX Authoring

- `@neith/vfx-core`, `@neith/vfx-spawn`, and `@neith/vfx-attribute`: effect
  asset model, emitters, systems, spawn rules, bursts, attribute buffers, data
  layouts, parameter binding, and versioned assets.
- `@neith/vfx-modules`, `@neith/vfx-renderers`, `@neith/vfx-sim`,
  `@neith/vfx-data-interfaces`, `@neith/vfx-editor`, `@neith/vfx-perf`, and
  `@neith/vfx-library`: motion/appearance/collision/event modules, sprite, mesh,
  ribbon and volumetric renderers, simulation stages, external data interfaces,
  editor UI, LOD/budgets, and preset libraries.

### Phase 162: MetaHuman-Class Digital Human Pipeline

- `@neith/dh-creator`, `@neith/dh-skin`, and `@neith/dh-eyes`: character
  creator, identity/shape controls, skin pores, materials, eyes, ocular wetness,
  lashes, hair hooks, and presets.
- `@neith/dh-facerig`, `@neith/dh-bodyrig`, `@neith/dh-sim`,
  `@neith/dh-clothing`, `@neith/dh-animator`, `@neith/dh-voice`,
  `@neith/dh-retarget`, `@neith/dh-sdk`, and `@neith/dh-ethics`: FACS facial
  rigs, body deformation, Ziva-class muscle/fat/skin sim, garments, performance
  capture, voice/speech bridge, retargeting, runtime SDK, consent, likeness
  rights, and provenance.

### Phase 163: Virtual Production Stack

- `@neith/vp-cluster`, `@neith/vp-wall`, `@neith/vp-camera`, and
  `@neith/vp-frustum`: multi-node render clusters, sync, LED volume geometry,
  mapping, camera tracking/metadata, inner/outer frustum rendering, latency, and
  calibration.
- `@neith/vp-color`, `@neith/vp-scene`, `@neith/vp-mr`, `@neith/vp-control`,
  `@neith/vp-broadcast`, `@neith/vp-record`, and `@neith/vp-pipeline`: on-set
  color pipeline, virtual scene content, ICVFX, mixed reality, operator
  controls, broadcast studio, capture/playback, and editorial/VFX handoff.

### Phase 164: Engine Monetization and LiveOps

- `@neith/liveops-iap`, `@neith/liveops-ads`, and `@neith/liveops-analytics`:
  in-app purchases, storefronts, subscriptions, ads, mediation, impressions,
  reward flows, game analytics, events, funnels, and revenue reporting.
- `@neith/liveops-remote`, `@neith/liveops-experiments`,
  `@neith/liveops-economy`, `@neith/liveops-cloud-save`,
  `@neith/liveops-attribution`, `@neith/liveops-crm`, `@neith/liveops-cs`,
  `@neith/liveops-compliance`, and `@neith/liveops-portal`: remote config,
  feature flags, A/B tests, virtual economy, cloud saves, attribution, CRM,
  player messaging, customer support, regional compliance, and operator portal.

### Phase 165: Engine Creator Marketplace and Asset Store

- `@neith/market-catalog`, `@neith/market-creator`, and
  `@neith/market-licensing`: asset types, metadata, previews, creator
  onboarding, verification, tax/payout details, licensing, rights, usage tiers,
  and provenance.
- `@neith/market-commerce`, `@neith/market-dl`, `@neith/market-discover`,
  `@neith/market-review`, `@neith/market-moderation`,
  `@neith/market-buyer-portal`, `@neith/market-creator-analytics`, and
  `@neith/market-sdk`: transactions, installs, DRM-lite, search/recommendations,
  ratings, QA, trust/safety, buyer/creator portals, seller analytics, and SDK
  integration.

### Phase 166: Spatial Computing and visionOS Runtime

- `@neith/spatial-core`, `@neith/spatial-volumes`, and `@neith/spatial-input`:
  sessions, scene anchors, world anchors, volumes, immersive/shared spaces,
  gaze, pinch, hands, controllers, and voice input.
- `@neith/spatial-avatars`, `@neith/spatial-render`, `@neith/spatial-physics`,
  `@neith/spatial-audio`, `@neith/spatial-sdk`, `@neith/spatial-anchors-collab`,
  and `@neith/spatial-os`: personas, avatars, presence, stereoscopic/foveated
  rendering, passthrough physics, spatial audio, developer SDK, collocated
  sessions, and spatial OS shell integration.

### Phase 167: Engine Audio Architecture Depth

- `@neith/audio-graph`, `@neith/audio-source`, and `@neith/audio-spatial`:
  game-audio graph, source playback, streaming, procedural sources, 3D
  spatialization, HRTF, occlusion, obstruction, portals, room modeling, and
  binaural output.
- `@neith/audio-environment`, `@neith/audio-mix`, `@neith/audio-dialogue`,
  `@neith/audio-music`, `@neith/audio-synth`, `@neith/audio-voice`,
  `@neith/audio-profiler`, `@neith/audio-tooling`, and
  `@neith/audio-accessibility`: acoustics, reverbs, snapshots, ducking,
  dialogue, localization, adaptive music, procedural SFX, mic/voice chat,
  diagnostics, designer tools, captions, visualizers, and accessibility.

### Phase 168: Modern Global Illumination Pipeline

- `@neith/gi-core`, `@neith/gi-sdfgi`, and `@neith/gi-voxel`: GI abstraction,
  render graph integration, signed-distance-field GI, voxel GI, tracing, cascade
  updates, cache invalidation, and dynamic scene updates.
- `@neith/gi-probe`, `@neith/gi-lumen`, `@neith/gi-shadow`,
  `@neith/gi-lightmap`, `@neith/gi-ao`, `@neith/gi-volumetric`,
  `@neith/gi-emissive`, and `@neith/gi-sky`: irradiance/reflection probes,
  software/hardware ray-traced GI, unified shadows, baked lightmaps, ambient
  occlusion, volumetric lighting, emissive injection, sky, atmosphere, and
  time-of-day.

### Phase 169: GPU Compute Shader Framework

- `@neith/compute-abstraction`, `@neith/compute-lang`, and
  `@neith/compute-resources`: Vulkan/Metal/DX12/WebGPU/CUDA/HIP/OpenCL/SYCL
  backend abstraction, shader language, compiler, buffers, textures, binding
  layouts, and resource lifetime.
- `@neith/compute-dispatch`, `@neith/compute-wave`, `@neith/compute-memory`,
  `@neith/compute-ml`, `@neith/compute-sim`, `@neith/compute-render`,
  `@neith/compute-debug`, and `@neith/compute-sdk`: dispatch, queues, barriers,
  wave/subgroup operations, allocators, ML tensor ops, simulation kernels,
  render helpers, validation, debugging, profiling, and SDK tooling.

### Phase 170: Sculpting Depth and NPR/Freestyle Rendering

- `@neith/sculpt-core`, `@neith/sculpt-topology`, `@neith/sculpt-layers`, and
  `@neith/sculpt-brushes`: sculpt mode, dynamic topology, multires, layers,
  non-destructive edits, complete brush library, masking, symmetry, strokes, and
  stabilization.
- `@neith/sculpt-face-sets`, `@neith/sculpt-mask`, `@neith/sculpt-polypaint`,
  `@neith/sculpt-retopo`, `@neith/sculpt-export`, `@neith/npr-line`,
  `@neith/npr-cel`, and `@neith/npr-inking`: face sets/poly groups, color
  sculpting, retopology, export, Freestyle-class line rendering, cel/toon
  shading, hatching, cross-hatching, and halftone output.

### Phases 171-174: Unreal Engine and Blender Final Parity Sweeps

- **Phase 171**: Verse/UEFN-class scripting, large-world coordinates, level
  instances, packed actors, MegaLights, runtime virtual textures, rect/disc/tube
  and IES lights, in-editor modeling, Geometry Script, mesh distance fields,
  Smart Objects, Chooser tables, pose-search motion matching, Motion Design,
  StateTree/behavior-tree convergence, Animation Insights, plus Blender
  metaballs, NURBS curves/surfaces, 3D text, preferences/keymap depth, Geometry
  Nodes fields, simulation zones, repeat/for-each zones, node-groups-as-tools,
  BSurfaces retopo, library overrides, and Freestyle extensions.
- **Phase 172**: Enhanced Input, GameplayTags, GAS attributes/effects/cues,
  Movie Render Queue and graph, gameplay/cinematic cameras, DMX/ArtNet/sACN,
  Concert multi-user editing, Switchboard, Stage Monitor, remote control,
  virtual scouting, Live Link XR, PCG biome core, Common UI, Data Registry,
  data-driven CVars, Gauntlet, functional testing, automation, hot reload/live
  coding/Python scripting, landscape editor depth, plus Blender texture paint,
  color attributes, annotations, outliner/view layers/render passes, timeline,
  pose markers, Graph Editor and F-curves, drivers, multi-object edit,
  proportional editing, Pose Mode, Python console/script/info editors, and file
  browser.
- **Phase 173**: Asset Manager, IoStore, Pak, Zen DDC, cook pipeline,
  localization, Visual Logger, Gameplay Debugger, material functions/layers/MPC,
  animation notifies/montages/slots/compression, Modular Control Rig, IK Rig, IK
  Retargeter, ML Deformer, Geometry Cache, Mover, Mutable, NavMesh, AI
  Perception, Zone Graph, Mass Traffic, audio modulation, Dialogue Wave,
  Dataflow, subsystem framework, Level Snapshot, asset validation, Sequencer
  bindings/tracks/possessables/spawnables, Push Model replication, Demo
  Recorder, Online Services v2, plus Blender full modifier library, UV
  operators, `bmesh`/`mathutils`/`gpu` Python APIs, Cycles shadow catcher,
  holdout, persistent data, VDB volumes, Bendy Bones, custom bone shapes,
  ragdoll physics, sculpt mesh filter, scene mask, full shader/compositor node
  libraries, legacy particles, Data API, custom properties, and RNA reflection.
- **Phase 174**: Interchange framework, full Blueprint graph depth, Composure,
  source-control integration, asset diff and three-way merge, project settings,
  editor preferences, plugin manager UI, procedural foliage, HISM/ISM foliage
  instances, Game Features, Modular Gameplay, Lyra-class framework, Niagara Data
  Channels, Rewind Debugger, Unreal math library, actor pooling and spawn
  strategies, plus Blender snapping, transform orientations, pivot points, 3D
  cursor, workspaces, brush libraries, palettes, selection and mesh-edit
  operator libraries, constraints, gizmos, built-in add-ons, operator search,
  pie menus, quick favorites, redo panel, measure tools, speaker/sound system,
  SpaceMouse/tablet/gamepad input, viewport operators, and image editor.