The Ecosystem

The MIND compiler. Includes the CLI, type checker, and native-ELF backend (the normative self-host path — deterministic by construction). MLIR is the downstream-interchange and exotic-chip-reach backend via a pluggable backend trait. A reference CPU interpreter ships for learning and prototyping workloads. Production-grade GPU/accelerator backends ship in the commercial mind-runtime.

• Built-in CLI & Type Checker
• MIR/MLIR Optimization Pipeline
• Reference CPU Interpreter

The authoritative language specification, design documents, and RFCs. Changes to the language start here.

• Formal Language Specification
• RFC Design Documents
• Community Governance

Persistent, auditable memory for AI agents. Powers the Cognitive Kernel’s Memory Plane with versioned storage, contradiction detection, and cryptographic audit chains.

• Hybrid BM25 + Vector Retrieval
• MIND Scoring Kernels
• Cryptographic Audit Chain
• Drift Detection & Causal Graph
• Native MIC/MAP Wire Format
• 83 MCP Tools, Zero Runtime Deps

CPU-side cognitive router: Q16.16 inference loop that selects the right MIND backend for a given prompt. Drop-the-decoder sliding-window encoder, p95 ≤ 30 ms on a 4-core CPU, cross-arch bit-identity. Ships on PyPI and Hugging Face.

• 4 latency tiers, p95 ≤ 23 ms (daemon)
• Q16.16 cross-arch bit-identity gate
• 17-CLI installer matrix + MCP façade
• Rebuilt against every mindc release

The pure-MIND standard surface. Four collection / I/O modules written in MIND itself, on top of seven host-supplied __mind_* intrinsics. Bundled into mindc since 0.4.2 — use std.vec resolves with zero external file dependency. MIND_STDLIB_PATHenv-var override (v0.4.3, Phase D₁) lets regulated deployments fork without rebuilding; Named-struct parameter names preserved in error diagnostics (v0.4.4, Phase D₂a).

• 7 intrinsics, 4 modules, 33 pub fns
• Last-write-wins `use` shadowing
• Per-arg signature matching (Phase B)
• MIND_STDLIB_PATHfork-without-recompile (Phase D₁)
• Module-level feature gate — default build byte-identical

The native dense-vector surface any MIND program calls without an external BLAS dependency: dot, matmul, plus L1 / L∞ and Q16.16 variants. One surface targets multiple sub-backends — scalar / x86-SIMD / ARM-NEON ship today, with CUDA on the commercial roadmap and a photonic-projected Q16.16 path at research stage — so the cross-arch determinism story holds end-to-end with no if cpu == … branches in user code. Track A ships the AVX2-accelerated intrinsics; the Q16.16 path is byte-identical scalar-vs-SIMD (integer reduction is associative), preserving the cross-arch bit-identity gate. Track B increment 1 (mindc v0.6.3) is the thesis-pure path: the compiler itself emits the MLIR vector dialect — new IR VecLoad/VecFma/VecReduceAdd → vector.load/vector.fma/vector.reduction, giving dot_f32 a fused 8-lane SIMD loop with no C shim, clang, or -fPIC. Within 1e-4 of an f64 oracle to 1M elements; bootstrap fixed-point byte-identical. Increment 2 (Q16.16 vector + bit-identity gate, VecStore, L1/L∞/matmul) is the sequenced follow-on.

• 6 intrinsics, AVX2 fast path + scalar fallback
• Q16.16 byte-identical scalar-vs-SIMD (all lengths)
• Powers the mind-nerve score path — 9.3× vs scalar
• Track B-1: pure-mindc vector dialect, no C shim
• Module-gated — unpromoted constructs fail loud under default build (v0.7.1)

The first-party source-quality toolchain: deterministic formatting, lint diagnostics, and static checks for .mind source, shipped in mindc v0.6.8 as mindc fmt / mindc lint / mindc check. Its front-end is the compiler’s own self-hosted pure-MIND front-end — the same lexer, parser, AST and type-checker proven byte-identical at the bootstrap fixed-point. Each lint rule is itself a .mind file. The credibility ladder: the language front-end self-hosts, and the toolchain is built on that same self-hosted front-end (full-chain Rust independence is roadmap).

• mindc fmt, mindc lint, mindc check all live
• 5 lint rules: q16_overflow, unused_import, naming_convention, shadowing, trailing_whitespace
• CI integration via .github/workflows/mindcraft.yml
• LSP-compatible reporter for editor integration
• mindc fmtbyte-identical & idempotent; deterministic diagnostics

