New Code
Full Specification

Preface

Code was never natural to us. We naturalised it. Every programming language in existence is a compromise between what humans can read and what machines can execute — and for seventy years the compromise has favoured the humans. Keywords are English words. Operators are symbols from algebra. The machine has been asked to understand us.

That compromise is ending. The rise of large language models has produced a species of machine that can hold far more context than any human, reason across wider conceptual distances, and generate code faster than we can review it. Asking such a machine to keep speaking Python is like asking a concert pianist to communicate in semaphore.

New Code is a proposal for the other direction. A language whose primary reader is an AI system, whose primary writer is an AI compiling from human intent, and whose source text is optimised for machine interpretation rather than human legibility.

The language draws its primitive objects from Waveform Logic — a mathematical system in which numbers are oscillatory structures carrying frequency, amplitude, phase, and shape. Its execution model comes from Processism, the philosophical framework in which stasis is incoherent and process is fundamental.

1. Design Principles

New Code rests on six principles, stated in order of priority. When two conflict, the earlier one wins.

2. The Execution Model

A New Code program is a directed graph of processes. Execution is not the sequential evaluation of statements but the continuous unfolding of the graph.

Processes, not threads

A process in New Code is not a thread in the OS sense. It is the language's primitive unit of ongoing computation. A process has four components mirroring 𝕎: frequency (how often it produces output), amplitude (magnitude of output), phase (offset relative to a reference), and shape (functional form over time).

The unfolding

A New Code program does not run. It unfolds. The runtime unfolds the graph by allowing each process to advance along its own internal time. A New Code debugger does not step through instructions — it inspects the current realisation of a chosen process and optionally drifts it to examine nearby trajectories.

No implicit global time

New Code has no global clock. Each process carries its own τ parameter. When two processes must be coordinated, coordination is expressed as entanglement. This eliminates a large class of race conditions but introduces desynchronisation (phases drifting apart under independent evolution).

Termination

A program terminates when every process has either (a) reached a declared fixed point, (b) been collapsed and consumed, or (c) drifted to the square-wave attractor sq — called thermodynamic termination. Without external input, every process dies to the same shape.

3. Primitive Types

Example declarations

let carrier : 𝕎  = ⟨ 440.0, 1.0, 0.0, sine ⟩
let chord   : 𝕎* = ⟨440, 0.82, 0, σ_f⟩ ⊕ ⟨880, 0.34, 0, σ_2nd⟩
let beat    : proc<𝕎> = every ⟨1.0, 1.0, 0, pulse(0.1)⟩

4. Syntax

New Code's syntax is designed for unambiguous machine parsing. It is not pleasant to type. It is not meant to be — the compiler generates it from intent.

Declaration forms

※ Variable binding
let NAME : TYPE = EXPRESSION

※ Process declaration
process NAME : TYPE ≔ EXPRESSION

※ Function with intent
fn NAME (ARG : TYPE, ...) → RETURN_TYPE
    intent:  「what this function is for」
    forbid:  「what it must not do」
    ensure:  「invariant it must maintain」
    ≔ EXPRESSION

The ≔ symbol means "is defined as". A ≔ ?? is a hole — the compiler fills it from the intent declaration. intent, forbid, and ensure are mandatory for any function exposed outside its module. Private functions (prefixed _) may omit them.

String literals

Strings are bracketed with 「 and 」. They are primarily used in intent declarations and tags, not as a primary data type.

Comments

※ begins a line comment. Block comments use 《 ... 》.

5. Operators

Operator precedence (tightest → loosest)

1. Unary postfix: ⁻, ? (sample)
2. Bracket operators: ⌊·⌉, ⟪·,·⟫
3. Oscillation product: ⊚
4. Drift: ⇝
5. Superposition: ⊕
6. Synchronisation: ‖
7. Entanglement declaration: ▷◁

6. Control Flow

New Code has limited control flow. Most of what conventional languages do with branching is expressed through process composition.

