Machine Intelligence Native Design

Intelligence, compiled.

MIND is a full systems programming language for the SI (Super Intelligence) era: one ecosystem from intent to binary, where language, compiler, runtime, memory and governance are built to work as one.

Deterministic computation with evidence you can verify. Verified workloads produce bit-identical results on x86/x64, ARM, GPU and any chip, and every artifact carries a tamper-evident record of exactly what was compiled.

Get started Request enterprise demo

Browse the source on GitHub

fn main() {
    // Dense tensor literal: Phase 11 Tier 1 (v0.10.0)
    let t: tensor<f32[3]> = [1.0, 2.0, 3.0];
    // Elementwise ops work in-function
    let y = t .* 2.0;
    print(y);
}

From intent to binary

One pipeline, every step on the record

1
Intent
MIND-Intent
Every kind of intent becomes one explicit semantic contract.
- Human intent
  Natural language
  Goals
  Constraints
- SI agent
  Plans
  Tool use
  Generated code
- MIND source
  MIND syntax
  DSLs
- Existing code
  Rust
  C/C++
  Python
  TypeScript
- Models
  ML graphs
  Tensor programs
  Data pipelines
- Math & spec
  Formal models
  Proofs
  Requirements
Import · Migrate · Normalize
Language adapters → typed semantic contracts
Supported semantics are preserved; unsupported constructs are rejected explicitly.
2
Propose
SI models · humans · superoptimizer
Candidate implementations are written against the contract.
- SI models
  plans
  generated code
- Humans
  authored MIND source
- Superoptimizer
  searched kernels
- RFN-MIND
  our model architecture
  fixed-point inference
producesMIND sourceIRkernelsnativedevice plan
3
Establish
mindc front end
Parse, type and shape-check, prove what it can, and emit canonical mic@3 IR.
1. 1Normalize
2. 2Type & shape-check
3. 3Prove or check
4. 4Canonical mic@3 IR
- Established
  Authorize
- Rejected
  ↺ revise
- Unresolved
  ↺ revise
4
Authorize
MIND-Law
Invariants, governance and policy decide what is allowed to run.
- Invariants
  typed at compile time
- Governance
  MIND-Law decisions
- Policy
  who may run what
- Authorized
  Lower
- Refused (code)
  terminate · no execution
5
Lower
mindc native backend
Native code generation by default, with MLIR → LLVM as an option, onto every chip family.
- CPU
  x86-64 · AVX-512 · AMX
  ARM64 · NEON · SVE2 · SME2
  RISC-V · RVV 1.0
  POWER · IBM Z · LoongArch
- GPU
  CUDA
  ROCm
  Metal
  WebGPU · WebNN
- TPU · NPU
  Cloud systolic (TPU-class)
  Inference NPU
  Edge NPU
- FPGA · ASIC
  FPGA DSP lowering
  Custom ASIC
  In-memory compute
- Dataflow
  LPU (statically scheduled)
  Wafer-scale (WSE)
  DPU · IPU · RDU
- DSP · MCU
  Cortex-M class
  RISC-V MCU
  Minimal runtime
- Quantum
  Hybrid classical / quantum
  OpenQASM · QIR
- Neuromorphic · physical
  Spiking (Loihi-class)
  Analog · photonic
default path
Native
pure-MIND codegen
optional path
MLIR → LLVM
interchange · exotic targets
- ELF
  Linux
- PE
  Windows
- Mach-O
  macOS
- Wasm
  browser
- ONNX
  serving
Deterministic where physics permits: quantum and physical substrates run under an explicit statistical contract.
6
Artifact + evidence
mic@3
A bit-identical binary that carries its own record of exactly what was compiled.
- Bit-identical binary
  same bytes on every chip
- trace_hash
  SHA-256 of canonical IR
- Determinism · fp_mode
  re-derived at verify
- PQC signature
  opt-in
  ML-DSA-87 + SLH-DSA
trace_hash9a8d084b1cc8eae6513d63e3cb00053adde16b10e727932c008d5454d14c1c85
✓ trace_hash_valid✓ ssa_valid✓ ml-dsa-87 + slh-dsa-256s

