v0.16.0 · x86-64 Linux

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

Empezar Ver en GitHub

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.

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.

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

La documentación de referencia está en camino.