MIND

Features

One toolchain for SI development. A tensor-native language, built-in differentiable programming and a deterministic compiler pipeline: shape errors stop at compile time.
Get startedView the roadmap
One compiler at the centre of tensor types, shape checks, gradients, deterministic output and native code.

source.mind

tensor-native, statically typed

typed AST

shape and dtype checks: errors stop here

MIND IR (SSA)

Core v1 operators

mic@3

canonical bytes; trace_hash = SHA-256 over them

--backend native (default)

native backend

pure MIND, no MLIR or LLVM in the loop

ELF · PE · Mach-O

every chip family; self-host fixed point

--backend mlir (optional)

MLIR → LLVM

interchange and exotic targets

host binary

through the LLVM toolchain

mindc 0.10.x, as built from the public repository.

Language & compiler

The language and compiler

A native environment for intelligent systems: typed tensors, compiler gradients, device checks and builds you can prove.

  • Determinism + evidence

    Same bits on every chip

    Bit-identical on x86/x64, ARM, GPU and any chip. Build with --emit-evidence and the artifact carries a tamper-evident chain hashed over its own IR.

    • Evidence anchored on the canonical mic@3 IR
    • PQC hybrid signature (ML-DSA-87 + SLH-DSA), opt-in
    • The compiler bootstraps itself byte for byte

    source.mind

    mindc

    one canonical IR

    • x86/x64

    • ARM

    • GPU

    • Any chip

    One SHA-256

  • Typed tensors
    • Shapes in the type
    • Checked at build
    • Inferred across calls
  • Two backends
    • Native by default
    • MLIR → LLVM optional
    • GPU, TPU, FPGA
  • Built-in autodiff
    • No runtime tape
    • First-class gradients
    • Optimized both ways
  • Device semantics
    • CPU, GPU, any chip
    • Bad ops fail at build
    • Multi-target builds
  • Open core
    • Apache 2.0 compiler
    • Private backends
    • C/C++ and Python FFI

Runtime

Cognitive Kernel

A deterministic SI runtime that extends compiler guarantees into execution. Three isolated planes talk over typed message channels: every decision logged, every output verified, every failure able to roll back.

  • Control plane

    State machine · constraint engine · saga coordinator

  • Memory plane

    Versioned memory · snapshots · context optimizer

  • Verification plane

    Verification layer · audit logger · replay engine

Verified

output ships

Refused

never acts

Failed

rolls back

Architecture docs·MIND-Runtime

Standard library

Crypto, TLS and HTTP in pure MIND

A primitive library written in MIND itself, checked against RFC and NIST known-answer tests.

  • Known-answer tests from the RFCs and NIST
  • Same bits on every chip, like every MIND program
Ciphers and hashes
AES-128-GCMSHA-256SHA-3/SHAKEHKDF
Keys and signatures
X25519RSA-PSSECDSA-P256ML-KEM-768X.509 parsing
Protocols
TLS 1.3 key schedule, record, handshakeHPACKHTTP/2 framingTLS client and server over sockets

Platform

From model to production

One workflow from data preparation through training to production, with the same tooling at every stage.

  1. 01
    Data pipelines
    • Streaming ingestion
    • Type-safe transforms
    • Parallel loading
  2. 02
    Training at scale
    • Automatic sharding
    • NCCL and Gloo sync
    • Model parallelism
  3. 03
    Model versioning
    • Git-like versions
    • Experiment tracking
    • Reproducible runs
  4. 04
    Deployment
    • Cloud, edge, on-prem
    • Auto-scaling
    • Canary releases
  5. 05
    Observability
    • Live metrics
    • Drift detection
    • OpenTelemetry
End to endUnified CLI and API · CI/CD integration · Infrastructure as code
A matrix multiply checked at compile time: tensors f32[3, 4] and f32[4, 2] share the inner dimension 4 and flow into mindc, which builds the f32[3, 2] result cell by cell; then the gradient flows back to both inputs.

Try the compiler.

Install a released mindc binary and compile your first tensor program.

Get startedRequest enterprise demo