Ir al contenido
Molto

v0.16.0 · x86-64 Linux y Windows

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.3.3   checksum verified
            
                
                  ==> molto 0.16.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.

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.

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

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

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.