BRAIDGROUPEnterprise Licensing
Developer Documentation

Braid Language Specification

Braid is a statically typed, natively compiled language specifically designed to interface directly with Distinction Tree Storage (DTS) and execute deterministic mathematical proofs. It combines the syntax of Python, the speed and safety of Rust/C, and introduces novel features like Diameter Logic.

Core Syntax & Types

Braid supports standard variable declarations, native struct/method bindings, and strongly-typed functional definitions. Notably, standard conditional statements (true/false) map strictly to integers (1/0) at the VM level to enforce mathematical rigor.

// Example Structure & Method Binding
struct Tensor {
    data: float
}

impl Tensor {
    fn add(self, other: Tensor) -> Tensor {
        let result = self.data + other.data;
        return result;
    }
}

let a = 1;
while (a < 5) {
    // Loop constructs do not natively support boolean casting
    a = a + 1;
}

Dialectical Synthesis: Diameter Logic

Braid replaces probabilistic latency networks with Diameter Logic. Developers define a diameter block containing opposing truth poles. The VM mathematically cross-evaluates these constraints until it can synthesize an absolute truth.

diameter logic_gate: {
    pole a: { return "thesis"; }
    pole b: { return "antithesis"; }
}

fn synthesize() {
    let observation = logic_gate.observe();

    // Mathematically synthesizes the poles dynamically
    let absolute_truth = logic_gate.evolve();
    io.println(absolute_truth);
}

The std.dts Subsystem

The Braid engine communicates directly with the Distinction Tree Storage mapped in memory. This is exposed via the std.dts native package, allowing scripts to securely construct massive context hierarchies spanning billions of nodes in $O(1)$ time.

import std.dts;

let global_knowledge = dts.load("path/to/dts_core.bx");

// Deep Reasoning (System 2) Interaction
let sequence = "How";
let prediction = dts.predict(global_knowledge, sequence);

if (prediction != 0) {
    io.print("Synthesis Output: " + prediction);
}

Dynamic Self-Modification (Phase 5)

The highest tier of the Braid VM grants the engine the ability to rewrite its own source logic at runtime via the std.compiler module. It lexes, parses, and recompiles Braid logic as a closure pushed instantly to the running memory stack.

import std.compiler;

let logic_string = "fn rewrite() { return 1337; } rewrite();";
let result = compiler.eval(logic_string); // Immediately compiles & executes