Modes

NexArt supports multiple modes. A mode is a protocol surface for authoring a deterministic system, with defined inputs, execution semantics, and determinism guarantees. Protocol-enforced modes are executed through the Code Mode runtime and produce canonical units.

This page describes each mode at a conceptual level. Implementation details and parameter specifications are documented separately.

SoundArt

Intent. SoundArt enables audio-reactive deterministic systems. Audio input drives output through deterministic parameter mapping.

Inputs. Audio source normalized into a frozen SoundSnapshot, a seed value, and visual generation parameters.

Guarantees. SoundArt systems execute through the NexArt Code Mode runtime using deterministic system generation, seeded randomness, and frozen audio snapshots. No legacy rendering paths are permitted for protocol-compliant execution. Outputs are reproducible, verifiable, and protocol-native.

Execution. Audio features are normalized into a frozen SoundSnapshot, injected into the Code Mode runtime as read-only parameters, and rendered using seeded randomness and deterministic noise functions. Identical audio input and seed always produce identical output.

SoundArt Protocol Enforcement

SoundArt is fully protocol-enforced. Execution routes through the NexArt Code Mode engine exclusively, and protocol-compliant flows do not include fallback renderers.

What Changed

SoundArt previously operated through custom canvas renderers and legacy pipelines. With protocol enforcement, all SoundArt execution uses the Code Mode engine as the single execution path.

Why It Matters

• Determinism, identical audio input and seed produce identical output
• Verifiability, outputs can be independently verified against the protocol
• Shared runtime, SoundArt and Code Mode use the same execution engine

What This Enables

• New input types can be added using the same runtime
• Builder SDKs can target a single execution model across modes
• Third-party tools can render SoundArt systems with protocol guarantees

Code Mode

Intent. Code Mode allows direct specification of execution logic through code, intended for builders and advanced users.

Inputs. A code definition conforming to the protocol specification, along with seed values and parameters.

Guarantees. Code Mode execution is deterministic. The protocol enforces seeded randomness and controlled noise functions, and disallows non-deterministic operations. The execution surface is frozen under Protocol v1.2.0.

Runtime. Code Mode is the shared execution environment for protocol-enforced modes. SoundArt, Shapes, and Noise execute through the Code Mode runtime.

Shapes

Intent. Shapes provides geometric primitives for composition. Systems are built from circles, rectangles, lines, and other basic forms.

Inputs. A set of shape definitions with position, size, color, and transformation parameters.

Guarantees. Shapes systems are deterministic. The same parameters produce identical output across conforming implementations. Rendering is executed through the Code Mode runtime, and protocol-compliant flows do not include legacy rendering paths.

Execution. Shape definitions are processed by the Code Mode runtime using standardized primitive definitions and rasterization rules. Outputs are reproducible, verifiable, and protocol-native.

Noise

Intent. Noise generates textures and patterns using procedural noise functions such as Perlin, Simplex, and Worley.

Inputs. Noise type, frequency, amplitude, octaves, and seed values.

Guarantees. Noise systems are deterministic. The same algorithm, parameters, and seed produce identical output across conforming implementations. Rendering is executed through the Code Mode runtime, and protocol-compliant flows do not include legacy rendering paths.

Execution. Noise parameters are processed by the Code Mode runtime using specified algorithms and seeded randomness. Outputs are reproducible, verifiable, and protocol-native.

Enforcement Status

These modes are enforced by the NexArt Protocol and executed through the Code Mode runtime. No arbitrary rendering logic is permitted in protocol-compliant execution.

Mode Parity

The protocol goal is that all modes produce canonical units, all modes are versioned, and all modes declare determinism guarantees. Mode parity means each mode is a complete and independent way to author NexArt systems. Implementations are working toward this goal.

Future modes may be added to the protocol. The framework is designed to accommodate new creation primitives without disrupting existing ones.