MIND

The MIND ecosystem

39 components in 9 layers, all built on one deterministic compiler. The language and compiler are fully open; specialized runtimes power enterprise scale.
Get startedRequest enterprise demo
Browse the source on GitHub
Ecosystem components on two orbits around a central governance ring.

  • 39componentson one compiler

  • 9layerslanguage to apps

  • 12public reposopen on GitHub

  • 1governance layeracross every layer

The stack

From language to applications

Pick any component to see what it does. Public repositories link to GitHub; private work is shown at product level and is not linked.

Status
Source

Showing all 39 components

  1. Layer 9Applications & showcases
    • 4Shipped
    • 2In progress

    Programs built in MIND that show what the language does on real workloads.

    • NikolaChess

      Shipped

      Chess engine written in MIND with GPU neural evaluation and endgame tablebases.

      Public repositorygithub.com/star-ga/NikolaChess

    • NNUE Inference Bench

      Shipped

      Benchmark for chess neural-network evaluation with a deterministic CPU reference and GPU kernels.

      Public repository, MITgithub.com/star-ga/nnue-inference-bench

    • MIND-Ray

      Shipped

      Path tracer written in MIND with an optional GPU backend and published benchmarks.

      Public repository, MITgithub.com/star-ga/mind-ray

    • Fractal Voyager

      Shipped

      Interactive fractal explorer in the browser, compiled from MIND to GPU compute shaders.

      Public repository, MITgithub.com/star-ga/fractal-voyager

    • MIND-Parser

      In progress

      Deterministic web parsing and search for SI agents, where every field cites the bytes it came from.

      Not linked (private repository)

    • Riemann Research

      In progress

      Deterministic, certificate-checked computational research toward the Riemann Hypothesis, written in MIND.

      Not linked (private repository)
  2. Layer 8Physical systems (MHS)
    • 2Shipped
    • 1Planned

    Governed action for robots and physical devices, where no consequential action runs without admission.

    • PR-25 Robot Commandments

      Shipped

      Public paper defining 25 requirement families for safe, admitted robot actuation, with a reference model.

      Public repositorygithub.com/star-ga/pr25

    • PR-25 reference model

      Shipped

      The PR-25 admission model written in MIND, compiled natively and checked against an independent reference.

      Not linked (private repository)

    • MIND-Physical

      Planned

      Program for governed physical-device action across MIND, including compatibility with external hardware standards.

      Not linked (private repository)
  3. Layer 7OS & orchestration
    • 5In progress

    The SI operating system and the tools that plan, run, and coordinate work across agents.

    • NAESTRO

      In progress

      Self-evolving metacognitive SI operating system that coordinates models, tools, memory and policy, with adversarial deliberation and audit.

      Not linked (private repository)

    • MIND-Flow

      In progress

      Typed graph language for SI pipelines, built to compile to native programs with traceable runs.

      Not linked, commercial (private repository)

    • MIND-Intent

      In progress

      Turns a goal and constraints into a checkable contract, and refuses plans that cannot meet it.

      Not linked (private repository)

    • NAESTRO CLI

      In progress

      Command-line front end that coordinates several coding assistants through multi-model consensus.

      Not linked (private repository)

    • NAESTRO Bot

      In progress

      Personal assistant daemon that brings NAESTRO to messaging channels.

      Not linked (private repository)
  4. Layer 6Inference & models
    • 3In progress
    • 1Planned

    Running models inside MIND with reproducible outputs and evidence for every result.

    • MIND-Inference

      In progress

      LLM inference pipeline in MIND with KV cache, batching, speculative decoding, and a governance gate.

      Not linked (private repository)

    • MindLLM

      In progress

      Local deterministic model server in MIND with a standard chat endpoint and per-token evidence.

      Not linked (private repository)

    • Resonance Field Network

      In progress

      Research model architecture with memory-native, fixed-point inference that is bit-identical across runs.

      Not linked (private repository)

    • MIND-Voice

      Planned

      Voice synthesis in MIND targeting many accelerators with identical output on every backend.

      Not linked (private repository)
  5. Layer 5Routing & skills
    • 2Shipped

    Choosing the right skill or tool for each request without loading the whole library.

    • MIND-Nerve

      Shipped

      Intent router that picks the right skill or tool for a request, so library size does not raise token cost.

      Public repository, Apache-2.0github.com/star-ga/mind-nerve

    • MIND-Skills

      Shipped

      Governed library of agent skills that mind-nerve routes requests to.

      Not linked (private repository)
  6. Layer 4Memory & knowledge
    • 2Shipped
    • 2In progress

    Persistent, auditable memory and deterministic retrieval for SI agents.

    • MIND-Mem

      Shipped

      Persistent memory for SI agents with hybrid search, contradiction detection, and an audit trail.

      Public repository, Apache-2.0github.com/star-ga/mind-mem

    • MIND-KG

      In progress

      Deterministic knowledge-graph engine in MIND with one shared schema across the ecosystem.

      Not linked (private repository)

    • MIND-Vec

      In progress

      Deterministic compressed vector search engine designed for one contract across CPU, GPU, and FPGA backends.

      Not linked (private repository)

    • ClinicalMem

      Shipped

      Auditable clinical memory for healthcare SI agents that flags conflicts such as drug interactions.

      Not linked (private repository)
  7. Layer 3Governance & verification
    • 5In progress

    Rules compiled into programs, checked deterministically, with proof of every decision.

    • MIND-Law

      In progress

      Deterministic governance engine implementing the 512 legitimacy constraint, with tamper-evident proofs of compliance.

      Not linked (private repository)

    • MIND-Agents

      In progress

      Control plane for autonomous agents where policy is compiled and every action leaves evidence.

      Not linked (private repository)

    • MIND-Predict

      In progress

      Specification and test vectors proving a prediction was committed before its outcome was known.

      Not linked (private repository)

    • VeriSI

      In progress

      Open measurement protocol for testing whether an SI system learns new skills, compared with human reference groups.

      Not linked (private repository)

    • BitNet Governance Study

      In progress

      Reference ternary-weight model forward pass in MIND with a harness measuring compile-time governance overhead.

      Public repositorygithub.com/star-ga/bitnet-mind-governance
  8. Layer 2Runtime & evidence
    • 2Shipped
    • 1In progress

    Execution beyond the open compiler, and the shared hashing and evidence formats every component builds on.

    • MIND-Runtime

      Shipped

      Commercial runtime adding GPU and accelerator backends, distributed training, and model serving for MIND programs.

      Not linked, commercial (private repository)

    • MIND-Evidence

      In progress

      One shared evidence format so every MIND component produces records the others can verify.

      Not linked (private repository)

    • Canonical Hashing

      Shipped

      Canonical JSON and SHA-256 hashing written in MIND, reproducible on any machine that runs it.

      Not linked (private repository)
  9. Layer 1Language & compiler
    • 6Shipped
    • 1In progress

    The MIND language, its deterministic compiler, the specification, and tools for reading and checking MIND code.

    • MIND compiler (mindc)

      Shipped

      Deterministic compiler and standard library; covered workloads give bit-identical results on x86_64 and ARM64.

      Public repository, Apache-2.0github.com/star-ga/mind

    • MIND-Spec

      Shipped

      The language specification, design documents, and RFCs that define MIND.

      Public repository, Apache-2.0github.com/star-ga/mind-spec

    • MIND-Grammar

      Shipped

      TextMate grammar that gives editors syntax highlighting for MIND source files.

      Public repositorygithub.com/star-ga/mind-grammar

    • MLIR Tools

      Shipped

      Prebuilt MLIR tools for five platforms, used by MIND compiler builds in CI.

      Public repositorygithub.com/star-ga/mlir-tools

    • MIND-CodeGraph

      Shipped

      Symbol index and call graph for MIND code, answering who calls what and what a change affects.

      Not linked (private repository)

    • Arch-MIND

      Shipped

      Architectural governance scanner that scores code structure and records each change in a tamper-evident log.

      Not linked, commercial (private repository)

    • MIND-Lab

      In progress

      Research control plane that proposes, applies, evaluates and keeps changes overnight, with a replayable audit of every run.

      Not linked (private repository)