SI proposes. MIND establishes. MIND-Law authorizes. Hardware executes. Evidence records.

Around the pipeline

One ecosystem from intent to binary: cognition, governance, memory, routing, orchestration, runtime, research and physical systems. Full ecosystem map

Governance built in

MIND-Law governs the whole ecosystem

Built on the 512 legitimacy constraint, MIND-Law is compiled into every layer, not bolted on. Each decision is authorized or refused with a code, and recorded as evidence.

MIND-Law

One authority across every layer

Compilermindc
Only authorized programs lower and run
MemoryMIND-Mem
Writes are proposed, reviewed and applied
RoutingMIND-Nerve
Only permitted skills and tools are routed
AgentsMIND-Agents · NAESTRO
Every agent action passes policy first
RuntimeMIND-Runtime · Cognitive Kernel
The verification plane gates execution
PhysicalMIND-Physical
Device actions run under a physical contract

Authorized

runs

Refused (code)

never runs

Evidence

every decision

Why MIND

The problems we solve

SI systems today are fragmented, fail at runtime and cannot prove what they ran. MIND closes all three gaps in one language.

Problem
Runtime shape bugs
Tensor shape and dtype errors surface in production.
MIND
Statically checked tensors
Shapes, dtypes and devices live in the type system, so whole classes of bugs stop at compile time.
Problem
Fragmented toolchains
Python to prototype, C++ to ship, glue code in between.
MIND
One language, intent to binary
Tensor types, shape checks, autodiff and native code generation for every chip family in one toolchain.
Problem
Irreproducible results
Runs can't be reproduced or audited for compliance.
MIND
Bit-identical, with evidence
The same bits on x86/x64, ARM, GPU and any chip, with a tamper-evident record in every artifact.

How it works

One front end, one canonical IR, every chip

MIND lowers to native code for every chip family directly, with MLIR → LLVM available as an optional path for interchange and exotic targets.

Language & type system

Shape-aware tensors
Shape and dtype are part of the type
Compiler gradients
Autodiff at compile time, no runtime tape
Device annotations
CPU · GPU · any chip family

Compiler & runtime

Native backend, self-hosting
Byte-identical bootstrap, no LLVM
MLIR → LLVM, optional
Interchange and exotic targets
Lean runtime
AOT · JIT · embedded

Performance

Fast to build, exact to run

Microsecond front end, nanosecond canonical IR and kernels that beat hand-written code: speed without giving up reproducibility.

2,693,000×faster front end than Mojo's full build on a 512×1024 · 1024×512 matmul5.1 µs vs 13.8 s. Scope: MIND parse, type-check and lower vs mojo build

Detailed benchmarks·Compare frameworks

Who it's for

Built for teams that must be sure

SI labs & agent builders
Governed agents, memory and routing on a deterministic substrate.
Regulated industries
Healthcare, finance and autonomy, where provenance is not optional.
Platform teams
One language from research to production, no glue code.
Edge & embedded
Lean deterministic binaries for constrained hardware.

Editions

Open core + enterprise

Community

Apache 2.0

The open core: build on it today.

MIND language and compiler
Native backend, self-hosting
Standard library and spec
Evidence chain and mindc verify
MIND-Mem and MIND-Nerve

github.com/star-ga/mind

Enterprise

Commercial

Everything in Community, plus:

MIND-Runtime: GPU, distributed, serving
MIND-Law governance across the stack
Hosted control plane
Audit logs and compliance tooling
SLA-backed support

Enterprise overview

Start with the compiler.

Install a released mindc binary and compile your first program.

Get started Request enterprise demo

Intelligence, compiled.

One pipeline, every step on the record

Intent

Propose

Establish

Authorize

Lower

Artifact + evidence

MIND-Law governs the whole ecosystem

The problems we solve

Runtime shape bugs

Statically checked tensors

Fragmented toolchains

One language, intent to binary

Irreproducible results

Bit-identical, with evidence

One front end, one canonical IR, every chip

Fast to build, exact to run

Built for teams that must be sure

SI labs & agent builders

Regulated industries

Platform teams

Edge & embedded

Open core + enterprise

Community

Enterprise

Start with the compiler.