Ir al contenido
Molto

v0.54.0 · Linux, Windows y macOS

MoltoBuild-System, para C y C++.

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
tu primer proyecto

    
                $
                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!
            

Lo que dejas de mantener

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.

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.

Dependencias exactas

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.

Toolchains resueltas

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.

Formato y análisis incluidos

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.

Un inventario de materiales

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.

Incremental, y sincero al respecto

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.

Librerías del sistema, sin gestor de paquetes

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.

Programas y librerías

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.

Linux, Windows y macOS

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.

Toda la configuración

Esto es un proyecto completo. No hay un segundo archivo, ni un paso generador, ni una vuelta al Makefile.

Project.toml

        
                            [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.

Los comandos

Todos encuentran tu proyecto subiendo desde donde estés.

Tests, de serie

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.

Un binario por archivo, o una suite

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".

La cobertura es un perfil

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.

Fakes que sustituyen código real

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.

Sanitizers en un perfil

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.

Project.toml — la parte de los tests

        
                            [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"
                    
    

Paquetes de desarrollo

Van en [dev-deps]: llegan al build de los tests y nunca al programa que distribuyes.

moltest
El framework de tests: DESCRIBE, EXPECT y ASSERT, y es dueño de main().
moltest_coverage
Cobertura de líneas, ramas y funciones de src/ tras una ejecución con cobertura, lcov y JSON, y un mínimo fail_under leído de moltest-coverage.toml.
moltest_mock
MOCK_VALUE_FUNC y MOCK_VOID_FUNC: fakes que cuentan sus llamadas, recuerdan sus argumentos y devuelven lo que el test diga.

El registry

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.

Una coordenada nunca cambia de significado

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.

Checksums medidos, no declarados

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.

Podado a lo que usa una compilación

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.

El registry

    
                $
                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]
            
Explorar el registry

Búscalo, o lee lo que declara una receta.

Lee un proyecto de verdad

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.

wordcount

Un clon de wc sin dependencias: un ejecutable C23 cuyo compilador elige pickup a partir de requires, y tests que traen su propio main().

calculator

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.

todo

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.

hello_api

Una API REST que responde en JSON: libwebsockets configurada por su propio CMake, con OpenSSL como dependencia, y rutas probadas sin un servidor.

piano

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.

Ver los ejemplos

github.com/moltobuild/molto-examples

Constrúyelo con un comando

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 repositorio

O lee antes la documentación: cuenta lo que hace el binario hoy.