v0.15.0 · Linux / POSIX

MoltoBuild-System, for C and C++.

One manifest, one command, no build script. Molto discovers your sources, resolves your dependencies at exact versions and drives the toolchain your project actually needs.

Get started View on GitHub

your first project


    
                $
                molto new my_app
            
                
                  Created my_app
            
                $
                cd my_app && molto build
            
                
                  ● project    1 file
            
                
                  ████████████████  100%  1/1
            
                
                  Finished debug in 0.21s
            
                $
                molto run
            
                
                Hello, world!

What you stop maintaining

Every feature below replaces something you would otherwise hand-write in a Makefile, a CMakeLists.txt or a CI script.

No file lists

Every .c, .cpp and .cc file under src/ and tests/ is compiled automatically. You never enumerate sources again — but your build settings stay explicit in the manifest, so nothing is ever guessed.

Exact dependencies

molto add fetches a package and pins it at an exact version. Ranges are refused, not interpreted: no release enters your build without a diff. Molto.lock records the whole graph with checksums.

Toolchains, resolved

Your manifest states the capabilities your code needs. pickup answers which local compiler provides them, and the answer is cached in the workspace — asked once, not on every build.

Format and lint included

molto fmt and molto lint drive clang-format and clang-tidy from two JSON files. No .clang-format to copy between repositories, and no linter installed is still not an error.

A bill of materials

molto metadata writes a CycloneDX 1.6 document Dependency-Track, Grype and Trivy read untranslated. No timestamp, no serial number: two runs over one graph produce identical bytes.

Incremental, and honest about it

Only what changed is rebuilt, dependency objects are cached across projects, and every build writes compile_commands.json so clangd sees the flags the build actually used.

The whole configuration

This is a complete project. There is no second file, no generator step and no fallback to a 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 discovers your sources; it does not discover your build settings.
Sources are found for you. Include paths, defines, link libraries and test layout are only ever what the manifest says — which is why a build behaves the same on your machine and in CI.

The commands

Every one of them finds your project by walking up from where you stand.

molto buildCompile the project into build/<profile>/.
molto runBuild, then run, forwarding the program its own exit code.
molto testBuild and run the suite — one binary per test file by default.
molto add <dep>Add a dependency, written into the manifest at an exact version.
molto fmtFormat every source with clang-format. --check fails instead of writing.
molto lintAnalyse the project with clang-tidy and the compiler diagnostics.
molto metadataEmit the CycloneDX bill of materials for what this binary links.
molto publishPublish a package to the registry from its recipe.

Build it with one command

Molto is written in C and builds itself. Clone the repository, read the docs and try it on a project you already have.

Open the repository

The reference documentation is on the way.