Built with Mutant

Showcase

Every entry here is a document that ships worked material — a diagram, a runnable fence, or both. The list is derived from the corpus, so it tracks the docs rather than a hand-kept feature list.

type Compiler struct {
    constants         []object.Object        // Accumulates the constant pool
    symbolTable       *SymbolTable            // Current scope's symbol table
    scopes            []CompilationScope      // Stack of compilation scopes
    scopeIndex        int                     // Index into scopes[]
    structDefinitions map[string][]*ast.Identifier
    enumDefinitions   map[string][]string
    loopContexts      []LoopContext           // Stack of active for-loop contexts

    injectSecurityChecks bool                 // Enables OpChkDbg/OpChkSnd injection
    hasChkDbg            bool                 // Tracks whether DbgCheck was emitted
    hasChkSnd            bool                 // Tracks whether SndCheck was emitted

    polymorphicEngine *PolymorphicEngine      // nil = no mutation

Runtime

Mutant IR / ByteCode Reference

Mutant compiles to a flat, linear byte stream. There is no intermediate representation between the AST and the bytecode – the compiler walks the AST and emits bytes directly.

vmbytecodeir docs/BYTECODE_IR.md

Read it Source ↗

Diagrams Security Architecture Diagrams (Code-Synced) Visual reference for how Mutant's runtime security pipeline, policy decisions, and probe gates fit together, kept in sync with current code behavior. Security Diagrams + code Process Injection Detection LLD This Low Level Design (LLD) explains how Mutant currently detects process injection-related tampering and how to expand this into a richer, multi-process detector in the future. Security Runnable code Mutant Language Reference This document is the practical reference for Mutant language features, reserved keywords, and builtins. Reference

Mini-projects

Diagrams Security Low-Level Design (LLD) This document defines the low-level security design for Mutant's bytecode generation, signing, transport, loading, verification, runtime execution, anti-debugging, integrity… docs/SECURITY_LLD.md ↗ Diagrams Mutant LSP + VS Code Extension Low-Level Design (LLD) This is the implementation-level developer guide for the Mutant language tooling stack. docs/LSP_EXTENSION_LLD.md ↗ Runnable code Graph Database The db builtins embed a property graph database in the mutant runtime for modeling entities and the relationships between them: people and documents in a knowledge graph, or… docs/GRAPH_DATABASE.md ↗ Runnable code Security Runbook This runbook explains how to triage and respond to Mutant runtime security events using current code behavior. docs/SECURITY_RUNBOOK.md ↗ Runnable code Mutant WASM REPL Definitive Guide The WASM REPL runs the same compiler and virtual machine the CLI runs, over a capability-restricted builtin set, and keeps one persistent session. docs/WASM_REPL_REFERENCE.md ↗ Diagrams + code Mutant LSP + VS Code Extension Onboarding in 60 Minutes This guide is a practical first-hour path for a junior engineer to understand, run, debug, and safely modify Mutant language tooling. docs/LSP_EXTENSION_ONBOARDING_60_MIN.md ↗ Runnable code Runtime Integration: Embedding Lua Mutant can embed and run Lua scripts from a string, a file, or a remote HTTP endpoint. docs/RUNTIME_INTEGRATION.md ↗ Diagrams Security LLD Traceability Matrix This document provides end-to-end traceability from security design intent to concrete implementation and validation. docs/SECURITY_LLD_TRACEABILITY.md ↗ Runnable code Structured Data: JSON, Encoding, Compression & Conversion Every fallible builtin here follows the language convention of returning (result, err); destructure with let value, err = ... and check err before touching value. docs/STRUCTURED_DATA.md ↗

Everything here is in the repo

The examples are authored alongside the language. Clone it, run the corpus, and adapt the pieces you need.

Browse repo ↗