Getting started

Installed in one command

One command installs molto and pickup as static binaries, checksum-verified, without root. From nothing to a running program in about a minute.

$ curl -fsSL https://moltobuild.dev/install.sh | sh

This page installs the x86-64 Linux binary. Windows has its own one-liner, and the macOS arm64 binary lands in the next release — the docs carry the command for each platform and what is published for it today.

What the machine needs

Three things, and the third is optional because pickup can fetch it for you.

x86-64 Linux
The binaries are static: no glibc requirement, nothing to unpack.
curl
To fetch the binaries. The installer needs nothing else.
A C or C++ compiler, eventually
To build your own projects, not to install Molto. pickup install clang fetches one if this machine has none.

Step 1: Install molto and pickup

One command fetches both binaries, checks them against the SHA256SUMS published beside the release and puts them in ~/.local/bin. No root, nothing to unpack.


    
                $
                curl -fsSL https://moltobuild.dev/install.sh | sh
            
                
                  ==> pickup 0.6.3
            
                
                      checksum verified
            
                
                  ==> molto 0.20.0
            
                
                      checksum verified

Read the script before you pipe it into a shell — it is served from this site and it is 200 lines. Options go after --, for example | sh -s -- --dir /usr/local/bin, or --no-pickup for molto alone.

Step 2: Check what the machine can build with

Molto never chooses a compiler on its own: it asks pickup, and pickup proves every capability by compiling a program that uses it. doctor reports what is missing and how to fix it.


    
                $
                molto --version
            
                
                molto 0.20.0
            
                $
                pickup doctor
            
                
                  ✓ gcc@12.3.0    c17, c++17

If this machine has no compiler recent enough, pickup install clang fetches one into ~/.pickup. It needs curl, tar and zstd on the PATH.

Step 3: Create your first project

molto new writes Project.toml, src/main.c, include/, tests/ and a .gitignore. It never overwrites a file that already exists.


    
                $
                molto new my_app
            
                $
                cd my_app
            
                $
                molto run
            
                
                Hello, world!

molto run builds first, then forwards the program its own exit code. molto test builds one executable per file under tests/.

Other ways to install

The installer is a convenience, not a requirement.

By hand, from the release

Exactly what the script does, spelled out: download the binary, verify it against the checksums, put it on your PATH.


    
                $
                base=https://github.com/moltobuild/molto/releases/download/v0.20.0
            
                $
                curl -fsSLO $base/molto-0.20.0-x86_64-linux
            
                $
                curl -fsSLO $base/SHA256SUMS
            
                $
                sha256sum --check --ignore-missing SHA256SUMS
            
                $
                install -Dm755 molto-0.20.0-x86_64-linux ~/.local/bin/molto

From source

The Makefile is the bootstrap: it exists for the case where there is no molto yet. Needs gcc 12 or newer and GNU Make. Molto also builds itself once you have it.


    
                $
                git clone https://github.com/moltobuild/molto
            
                $
                cd molto && make build
            
                $
                install -Dm755 build/molto ~/.local/bin/molto

When it does not work

The four things that actually go wrong on a first install.

command not found: molto
The binary landed in ~/.local/bin, which your shell does not search. Add it to PATH in your shell profile.
export PATH="$HOME/.local/bin:$PATH"
Molto reports that no toolchain satisfies the project
Ask pickup what it found. If the machine genuinely has nothing recent enough, let pickup fetch one into ~/.pickup.
pickup doctor && pickup install clang
Molto cannot find pickup
Molto looks for pickup on the PATH. Point it somewhere else with MOLTO_PICKUP.
export MOLTO_PICKUP="$HOME/.local/bin/pickup"
It builds with make, but every #include fails under Molto
Molto discovers your sources, never your build settings. A manifest without include builds with no -I at all.
include = ["include"]

Where to go next

Project.toml has a key for everything the build needs: profiles, defines, link libraries, test layout and dependencies. That is the reference to read next.

Read the manifest reference