Cargo-retirement track, all seven phases shipped. mindc build is the build orchestrator (--target, --emit, --release, --out, --no-cache); mindc test discovers #[test]-annotated functions and runs them in parallel. Workspace support, path + git dependencies, Mind.lock mandatory enforcement, and an incremental cache (63× warm-rebuild speedup) all live. Phase G (KEYSTONE) verifies that mindc buildproduces the libmindc_mind.so byte-identical to the v0.6.1 fixed-point oracle — cargo is no longer load-bearing for the pure-MIND compile loop.

• Phase A: mindc build single-crate orchestrator
• Phase B: mindc test discovery + parallel runner
• Phase C: workspace, topo sort, cycle detection
• Phase D–E: path + git deps, Mind.lock mandatory
• Phase F: incremental cache (63× warm rebuild)
• Phase G (KEYSTONE): byte-identical self-host, cargo retired

Three-tier memory model: stack, region-interior (unrestricted aliasing inside region { } blocks), and generation-checked region-exterior (GenRef<T> with deref returning Option<&T>). extern "C" gets a first-class callconv tagged enum (.c / .sysv / .win64 / .aapcs) and per-symbol safety attribution. Phase A (extern "C" parser), Phase B (SysV struct passing), and Phase C (Win64 calling convention) are shipped. std.mlir (673 LOC, 209 fns) and std.llvm (669 LOC, 221 fns) scaffold the Phase E+F libMLIR/libLLVM C API bindings. Phases G/H (migrate mindc internals) + Phase I keystone (drop mlir-sys + inkwell = full Rust independence) remain.

• Phase A: extern "C" parser + callconv tagged enum
• Phase B: SysV AMD64 struct passing
• Phase C: Win64 calling convention
• Phase E+F scaffolded: std.mlir (209 fns) + std.llvm (221 fns)
• Phase I: pure-MIND libMLIR/libLLVM replaces Rust layer

The growing pure-MIND standard library: modules across containers, I/O, data formats, crypto & protocol primitives, FFI scaffolds, and hardware acceleration. Every module is written in MIND, ships bundled inside mindc, and resolves with zero external file dependency via use std.*.

• Containers: std.vec, std.string, std.map
• I/O: std.io, std.fs, std.net, std.process
• Data formats: std.toml (TOML 1.0, 1237 LOC), std.json (RFC 8259, 1127 LOC), std.regex (POSIX ERE NFA, 1042 LOC)
• Crypto & protocol primitives:AES-128-GCM, SHA-256, HKDF, X25519, X.509 parse+verify, SHA-3/SHAKE, RSA-PSS, ECDSA-P256, ML-KEM-768 (FIPS 203), TLS 1.3 key schedule/record/handshake, HPACK, HTTP/2 framing — RFC/NIST-KAT-verified primitive library (a socket-driven TLS client/server is roadmap)
• FFI scaffolds: std.mlir (libMLIR C API, 209 fns), std.llvm (libLLVM C API, 221 fns)
• Acceleration: std.blas (Track A + B Q16.16 SIMD path)

Scheduler injection model: async execution is explicit via a &Scheduler argument — no async fn keyword infection. Sender + Receiver algebra gives composable async values. Tasks form a tree-shaped hierarchy (parent waits for all children). ReplaySchedulerrecords and replays deterministic execution traces, making it the governance-substrate use case for auditable AI pipelines. Cooperative cancellation only — forced cancellation is explicit unsafe. Multiple schedulers coexist in the same program: Replay, SingleThread, and WorkStealing are each a value, not a global.

• Scheduler injection — explicit &Scheduler argument
• Sender + Receiver algebra for composable async values
• Tree-shaped task hierarchy, parent waits for children
• ReplayScheduler for deterministic governance traces
• Replay / SingleThread / WorkStealing coexist as values

Deterministic architectural-governance scanner. Nine Q16.16 fixed-point metric kernels over a typed dependency graph — bit-identical across machines, cryptographically chained session deltas, rules expressed as MIND compile-time invariants.

• 9 Q16.16 Metric Kernels
• 5 Languages via tree-sitter + MIND reflection
• HMAC-SHA256 / Ed25519 Evidence Chain
• Bit-Identical Reproducibility

Production runtime with GPU acceleration, distributed training, compliance tooling, streaming execution, and safety-critical mode.

• CUDA GPU & Distributed Training
• Compliance & Audit Toolkit
• BCI / Safety-Critical Runtime
• Enterprise Support & SLAs

Graph authoring and compilation — compiled AI systems on top of the MIND stack.

• Typed .flow.mindDSL — reuses the MIND type system
• Compiles to native ELF via mindc (native-ELF backend); MLIR interchange path for specialty targets
• Seven node kinds: native compute, LLM, tool, branch, memory, verify, plus agent delegation
• Deterministic trace; mind-mem as the memory plane