The MIND ecosystem, read from the top: applications at the top, the language and compiler at the base. Each layer builds on the layers below it. Status follows each repository’s own releases and README, as of 6 October 2026.

Governance layer

MIND-Law governs the whole ecosystem

One governance layer spans every layer of the stack, from the compiler to physical systems. Each decision is authorized or refused with a code, and recorded as evidence.

Requests, every layer

  1. Applications & showcasesL9
  2. Physical systems (MHS)L8
  3. OS & orchestrationL7
  4. Inference & modelsL6
  5. Routing & skillsL5
  6. Memory & knowledgeL4
  7. Governance & verificationL3
  8. Runtime & evidenceL2
  9. Language & compilerL1

MIND-Law

The governance layer. One authority for every layer of the stack.

Authorized

runs

Refused (code)

never runs

Evidence, every decision

  1. rec 1
  2. rec 2
  3. rec 3
  4. rec 4
  5. rec 5
  6. rec 6
  7. rec 7

Each record links to the one before it, so the history is tamper-evident.

Every layer, one gate. Requests from the compiler up to physical systems pass MIND-Law before anything runs.

Editions

Open core, commercial edge

The language, the compiler and the core libraries are open source. Execution beyond the open compiler, pipeline authoring and architecture governance are commercial.

Open source

