Ir al contenido
Molto

Primeros pasos

Instalado con un comando

Un solo comando instala molto y pickup, verificados por checksum, sin root ni permisos de administrador, en Linux, Windows y macOS. De cero a un programa funcionando en cosa de un minuto.

Linux y macOS

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

Windows (PowerShell)

PS> irm https://moltobuild.dev/install.ps1 | iex

En Windows el instalador añade su directorio al PATH de tu usuario, así que abre una terminal nueva después. Todas las opciones, y lo que se publica para cada plataforma, están en la documentación de instalación.

Lo que necesita la máquina

Tres cosas, y la tercera sólo hace falta cuando construyas algo tuyo.

  • Linux, Windows o macOS

    x86-64 Linux (un binario estático, sin requisito de glibc), x86-64 Windows 10 o posterior, o macOS en Apple silicon.

  • curl

    Para descargar los binarios. El instalador no necesita nada más.

  • Un compilador de C o C++, más adelante

    Para construir tus propios proyectos, no para instalar Molto. En Linux, pickup install clang trae uno si la máquina no tiene ninguno; en Windows, el GCC de MSYS2; en macOS, xcode-select --install.

Paso

  1. Paso 1: Instala molto y pickup

    Un solo comando descarga ambos binarios, los verifica contra el SHA256SUMS publicado junto a la release y los deja en ~/.local/bin. Sin root y sin nada que descomprimir.

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

    Lee el script antes de pasarlo por un shell: se sirve desde este mismo sitio. Las opciones van después de --, por ejemplo | sh -s -- --dir /usr/local/bin, o --no-pickup para instalar sólo molto. En Windows instala en %LOCALAPPDATA%\Programs\molto.

  2. Paso 2: Comprueba con qué puede construir la máquina

    Molto nunca elige compilador por su cuenta: se lo pregunta a pickup, y pickup demuestra cada capacidad compilando un programa que la usa. doctor dice qué falta y cómo arreglarlo.

    
        
                    $
                    molto --version
                
                    
                    molto 0.54.0
                
                    $
                    pickup doctor
                
                    
                    compilers
                
                    
                      ✓ 1 found - gcc 14.2.0
                
                    
                      ✓ 1 of them build C and C++
                
    

    Si una máquina Linux no tiene ningún compilador lo bastante reciente, pickup install clang descarga uno en ~/.local/share/pickup; necesita curl, tar y zstd. En Windows y macOS pickup responde por el compilador que ya tienes.

  3. Paso 3: Crea tu primer proyecto

    molto new --bin escribe Project.toml, src/main.c y un .gitignore. Nunca sobrescribe un archivo que ya exista, y el mismo proyecto construye en las tres plataformas.

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

    Sin --bin, molto new crea una librería con los tests de moltest ya preparados: molto test los construye y ejecuta. molto run construye primero y luego propaga el código de salida del programa.

  4. Paso 4: Añade una dependencia

    molto add le pide al registry la release más reciente y escribe esa versión exacta en Project.toml. El siguiente build la descarga a una caché que comparten todos los proyectos de la máquina.

    
        
                    $
                    molto add sqlite
                
                    
                    Added sqlite = "3.53.4" to [deps]
                
                    $
                    molto build
                
                    
                     ✓ Finished `debug` build
                
    

    Las versiones son exactas y Molto.lock registra lo que se resolvió, así que commitéalo. molto add gtk también funciona: usa el GTK del sistema, o descarga los paquetes de tu plataforma.

Otras formas de instalar

El instalador es una comodidad, no un requisito.

A mano, desde la release

Exactamente lo que hace el script, paso a paso para Linux: descargar el binario, verificarlo contra los checksums y ponerlo en tu PATH. La release también trae molto-<versión>-x86_64-windows.exe y molto-<versión>-arm64-macos.


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

Desde el código fuente

El Makefile es el bootstrap: existe para el caso en que todavía no hay ningún molto. Necesita gcc 12 o superior y GNU Make; en macOS, make build CC=clang con las herramientas de Xcode. Una vez lo tienes, molto también se construye a sí mismo.


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

Cuando no funciona

Las cinco cosas que de verdad fallan en una primera instalación.

  • command not found: molto

    El binario quedó en ~/.local/bin y tu shell no lo busca ahí. Añádelo al PATH en el perfil de tu shell. En Windows, abre una terminal nueva: la que usaste para instalar conserva el PATH anterior.

    export PATH="$HOME/.local/bin:$PATH"
  • Molto dice que ninguna toolchain cumple lo que pide el proyecto

    Pregúntale a pickup qué encontró. Si una máquina Linux de verdad no tiene nada suficientemente reciente, deja que pickup traiga uno; en Windows instala el GCC de MSYS2, en macOS las herramientas de línea de comandos de Xcode.

    pickup doctor && pickup install clang
  • Molto no encuentra pickup

    Molto busca pickup en el PATH. Apúntalo a otro sitio con MOLTO_PICKUP.

    export MOLTO_PICKUP="$HOME/.local/bin/pickup"
  • molto run dice que el proyecto no tiene nada que ejecutar

    molto new crea una librería por defecto, y una librería no tiene nada que ejecutar: la ejercita molto test. Para un programa, créalo con --bin.

    molto new my_app --bin
  • Compila con make, pero bajo Molto falla cada #include

    Molto descubre tus fuentes, nunca tus ajustes de build. Un manifiesto sin include compila sin ningún -I.

    include = ["include"]

Por dónde seguir

Project.toml tiene una clave para todo lo que necesita el build: perfiles, defines, librerías que enlazar, disposición de los tests y dependencias. Esa es la referencia que conviene leer a continuación, o empieza por un proyecto completo de molto-examples: un clon de wc, una calculadora con GTK, una lista de tareas con GTK guardada en SQLite, una API REST con libwebsockets o un piano con SDL 3 y FFmpeg.