Ir al contenido
Molto

Los comandos

Cada subcomando, sus opciones, el código de salida que devuelve y qué imprime en una terminal o en una tubería — igual en Linux, Windows y macOS.

Todos los comandos encuentran tu proyecto subiendo desde el directorio actual, así que funcionan desde cualquier subdirectorio. Se comportan igual en Linux, Windows y macOS: un binario por plataforma, las mismas opciones, los mismos códigos de salida, la misma salida.

Comando Opciones
molto new <nombre> --lib (por defecto), --bin
molto init --lib (por defecto), --bin
molto build -p/--profile, -t/--target, --refresh-toolchain, -j/--jobs
molto run [-- args] -p/--profile, --refresh-toolchain, -j/--jobs
molto test [-- args] -p/--profile, --refresh-toolchain, -j/--jobs
molto clean -a/--all
molto fmt -c/--check, -d/--diff, --refresh-tools, --refresh-analysis, -j
molto lint -p/--profile, -f/--format, --refresh-toolchain, --refresh-tools, --refresh-analysis, -j
molto add <dep>[@<versión>] · git+<url>[#<ref>] -d/--dev, --git, --path, --archive, --registry
molto remove <dep> —
molto metadata -o/--output, --include-dev
molto ir -o/--output, -p/--profile
molto login -r/--registry, -e/--email, -t/--token
molto publish --recipe, -f/--file, -p/--pack, --dry-run
molto plugin <list|info|install|remove> [nombre] -r/--registry, -y/--yes

molto bench, molto migrate y molto update existen en la CLI y salen con 5: el comando se reconoce, el comportamiento no está implementado. update se queda así a propósito — molto add <nombre> es la actualización, igual que lo es npm install.

El parser acepta --opt valor, --opt=valor, -o valor y flags booleanos. Todo lo que va tras -- se reenvía al programa bajo molto run, y a los ejecutables de test bajo molto test. --help y --version vienen de serie.

Empezar un proyecto

molto new my_lib          # una librería estática, probada con moltest (por defecto)
molto new my_app --bin    # un programa con src/main.c
molto init                # cualquiera de los dos, en el directorio donde ya estás

--lib escribe include/<nombre>.h, src/<nombre>.c, un test en tests/ y un manifiesto con artifact = "static", [test] mode = "single" y moltest en [dev-deps], fijado a su release más reciente, que se le pregunta al repositorio (sin red, la más reciente que Molto conoce). --bin escribe src/main.c y el manifiesto. Ninguno de los dos sobrescribe un archivo que ya exista, y ninguno inicializa git.

Construir y ejecutar

molto build                     # en build/debug/
molto build -p release          # en build/release/
molto build --target <triple>   # para otra plataforma, en build/<triple>/debug/
molto run -- --flag valor       # construye, ejecuta y reenvía todo lo que va tras --
molto test                      # construye y ejecuta los tests
molto test --profile coverage   # lo mismo, instrumentado para cobertura

Perfiles: debug (por defecto), release, bench, custom y coverage. En el manifiesto está qué fija cada uno.

molto run propaga literalmente el código de salida del programa; en Linux y macOS reporta 128 + N cuando muere por la señal N. Es el único comando cuyo código de salida no es de Molto. En una librería (artifact = "static" o "shared") se niega antes de compilar nada: no hay nada que ejecutar, y lo que la ejercita es molto test.

-j <n> limita el pool de workers; si no está, usa todos los núcleos. Se rechaza salvo que sea un número entre 1 y 1024, y nunca se registra ni entra en la huella: dos builds que sólo se diferencien en -j producen los mismos objetos.

Estructura de salida

Ruta Contenido
build/<perfil>/<paquete> El ejecutable (<paquete>.exe en Windows)
build/<perfil>/lib<paquete>.a Una librería estática
build/<perfil>/lib<paquete>.so.X.Y.Z Una librería compartida en Linux; lib<paquete>.X.Y.Z.dylib en macOS
build/<perfil>/obj/src/**/*.c.o Objetos intermedios
build/<perfil>/tests/<nombre> Un ejecutable de test por archivo (per_file)
build/<perfil>/tests/<paquete>_tests El ejecutable único de tests (single)
build/<triple>/<perfil>/… La misma estructura, para un build con --target
.bin/wsdb Estado incremental y la respuesta cacheada de la toolchain
compile_commands.json La base de datos de compilación, en la raíz del proyecto
Molto.lock El grafo de dependencias resuelto

build/ y .bin/ son de Molto y están en el gitignore. Molto.lock se genera y se commitea. molto clean borra build/; molto clean --all borra además .bin/. Ninguno toca la caché compartida que se describe más abajo.

compile_commands.json lo escribe un build, y manda el último: molto build cubre src/ más las dependencias, molto test cubre eso y tests/, y -p release deja una base de datos que describe release. fmt y lint no escriben ninguna. Se escribe incluso cuando el build falla.

Tests

molto test                      # todos los tests, en el modo que diga el manifiesto
molto test -- -k parser         # lo que va tras -- llega a los ejecutables de test
molto test --profile coverage   # instrumentado; moltest_coverage imprime el informe
molto test --profile custom     # p. ej. sanitizers, desde [profile.custom].flags

Por defecto (per_file) cada archivo de tests/ es un ejecutable propio, enlazado contra los objetos del proyecto menos src/main.c. Con un framework que es dueño de main(), como moltest, mode = "single" lo enlaza todo en uno. Un archivo de [[test.isolated]] se enlaza solo, sin las fuentes que replaces, para que un fake ocupe su lugar. Cada ejecutable conoce su posición en la ejecución por MOLTO_TEST_INDEX (desde 1) y MOLTO_TEST_COUNT, que es como un informe de cobertura sabe cuándo terminó el último. Los detalles están en el manifiesto.

Códigos de salida

Código Significado
0 Éxito
1 Fallo de build; fmt --check encontró archivos sin formatear; lint produjo un error
2 Manifiesto o configuración inválidos
3 Fallo de dependencias
4 Error de uso
5 El comando existe pero no está implementado
6 Falló un plugin

Un warning de lint se reporta y aun así sale con 0. Sólo la severidad error hace fallar el comando.

Qué imprime un build

Todo va a stderr, así que molto build > log sigue mostrando el build y molto run > out captura sólo tu programa.

En una terminal dibuja un inventario, luego una región viva, y retira la región cuando el trabajo para:

 ◆ registry   sqlite v3.53.4
 ◇ modules    network
 ● project    62 files
 ○ cached     20 files

 ● project    services/build_service.c
 ◆ sqlite     sqlite3.c
 … and 5 more
 ████████░░░░░░░░  22%  47/210

Una dependencia ocupa una línea, tenga las fuentes que tenga: un paquete es una unidad de trabajo. Nada que ya esté al día se lista; se cuenta en cached, así que una reconstrucción sin cambios son tres líneas y ninguna región.

Redirige stderr —una tubería, un archivo, un job de CI— y obtienes una línea por fuente, sin región, sin barra y sin una sola secuencia de escape. Ese es el registro completo, y es lo que la CI debería guardar. NO_COLOR=1 quita el color en una terminal pero no la región, que va de movimiento. El cursor nunca se oculta, así que Ctrl-C deja la terminal como la encontró.

Una unidad que falla se reporta en un marco con la línea de código, un cursor bajo el carácter que la herramienta señaló y un pie que dice de quién era el código. El diagnóstico entero se compone y se entrega al informe en una sola llamada, así que dos workers nunca pueden entrelazarse. Un build que falla no imprime línea de Finished.

Dónde guarda Molto sus archivos

Qué Linux y macOS Windows
La credencial del registry ~/.config/molto %APPDATA%\molto
Los plugins instalados ~/.local/share/molto %APPDATA%\molto
Fuentes, objetos, archivos de plataforma ~/.cache/molto %APPDATA%\molto\cache

En Linux y macOS las tres siguen $XDG_CONFIG_HOME, $XDG_DATA_HOME y $XDG_CACHE_HOME. MOLTO_HOME lo pone todo en un solo directorio, y MOLTO_CACHE mueve sólo la caché. Un ~/.molto que haya dejado un Molto anterior se migra la primera vez que corre uno nuevo.

Variables de entorno

Variable Efecto
MOLTO_PICKUP Ruta al binario de pickup cuando no está en el PATH
C_COMPILER Fuerza el driver de C: se salta pickup y se salta la verificación de requires
CPP_COMPILER Fuerza el driver de C++, con la misma salvedad
MOLTO_CLANG_FORMAT Ruta al formateador; evita la resolución y no se cachea
MOLTO_CLANG_TIDY Ruta al linter; igual
MOLTO_HOME Un solo directorio para todo lo que guarda Molto, en vez de los de la plataforma
MOLTO_CACHE Sólo la caché compartida
MOLTO_PKG_CONFIG El pkg-config al que se pregunta por librerías de [target].host y paquetes de plataforma
MOLTO_ZSTD El zstd que desempaqueta los paquetes de plataforma (en Windows se descarga si falta)
NO_COLOR Quita el color en una terminal

Molto imprime un aviso en stderr cuando se usa C_COMPILER, porque un compilador elegido a mano nunca se contrastó con [target].requires.

Dónde entra pickup

Molto no elige compilador. Un manifiesto declara las capacidades que necesita el código; pickup responde qué binario local las proporciona, y la respuesta se cachea en la base de datos del workspace: la pregunta se hace una vez, no en cada build.

pickup list       # todas las toolchains de esta máquina
pickup doctor     # qué impide construir aquí, y cómo arreglarlo
pickup install clang
pickup tools      # el formateador y el linter, y dónde están

Si pickup resolve reporta un runtime_dirs para una toolchain que instaló él, lo que Molto enlaza lleva el -rpath consigo, así que el binario sigue ejecutándose vaya donde vaya.

Plataformas

Plataforma Estado
Linux La puerta: la suite, un build de sí mismo, cuatro combinaciones de compilador y optimización, sanitizers, un binario estático
Windows Soportado desde el 2026-09-04: src/ y tests/ compilan, Molto construye un proyecto, se construye a sí mismo y pasa su suite en un runner Windows
macOS (arm64) Soportado desde el 2026-09-05, con las mismas cuatro medidas, en un runner macOS arm64

Cada release publica un binario para cada una de las tres, y cada uno se ejercita en su plataforma antes de publicarse: ver Instalación y plataformas. Un proyecto no necesita nada por plataforma: el mismo Project.toml construye en las tres.