Sin listas de archivos
Todo archivo .c, .cpp y .cc bajo src/ y tests/ se compila automáticamente. No vuelves a enumerar fuentes, pero tus ajustes de build siguen siendo explícitos en el manifiesto: nunca se adivina nada.
v0.54.0 · Linux, Windows y macOS
Un manifiesto, un comando y ningún script de build. Molto descubre tus fuentes, resuelve tus dependencias en versiones exactas y maneja la toolchain que tu proyecto necesita de verdad.
$ curl -fsSL https://moltobuild.dev/install.sh | sh
$
curl -fsSL https://moltobuild.dev/install.sh | sh
==> pickup 0.11.0 checksum verified
==> molto 0.54.0 checksum verified
$
molto new my_app && cd my_app
$
molto run
Hello, world!
Cada característica de aquí abajo sustituye algo que, si no, escribirías a mano en un Makefile, un CMakeLists.txt o un script de CI.
Todo archivo .c, .cpp y .cc bajo src/ y tests/ se compila automáticamente. No vuelves a enumerar fuentes, pero tus ajustes de build siguen siendo explícitos en el manifiesto: nunca se adivina nada.
molto add descarga un paquete y lo fija en una versión exacta. Los rangos se rechazan, no se interpretan: ninguna release entra en tu build sin un diff. Molto.lock registra el grafo completo con sus checksums.
Tu manifiesto declara las capacidades que necesita tu código. pickup responde qué compilador local las cumple, y la respuesta queda cacheada en el workspace: se pregunta una vez, no en cada build.
molto fmt y molto lint gobiernan clang-format y clang-tidy desde dos archivos JSON. Ningún .clang-format que copiar entre repositorios, y no tener linter instalado sigue sin ser un error.
molto metadata escribe un documento CycloneDX 1.6 que Dependency-Track, Grype y Trivy leen sin traducir. Sin timestamp ni número de serie: dos ejecuciones sobre un grafo producen bytes idénticos.
Sólo se reconstruye lo que cambió, los objetos de las dependencias se cachean entre proyectos y cada build escribe compile_commands.json, así clangd ve los flags que el build usó realmente.
molto add gtk usa el GTK que tu sistema ya tiene. Si no lo tiene, Molto descarga los paquetes de esa plataforma — bottles de Homebrew, MSYS2, los paquetes de desarrollo de Ubuntu, Fedora o Arch —, verifica cada SHA-256 y los guarda en su caché. Sin apt, sin brew, sin root.
artifact = "static" o "shared" construye una librería en vez de un programa, con el soname y los enlaces de versión que espera cada plataforma. El mismo manifiesto, a una clave de distancia.
Cada release trae un binario x86-64 para Linux, otro x86-64 para Windows y uno arm64 para macOS. molto build --target <triple> compila tu proyecto para una plataforma distinta de la tuya.
Esto es un proyecto completo. No hay un segundo archivo, ni un paso generador, ni una vuelta al Makefile.
[package]
name
=
"my_app"
version
=
"0.1.0"
[target]
std
=
"c17"
include
=
["include"]
link
=
["m"]
[deps]
sqlite
=
"3.53.4"
[profile.release]
opt_level
=
3
debug_info
=
false
Molto descubre tus fuentes; no descubre tus ajustes de build.
Las fuentes se encuentran solas. Los include, los defines, las librerías y la disposición de los tests son únicamente lo que dice el manifiesto, y por eso un build se comporta igual en tu máquina y en CI.
Todos encuentran tu proyecto subiendo desde donde estés.
molto buildCompila el proyecto en build/<perfil>/.molto runConstruye y ejecuta, propagando el código de salida del programa.molto testConstruye y ejecuta la suite: por defecto, un binario por archivo de test.molto add <dep>Añade una dependencia, escrita en el manifiesto con versión exacta.molto fmtFormatea las fuentes con clang-format. Con --check falla en vez de escribir.molto lintAnaliza el proyecto con clang-tidy y los diagnósticos del compilador.molto metadataGenera el inventario CycloneDX de lo que enlaza este binario.molto publishPublica un paquete en el registry a partir de su recipe.molto test compila la suite y la ejecuta. Cobertura, fakes y sanitizers están a un perfil o a una clave del manifiesto — nunca un segundo sistema de build para los tests.
Por defecto cada archivo de tests/ es su propio ejecutable, enlazado con tu código menos src/main.c. Un framework que es dueño de main() — moltest — enlaza todo en una sola suite con mode = "single".
molto test --profile coverage instrumenta src/ y tests/ por sí mismo; el manifiesto no necesita nada. Las dependencias quedan fuera, así que la cifra es la de tu código. Una suite de varios ejecutables se mide como una sola ejecución.
Un archivo [[test.isolated]] se enlaza solo, sin las fuentes que nombra, de modo que un fake que define ocupa el lugar de la función real — el error que un disco o una red no dan cuando uno quiere.
Las flags de un perfil llegan a la línea de compilación y a la de enlace, así que un [profile.custom] con -fsanitize=address,undefined corre toda la suite bajo AddressSanitizer y UBSan. El CI de Molto hace exactamente eso.
[test]
mode
=
"single"
# Isolated: linked alone, without what it replaces
[[test.isolated]]
file
=
"tests/test_store_failures.c"
replaces
=
["src/disk.c"]
# The [dev-deps.<name>] table is [dev-deps] spelled long
[dev-deps.moltest]
git
=
"https://github.com/moltobuild/moltest"
tag
=
"v0.3.0"
[dev-deps.moltest_coverage]
git
=
"https://github.com/moltobuild/moltest-coverage"
tag
=
"v0.2.1"
[dev-deps.moltest_mock]
git
=
"https://github.com/moltobuild/moltest-mock"
tag
=
"v0.4.0"
Van en [dev-deps]: llegan al build de los tests y nunca al programa que distribuyes.
Donde una coordenada se convierte en bytes. Un solo protocolo sirve toolchains a pickup y paquetes a molto, de modo que una compilación descarga lo que necesita en lugar de una release entera del compilador.
Un archivo por nombre, versión y target, para siempre. Nada se borra: lo retirado se marca como yanked, así que las compilaciones que ya lo fijaron siguen resolviendo.
El SHA-256 se calcula sobre el archivo almacenado y viaja con la descarga, de modo que el cliente verifica los bytes que recibió y no los que una receta prometía.
Un clang publicado ocupa 77 MB donde la release original ocupa 11 GB: los sanitizers que nadie enlaza, el depurador y el kit de desarrollo se quedan fuera.
$
pickup install clang@22.1.8
==> clang 22.1.8 checksum verified
$
molto add sqlite@3.53.4
added sqlite 3.53.4 to [deps]
$
molto add gtk
added gtk 4.14.0 to [deps]
Búscalo, o lee lo que declara una receta.
Cinco proyectos pequeños y completos, cada uno con su Project.toml, sus fuentes y sus tests. Clona el repositorio y ejecuta cualquiera con molto run.
Un clon de wc sin dependencias: un ejecutable C23 cuyo compilador elige pickup a partir de requires, y tests que traen su propio main().
Una calculadora de escritorio con GTK 4: gtk desde el registry como los paquetes de cada plataforma, y sus reglas probadas con moltest, aparte de la ventana.
Una lista de tareas con GTK 4 guardada en SQLite: dos tipos de dependencia lado a lado, y un almacén probado contra una base de datos real, en memoria y en disco.
Una API REST que responde en JSON: libwebsockets configurada por su propio CMake, con OpenSSL como dependencia, y rutas probadas sin un servidor.
Un piano que tocas con el ratón o el teclado: SDL 3 para la ventana y el sonido, FFmpeg para leer muestras y grabar lo que tocas, ambas compiladas desde recetas de fuentes.
github.com/moltobuild/molto-examples
Molto está escrito en C y se construye a sí mismo. Clona el repositorio, lee la documentación y pruébalo en un proyecto que ya tengas.
Abrir el repositorioO lee antes la documentación: cuenta lo que hace el binario hoy.