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.