12 public repositories

Commercial edge

From STARGA, Inc.

MIND-Runtime

Production runtime for MIND programs beyond the open compiler.

  • GPU and accelerator backends, including CUDA
  • Distributed training and model serving
  • Compliance and audit toolkit

MIND-Flow

Graph authoring and compilation: compiled SI systems on top of the MIND stack.

  • Typed .flow.mind DSL that reuses the MIND type system
  • Seven node kinds: native compute, LLM, tool, branch, memory, verify, plus agent delegation
  • Deterministic trace, with MIND-Mem as the memory plane
  • Native compilation through mindc

Arch-MIND

v0.2.0

Deterministic architectural-governance scanner: nine Q16.16 fixed-point metric kernels over a typed dependency graph, with rules declared in .mind.

  • Five languages: Python, TypeScript, Go and Rust through tree-sitter, MIND through heuristic scoring
  • Session deltas chained with HMAC-SHA256 by default; public-key signing when a key is set up
  • Deterministic Python reference scorer; bit-identical reproducibility
Open the demo (static fixture)

Private repositories are shown at product level and are never linked. Enterprise overview

Open components

Open components in depth

These components power the MIND Cognitive Kernel, a deterministic SI runtime with Control, Memory, and Verification planes.

MIND compiler

mind · Apache-2.0

The CLI and type checker. The native backend is the default and self-hosts with a byte-identical bootstrap; MLIR → LLVM is optional for interchange and exotic targets. GPU and accelerator execution ships in the commercial MIND-Runtime.

  • Default native backend, self-hosting, no LLVM required
  • Optional MLIR → LLVM path for interchange and exotic targets
  • Bit-identical on x86/x64, ARM, GPU and any chip
  • Reference CPU interpreter for learning and prototyping
github.com/star-ga/mind

MIND-Spec

mind-spec · Apache-2.0

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

  • Formal language specification
  • RFC design documents
  • Community governance
github.com/star-ga/mind-spec

MIND-Mem

mind-mem · Apache-2.0

107MCP tools

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

  • Hybrid BM25 + vector retrieval, optional native scoring kernels
  • Drift detection and causal graph
  • Native MIC/MAP wire format
  • 107 registered MCP tools (release 5.0.3), zero core runtime deps
github.com/star-ga/mind-mem

MIND-Nerve

mind-nerve · Apache-2.0

0.58ms score step

