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.