Conditional: when

let response : 𝕎 = when signal_strength > threshold
                   then amplified_signal
                   else silence

when is an expression, not a statement. Both branches must have the same type. A when without an else is a type error.

Pattern matching: case

case incoming of
    ⟨f, _, _, sine⟩ when f < 100  ↦ handle_sub_bass(incoming)
    ⟨f, A, _, _⟩ when A < 0.01   ↦ noise_floor()
    ⟨_, _, _, σ⟩                  ↦ generic_processor(σ, incoming)

The compiler verifies exhaustiveness. Non-exhaustive cases are a compile error, not a warning.

Iteration: fold

let combined : 𝕎* = voices fold with ⊕ from silence

New Code has no for or while loop. Iteration over finite structure is expressed as a fold.

7. Functions and Processes

Pure functions

A function declared with fn is pure: given the same input, it returns the same output. Purity is enforced — attempting to read external state from within a fn is a compile error.

Processes

A process is introduced with process and is permitted to have internal state, external effects, and ongoing unfolding. The cost is that a process must declare its interaction interface explicitly through emits and consumes clauses.

process audio_in : proc<𝕎>
    intent:   「continuously sample microphone input as waveform」
    emits:    𝕎 at 48000 Hz
    consumes: hardware_channel<mic>
    ≔ ...

Higher-order functions

Functions may accept and return other functions. Higher-order functions must declare constraints on the intents of their function arguments using requires clauses:

fn apply_to_signal (f : fn(𝕎) → 𝕎, w : 𝕎) → 𝕎
    intent:   「apply a shape-preserving transformation f to w」
    requires: f.ensure contains 「preserves shape」
    ≔ f(w)

8. The Intent Layer

The intent layer is what distinguishes New Code from every language preceding it. It is where humans, in practice, actually write.

The hole

fn classify (sample : 𝕎, known : [signature]) → signature | fault<no_match>
    intent:  「identify the instrument whose prototype has smallest coherence distance」
    forbid:  「return a match if the best distance exceeds the ambiguity threshold 0.65」
    ensure:  「output is the unique nearest signature, or a no-match fault」
    ≔ ??

The ≔ ?? is a hole. The compiler fills it. If the compiler can produce an implementation that satisfies all three declarations, it does so. If it cannot, it reports which intent it cannot satisfy and asks you to refine.

Intent inheritance

Modules declare their own intent clauses, which propagate to all contained functions as a constraint. A function whose local intent contradicts the containing module's intent is a compile error. This enforces architectural coherence at the language level.

9. Entanglement and Coupled State

Two values in New Code are entangled when there exists a declared coupling function Φ such that any transformation of one induces Φ on the other.

let stereo_field : ⟨𝕎 ▷◁ 𝕎⟩ = entangle(L, R) via φ_haas

※ Transforming one side propagates through Φ automatically
let new_pair = amplify(stereo_field.left, 2.0)

※ Disentangle to work on sides independently (lossy)
let ⟨L, R⟩ = disentangle(stereo_field)

Key properties

• Symmetric — both sides propagate to each other
• Not transitive — A ▷◁ B and B ▷◁ C does not imply A ▷◁ C
• Runtime-enforced — not a convention, not a test, not a hope

10. Drift, Decay, and Temporal Semantics

The drift operator

Drift (⇝) takes a process and a scalar δ and returns a process advanced by δ units along the drift trajectory. This is distinct from waiting δ units of wall-clock time. Drift simultaneously:

• Shifts frequency by δA (amplitude-modulated)
• Decays amplitude by exp(−|δ|)
• Rotates phase by δf
• Deforms shape toward the square-wave attractor by |δ|

A process drifted by δ = 0 is unchanged. A process drifted by a large δ converges toward sq — the terminal configuration of all oscillation.

Three uses of drift

11. Collapse and the Interface to Conventional Systems

New Code must interoperate with conventional systems that expect scalars. The collapse operator is the bridge.

