Mapa de Crates

Dependencias y responsabilidades de los crates del workspace.

El workspace de Achronyme contiene 19 crates. Todos comparten la misma versión y edición de Rust. La organización por capas posterior a la limpieza (cerrada el 2026-04-24) los agrupa en cuatro niveles: hojas sin dependencias del workspace, crates de vocabulario, pila de IR/compilador, y orquestación de alto nivel.

Resumen de crates

Crate	Ruta	Propósito
`diagnostics`	`crates/diagnostics/`	Spans, errores, sugerencias, renderer estilo rustc (hoja sin dependencias)
`memory`	`crates/memory/`	`FieldElement<F>` (BN254/BLS12-381/Goldilocks), trait `FieldBackend`, arenas de heap, GC
`ach-macros`	`crates/ach-macros/`	Proc macros: `#[ach_native]`, `#[ach_module]`
`achronyme-parser`	`crates/achronyme-parser/`	Lexer, parser Pratt+descenso recursivo, tipos AST con propiedad
`resolve`	`crates/resolve/`	Tabla de símbolos, registro de builtins, resolver unificado de dispatch (Movimiento 2)
`lysis-types`	`crates/lysis-types/`	`InstructionKind<F>`, `NodeId` compartidos con la Lysis VM
`constraints`	`crates/constraints/`	`Variable`, `LinearCombination`, sistemas R1CS + Plonkish, Poseidon, exportación binaria
`ir-core`	`crates/ir-core/`	Hoja SSA: `Instruction<F>`, `SsaVar`, `Visibility`, `IrType`
`ir-forge`	`crates/ir-forge/`	Plantillas ProveIR, compilador AST→ProveIR, walker del lift de Lysis
`ir`	`crates/ir/`	Pases de IR (DCE, CSE, const-fold, taint), module loader, inspector, orquestación de ProveIR
`zkc`	`crates/zkc/`	Compilador de constraints: backend R1CS, backend Plonkish, witness ops, andamiaje del oracle
`akronc`	`crates/akronc/`	Compilador de bytecode para la Akron VM (antes `compiler`)
`akron`	`crates/akron/`	VM de bytecode de propósito general basada en registros (antes `vm`)
`artik`	`crates/artik/`	VM SSA de cómputo de testigos (antes `witness`) — ver Artik
`lysis`	`crates/lysis/`	Tercera VM, instanciador estructural de plantillas con hash-consing — en progreso
`circom`	`crates/circom/`	Frontend de Circom 2.x: lexer, parser, análisis, lowering — ver Frontend de Circom
`proving`	`crates/proving/`	Groth16 (arkworks), PlonK (halo2-KZG), generación de verificadores Solidity
`achronyme-std`	`crates/std/`	Biblioteca estándar vía el trait `NativeModule`
`cli`	`crates/cli/`	Interfaz de línea de comandos, orquestación de pruebas

Renombramientos de crates (post-limpieza)

La limpieza estructural del 2026-04-18 → 2026-04-24 renombró tres crates y dividió ir en tres:

Nombre antiguo	Nombre nuevo	Razón
`vm`	`akron`	Distinguir de la VM de testigos y de la Lysis VM en progreso
`witness`	`artik`	Coincidir con el magic de bytecode `ARTK` y la extensión `.artik`
`compiler`	`akronc`	Desambiguar del compilador de constraints `zkc`; “compilador de akron”
`ir`	`ir-core` + `ir` + `ir-forge`	Romper ciclos de dependencias; exponer primitivas SSA como crate hoja

Los nombres antiguos aparecen en el historial de git previo al 2026-04-18 y en algunos comentarios legacy de rutas de archivo — todos mapean mecánicamente a los nuevos nombres.

Niveles de dependencias

Nivel 0 — Fundación (sin dependencias del workspace)

diagnostics, memory, ach-macros, lysis-types. Hojas puras. En conjunto definen el vocabulario universal del workspace: spans, errores, elementos de campo, formas de tokens de opcodes y proc macros.

Nivel 1 — Vocabulario

achronyme-parser (depende de diagnostics) — AST de superficie.

resolve (depende de achronyme-parser, diagnostics) — tabla de símbolos, registro de builtins, ModuleGraph. Aloja SymbolId, CallableKind, Availability. Después de Movimiento 2, todo el dispatch (llamada a método, Type::MEMBER, llamada nativa) pasa por resolve en lugar de búsquedas ad-hoc en tablas.

constraints (depende de memory) — LinearCombination, ConstraintSystem, PlonkishSystem, parámetros de Poseidon, escritores binarios .r1cs/.wtns en formato iden3.

ir-core (depende de memory, diagnostics) — Instruction<F> SSA, SsaVar, Visibility, IrType. Crate hoja para que ir e ir-forge puedan depender ambos sin formar un ciclo.

Nivel 2 — IR y compilación de circuitos

ir-forge (depende de ir-core, achronyme-parser, resolve, diagnostics, lysis-types, circom para hooks de lowering)

Tipos de datos de ProveIR (ProveIR, CircuitExpr, CircuitNode, CaptureDef), compilador AST→ProveIR (ProveIrCompiler), walker del lift de Lysis. La única capa donde sucede el razonamiento simbólico de circuitos en tiempo de compilación. Ver ProveIR.

ir (depende de ir-core, ir-forge, resolve)

Orquestación de IR: pases (const_fold, cse, dce, bool_prop, taint, bound_inference), evaluador, module loader, constructor del grafo del inspector. Aloja el trait CircomLibraryHandle.