CPU-side cognitive router: a Q16.16 inference loop that selects the right skill, tool, or agent for a prompt. Ships on PyPI and Hugging Face.

  • Score step: 0.58 ms mean / 0.97 ms p95 on a 12-thread x86_64 desktop CPU (mind-nerve docs/benchmarks.md)
  • Pipeline bit-identical on x86/x64, ARM, GPU and any chip
  • Per-prompt hook: 1,300+ skills, ~2k-token announce; acquire verb for vetted external skill and MCP installs
  • 20-CLI installer matrix + verify verb
github.com/star-ga/mind-nerve

Inside mindc

Inside the open compiler

Subsystems that live in the mind repository itself, each specified by its own RFC.

  • Standard library (std)

    std on GitHub

    Pure-MIND modules bundled inside mindc; use std.* resolves with zero external file dependency.

  • mind-blas

    RFC 0006

    Native dense-vector surface (dot, matmul, L1 / L∞ and Q16.16 variants) with no external BLAS dependency.

    9.3× vs scalar

  • Mindcraft

    RFC 0007

    Source-quality toolchain for .mind: deterministic formatting, lint diagnostics and static checks, as mindc fmt and mindc check.

    5 lint rules

  • mindc build · mindc test

    RFC 0008

    Build orchestrator and test runner: workspaces, path and git dependencies, mandatory Mind.lock, and an incremental cache.

    63× warm rebuild

  • Memory safety · C ABI

    RFC 0010

    Three-tier memory model (stack, region-interior, generation-checked GenRef<T>) and a first-class extern "C" calling-convention enum.

  • Async · structured concurrency

    RFC 0011

    Async through an explicit &Scheduler argument, with no async fn keyword infection. std/async.mind ships the schedulers as plain values.

Details from each RFC

Standard library (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), std.json (RFC 8259), std.regex (POSIX ERE NFA)
  • Crypto and protocol primitives verified against RFC / NIST known-answer tests, among them ML-KEM-768 (FIPS 203) and the TLS 1.3 key schedule, with a socket-driven TLS client and server
  • FFI scaffolds: std.mlir (libMLIR C API, 209 fns), std.llvm (libLLVM C API, 221 fns)
  • MIND_STDLIB_PATH override lets regulated deployments fork without rebuilding

mind-blasRFC 0006

  • Scalar, x86-SIMD and ARM-NEON sub-backends; CUDA ships in the commercial MIND-Runtime
  • Q16.16 path byte-identical scalar-vs-SIMD at all lengths
  • Track B: the compiler emits the MLIR vector dialect itself, no C shim
  • Powers the MIND-Nerve score path: 9.3× vs scalar

MindcraftRFC 0007

  • 5 lint rules, run inside mindc check: q16_overflow, unused_import, naming_convention, shadowing, trailing_whitespace
  • mindc fmt is byte-identical and idempotent for a fixed (source, version) pair
  • CI integration via .github/workflows/mindcraft.yml; LSP-compatible reporter

mindc build · mindc testRFC 0008

  • mindc test discovers #[test] functions and runs them in parallel
  • Incremental cache: 63× warm-rebuild speedup
  • Keystone: byte-identical self-host build, cargo no longer load-bearing for the pure-MIND compile loop

Memory safety · C ABIRFC 0010

  • extern "C" parser, SysV AMD64 struct passing, Win64 calling convention
  • std.mlir (209 fns) and std.llvm (221 fns) bindings
  • mindc internals on the memory model, with a pure-MIND libMLIR / libLLVM layer in place of the Rust one

Async · structured concurrencyRFC 0011

  • ReplayScheduler records and replays deterministic execution traces
  • Sender + Receiver algebra; tree-shaped task hierarchy where a parent waits for its children
  • Cooperative cancellation; Replay, SingleThread and WorkStealing schedulers are values, not globals
The MIND compiler as a hub, connected to NAESTRO, MIND-Nerve, MIND-Mem, MIND-Law and MIND-Runtime, with an open slot where your own build drops in.

Building on any of these?

Join the conversation in the MIND Discord: compiler internals, RFC discussions, and early-access channels.

Join the DiscordRead the architecture docs