※ The collapse operation
⌊ ⟨f, A, φ, σ⟩ ⌉ = A · γ(⟨f, A, φ, σ⟩, e₀)

※ A function that collapses marks its return type
fn peak_detector (w : 𝕎) → ⌊ℝ⌉
    intent:  「identify the peak amplitude of w as a scalar」
    forbid:  「claim to preserve structure」
    ensure:  「output is A of input」
    ≔ ⌊w⌉

※ Callers pattern-match on the collapse marker
let ⌊peak⌉ = peak_detector(signal)

12. Modules and Composition

module audio.analysis
    intent:  「provide primitives for analysis of incoming audio streams」
    forbid:  「produce outputs claiming precision beyond numerical floor of input」
    ensure:  「all exported functions are shape-preserving or explicitly marked collapsing」

    export fn spectral_centroid ...
    export fn onset_detection ...

Every module carries an intent block. Functions whose local intent contradicts the module's intent are compile errors — architectural coherence is enforced at the language level, not the conventions level.

13. Error Model

New Code has no exception mechanism. A function that may fail declares its failure modes in its return type as a sum type.

fn parse_frequency (source : ⌊string⌉) → 𝕎 | fault<parse>
    intent: 「parse a textual frequency specification into a waveform number」
    forbid: 「produce silent defaults on malformed input」
    ensure: 「failure cases are explicit」
    ≔ ...

※ Callers must handle both branches
case parse_frequency(「four forty」) of
    ⟨f, _, _, _⟩                   ↦ use_it(f)
    fault<parse>(location, payload) ↦ diagnose(location, payload)

Faults are structured values with a type, a location, and a payload. Thermodynamic termination (drifting to sq) is not a fault.

14. Worked Example: Timbre Classification

This example implements timbre classification — given a recorded instrument sample, identify which instrument it is. Coherence distance does the heavy lifting; shape information is preserved throughout.

module audio.timbre
    intent: 「classify musical instruments by timbre, independent of pitch」
    forbid: 「rely on features that collapse shape information before comparison」
    ensure: 「classifications are stable under drift up to the declared identifiability horizon」

    import waveform.algebra.{⊚, ⟪·,·⟫, d_γ, ⇝}
    import audio.capture.mic_input

    record signature ≔ { name : ⌊string⌉, prototype : 𝕎 }

    fn classify (sample : 𝕎, known : [signature]) → signature | fault<no_match>
        intent: 「identify the instrument whose prototype has smallest coherence distance to sample」
        forbid: 「return a match if the best distance exceeds the ambiguity threshold 0.65」
        ensure: 「output is the unique nearest signature, or a no-match fault」
        ≔ ??

    export classify, fingerprint, identifiability_horizon

A human who cared only about the intent could write exactly that ≔ ??. The compiler produces an implementation equivalent to the full body — distances computed, threshold enforced, nearest signature returned.

15. Use Cases

New Code is not a general-purpose replacement for Python or Rust. It is a language for specific domains where its primitive commitments produce real advantages.

New Code is explicitly not well suited to: low-level systems programming where every cycle counts, scripting and one-liners, or any task where intent declarations would drown out the work.

16. Relation to Existing Languages

New Code is not invented from nothing. It draws from:

• ML family (OCaml, Haskell, Rust) — algebraic data types, sum types for errors, pure functions as default
• Dataflow languages (Lucid, Esterel, Max/MSP) — programs as networks of continuously-running nodes
• Dependently-typed languages (Idris, Agda) — types that carry propositions, compiler-verified propositional content
• Prolog / logic programming — the compiler-fills-the-hole pattern (≔ ??) with a neural compiler in place of a resolution engine
• Literate programming (Knuth's WEB) — documentation, specification, and code as a single artefact

What is new is the combination: waveform numbers as primitive, entanglement as a type-level primitive, intent declarations as part of the function signature, verified by a neural compiler.

17. Open Problems

18. Glossary

Operators and Symbols