zkc (depende de ir-core, constraints, memory)

El compilador de constraints. Backend R1CS (compile_to_r1cs), backend Plonkish, operaciones de testigos (WitnessOp), andamiaje del oracle para el gate de la Fase 3.C de Lysis.

circom (depende de achronyme-parser, diagnostics, ir-forge, resolve)

Frontend completo de Circom 2.x. Hace lift de cuerpos de funciones no inlinables a Artik vía lowering::artik_lift.

Nivel 3 — Bytecode + VMs

akronc (depende de achronyme-parser, resolve, diagnostics)

Compilador de bytecode para la Akron VM. Aloja el optimizador de bytecode (peephole, const-fold, eliminación de stores muertos).

akron (depende de memory, constraints, ir, ir-forge)

VM de propósito general basada en registros. 43 opcodes, GC tri-color de marcado y barrido, valores etiquetados (tagged values) de 64 bits. Carga archivos .achb vía akron::loader. Aloja la ejecución de prove {} en runtime vía el trait ProveHandler.

artik (depende de memory)

VM dedicada al cómputo de testigos. ~25 opcodes, registros estilo SSA, sin heap, sin GC. Carga blobs .artik embebidos en WitnessOp::ArtikCall.

lysis (depende de memory, artik, lysis-types)

Tercera VM — en progreso. Instanciador estructural de plantillas con interner de hash-consing. Ver Lysis VM. El walker vive en ir-forge::lysis_lift; el andamiaje del oracle en zkc::lysis_oracle.

Nivel 4 — Orquestación de alto nivel

proving (depende de constraints, memory)

Groth16 in-process (ark-groth16 + ark-bn254) y PlonK (halo2 KZG, fork de PSE). Genera verificadores Solidity para verificación on-chain de Groth16.

achronyme-std (depende de akron, memory, ach-macros)

Nativos de la biblioteca estándar vía el trait NativeModule. 16 nativos, registrados a través de proc macros #[ach_native].

cli (depende de akron, akronc, ir, ir-forge, zkc, circom, proving, resolve, achronyme-std)

Binario de cara al usuario. Despacha ach run, ach circuit, ach circom, ach prove, ach inspect, ach init. Aloja las implementaciones DefaultCircomWitnessHandler y ProveHandler inyectadas en Akron.

Grafo de dependencias

diagnostics ─── lysis-types ─── ach-macros        (Tier 0 leaves)
    │                                  │
    ├── achronyme-parser               │
    │       │                          │
    │       └── resolve                │
    │              │                   │
    ├── memory ────┼── constraints     │
    │              │       │           │
    │              ├── ir-core         │
    │              │       │           │
    │              ├── ir-forge ◀──────┴── (uses lysis-types)
    │              │       │
    │              ├── ir ─┘
    │              │
    │              ├── zkc
    │              │
    │              ├── circom
    │              │
    │              ├── akronc
    │              │
    │              ├── akron
    │              │       │
    │              ├── artik
    │              │       │
    │              └── lysis ◀───── (uses artik, lysis-types)
    │
    ├── proving
    ├── achronyme-std
    └── cli ◀── (uses everything)

Puntos de entrada clave

Tarea	Crate	Función
Parsear fuente `.ach`	`achronyme-parser`	`parse_program(source)`
Parsear fuente `.circom`	`circom`	`circom::parser::parse_circom(source)`
Compilar bytecode	`akronc`	`Compiler::compile(&program)`
Compilar bloque prove	`ir-forge`	`ProveIrCompiler::compile_prove_block(...)`
Compilar plantilla circom	`circom`	`compile_to_prove_ir(source)`
Instanciar ProveIR	`ir`	`ProveIR::instantiate(captures, ...)`
Lower de AST a IR (circuito)	`ir`	`IrLowering::lower_circuit(source, pub, wit)`
Optimizar IR	`ir`	`passes::optimize(&mut program)`
Compilar a R1CS	`zkc`	`compile_to_r1cs(program)`
Compilar a Plonkish	`zkc`	`PlonkishCompiler::compile_ir(program)`
Generar testigo	`zkc`	`compile_to_r1cs_with_witness(program, inputs)`
Ejecutar Akron VM	`akron`	`Vm::run(function)`
Ejecutar Artik	`artik`	`artik::execute_with_budget(program, ctx, budget)`
Ejecutar Lysis (en progreso)	`lysis`	`lysis::execute(program, sink)`
Hacer lift de función Circom a Artik	`circom`	`lowering::artik_lift::lift(...)`
Hacer lift de ProveIR a Lysis	`ir-forge`	`lysis_lift::Walker::lift(...)`
Generar prueba Groth16	`proving`	`proving::groth16::prove(cs, witness, pk)`
Generar prueba PlonK	`proving`	`proving::halo2_proof::prove(cs, witness, pk)`
Verificador Solidity	`proving`	`proving::solidity::generate(...)`
Ejecutar CLI	`cli`	`main()` → dispatch de comandos

Referencias cruzadas

Para el pipeline completo, ver Visión General del Pipeline.
Para detalles de SSA + optimización, ver IR y Optimización.
Para los backends de constraints, ver Backends.
Para internals de las VMs, ver Akron VM, Artik VM, Lysis VM.
Para ProveIR y plantillas, ver ProveIR.
Para diagnósticos, ver Diagnósticos.
Para internals de Circom, ver Frontend de Circom.