Highlights

Recipes in Python

Tasks, dependencies and parameters are Python code, so there is no new language to learn and no limit to what a task can do.

Cached by content

A task’s identity is a hash of its source, parameters, files and dependencies, so a cached result is only reused when nothing that matters has changed.

Shared caches

Artifacts are uploaded to a cache server, and anyone who needs the same result downloads it instead of building it.

Distributed builds

jolt build -n sends tasks to a cluster of workers that run them in parallel. The scheduler, workers and cache run as containers on Docker or Kubernetes.

Over 150 packages

Compilers, libraries and tools, from zlib and OpenSSL to LLVM, Qt and gRPC, built from source and kept apart for each platform and compiler.

One command for everything

C++, Rust, Go, Node.js, Python or containers: every task is built the same way, so nobody needs to learn the others’ build tools.

Secure by default

TLS between all services, tokens or single sign-on with an OpenID Connect provider, and builds that only their owners can stop.

Kind to your machines

A built-in jobserver shares the CPUs between all builds on a machine and slows down before memory runs out.

Quick start

Install Jolt from PyPI:

$ pip install jolt

Write a task in a file called hello.jolt:

from jolt import Task


class Hello(Task):
    """ Says hello, and publishes it. """

    def run(self, deps, tools):
        tools.write_file("hello.txt", "Hello, world!")

    def publish(self, artifact, tools):
        artifact.collect("hello.txt")

Build it:

$ jolt build hello
$ jolt build hello    # Nothing to do: the artifact is already cached

Change the message, and Jolt builds it again. Change it back, and the original artifact is used without building anything.

Examples

A C++ application built with CMake, using the fmt library from Jolt’s packages. Jolt builds fmt first, or downloads it if someone already has, and tells CMake where to find it:

from jolt.plugins import cmake
from jolt.pkgs import fmt


class App(cmake.CMake):
    """ The application, in the app directory. """

    requires = ["fmt"]
    srcdir = "app"

A web application built with a Node.js that Jolt provides, so the build doesn’t depend on what happens to be installed on the machine:

from jolt import Task
from jolt.pkgs import nodejs


class WebApp(Task):
    """ Builds the web application. """

    requires = ["nodejs"]

    def run(self, deps, tools):
        with tools.cwd("webapp"):
            tools.run("npm ci")
            tools.run("npm run build")

Parameters select variants of a task, each cached separately:

$ jolt build fmt:shared=true
$ jolt display app    # Show what app depends on
$ jolt inspect app    # Show its parameters, identity and cache status

Scaling up

Point Jolt at a cache server, and everyone shares their artifacts:

[cache]
http_uri = https://cache.example.com:8080

Add a scheduler and workers, and builds run in the cluster:

$ jolt build -n app

The build cluster guide shows how to deploy the services on Docker or Kubernetes, and how to secure them with TLS, tokens and single sign-on.

Installing

From PyPI, for Python 3.9 or later:

$ pip install jolt

As a Docker image:

$ docker run robrt/jolt

Learn more

• Documentation: the tutorial, user guides and reference

• Packages: the packages that Jolt can build

• Issues: bugs and ideas

Jolt is free software, licensed under the GNU General Public License v2.