Reference

Alias

class jolt.Alias(*args, **kwargs)

An alias task.

Aliases are a special kind of task which can be used to introduce new names for other tasks or groups of tasks. They are useful as milestones when building continuous integration pipelines since they won’t be executed, thus saving time compared to a regular task.

name

Name of the alias. Derived from class name if not set.

requires = []

List of dependencies to other tasks.

Artifact

class jolt.Artifact(cache, node, name=None, identity=None, tools=None, session=False)

An artifact is a collection of files and metadata produced by a task.

Task implementors call artifact methods to collect files to be published. In addition to files, other metadata can be provided as well, such as variables that should be set in the environment of consumer tasks.

cmake = {}

Artifact CMake configuration.

A task can add CMake configuration to an artifact. Such configuration will automatically be applied when consumer CMake tasks are executed. A common use-case is to add CMake options that control the build of consumer tasks.

These fields are supported:

• options - List of options, passed to CMake as ‘-D<option>’.

  Use the append() method to add options.

Example

def publish(self, artifact, tools):
    artifact.cmake.options.append("ANDROID_PLATFORM=android-30")

collect(files, dest=None, flatten=False, symlinks=False, cwd=None)

Collect files to be included in the artifact.

Parameters:

• files (str) – A filename pattern matching the files to be included in the artifact. The pattern may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

• dest (str, optional) – Destination path within the artifact. If the string ends with a path separator a new directory will be created and all matched source files will be copied into the new directory. A destination without trailing path separator can be used to rename single files, one at a time.

• flatten (boolean, optional) – If True, the directory tree structure of matched source files will flattened, i.e. all files will be copied into the root of the destination path. The default is False, which retains the directory tree structure relative to the current working directory.

• symlinks (boolean, optional) – If True, symlinks are copied. The default is False, i.e. the symlink target is copied.

• cwd (str, optional) – Change current working directory before starting collection.

copy(files, dest, flatten=False, symlinks=False, cwd=None)

Copy files from the artifact.

Parameters:

• files (str) – A filename pattern matching the files to be copied from the artifact. The filepath is relative to the artifact root and may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

• dest (str, optional) – Destination path, relative to the current working directory. If the string ends with a path separator a new directory will be created and all matched source files will be copied into the new directory. A destination without trailing path separator can be used to rename single files, one at a time.

• flatten (boolean, optional) – If True, the directory tree structure of matched source files will flattened, i.e. all files will be copied into the root of the destination path. The default is False, which retains the directory tree structure.

• symlinks (boolean, optional) – If True, symlinks are copied. The default is False, i.e. the symlink target is copied.

• cwd (str, optional) – Change destination working directory before starting copy.

cxxinfo = {}

Artifact C/C++ build metadata.

A task can add compilation metadata to an artifact. Such metadata will be automatically applied when consumer compilation tasks are executed. A common use-case is to add preprocessor definitions, link libraries, etc. These string fields are supported:

• asflags - assembler flags (string)

• cflags - compiler flags (string)

• cxxflags - compiler flags (string)

• ldflags - linker flags (string)

• libraries - libraries to link with (list, use append())

• macros - preprocessor macros to set (list, use append())

• sources - source files to compile (list, use append())

Values appended to PATH-type metadata fields are relative to the artifact root. They will be automatically expanded to absolute paths. These PATH-type fields are supported:

• incpaths - preprocessor include paths (list, use append())

• libpaths - linker library search paths (list, use append())

Example

def publish(self, artifact, tools):
    artifact.collect("*.h", "include/")
    artifact.cxxinfo.incpaths.append("include")
    artifact.cxxinfo.macros.append("PACKAGE_VERSION=1.0")

environ = {}

Artifact environment variables.

A task can add environment variables to an artifact. Such a variable will automatically be set in the environment when consumer tasks are executed. A common use-case is to add programs to the PATH.

Values appended to PATH variables are relative to the artifact root. They will be automatically expanded to absolute paths. This applies to all variables with PATH in the name.

Example

def publish(self, artifact, tools):
    artifact.environ.PATH.append("bin")
    artifact.environ.JAVA_HOME = artifact.final_path

property final_path

The final location of the artifact in the local cache.

Type:

str

property path

The current location of the artifact in the local cache.

Type:

str

paths = {}

Artifact paths.

A task can add paths to files and directories inside an artifact. Paths are relative to the root of the artifact when created, but are expanded to absolute paths when the artifact is consumed by a task.

This is useful as an abstraction when directories or filenames have varying names.

Example

def publish(self, artifact, tools):
    artifact.paths.file = "{date}.txt"

The file path is then expanded to a full path for consumers:

requires = ["dep"]

def run(self, deps, tools):
    filedata = tools.read_file(deps["dep"].paths.file)

python = {}

Artifact Python configuration.

A task can add Python configuration to an artifact. Such configuration will automatically be set in the environment when consumer tasks are executed. A common use-case is to add Python modules to the PATH so that they can be easily imported by a consumer.

Values appended to PATH-type variables are relative to the artifact root. They will be automatically expanded to absolute paths.

Example

def publish(self, artifact, tools):
    artifact.python.PATH.append("my_module")

strings = {}

Artifact strings.

A task can add arbitrary string values to an artifact. Such a string will be available for consumer tasks to read.

Example

def publish(self, artifact, tools):
    artifact.strings.version = "1.2"

Autotools

class jolt.plugins.autotools.Autotools(parameters=None, **kwargs)

Base class for Autotools-based build tasks.

incremental = True

Keep build directories between builds, so that builds are incremental.

install_threads = None

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

options = []

Options passed to the configure script.

srcdir = None

Source directory. If not set, the working directory of the task is used.

Chroot

class jolt.Chroot(*args, **kwargs)

Resource to use task artifact or directory path as chroot in consumers.

Example

from jolt import Chroot, Task
from jolt.plugins.podman import ContainerImage

class SdkImage(ContainerImage):
    dockerfile = """
    FROM debian:sid-slim
    ARG DEBIAN_FRONTEND=noninteractive
    RUN apt-get update && apt-get install -y --no-install-recommends gcc g++ && apt-get clean
    """
    output = "directory"

class Sdk(Chroot):
    chroot = "sdkimage"

class Compile(Task):
    requires = ["sdk"]

    def run(self, deps, tools):
        tools.run("gcc -v")

chroot = None

Task name or directory path to use as chroot

Context

class jolt.Context(cache, node)

Execution context and dependency wrapper.

A Context gathers dependencies and initializes the environment for an executing task. It is passed as an argument to the Task’s run() method.

A task implementor can use the context as a dictionary of dependencies where the key is the name of a dependency and the value is the dependency’s Artifact.

__getitem__(key)

Get artifact for a task listed as a requirement.

Parameters:

key (str) – Name of the task listed as a requirement.

Returns:

The Artifact associated with the task.

Example

requires = "dependency"

def run(self, deps, tools):
    dependency_artifact = deps["dependency"]

items()

List all requirements and their artifacts.

Returns:

Requirement dictionary items. Each item is a tuple with the requirement name and the artifact.

Decorators

class jolt.attributes

static artifact(name, session=False)

Decorator adding an additional artifact to a task.

Jolt calls the new publish method publish_<name> with the new artifact as argument. Non-alphanumeric characters in the name are replaced with underscores (_). The new artifact is consumable from another task by using the string format <artifact-name>@<task-name> to index dependencies. The standard artifact is named main. See the example below.

If session is True, the new artifact will be a session artifact that is only valid during a single Jolt invokation. Session artifacts are published even if the task fails and may be used to save logs and data for post-mortem analysis.

Parameters:

• name (str) – Name of artifact. Used as reference from consuming tasks.

• session (boolean, False) – Session artifact.

Example

examples/artifacts/build.jolt

from jolt import Task, attributes


@attributes.artifact("logs", session=True)
class Producer(Task):
    def run(self, deps, tools):
        with tools.cwd(tools.builddir()):
            tools.write_file("file.txt", "a text file")
            tools.write_file("file.log", "a log file")

    def publish(self, artifact, tools):
        # Publish text files into main artifact
        with tools.cwd(tools.builddir()):
            artifact.collect("*.txt")

    def publish_logs(self, artifact, tools):
        # Publish logs into session artifact.
        # The artifact is created and shared
        # even if the task fails.
        with tools.cwd(tools.builddir()):
            artifact.collect("*.log")


class Consumer(Task):
    requires = ["producer"]

    def run(self, deps, tools):
        # Display file in main artifact
        with tools.cwd(deps["main@producer"].path):
            tools.run("cat *.txt")

        # Display logs
        try:
            with tools.cwd(deps["logs@producer"].path):
                tools.run("cat *.log")
        except KeyError:
            # KeyError is raised if the producer task
            # didn't have to be executed due to caching.
            # In that case, no session artifact exists.
            print("No logs available")

static artifact_upload(uri, name='main', condition=None)

Decorator to add uploading of an artifact to a server.

Upon successful completion of the task, the resulting artifact uploaded to the specified URI. The URI should be in the format protocol://user:password@host/path.

The following protocols are supported:

• http://

• https://

• file://

Local path are also supported in which case the artifact is copied to the specified location.

If the path ends with a slash, the artifact is treated as a directory and copied into the root of the directory.

If the path ends with a supported archive extension, the artifact is archived and optionally compressed before being copied. See jolt.Tools.archive() for supported archive and compression formats.

Usernames and passwords are optional. If omitted, the artifact is uploaded anonymously. Environment variables can be used to store sensitive information, such as passwords. Specify the environment variable name in the URI as protocol://{environ[USER]}:{environ[PASS]}@host/path.

The upload can be conditioned on the return value of a function. The function is passed the task instance as an argument and should return a boolean value. If the function returns False, the upload is skipped. The value of the condition influences the hash of the task.

Parameters:

• condition (str) – Condition function to evaluate before uploading the artifact. The function is passed the task instance as an argument and should return a boolean value. By default, the artifact is always uploaded.

• name (str) – Name of the artifact to upload.

• uri (str) – Destination URI for the artifact.

Example

examples/artifacts/upload.jolt

from jolt import Parameter, Task, attributes
from jolt.plugins.docker import DockerContainer


class Server(DockerContainer):
    name = "server"
    image = "robrt/jolt-cache:latest"
    arguments = ["-i"]
    user = "root"


@attributes.artifact_upload("http://{server}:8080/files/artifact-{version}.zip", condition=lambda self: self.tools.getenv("UPLOAD", None) is not None)
class Upload(Task):
    """ Uploads the artifact to a server """

    requires = ["server"]
    version = Parameter(help="Version of the artifact to upload")

    def run(self, deps, tools):
    	self.server = deps["server"].info["NetworkSettings"]["IPAddress"]

    def publish(self, artifact, tools):
        with tools.cwd(tools.builddir()):
            tools.write_file("hello.txt", "Hello, world!")
            artifact.collect("hello.txt")

static attribute(alias, target, influence=True, default=False)

Decorates a task with an alias for another attribute.

Parameters:

• attrib (str) – Name of alias attribute.

• target (str) – Name of target attribute. Keywords are expanded.

• influence (boolean) – Add value of target attribute as influence of the task.

• default (boolean) – Return alias attribute if target attribute does not exist. Value is accessed through the alias attribute name with a leading underscore, e.g. ‘_alias’.

static common_metadata(aclocal=True, cmake=True, cxxinfo=True, path=True, pkgconfig=True)

Decorator adding common metadata to published artifacts.

The decorator adds common environment variables and C/C++ build information to the published artifact:

• Adds bin/ to PATH environment variable if it exists.

• Adds lib/ and lib64/ to C++ library paths if they exist.

• Adds include/ to C++ include paths if it exists.

• Adds lib/pkgconfig/, lib64/pkgconfig/ and share/pkgconfig/ to PKG_CONFIG_PATH environment variable if .pc files are found. The prefix variable in .pc files is relocated to allow installation in arbitrary locations.

• Adds lib/cmake/, lib64/cmake/ and share/cmake/ to CMAKE_PREFIX_PATH environment variable if they exist.

• Adds share/aclocal/ to ACLOCAL_PATH environment variable if it exists.

static environ(envname, influence=True)

Decorator marking the task as dependent on an environment variable.

The value of the environment variable will be automatically transferred to workers in distributed network builds.

Parameters:

• envname (str) – Name of the environment variable.

• influence (boolean) – Add value of environment variable as influence of the task. Default: True.

static load(filepath)

Decorator which loads task class attributes from a file.

The loaded file is Python source file declaring a dictionary with keys and values to be assigned to the task instance.

The file is automatically registered as task hash influence.

Example:

@attributes.load("attributes-{os}.py")
class Print(Task):
    os = Parameter()

    def run(self, deps, tools):
        print("OS Author: ", self.os_author)

# attributes-linux.py
{
    "os_author": "Torvalds",
}

$ jolt build print:os=linux

static requires(attrib)

Decorates a task with an alternative requires attribute.

The new attribute will be concatenated with the regular requires attribute.

Parameters:

attrib (str) – Name of alternative attribute. Keywords are expanded.

static system(cls)

Decorates a task with a property returning the operating system name.

Examples: “linux”, “windows”

static timeout(seconds)

Decorator setting a timeout for a task.

The timeout applies to the task’s run method. A JoltTimeoutError is raised if the task does not complete within the specified time.

Parameters:

seconds (int) – Timeout in seconds.

Example:

@attributes.timeout(5)
class Example(Task):
    def run(self, deps, tools):
        time.sleep(10)

Download

class jolt.tasks.Download(parameters=None, **kwargs)

Downloads file(s) over HTTP(S).

Once downloaded, archives are extracted and all of their files are published. If the file is not an archive it is published as is. Recognized archive extensions are:

• .7z

• .tar

• .tar.bz2

• .tar.gz

• .tar.xz

• .tgz

• .zip

Example

class NodeJS(Download):
    """ Downloads and publishes Node.js. Adds binaries to PATH. """

    version = Parameter("14.16.1")
    url = "https://nodejs.org/dist/v{version}/node-v{version}-win-x64.zip"

    def publish(self, artifact, tools):
        super(publish).publish(artifact, tools)
        artifact.environ.PATH.append("node-v{version}-win-x64")

collect = ['*']

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

Example

collect = [
    "*",                           # Collect all files
    ("*", "src/"),                 # Collect all files into the artifact's src/ directory
    {"files": "*", cwd="subdir"},  # Collect all files from the archive's subdir/ directory
]

extract = True

Automatically extract archives.

url = None

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

Fetch

class jolt.plugins.fetch.Fetch(*args, **kwargs)

Fetch a file from a URL and extract it.

By default, the fetched file is extracted if it is a supported archive type. Extraction may be disable by assigning the extract parameter to false.

The fetched content is placed in a build directory named after the resource. The path parameter can be used to specify a different location relative to the workspace root.

The path of the fetched content is made available to consuming tasks through the fetch attribute. The fetch attribute is a dictionary where the key is the name of the fetched file and the value is a path relative to the workspace root. You can specify an alias for the filename / key through the alias parameter.

The plugin must be loaded before it can be used. This is done by importing the module, or by adding the following line to the configuration file:

[fetch]

Example:

from jolt.plugins import fetch

class Example(Task):
    requires = ["fetch:alias=zlib,url=https://zlib.net/zlib-1.3.1.tar.gz"]

    def run(self, deps, tools):
        self.info("The source tree is located at: {fetch[zlib]}")
        with tools.cwd(self.fetch["zlib"]):
            tools.run("make")

Git

class jolt.plugins.git.Git(*args, **kwargs)

Resource that clones and monitors a Git repo.

By default, the repo is cloned into a build directory named after the resource. The ‘path’ parameter can be used to specify a different location relative to the workspace root.

The path of the cloned repo is made available to consuming tasks through their ‘git’ attribute. The ‘git’ attribute is a dictionary where the key is the name of the git repository and the value is the relative path to the repository from the consuming task’s workspace.

The resource influences the hash of consuming tasks, causing tasks to be re-executed if the cloned repo is modified.

The plugin must be loaded before it can be used. This is done by importing the module, or by adding the following line to the configuration file:

[git]

Example:

from jolt.plugins import git

class Example(Task):
    requires = ["git:url=https://github.com/user/repo.git"]

    def run(self, deps, tools):
        self.info("The git repo is located at: {git[repo]}")
        with tools.cwd(self.git["repo"]):
            tools.run("make")

hash = <jolt.tasks.BooleanParameter object>

Let repo content influence the hash of consuming tasks. Default True. Optional.

path = <jolt.tasks.Parameter object>

Alternative path where the repository should be cloned. Relative to joltdir. Optional.

rev = <jolt.tasks.Parameter object>

Specific commit or tag to be checked out.

When shallow is True and the repository has not already been cloned, an unset revision fetches the remote’s default branch. Optional.

submodules = <jolt.tasks.BooleanParameter object>

Initialize and update git submodules after cloning. Default False. Optional.

url = <jolt.tasks.Parameter object>

URL to the git repo to be cloned. Required.

Influence

jolt.influence.always(cls)

Always execute the task.

Example

from jolt import influence

@influence.always
class Example(Task):

jolt.influence.attribute(name, type=None, sort=False, expand=False)

Add task attribute value as hash influence.

Parameters:

• name (str) – Name of task class attribute/property.

• type (InfluenceProvider, optional) – Alternative HashInfluenceProvider implementation used to interpret the value of the attribute. If the attribute is a list, the provider will be instantiated once for each item in the list. For example, if the attribute is a list of filesystem paths, the FileInfluence class could be passed as argument to automatically monitor files at those paths.

• sort (boolean, optional) – Optionally sort the value. Always sort values that are unstable, such as dictionaries.

• expand (boolean, optional) – Expand keywords in the value, or in the strings of a list, such as {version}. Use it for values that differ when they are expanded, for example by platform.

Example:

from jolt import influence

@influence.attribute("attribute")
class Example(Task):
    attribute = False

from jolt import influence

@influence.attribute("sources", type=influence.FileInfluence)
class Example(Task):
    sources = [
        "main.cpp",
        "utils.cpp",
    ]

jolt.influence.daily(cls)

Add daily hash influence.

If nothing else changes, the task is re-executed once every day.

Example

from jolt import influence

@influence.daily
class Example(Task):

jolt.influence.environ(variable)

Add environment variable hash influence.

Parameters:

variable (str) – Name of an environment variable that will influence the hash of the task.

Example:

from jolt import influence

@influence.environ("CFLAGS")
class Example(Task):

jolt.influence.files(pathname)

Add file content hash influence.

Parameters:

pathname (str) – A pathname pattern used to find files that will influence the hash of the task The pattern may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

Example:

from jolt import influence

@influence.files("*.cpp")
class Example(Task):

jolt.influence.function(fn)

Add the result of a function as hash influence.

The function is called with the task when its identity is calculated. It may return a string or a dictionary, whose keys and values are hashed in sorted order. Use it to make the identity depend on things that are probed rather than declared, such as the output of a command.

Parameters:

fn (callable) – Function that takes the task as argument.

Example:

from jolt import influence

def compiler(task):
    return {
        "version": task.tools.run("cc --version", output=False).splitlines()[0],
        "target": task.tools.run("cc -dumpmachine", output=False).strip(),
    }

@influence.function(compiler)
class Example(Task):

jolt.influence.hourly(cls)

Add hourly hash influence.

If nothing else changes, the task is re-executed once every hour.

Example

from jolt import influence

@influence.hourly
class Example(Task):

jolt.influence.monthly(cls)

Add monthly hash influence.

If nothing else changes, the task is re-executed once every month.

Example

from jolt import influence

@influence.monthly
class Example(Task):

jolt.influence.weekly(cls)

Add weekly hash influence.

If nothing else changes, the task is re-executed once every week.

Example

from jolt import influence

@influence.weekly
class Example(Task):

jolt.influence.yearly(cls)

Add yearly hash influence.

If nothing else changes, the task is re-executed once every year.

Example

from jolt import influence

@influence.yearly
class Example(Task):

Meson

class jolt.plugins.meson.Meson(parameters=None, **kwargs)

Base class for Meson-based build tasks.

incremental = True

Keep build directories between builds, so that builds are incremental.

options = []

Options passed to Meson, as option=value.

srcdir = None

Source directory. If not set, the working directory of the task is used.

Parameter

class jolt.Parameter(default=None, values=None, required=True, const=False, influence=True, help=None, valuesfn=None)

Generic task parameter type.

__init__(default=None, values=None, required=True, const=False, influence=True, help=None, valuesfn=None)

Creates a new parameter.

Parameters:

• default (str, optional) – An optional default value.

• values (list, optional) – A list of accepted values. An assertion is raised if an unlisted value is assigned to the parameter.

• valuesfn (func, optional) – If both values and valuesfn are specified, the values list is validated first. The function is passed the assigned value and should return. boolean value. If the function returns False, a ParameterValueError is raised.

• required (boolean, optional) – If required, the parameter must be assigned a value before the task can be executed. The default is True.

• const (boolean, optional) – If const is True, the parameter is immutable and cannot be assigned a non-default value. This is useful in a class hierarchy where a subclass may want to impose restrictions on a parent class parameter. The default is False.

• influence (boolean, optional) – If influence is False, the parameter value will not influence the identity of the task artifact. The default is True.

• help (str, optional) – Documentation for the parameter. This text is displayed when running the info command on the associated task.

Raises:

ParameterValueError – If the parameter is assigned an illegal value.

__str__()

Returns the parameter value as a string

get_default()

Get the default value of the parameter.

Returns:

The default value or None if no default was given.

get_value()

Get the parameter value.

is_default()

Check if parameter is set to its default value.

Returns:

True if the assigned value is the default value.

is_set()

Check if the parameter is set to a non-default value.

Returns:

True if the assigned value is not the default value.

is_unset()

Check if the parameter is unset.

Returns:

True if the assigned value is None.

set_value(value)

Set the parameter value.

Parameters:

value (str) – The new parameter value.

Raises:

ParameterValueError – If the parameter is assigned an illegal value.

class jolt.BooleanParameter(default=None, required=True, const=False, influence=True, help=None)

Boolean task parameter.

Accepted values are:

• False

• True

• “false”

• “true”

• “no”

• “yes”

• “0”

• “1”

__bool__()

Returns the boolean parameter value

__getitem__(key)

Returns a substitution string depending on the parameter value.

Parameters:

• key (str) – A special key syntax, enabled,disabled, where

• returned (and either enabled or disabled would be) –

• below. (depending on the paramter value. See the example) –

Returns:

Substitution string.

Example

class Example(Task):
   debug = BooleanParameter()

   def run(self, deps, tools):
       self.info("debug is {debug[enabled,disabled]}")

$ jolt build example:debug=true
[INFO] debug is enabled (example)

$ jolt build example:debug=false
[INFO] debug is disabled (example)

__init__(default=None, required=True, const=False, influence=True, help=None)

Creates a new parameter.

Parameters:

• default (boolean, optional) – An optional default boolean value.

• required (boolean, optional) – If required, the parameter must be assigned a value before the task can be executed. The default is True.

• const (boolean, optional) – If const is True, the parameter is immutable and cannot be assigned a non-default value. This is useful in a class hierarchy where a subclass may want to impose restrictions on a parent class parameter. The default is False.

• influence (boolean, optional) – If influence is False, the parameter value will not influence the identity of the task artifact. The default is True.

• help (str, optional) – Documentation for the parameter. This text is displayed when running the inspect command on the associated task.

Raises:

ParameterValueError – If the parameter is assigned an illegal value.

__str__()

Returns the parameter value as a string

get_default()

Get the default value of the parameter.

Returns:

The default value or None if no default was given.

get_value()

Get the parameter value.

is_default()

Check if parameter is set to its default value.

Returns:

True if the assigned value is the default value.

property is_false

The parameter value is False.

is_set()

Check if the parameter is set to a non-default value.

Returns:

True if the assigned value is not the default value.

property is_true

The parameter value is True.

is_unset()

Check if the parameter is unset.

Returns:

True if the assigned value is None.

class jolt.IntParameter(default=None, min=None, max=None, values=None, required=True, const=False, influence=True, help=None, valuesfn=None)

Integer task parameter.

Implements all regular unary and binary integer operators.

__bool__()

Evaluates to False if the value is 0, True otherwise

__init__(default=None, min=None, max=None, values=None, required=True, const=False, influence=True, help=None, valuesfn=None)

Creates a new parameter.

Parameters:

• default (int, optional) – An optional default integer value.

• min (int, optional) – Minimum allowed value.

• max (int, optional) – Maximum allowed value.

• values (list, optional) – A list of accepted values. An assertion is raised if an unlisted value is assigned to the parameter.

• required (boolean, optional) – If required, the parameter must be assigned a value before the task can be executed. The default is True.

• const (boolean, optional) – If const is True, the parameter is immutable and cannot be assigned a non-default value. This is useful in a class hierarchy where a subclass may want to impose restrictions on a parent class parameter. The default is False.

• influence (boolean, optional) – If influence is False, the parameter value will not influence the identity of the task artifact. The default is True.

• help (str, optional) – Documentation for the parameter. This text is displayed when running the inspect command on the associated task.

Raises:

ParameterValueError – If the parameter is assigned an illegal value.

__int__()

Returns the integer parameter value

__str__()

Returns the parameter value as a string

get_default()

Get the default value of the parameter.

Returns:

The default value or None if no default was given.

get_value()

Get the parameter value.

is_default()

Check if parameter is set to its default value.

Returns:

True if the assigned value is the default value.

is_set()

Check if the parameter is set to a non-default value.

Returns:

True if the assigned value is not the default value.

is_unset()

Check if the parameter is unset.

Returns:

True if the assigned value is None.

class jolt.ListParameter(*args, **kwargs)

List parameter type.

A list parameter allows multiple values to be assigned to it. Values are separated by the ‘+’ character in qualified task names. Each assigned value is validated against the list of accepted values. They are sorted in alphabetical order before the task is executed.

Example

class Example(Task):
    arg = ListParameter(default=["c"], values=["a", "b", "c"], help="A list parameter")

    def run(self, deps, tools):
        for item in self.arg:
            print(item)

$ jolt build example example:arg=a example:arg=a+b

__getitem__(key)

Returns an element or a slice from the list.

Parameters:

key (int, slice, str) –

Element index or slice. A key string can be used to check for the existence of that value in the list. If the key is present the same value is returned, otherwise None.

A special key syntax is also available to request an alternate return value depending on the presence of the key. Instead of a list value you pass value,present,absent and either present or absent will be returned. See the example below.

Returns:

Element value, or substitution.

Example

class Example(Task):
   features = ListParameter(values=["optimize", "strip"], required=False)

   def run(self, deps, tools):
       if len(self.features) > 0:
           self.info("first feature is {features[0]}")
           self.info("optimize == {features[optimize]}")
           self.info("optimization is {features[optimize,enabled,disabled]}")

$ jolt build example:features=optimize+strip
[INFO] first feature is optimize (example)
[INFO] optimize = optimize (example)
[INFO] optimization is enabled (example)

$ jolt build example:features=strip
[INFO] first feature is debug (example)
[INFO] optimize = None (example)
[INFO] optimization is disabled (example)

__init__(*args, **kwargs)

Creates a new list parameter.

Parameters:

• default (boolean, optional) – An optional list of default values.

• values (list, optional) – A list of accepted values. An assertion is raised if an unlisted value is assigned to the parameter.

• required (boolean, optional) – If required, the parameter must be assigned a value before the task can be executed. The default is True.

• const (boolean, optional) – If const is True, the parameter is immutable and cannot be assigned a non-default value. This is useful in a class hierarchy where a subclass may want to impose restrictions on a parent class parameter. The default is False.

• influence (boolean, optional) – If influence is False, the parameter value will not influence the identity of the task artifact. The default is True.

• help (str, optional) – Documentation for the parameter. This text is displayed when running the inspect command on the associated task.

Raises:

ParameterValueError – If the parameter is assigned an illegal value.

__iter__()

Returns a sequence iterator.

__len__()

Returns the length of the list.

__str__()

Returns the list parameter value as a string.

get_default()

Get the default value of the parameter.

Returns:

The default value or None if no default was given.

get_value()

Get the parameter value.

is_default()

Check if parameter is set to its default value.

Returns:

True if the assigned value is the default value.

is_set()

Check if the parameter is set to a non-default value.

Returns:

True if the assigned value is not the default value.

is_unset()

Check if the parameter is unset.

Returns:

True if the assigned value is None.

Resource

class jolt.tasks.Resource(*args, **kwargs)

Bases: Task

A resource task.

Resources are special tasks executed in the Context of other tasks. They are invoked to acquire and release a resource, such as hardware equipment, before and after the execution of a task. No artifact is produced by a resource.

A resource may require other resources. Those are acquired before, and released after, the resource that requires them, and their artifacts are available in the deps context passed to acquire() and release(). The owner argument is always the consuming task, never an intermediate resource. In a distributed build, a resource and the resources it requires are acquired on the same host; a resource with local set to True may therefore not be required by a non-local resource.

Implementors should override acquire() and release().

acquire(artifact, deps, tools, owner)

Called to acquire the resource.

An implementor overrides this method in a subclass. The acquired resource must be released manually if an exception occurs before the method has returned. If this method returns successfully, the release() method is guaranteed to be called in the future upon completion of the consuming task (unless the process is forcibly interrupted or killed).

Parameters:

• artifact (Artifact) – The artifact associated with the resource. It is not possible to publish files from a resource, but the implementor can still use the resource to pass information to consuming tasks.

• deps (Context) – Task execution context used to access the artifacts of dependencies.

• tools (Tools) – A task specific toolbox.

• owner (Task) – The owner task for which the resource is acquired.

release(artifact, deps, tools, owner)

Called to release the resource.

An implementor overrides this method in a subclass.

Parameters:

• artifact (Artifact) – The artifact associated with the resource. It is not possible to publish files from a resource, but the implementor can still use the resource to pass information to consuming tasks.

• deps (Context) – Task execution context used to access the artifacts of dependencies.

• tools (Tools) – A task specific toolbox.

• owner (Task) – The owner task for which the resource is released.

Runner

class jolt.tasks.Runner(parameters=None, **kwargs)

Bases: Task

A Runner task executes applications packaged by other tasks.

It is typically used to run test applications compiled and linked by other tasks. The Runner finds the executable through the artifact metadata string artifact.strings.executable which must be exported by the consumed task artifact.

Example

from jolt import Runner, Task

class Exe(Task):
    """ Publish a script printing 'Hello world' to stdout """
    def publish(self, artifact, tools):
        with tools.cwd(tools.builddir()):
            # Create Hello world script
            tools.write_file("hello.sh", "#!/bin/sh\necho Hello world")

            # Make it executable
            tools.chmod("hello.sh", 0o555)

            # Publish script in artifact
            artifact.collect("hello.sh")

            # Inform consuming Runner task about executable's name
            artifact.strings.executable = "hello.sh"

class Run(Runner):
    """ Runs the 'Hello world' script """
    requires = ["exe"]

The Ninja CXXExecutable task class automatically sets the required artifact metadata.

Example

from jolt import Task
from jolt.plugins.ninja import CXXExecutable

class Exe(CXXExecutable):
    """ Compiles and links the test application """
    sources = ["test.cpp"]

class Run(Runner):
    """ Runs the test application """
    requires = ["exe"]

args = []

List of arguments to pass to executables.

The arguments are passed the same way to all executables if there are multiple task requirements.

requires = []

List of tasks packaging executables to run.

shell = True

Launch the executables through a shell.

Script

class jolt.tasks.Script(parameters=None, **kwargs)

Bases: Task

A simple shell script task.

The script source is extracted directly from the task class documentation. All text following a --- separator will be executed.

A temporary build directory is automatically created and can be accessed with {builddir}. All other task attributes are also expanded as usual. Dependency artifacts are accessible through the deps dictionary.

echo {deps[task].path}

By default, all files in the build directory are published in the task artifact. The collect attribute can be used to customize file collection. Alternatively, the publish method may be overridden.

Keep in mind that shell scripts are not necessarily portable between host operating systems. Implement your tasks in Python code if portability is a concern.

Example

class Hello(Script):
    """
    Classic Hello World!
    ---
    # Script source

    echo "Hello world!" > {builddir}/hello.txt
    """

collect = [{'files': '*', 'cwd': '{builddir}'}]

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

By default, all files in the build directory are published.

Example

collect = [
    "*",                              # Collect all files
    ("*", "src/"),                    # Collect all files into the artifact's src/ directory
    {"files": "*", "cwd": "subdir"},  # Collect all files from the archive's subdir/ directory
]

Task

class jolt.tasks.Task(parameters=None, **kwargs)

abstract = True

An abstract task class indended to be subclassed.

Abstract tasks can’t be executed and won’t be listed.

cacheable = True

Whether the task produces an artifact or not.

clean(tools)

Cleans up resources and intermediate files created by the task.

The method is invoked in response to the user running clean on the command line. It should restore the environment to its original state. The next execution of the task should behave as if the task is executed for the first time.

An implementation must not clean any local or remote artifact cache.

debugshell(deps, tools)

Invoked to start a debug shell.

The method prepares the environment with attributes exported by task requirement artifacts. The shell is entered by passing the -g flag to the build command.

Task execution resumes normally when exiting the shell.

error(fmt, *args, **kwargs)

Log an error concerning the task

expand(string_or_list, *args, **kwargs)

Expands keyword arguments/macros in a format string.

See jolt.Tools.expand() for details.

expires = <jolt.expires.Immediately object>

An expiration strategy, defining when the artifact may be evicted from the cache.

When the size of the artifact cache exceeds the configured limit an attempt will be made to evict artifacts from the cache. The eviction algorithm processes artifacts in least recently used (LRU) order until an expired artifact is found.

By default, an artifact expires immediately and may be evicted at any time (in LRU order). An exception to this rule is if the artifact is required by a task in the active task set. For example, if a task A requires the output of task B, B will never be evicted by A while A is being executed.

There are several expiration strategies to choose from:

• jolt.expires.WhenUnusedFor

• jolt.expires.After

• jolt.expires.Never

Examples

# May be evicted if it hasn't been used for 15 days
expires = WhenUnusedFor(days=15)

# May be evicted 1h after creation
expires = After(hours=1)

# Never evicted
expires = Never()

extends = ''

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

fast = False

Indication of task speed.

The information is used by the distributed execution strategy to optimize how tasks are scheduled. Scheduling tasks remotely is always associated with some overhead and sometimes it’s beneficial to instead schedule fast tasks locally if possible.

An extended task is only considered fast if all extensions are fast.

influence = []

List of influence provider objects

info(fmt, *args, **kwargs)

Log information about the task.

joltdir = '.'

Path to the directory of the .jolt file where the task was defined.

joltproject = None

Name of project this task belongs to.

local = False

A local task is only executed on the local node where the build is initiated.

name = None

Name of the task. Derived from class name if not set.

platform = {}

Dictionary of task platform requirements.

Platform requirements control where tasks are allowed to execute. Multiple requirement key/values may be specified in which case all must be fulfilled in order for the task to be schedulable on a node.

The following builtin requirement labels exist:

• node.arch [“arm”, “amd64”]

• node.os [“linux”, “windows”]

Example

class Hello(Task):
    # This task must run on Linux.
    platform = {
        "node.os": "linux",
    }

publish(artifact, tools)

Publishes files produced by run().

Files can be collected in to the artifact by calling artifact.collect().

Additional metadata can be provided, such as environment variables that should be set whenever the task artifact is consumed. Example:

# Append <artifact-path>/bin to the PATH
artifact.environ.PATH.append("bin")

# Pass an arbitrary string to a consumer
artifact.strings.foo = "bar"

report()

Provide error analysis for task.

Intentionally undocumented. Use at own risk.

requires = []

List of dependencies to other tasks.

run(deps, tools)

Performs the work of the task.

Dependencies specified with “requires” are passed as the deps dictionary. The tools argument provides a set of low level tool functions that may be useful.

with tools.cwd("path/to/subdir"):
    tools.run("make {target}")

When using methods from the toolbox, task parameters, such as target above, are automatically expanded to their values.

selfsustained = False

Consume this task independently of its requirements.

Requirements of a self-sustained task will be pruned if the task artifact is present in a cache. In other words, if the task is not executed its requirements are considered unnecessary.

For example, consider the task graph A -> B -> C. If B is self-sustained and present in a cache, C will never be executed. C will also never be a transitive requirement of A. If A requires C, it should be listed as an explicit requirement.

Using this attribute speeds up execution and reduces network traffic by allowing the task graph to be reduced.

taint = None

An arbitrary value used to change the identity of the task.

It may be hard to remove bad artifacts in a distributed build environment. A better method is to taint the task and let the artifact be recreated with a different identity.

unpack(artifact, tools)

Unpacks files published by publish() .

The intention of this hook is to make necessary adjustments to artifact files and directories once they have been downloaded into the local cache on a different machine. For example, paths may have to be adjusted or an installer executed.

This hook is executed in the context of a consuming task.

unstable = False

An unstable task is allowed to fail without stopping or failing the entire build.

The unstable task is still reported as a failure at the end of the build.

verbose(fmt, *args, **kwargs)

Log verbose information about the task.

warning(fmt, *args, **kwargs)

Log a warning concerning the task

weight = 0

Indication of task execution time.

The weight is used to optimize the order in which tasks are executed using a heuristic scheduling algorithm where ready tasks along the critical path are favored.

MultiTask

class jolt.tasks.MultiTask(*args, **kwargs)

A task with subtasks that are executed in parallel with intermediate caching.

A MultiTask is useful for tasks with many subtasks that benefit from intermediate caching, such as compilation tasks where multiple source files are compiled into object files and then either linked into an executable or archived into a library.

Subtasks are executed in parallel and their output is cached locally in a build directory. The output is not automatically shared with other Jolt clients, only the files published by the MultiTask is shared. A subtask is only re-executed if the influence one of its dependencies change.

Subtasks are defined in the MultiTask method generate() and they can be either a shell command or a python function. Helper methods in the class allow implementors to define outputs and inter-subtask dependencies.

Example

flags = ["-DDEBUG"]

def generate(self, deps, tools):
    sources = ["a.cpp", "b.cpp", "c.cpp"]
    objects = []

    # Create compilation subtasks for each source file
    for source in sources:
        object = self.command(
            "g++ {flags} -c {inputs} -o {outputs} ",
            inputs=[source],
            outputs=[source  +".o"])
        objects.append(object)

    # Create linker subtask
    executable = self.command(
        "g++ {inputs} -o {output}",
        inputs=objects,
        outputs=["executable"])

call(fn, outputs, **kwargs)

Create a Python function call subtask.

The subtask executes the specified Python function, passing the subtask as argument.

Parameters:

• fn (func) – Python function to execute.

• outputs (str, list) – list of files that the subtasks produces.

• kwargs – additional keyword values used to format the output file paths.

Returns:

Subtask object.

Example

def mkdir(subtask):
    for output in subtask.outputs:
        self.tools.mkdir(output)

dirtask = self.call(mkdir, outputs=["newly/created/directory"])

command(command, inputs=None, outputs=None, message=None, mkdir=True, **kwargs)

Create shell command subtask.

The subtask executes the specified command. String format specifiers may be used and are resolved primarily by kwargs and secondarily by task attributes.

Parameters:

• inputs (str, list) – files or subtasks that the command depends on.

• outputs (str, list) – list of files that the subtasks produces.

• message (str) – custom message that the subtask will print when executed.

• mkdir (boolean) – automatically create directories for outputs. If False, the caller must ensure that the directories exist before the the subtask is executed.

• kwargs – additional keyword values used to format the command line string.

Returns:

Subtask object.

Example

executable = self.command(
    "g++ {inputs} -o {output}",
    inputs=["main.cpp"],
    outputs=["executable"])

generate(deps, tools)

Called to generate subtasks.

An implementer can override this method in order to create subtasks that will later be executed during the run() stage of the task.

Subtasks can be defined using either of these helper methods:

• call()

• command()

• mkdir()

• mkdirname()

• render()

• render_file()

mkdir(path, *args, **kwargs)

Create a subtask that creates a directory.

Parameters:

• path (str) – Path to directory.

• kwargs – additional keyword values used to format the directory path string.

Returns:

Subtask object.

Example

dirtask = self.mkdir("{outdir}/directory", outdir=tools.builddir())

mkdirname(path, *args, **kwargs)

Create a subtask that creates a parent directory.

Parameters:

• path (str) – Path for which the parent directory shall be created.

• kwargs – additional keyword values used to format the directory path string.

Returns:

Subtask object.

Example

# Creates {outdir}/directory
dirtask = self.mkdir("{outdir}/directory/object.o", outdir=tools.builddir())

render(template, outputs, **kwargs)

Create a subtask that renders a Jinja template string to file.

Parameters:

• template (str) – Jinja template string.

• outputs (str, list) – list of files that the subtasks produces.

• kwargs – additional keyword values used to render the template and output file paths.

Returns:

Subtask object.

Example

# Creates file.list with two lines containing "a.o" and "b.o"

template_task = self.render(
    "{% for line in lines %}{{ line }}\n{% endfor %}",
    outputs=["file.list"],
    lines=["a.o", "b.o"])

render_file(template, outputs, **kwargs)

Create a subtask that renders a Jinja template file to file.

Parameters:

• template (str) – Jinja template file path.

• outputs (str, list) – list of files that the subtasks produces.

• kwargs – additional keyword values used to format the output file paths.

Returns:

Subtask object.

Example

# Render file.list.template into file.list
template_task = self.render_file("file.list.template", outputs=["file.list"])

Python

class jolt.plugins.python.PythonEnv(parameters=None, **kwargs)

Base class for Python virtual environment tasks.

Builds a Python virtual environment and installs specified packages.

The venv module from the Python standard library must be available in the Python installation used to run the task.

requirements = []

List of Python packages to install in the virtual environment.

Each entry should be a string suitable for pip, e.g., “package==version”.

Rust

class jolt.plugins.rust.Rust(parameters=None, **kwargs)

Base class for Rust-based build tasks.

srcdir = None

Source directory for the Rust project.

If None, defaults to the task work directory (joltdir).

Test

class jolt.tasks.Test(*args, **kwargs)

A test task.

The test task combines a regular Jolt task with a Python unittest.TestCase. As such, a test task is a collection of similar test-cases where each test-case is implemented as an instancemethod named with a test_ prefix. When executed, the task runs all test-case methods and summarizes the result.

All regular unittest assertions and decorators can be used in the test methods. For details about inherited task attributes, see jolt.tasks.Task and Python unittest.TestCase.

Example:

class OperatorTest(Test):

    def test_add(self):
        self.assertEqual(1+1, 2)

    def test_sub(self):
        self.assertEqual(2-1, 1)

cleanup()

Implement this method to clean up after a test

static parameterized(args)

Parameterizes a test method.

The test method is instantiated and called once with each argument tuple in the list.

Example

class Example(Test):
   @Test.parameterized([
       (1, 1, 1),  # 1*1 == 1
       (1, 2, 2),  # 1*2 == 2
       (2, 1, 2),  # 2*1 == 2
       (2, 2, 4),  # 2*2 == 4
   ])
   def test_multiply(self, factor1, factor2, product):
       self.assertEqual(factor1*factor2, product)

setup(deps, tools)

Implement this method to make preparations before a test

Tools

class jolt.Tools(task=None, cwd=None, env=None)

A collection of useful tools.

Any {keyword} arguments, or macros, found in strings passed to tool functions are automatically expanded to the value of the associated task’s parameters and properties. Relative paths are made absolute by prepending the current working directory.

append_file(pathname, content, expand=True)

Appends data at the end of a file.

Parameters:

• pathname (str) – Path to file. The file must exist.

• content (str) – Data to be appended at the end of the file.

archive(pathname, filename)

Creates a (compressed) archive.

The type of archive to create is determined by the filename extension. Supported formats are:

• 7z

• tar

• tar.bz2

• tar.gz

• tar.xz

• tar.zst

• zip

Parameters:

• pathname (str) – Directory path of files to be archived.

• filename (str) – Name/path of created archive.

autotools(deps=None, incremental=False)

Creates an AutoTools invokation helper

builddir(name=None, incremental=False, unique=True)

Creates a temporary build directory.

The build directory will persist for the duration of a task’s execution. It is automatically removed afterwards.

Parameters:

• name (str) – Name prefix for the directory. A unique autogenerated suffix will also be appended to the final name.

• incremental (boolean) – If false, the created directory is deleted upon completion of the task.

Returns:

Path to the created directory.

property buildroot

Return the root path of all build directories

checksum_file(filelist, concat=False, hashfn=<class 'blake3.blake3.blake3'>)

Calculate a checksum of one or multiple files.

Parameters:

• filelist (str,list) – One or multiple files.

• concat (boolean) – Concatenate files and return a single digest. If False, a list with one digest for each file is returned. Default: False.

• hashfn – The hash algorithm used. Any type which provides an update() and hexdigest() method is accepted. Default: blake3

Returns:

A list of checksum digests, or a single digest if files where concatenated.

chmod(pathname, mode)

Changes permissions of files and directories.

Parameters:

• pathname (str) – Path to a file or directory to change permissions for.

• mode (int) – Requested permission bits.

chroot(chroot, *args, path=None, **kwargs)

Experimental: Use chroot as root filesystem when running commands.

Mounts the specified chroot as the root filesystem in a new Linux namespace, which is used when calling Tools.run().

Requires a Linux host.

Parameters:

• chroot (str, artifact) – Path to rootfs directory, or an artifact with a ‘rootfs’ metadata path (artifact.paths.rootfs).

• path (list) – List of directory paths within the chroot to add to the PATH environment variable, e.g. [“/usr/bin”, “/bin”]. By default, the current PATH is used also within the chroot.

Example

with tools.choot("path/to/rootfs"):
    tools.run("ls")

cmake(deps=None, incremental=False)

Creates a CMake invokation helper

compress(src, dst)

Compress a file.

Supported formats are:

• .bz2

• .gz

• .xz

• .zst

Parameters:

• src (str) – Source file to be compressed.

• dst (str) – Destination path for compressed file. The filename extension determines the compression algorithm used.

copy(src, dst, symlinks=False)

Copies file and directories (recursively).

The directory tree structure is retained when copying directories.

Parameters:

• src (str) – Path to a file or directory to be copied.

• dest (str) – Destination path. If the string ends with a path separator a new directory will be created and source files/directories will be copied into the new directory. A destination without trailing path separator can be used to rename single files, one at a time.

• symlinks (boolean, optional) – If True, symlinks are copied. The default is False, i.e. the symlink target is copied.

cpu_count()

The number of CPUs on the host.

Returns:

The number of CPUs on the host.

Return type:

int

cwd(pathname, *args)

Change the current working directory to the specified path.

This function doesn’t change the working directory of the Jolt process. It only changes the working directory for tools within the tools object.

Parameters:

pathname (str) – Path to change to.

Example

with tools.cwd("subdir") as cwd:
    print(cwd)

download(url, pathname, exceptions=True, auth=None, **kwargs)

Downloads a file using HTTP.

Automatically expands any {keyword} arguments in the URL and pathname.

Basic authentication is supported by including the credentials in the URL. Environment variables can be used to hide sensitive information. Specify the environment variable name in the URI as e.g. http://{environ[USER]}:{environ[PASS]}@host. Alternatively, the auth parameter can be used to provide an authentication object that is passed to the requests.get() function.

Throws a JoltError exception on failure.

Parameters:

• url (str) – URL to the file to be downloaded.

• pathname (str) – Name/path of destination file.

• kwargs (optional) – Addidional keyword arguments passed on directly requests.get().

environ(**kwargs)

Set/get environment variables.

Only child processes spawned by the same tools object will be affected by the changed environment.

The changed environment is only valid within a context and it is restored immediately upon leaving the context.

Parameters:

kwargs (optinal) – A list of keyword arguments assigning values to environment variable.

Example

with tools.environ(CC="clang"):
    tools.run("make all")

exists(pathname)

Checks if a file or directory exists.

Parameters:

pathname (str) – Path to file or directory.

Returns:

True if the file or directory exists, False otherwise.

Return type:

bool

expand(string, *args, **kwargs)

Expands keyword arguments/macros in a format string.

This function is identical to str.format() but it automatically collects keyword arguments from a task’s parameters and properties.

It also supports three additional conversion specifiers:

• c: call method without arguments

• l: convert string to lower case

• u: convert string to upper case

Parameters:

• string (str) – The string to be expanded.

• args (str, optional) – Additional positional values required by the format string.

• kwargs (str, optional) – Additional keyword values required by the format string.

Returns:

Expanded string.

Return type:

str

Example

target = Parameter(default="all")
verbose = "yes"

def run(self, deps, tools):
    print(tools.expand("make {target} VERBOSE={verbose}"))  # "make all VERBOSE=yes"

expand_path(pathname, *args, **kwargs)

Expands keyword arguments/macros in a pathname format string.

This function is identical to str.format() but it automatically collects keyword arguments from a task’s parameters and properties.

The function also makes relative paths absolute by prepending the current working directory.

Parameters:

• pathname (str) – The pathname to be expanded.

• args (str, optional) – Additional positional values required by the format pathname.

• kwargs (str, optional) – Additional keyword values required by the format pathname.

Return

str: Expanded string.

expand_relpath(pathname, relpath=None, *args, **kwargs)

Expands keyword arguments/macros in a pathname format string.

This function is identical to str.format() but it automatically collects keyword arguments from a task’s parameters and properties.

The function also makes absolute paths relative to a specified directory.

Parameters:

• pathname (str) – The pathname to be expanded.

• relpath (str, optional) – Directory to which the returned path will be relative. If not provided, the joltdir attribute is used.

• args (str, optional) – Additional positional values required by the format pathname.

• kwargs (str, optional) – Additional keyword values required by the format pathname.

Return

str: Expanded string.

extract(filename, pathname, files=None, ignore_owner=False)

Extracts files in an archive.

Supported formats are:

• 7z

• tar

• tar.bz2

• tar.gz

• tar.xz

• tar.zst

• zip

Parameters:

• filename (str) – Name/path of archive file to be extracted.

• pathname (str) – Destination path for extracted files.

• files (list, optional) – List of files the be extracted from the archive. If not provided, all files are extracted.

file_size(pathname)

Determines the size of a file.

Parameters:

pathname (str) – Name/path of file for which the size is requested.

Returns:

The size of the file in bytes.

Return type:

int

getcwd()

Returns the current working directory.

getenv(key, default=None)

Returns the value of an environment variable.

Only child processes spawned by the same tools object can see the environment variables and their values returned by this method. Don’t assume the same variables are set in the Jolt process’ environment.

glob(pathname, expand=False)

Enumerates files and directories.

Parameters:

• pathname (str) – A pathname pattern used to match files to be included in the returned list of files and directories. The pattern may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

• expand (boolean) – Expand matches to absolute paths. Default: false.

Returns:

A list of file and directory pathnames. The pathnames are relative to the current working directory unless the pathname argument was absolute.

Example

textfiles = tools.glob("*.txt")

isdir(pathname)

Determines if a path is a directory.

Parameters:

pathname (str) – Path to a file or directory.

Returns:

True if the path is a directory, False otherwise.

Return type:

boolean

make_jobs(threads=None)

The option that sets the number of parallel jobs of make or Ninja.

Make and Ninja ignore the jobserver that they inherit through MAKEFLAGS when they are given a number of jobs, so the option is empty when there is a jobserver.

Parameters:

threads (int, optional) – Number of jobs to run without a jobserver. The default is thread_count().

Returns:

An option such as -j8, or an empty string.

Return type:

str

Example

tools.run("make {}", tools.make_jobs())

map_concurrent(callable, iterable, max_workers=None)

Concurrent ~map().

Parameters:

• callable – A callable object to be executed for each item in the collection.

• iterable – An iterable collection of items.

• max_workers (optional) – The maximum number of worker threads allowed to be spawned when performing the work. The default is the value returned by jolt.Tools.cpu_count().

Returns:

List of return values.

Return type:

list

Example

def compile(self, srcfile):
    objfile = srcfile + ".o"
    tools.run("gcc -c {0} -o {1}", srcfile, objfile)
    return objfile

srcfiles = ["test.c", "main.c"]
objfiles = tools.map_concurrent(compile, srcfiles)

map_consecutive(callable, iterable)

Same as map().

meson(deps=None, incremental=False)

Creates a Meson invokation helper

mkdir(pathname, recursively=True)

Create directory.

mkdirname(pathname, recursively=True)

Create parent directory.

move(src, dst)

Move/rename file.

Parameters:

• src (str) – Path to a file or directory to be moved.

• dest (str) – Destination path. If the destination is an existing directory, then src is moved inside that directory. If the destination already exists but is not a directory, it may be overwritten. If the destination is not on the same filesystem, the source file or directory is copied to the destination and then removed.

nixpkgs(nixfile=None, packages=None, pure=False, path=None, options=None)

Creates a Nix environment with the specified packages.

Parameters:

• nixfile (str) – Path to a Nix expression file.

• packages (list) – List of Nix packages to include in environment.

• pure (boolean) – Create a pure environment.

• path (list) – List of Nix expression paths.

• options (dict) – Nix configuration options.

Example

def run(self, deps, tools):
    with tools.nixpkgs(packages=["gcc13"]):
        tools.run("gcc --version")

popen(cmd, *args, **kwargs)

Runs a command in a shell interpreter and returns a file-like object for reading the command’s output. The object provides these functions:

• read(): Reads the command’s output until EOF and returns it as a string.

• readline(): Reads a single line of output from the command and returns it as a string.

• readlines(): Reads all lines of output from the command and returns them as a list of strings.

• write(): Writes a string to the command’s standard input.

• flush(): Flushes the command’s standard input stream.

• close(): Closes the command’s standard input stream.

These additional environment variables will be set when the command is run:

• JOLTDIR - Set to Task.joltdir

• JOLTCACHEDIR - Set to the location of the Jolt cache

A JoltCommandError exception is raised on failure.

Parameters:

• cmd (str) – Command format string.

• args – Positional arguments for the command format string.

• kwargs – Keyword arguments for the command format string.

• output (boolean, optional) – By default, the executed command’s output will be written to the console. Set to False to disable all output.

• output_on_error (boolean, optional) – If True, no output is written to the console unless the command fails. The default is False.

• output_rstrip (boolean, optional) – By default, output written to stdout is stripped from whitespace at the end of the string. This can be disabled by setting this argument to False.

• progress (callable, optional) – Called with every line written to stderr, including lines terminated by a carriage return which commands use to redraw progress indicators. Those lines are not logged. Other lines are logged unless the callable returns True. Default: None.

• shell (boolean, optional) – Use a shell to run the command. Default: True.

• timeout (int, optional) – Timeout in seconds. The command will first be terminated if the timeout expires. If the command refuses to terminate, it will be killed after an additional 10 seconds have passed. Default: None.

• new_session (boolean, optional) – If True, the command will be run in a new session. Default: False.

Example

with tools.popen("echo Hello, World!") as f:
    print(f.read())

read_depfile(pathname)

Reads a Make dependency file.

Returns:

Dictionary of files and their dependencies.

Return type:

dict

read_file(pathname, binary=False)

Reads a file.

read_json(pathname)

Reads a JSON file.

Parameters:

pathname (str) – Name/path of file to be read.

Returns:

Dictionary of JSON data.

Return type:

dict

render(template, **kwargs)

Render a Jinja template string.

Parameters:

• template (str) – Jinja template string.

• kwargs (dict) – Keywords made available to the template context. Task attributes are automatically available.

Returns:

Renderered template data.

Return type:

str

render_file(template, **kwargs)

Render a Jinja template file.

Parameters:

• template (str) – Filesystem path to template file.

• kwargs (dict) – Keywords made available to the template context. Task attributes are automatically available.

Returns:

Renderered template data.

Return type:

str

replace_in_file(pathname, search, replace, regex=False)

Replaces all occurrences of a substring in a file.

Parameters:

• pathname (str) – Name/path of file to modify.

• search (str) – Substring to be replaced.

• replace (str) – Replacement substring.

• regex (boolean) – Interpret search parameter as a regular expression matching the string to be replaced.

Example

version = Parameter(default="1.0")

def run(self, deps, tools):
    tools.replace_in_file("Makefile", "VERSION := 0.9", "VERSION := {version}")

rmtree(pathname, *args, **kwargs)

Removes a directory tree from disk.

Parameters:

• pathname (str) – Path to the file or directory to be removed.

• ignore_errors (boolean, optional) – Ignore files that can’t be deleted. The default is False.

rsync(srcpath, dstpath, *args, **kwargs)

Synchronizes files from one directory to another.

The function performs a smart copy of files from the srcpath directory to the dstpath directory in such a way that dstpath will mirror srcpath.

If dstpath is empty, the files are copied normally.

If dstpath already contains a sub or superset of the files in srcpath, files are either copied or deleted depending on their presence in the source directory. Common files are only copied if the file content differs, thereby retaining metadata (such as timestamps) of identical files already present in dstpath.

Parameters:

• srcpath (str) – Path to source directory. The directory must exist.

• dstpath (str) – Path to destination directory.

run(cmd, *args, **kwargs)

Runs a command in a shell interpreter.

These additional environment variables will be set when the command is run:

• JOLTDIR - Set to Task.joltdir

• JOLTCACHEDIR - Set to the location of the Jolt cache

A JoltCommandError exception is raised on failure.

Parameters:

• cmd (str) – Command format string.

• args – Positional arguments for the command format string.

• kwargs – Keyword arguments for the command format string.

• output (boolean, optional) – By default, the executed command’s output will be written to the console. Set to False to disable all output.

• output_on_error (boolean, optional) – If True, no output is written to the console unless the command fails. The default is False.

• output_rstrip (boolean, optional) – By default, output written to stdout is stripped from whitespace at the end of the string. This can be disabled by setting this argument to False.

• progress (callable, optional) – Called with every line written to stderr, including lines terminated by a carriage return which commands use to redraw progress indicators. Those lines are not logged. Other lines are logged unless the callable returns True. Default: None.

• shell (boolean, optional) – Use a shell to run the command. Default: True.

• timeout (int, optional) – Timeout in seconds. The command will first be terminated if the timeout expires. If the command refuses to terminate, it will be killed after an additional 10 seconds have passed. Default: None.

• new_session (boolean, optional) – If True, the command will be run in a new session. Default: False.

Returns:

stdout from command unless output=False

Return type:

str

Example

target = Parameter(default="all")
verbose = "yes"

def run(self, deps, tools):
    tools.run("make {target} VERBOSE={verbose} JOBS={0}", tools.cpu_count())

runprefix(cmdprefix, *args, **kwargs)

Adds a command prefix to all commands executed by run().

A new prefix is appended to any existing prefix.

Parameters:

• cmdprefix (str, list) – The command prefix. The string, or list, is expanded with expand().

• args (str, optional) – Additional positional values passed to expand().

• kwargs (str, optional) – Additional keyword values passed to expand().

Example

with tools.runprefix("docker exec container"):
    tools.run("ls")

The above code is equivalent to:

tools.run("docker exec container ls")

sandbox(artifact, incremental=False, reflect=False)

Creates a temporary build directory populated with the contents of an artifact.

Files are copied using rsync.

Parameters:

• artifact (cache.Artifact) – A task artifact to be copied into the sandbox.

• incremental (boolean) – If false, the created directory is deleted upon completion of the task.

• reflect (boolean) – If true, a virtual sandbox is constructed from artifact metadata only. Files are not copied, but instead symlinks are created pointing at the origin of each file contained within the artifact. The sandbox reflects the artifact with a live view of the the current workspace.

Returns:

Path to the build directory..

Return type:

str

Example

def run(self, deps, tools):
   sandbox = tools.sandbox(deps["boost"], incremental=True)

setenv(key, value=None)

Sets or unset an environment variable.

Only child processes spawned by the same tools object can see the set environment variable and its value. Don’t assume the same variable is set in the Jolt process’ environment.

Parameters:

• key (str) – Name of variable to set.

• value (str) – Value of the variable or None to unset it.

symlink(src, dst, replace=True, relative=True)

Creates a symbolic link.

Parameters:

• src (str) – Path to target file or directory.

• dst (str) – Name/path of symbolic link.

• replace (boolean) – Replace existing file or link. Default: false.

• relative (boolean) – Create link using relative path to target. Default: false (absolute path).

thread_count()

Number of threads to use for a task.

The number is configured with jolt.threads or JOLT_THREADS. A value of 0 selects the number of CPUs on the host.

Returns:

number of threads to use.

Return type:

int

timeout(seconds)

Context manager to set a timeout for a block of code.

A TimeoutError exception is raised if the block of code does not complete within the specified time.

Parameters:

seconds (int) – Timeout in seconds.

Example

with tools.timeout(5):
    tools.run("sleep 10")

tmpdir(name=None)

Creates a temporary directory.

The directory is only valid within a context and it is removed immediately upon leaving the context.

Parameters:

name (str) – Name prefix for the directory. A unique autogenerated suffix will also be appended to the final name.

Example

with tools.tmpdir() as tmp, tools.cwd(tmp):
    tools.write_file("tempfile", "tempdata")

unlink(pathname, *args, **kwargs)

Removes a file from disk.

To remove directories, use rmtree().

Parameters:

pathname (str) – Path to the file to be removed.

unshare(uid=0, gid=0, groups=[0], uidmap=None, gidmap=None)

Experimental: Create a Linux namespace.

This method yields a new Linux namespace in which Python code may be executed. By default, the current user is mapped to root inside the namespace and all other users and groups are automatically mapped to the other user’s configured subuids and subgids.

The main use-case for namespaces is to fake the root user which may be useful in a number of situations:

• to allow chroot() without beeing root

• to allow mount() without beeing root

• to preserve file ownership after tar file extraction

• etc…

Requires a Linux host.

Note that the fork() system call is used. Changes made to variables will not persist after leaving the namespace.

Parameters:

• uid (int) – Requested uid inside the namespace. This is always mapped to the uid of the caller.

• gid (int) – Requested gid inside the namespace. This is always mapped to the gid of the caller.

• uidmap (list) – List of uids to map in the namespace. A list of tuples is expected: (inner uid, outer id, number of ids to map).

• gidmap (list) – List of gids to map in the namespace. A list of tuples is expected: (inner gid, outer id, number of ids to map).

Example

with tools.unshare() as ns, ns:
    # Inside namespace
    tools.run("whoami")  # "root"
# Back outside namespace, namespace destructed

upload(pathname, url, exceptions=True, auth=None, **kwargs)

Uploads a file using HTTP (PUT).

Automatically expands any {keyword} arguments in the URL and pathname.

Basic authentication is supported by including the credentials in the URL. Environment variables can be used to hide sensitive information. Specify the environment variable name in the URI as e.g. http://{environ[USER]}:{environ[PASS]}@host. Alternatively, the auth parameter can be used to provide an authentication object that is passed to the requests.get() function.

Throws a JoltError exception on failure.

Parameters:

• pathname (str) – Name/path of file to be uploaded.

• url (str) – Destination URL.

• auth (requests.auth.AuthBase, optional) – Authentication helper. See requests.auth for details.

• kwargs (optional) – Addidional keyword arguments passed on directly to ~requests.put().

which(executable)

Find executable in PATH.

Parameters:

executable (str) – Name of executable to be found.

Returns:

Full path to the executable.

Return type:

str

write_file(pathname, content=None, expand=True, **kwargs)

Creates a file.

Note

Existing files are overwritten.

Parameters:

• pathname (str) – Name/path of file to be created.

• content (str, optional) – Data to be written to the file.

• expand (boolean, optional) – Expand macros in file content. Default: True.

• **kwargs (dict, optional) – Additional key value dictionary used in macro expansion.

write_json(pathname, data, indent=4, sort_keys=True)

Writes a JSON file.

Parameters:

• pathname (str) – Name/path of file to be written.

• data (dict) – Dictionary of JSON data.

• indent (int) – Indentation level for JSON output.

property wsroot

Return the root path of all build directories

CMake

CMake

class jolt.plugins.cmake.CMake(parameters=None, **kwargs)

Builds and publishes a CMake project

cmakelists = 'CMakeLists.txt'

Path to CMakeLists.txt or directory containing CMakelists.txt

options = []

Options passed to CMake, as option[:type]=value.

Conan

Conan

class jolt.plugins.conan.Conan2(*args, **kwargs)

Conan package installer task.

This task base class can be used to fetch, build and publish Conan packages as Jolt artifacts. All package metadata is transfered from the Conan package manifest to the Jolt artifact so that no manual configuration of include paths, library paths, macros, etc is required.

An existing installation of Conan is required. Please visit https://conan.io/ for installation instructions and documentation.

A minimal task to download and publish the Boost C++ libraries can look like this:

from jolt.plugins.conan import Conan

class Boost(Conan):
    packages = ["boost/1.74.0"]

Boost may then be used from Ninja tasks by declaring a requirement:

from jolt.plugins.ninja import CXXExecutable

class BoostApplication(CXXExecutable):
    requires = ["boost"]
    sources = ["main.cpp"]

The task supports using an existing conanfile.txt, but it is not required. Packages are installed into and collected from Jolt build directories. The user’s regular Conan cache will not be affected.

conanfile = None

An existing conanfile.txt file to use.

Instead of generating the conanfile.txt file on-demand, an external file may be used. If this attribute is set, the generators, options and packages attributes must not be set.

See Conan documentation for further details.

incremental = True

Keep installed packages in the Conan cache between Jolt invokations.

If incremental build is disabled, the Jolt Conan cache is removed before execution begins.

options = []

A list of Conan package options to apply

The option format is PkgName:Option=Value. See Conan documentation for further details.

Any {keyword} arguments, or macros, found in the strings are automatically expanded to the value of the associated task’s parameters and properties.

Example:

options = [
    "boost:shared=True",
    "zlib:shared=True",
]

packages = []

A list of Conan package references to collect and publish.

The reference format is PkgName/<version>@user/channel. See Conan documentation for further details.

Any {keyword} arguments, or macros, found in the strings are automatically expanded to the value of the associated task’s parameters and properties.

Example:

sdl_version = Parameter("2.0.12")

packages = [
    "boost/1.74.0",
    "sdl2/{sdl_version}@bincrafters/stable",
]

remotes = {}

A dictionary with Conan remotes to use when fetching packages.

The dictionary key is the name of remote and its value is the URL.

Example:

remotes = {
    "bincrafters": "https://api.bintray.com/conan/bincrafters/public-conan"
}

Docker

DockerClient

class jolt.plugins.docker.DockerClient(parameters=None, **kwargs)

Task: Downloads and publishes the Docker command line client.

The task will be automatically made available after importing jolt.plugins.docker.

arch = <jolt.tasks.Parameter object>

Host architecture [x86_64]

host = <jolt.tasks.Parameter object>

Host operating system [autodetected]

name = 'docker/cli'

Name of the task

url = 'https://download.docker.com/{host}/static/stable/{arch}/docker-{version}.tgz'

URL of binaries

version = <jolt.tasks.Parameter object>

Docker version [27.4.1]

DockerContainer

class jolt.plugins.docker.DockerContainer(*args, **kwargs)

Resource: Starts and stops a Docker container.

arguments = []

Container argument list

cap_adds = []

A list of capabilities to add to the container

cap_drops = []

A list of capabilities to remove from the container

entrypoint = None

Container entrypoint

environment = []

Environment variables

image = None

Image tag or Jolt task.

If a Jolt task is specified, its artifact must export a metadata string named tag with the name of the image tag.

labels = []

A list of container metadata labels

ports = []

A list of container ports to publish.

Example:

ports = [
    "80",
    "443:443",
]

Alternatively, assign True to publish all exposed ports to random ports.

privileged = False

Start container with elevated privileges.

user = None

Username or UID.

Defaults to the current user.

volumes = []

A list of volumes to mount.

By default, the cache directory and joltdir are automatically mounted in the container. See volumes_default.

volumes_default = ['{joltdir}:{joltdir}', '{joltcachedir}:{joltcachedir}']

A list of default volumes to mount.

By default, the cache directory and joltdir are automatically mounted in the container. Override to disable.

DockerImage

class jolt.plugins.docker.DockerImage(*args, **kwargs)

Abstract Task: Builds and publishes a Docker image.

Builds the selected Dockerfile and optionally tags and pushes the image to a registry. The image can also be saved to file and published in the task artifact. Compression formats supported are bzip2, gzip and lzma.

By default, base images referenced in the Dockerfile will be pulled during the build. Note that Jolt has no way of knowing beforehand if images have been updated in the registry. Use time-based influence to trigger rebuilds if it’s important that base images are kept up-to-date.

No automatic influence for Dockerfile or context is collected. Make sure to use an appropriate influence decorator.

Optionally add requirements to:

• docker/cli to provision the Docker client, if none is available on the host.

• docker/login to automatically login to the Docker registry.

This class must be subclassed.

Example:

# Dockerfile

FROM busybox:latest
CMD ["busybox"]

# build.jolt

from jolt.plugins.docker import DockerImage

class Busybox(DockerImage):
    """ Publishes Busybox image as gzip-compressed tarball """
    compression = "gz"
    requires = ["docker/cli"]
    tags = ["busybox:{identity}"]

autoload = True

Automatically load image file into local registry when the artifact is consumed by another task.

If the built image is saved to a file (i.e. imagefile is set), the image file is automatically loaded into the local Docker registry when the task artifact is consumed by another task. The image is also automatically removed from the registry upon completion of the consumer task.

Default: True.

buildargs = []

List of build arguments and their values (“ARG=VALUE”).

The arguments are passed to Docker using --build-arg.

cleanup = True

Remove image from Docker daemon upon completion [True]

compression = None

Optional image compression “bz2”, “gz”, or “xz”.

context = '.'

Path to build context, relative to joltdir (directory).

dockerfile = 'Dockerfile'

Path to the Dockerfile to build, or the full source code of such a file.

extract = False

Extract image and publish rootfs tree.

This option is useful when building a chroot to be used with jolt.Tools.chroot(). It disables saving of the image to a tarball.

imagefile = '{canonical_name}.tar'

Name of the image tarball published by the task.

If set to None, no image file will be saved and published.

Defaults to the task’s canonical name.

labels = []

A list of image metadata labels

platform = {}

Dictionary of task platform requirements.

Platform requirements control where tasks are allowed to execute. Multiple requirement key/values may be specified in which case all must be fulfilled in order for the task to be schedulable on a node.

The following builtin requirement labels exist:

• node.arch [“arm”, “amd64”]

• node.os [“linux”, “windows”]

Example

class Hello(Task):
    # This task must run on Linux.
    platform = {
        "node.os": "linux",
    }

pull = True

Always pull images when building.

Passes –pull to the Docker client.

push = False

Optionally push image to registry [False]

To be able to push images, the current user must login to the Docker Registry. The docker/login Jolt resource can be used for that purpose.

squash = False

Squash image layers

tags = ['{canonical_name}:{identity}']

Optional list of image tags. Defaults to task’s canonical name.

DockerLogin

class jolt.plugins.docker.DockerLogin(*args, **kwargs)

Resource: Logs in and out of a Docker Registry.

If the user and password parameters are unset, credentials are fetched from the environment variables:

• DOCKER_USER

• DOCKER_PASSWD

The resource will be automatically made available after importing jolt.plugins.docker.

name = 'docker/login'

Name of the resource

passwd = <jolt.tasks.Parameter object>

Docker Registry password.

If not set, the environment variable DOCKER_PASSWD is read instead.

user = <jolt.tasks.Parameter object>

Docker Registry username.

If not set, the environment variable DOCKER_USER is read instead.

Metadata

The Docker module registers and makes available these artifact metadata attributes:

• artifact.docker.load - List of image files to be loaded from the artifact into the local Docker registry when the artifact is consumed.

  Example:

  def publish(self, artifact, tools):
      artifact.docker.load.append("image.tar")
  

• artifact.docker.pull - List of image tags to be pulled from a remote registry to the local Docker registry when the artifact is consumed.

  Example:

  def publish(self, artifact, tools):
      artifact.docker.pull.append("busybox:latest")
  

• artifact.docker.rmi - List of image tags to remove from the local Docker registry when a consuming task has finished.

  Example:

  def publish(self, artifact, tools):
      artifact.docker.rmi.append("busybox:latest")
  

Google Test

This module provides the GTestRunner task base class, a derivation of jolt.tasks.Runner for running Google Test applications. Several parameters can be assigned or overidden to control the behavior.

Example

examples/googletest/runner.jolt

from jolt.pkgs import googletest
from jolt.plugins.googletest import GTestRunner
from jolt.plugins.ninja import CXXExecutable


class Test(CXXExecutable):
    cxxflags = ["-std=c++17"]
    requires = ["gtest/main"]
    sources = ["test.cpp"]


class Run(GTestRunner):
    requires = ["test"]
    shuffle = False

The module also provides a set of task decorators for use with standalone task classes. They set different GTEST_* environment variables to control the behavior of Google Test executables in the same manner as the parameters in GTestRunner do.

Example

from jolt import Task
from jolt.plugins import googletest

# ....

@googletest.fail_fast(default=True)
@googletest.repeat(default=10)
@googletest.filter()
@googletest.junit_report()
class TestRunner(Task):
    requires = ["test"]

    def run(self, deps, tools):
        tools.run("unittest")

$ jolt build testrunner:repeat=1,filter=TestModule.*

jolt.plugins.googletest.break_on_failure(default: bool = False, param: bool = True, attr: str = 'break_on_failure')

Task class decorator controlling the GTEST_BREAK_ON_FAILURE environment variable.

When the variable is set, test applications failures trigger breakpoints. On Linux, this typically results in a core dump that can be loaded into the debugger.

The value is taken from the parameter break_on_failure which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.brief(default: bool = False, param: bool = True, attr: str = 'brief')

Task class decorator controlling the GTEST_BRIEF environment variable.

When the variable is set, only failed test-cases are logged.

The value is taken from the parameter brief which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

GoogleTest version >= 1.11 is required.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.disabled(default: bool = False, param: bool = True, attr: str = 'disabled')

Task class decorator controlling the GTEST_ALSO_RUN_DISABLED_TESTS environment variable.

When the variable is set, disabled test-cases are also run.

The value is taken from the parameter disabled which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.fail_fast(default: bool = False, param: bool = True, attr: str = 'fail_fast')

Task class decorator controlling the GTEST_FAIL_FAST environment variable.

When the variable is set, test applications will abort when the first failure is found.

The value is taken from the parameter fail_fast which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.filter(default: str = '*', param: bool = True, attr: str = 'filter')

Task class decorator controlling the GTEST_FILTER environment variable.

The variable instructs test applications to only run test-cases that matches a wildcard filter string (default: *).

The value is taken from the parameter filter which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.json_report()

Decorator enabling JSON test reporting in Google Test applications.

The decorator sets the GTEST_OUTPUT environment, thereby instructing test applications to write a JSON report file upon test completion. The task publishes the report in the task artifact under report/json/.

Any errors found in the report are parsed and attached to the task. They are included in email reports if the email plugin is enabled.

jolt.plugins.googletest.junit_report()

Decorator enabling JUnit test reporting in Google Test applications.

The decorator sets the GTEST_OUTPUT environment, thereby instructing test applications to write a JUnit report file upon test completion. The task publishes the report in the task artifact under report/junit/.

Any errors found in the report are parsed and attached to the task. They are included in email reports if the email plugin is enabled.

jolt.plugins.googletest.repeat(default: int = 1, param: bool = True, attr: str = 'repeat')

Task class decorator controlling the GTEST_REPEAT environment variable.

The variable instructs test applications to repeat test-cases the specified number of times.

The value is taken from the parameter repeat which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.seed(default: int = 0, param: bool = True, attr: str = 'seed')

Task class decorator controlling the GTEST_RANDOM_SEED environment variable.

The variable sets an initial value for the random number generator used to shuffle test-cases. In order to reproduce ordering issues, a user may assign a specific seed to get the same test-case order. The default value is 0 which causes Google Test to use time as the seed.

The value is taken from the parameter seed which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

jolt.plugins.googletest.shuffle(default: bool = False, param: bool = True, attr: str = 'shuffle')

Task class decorator controlling the GTEST_SHUFFLE environment variable.

When set, the test application runs its test-cases in random order. In order to reproduce test-case ordering issues, a user may assign a specific random number generator seed to get the same test-case execution order. See seed().

The value is taken from the parameter shuffle which is created by default. If no parameter is created, the value is instead taken from the class attribute with the same name. The name of the paramter/attribute can be changed.

Parameters:

• default (boolean) – Default value of the parameter and env. variable. Default: False.

• param (boolean) – Create a task parameter. Default: True.

• attr (str) – Name of parameter or class attribute.

class jolt.plugins.googletest.GTestRunner(parameters=None, **kwargs)

Abstract task base class that runs Google Test applications.

Test executables are consumed from requirement artifacts. The artifacts must export metadata indicating the name of the binary, using artifact.strings.executable.

A number of parameters can be assigned from the command line to control the behavior of the task. Parameters can also be overridden using regular Python class attributes in subclasses.

A JUnit test report is generated and published in the task artifact. The results of the report are also imported into Jolt and distributed with report emails if the email plugin has been enabled.

Example:

examples/googletest/runner.jolt

from jolt.pkgs import googletest
from jolt.plugins.googletest import GTestRunner
from jolt.plugins.ninja import CXXExecutable


class Test(CXXExecutable):
    cxxflags = ["-std=c++17"]
    requires = ["gtest/main"]
    sources = ["test.cpp"]


class Run(GTestRunner):
    requires = ["test"]
    shuffle = False

break_on_failure = <jolt.tasks.BooleanParameter object>

Trigger breakpoint on test-case failure.

brief = <jolt.tasks.BooleanParameter object>

Only print failed test-cases.

disabled = <jolt.tasks.BooleanParameter object>

Also run disabled test-cases.

fail_fast = <jolt.tasks.BooleanParameter object>

Stop when the first failure is found.

filter = <jolt.tasks.Parameter object>

Test-case filter.

repeat = <jolt.tasks.IntParameter object>

Test-case repetitions.

seed = <jolt.tasks.IntParameter object>

Random number generator seed.

shuffle = <jolt.tasks.BooleanParameter object>

Randomize test-case execution order.

Linux

class jolt.plugins.linux.ArchParameter(*args, **kwargs)

Linux target architecture parameter.

Supported values:

• amd64

• arm

• arm64

• armv5

• mips

• powerpc

• riscv

• s390

• x86

class jolt.plugins.linux.DebianHostSdk(parameters=None, **kwargs)

Helper task that exports a Debian host’s cross-compiler toolchains to consumers.

The task verifies that the cross-compiler toolchains are installed on the host. If not, the task will raise an error with instructions.

Exported environment variables:

• CC: Cross-compiler

• CPP: Cross-preprocessor

• CXX: Cross-C++ compiler

• CROSS_COMPILE: Cross-compile prefix

arch = <jolt.plugins.linux.ArchParameter object>

Target architecture [amd64, arm, arm64, armv5, mips, powerpc, riscv, s390, x86]

class jolt.plugins.linux.FIT(parameters=None, **kwargs)

Builds and publishes a FIT Image.

The task builds a FIT image using the given kernel, device tree and ramdisk tasks and publishes the resulting image. Multiple FIT configurations can be created by defining the configs attribute. The image is optinally signed using the provided key.

The task requires the mkimage tool to be available in PATH.

configs = {}

FIT configurations to create.

Dictionary of 2 or 3 element tuples according to this format:

configs = {
  "<name of config>": ("<name of kernel task>", "<name of dtb>"),
  "<name of config with ramdisk>": ("<name of kernel task>", "<name of dtb>", "<name of ramdisk task>"),
}

Example:

requires = [
  "kernel=linux/kernel:arch=arm,targets=dtbs+binary_gz,defconfig=bcm2835",
  "ramdisk=busybox/irfs:arch=armv7"
]

configs = {
  "conf-rpi0w": ("kernel", "bcm2835-rpi-zero-w.dtb"),
  "conf-rpi0w-irfs": ("kernel", "bcm2835-rpi-zero-w.dtb", "ramdisk"),
}

Loaded from defs/{defconfig}.py

signature_key_name = None

Name of key used to sign image. If None, image won’t be signed.

signature_key_path = None

Directory path to signature key

class jolt.plugins.linux.Initramfs(*args, **kwargs)

Builds an initramfs image using Podman.

The task builds the initramfs image using the given Dockerfile and publishes the resulting cpio archive. The task requires the following attributes to be set:

• arch: Target architecture

• dockerfile: Path to Dockerfile, or Dockerfile content.

When building images for an architecture other than the host, the binfmt-support package must be installed and configured to support the target architecture. The package is available in most Linux distributions.

The location of the resulting cpio archive is stored in the ‘artifact.paths.cpio’ attribute.

arch = <jolt.plugins.linux.ArchParameter object>

Target architecture [amd64, arm, arm64, armv5, mips, powerpc, riscv, s390, x86]

dockerfile = 'Dockerfile'

Path to the Dockerfile to build, or the full source code of such a file.

class jolt.plugins.linux.Kernel(parameters=None, **kwargs)

Builds kernel makefile target(s) and publishes the result.

Targets are selected by assigning the targets parameter. The following values are supported:

• binary: Build kernel binary

• dtbs: Build device trees

• dtc: Build device tree compiler

• gzimage: Build gzipped kernel image

• image: Build kernel image

• modules: Build kernel modules

• uimage: Build uImage

• vmlinux: Build vmlinux

• zimage: Build zImage

Mutliple targets can be selected at once, such as vmlinux+dtbs+modules. The resulting artifacts are published into different directories based on the target name.

It is recommended to use a task dependency to setup the required tools by adding them to PATH and/or setting the CROSS_COMPILE environment variable. When building on a Debian host, the jolt.plugins.linux.DebianHostSdk helper task can be used to export the cross-compiler tools.

The following tools are required to be available in PATH:

• bison

• flex

• make

• gcc

Artifact path attributes are created to point to the published files.

arch = <jolt.plugins.linux.ArchParameter object>

Linux target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86]

configpaths = ['{srcdir}/arch/{arch}/configs']

Paths to configuration file snippets.

When building the kernel with features, the task will search for feature configuration snippets in these directories. The snippets are applied and merged with the selected defconfig.

defconfig = <jolt.tasks.Parameter object>

Default configuration

defconfigpath = 'arch/{arch}/configs/{defconfig}_defconfig'

Path to defconfig file.

dtbs = []

List of device trees to build when the ‘dtbs’ target is requested.

If empty, all device trees associated with the target architecture are built.

features = <jolt.tasks.ListParameter object>

List of feature configuration snippets to apply.

If used, the task will search for feature configuration snippets in the configured paths and merge them into the selected defconfig.

loadaddr = 0

Kernel load address.

loadaddr_fdt = 0

Device-tree load address.

srcdir = None

Location of Linux kernel source tree

targets = <jolt.tasks.ListParameter object>

Build targets [binary, dtbs, dtc, gzimage, image, modules, uimage, vmlinux, zimage]

class jolt.plugins.linux.Module(parameters=None, **kwargs)

Builds a kernel module from external source tree.

The task is based on the Kernel task and builds a kernel module from the given source tree specified by the srcdir_module attribute. The targets attribute is set to modules by default.

See Kernel for additional information on building kernel targets. In particular, the srcdir attribute must be set to the kernel source tree to build the modules against.

arch = <jolt.plugins.linux.ArchParameter object>

Linux target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86]

configpaths = ['{srcdir}/arch/{arch}/configs']

Paths to configuration file snippets.

When building the kernel with features, the task will search for feature configuration snippets in these directories. The snippets are applied and merged with the selected defconfig.

defconfig = <jolt.tasks.Parameter object>

Default configuration

defconfigpath = 'arch/{arch}/configs/{defconfig}_defconfig'

Path to defconfig file.

features = <jolt.tasks.ListParameter object>

List of feature configuration snippets to apply.

If used, the task will search for feature configuration snippets in the configured paths and merge them into the selected defconfig.

srcdir = None

Location of Linux kernel source tree

srcdir_module = None

Path to kernel module source tree

class jolt.plugins.linux.Qemu(parameters=None, **kwargs)

Runs Qemu with the given kernel, initramfs and rootfs.

The task automatically selects the correct Qemu binary for the architecture and builds the command line arguments based on the provided kernel, initramfs and rootfs tasks.

Additional arguments can be passed to QEMU by setting the arguments attribute.

The selected Qemu binary must be available in PATH.

arch = <jolt.plugins.linux.ArchParameter object>

Target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86]

arguments = []

Additional arguments to pass to QEMU

dtb = None

Path to device tree in kernel artifact

initrd = None

Name of initrd/ramfs task, if any

kernel = None

Name of kernel task

machine = None

Target machine

memory = None

512M

Type:

Memory size. Example

rootfs = None

Name of rootfs task, if any

class jolt.plugins.linux.Squashfs(*args, **kwargs)

Builds a squashfs image using Podman.

The task builds a container image using the given Dockerfile and converts the resulting container filesystem to a squashfs image which is published.

When building images for an architecture other than the host, the binfmt-support package must be installed and configured to support running applications for the target architecture. The package is available in most Linux distributions.

The location of the resulting squashfs image is stored in the artifact.paths.squashfs artifact attribute.

arch = <jolt.plugins.linux.ArchParameter object>

Target architecture [amd64, arm, arm64, armv5, mips, powerpc, riscv, s390, x86]

dockerfile = 'Dockerfile'

Path to the Dockerfile to build, or the full source code of such a file.

size = None

Size of the squashfs image.

Typically used to align the image size to a supported SD card size (power of two).

Supported units are ‘K’, ‘M’, ‘G’, ‘T’.

class jolt.plugins.linux.UBoot(parameters=None, **kwargs)

Builds u-boot makefile target(s) and publishes the result.

An implementor must subclass this task and set the following attributes:

• srcdir: Path to U-boot source tree

It is recommended to use a task dependency to setup the required tools by adding them to PATH and/or setting the CROSS_COMPILE environment variable. When building on a Debian host, the jolt.plugins.linux.DebianHostSdk helper task can be used to export the cross-compiler tools.

arch = <jolt.plugins.linux.ArchParameter object>

Linux target architecture [amd64, arm, arm64, mips, powerpc, riscv, s390, x86]

configpaths = ['{srcdir}/arch/{arch}/configs']

Paths to configuration file snippets.

When building the kernel with features, the task will search for feature configuration snippets in these directories. The snippets are applied and merged with the selected defconfig.

defconfig = <jolt.tasks.Parameter object>

Default configuration

defconfigpath = 'arch/{arch}/configs/{defconfig}_defconfig'

Path to defconfig file.

features = <jolt.tasks.ListParameter object>

List of feature configuration snippets to apply.

If used, the task will search for feature configuration snippets in the configured paths and merge them into the selected defconfig.

srcdir = None

Location of Linux kernel source tree

targets = <jolt.tasks.ListParameter object>

Build targets [tools, uboot]

Ninja

CXXExecutable

class jolt.plugins.ninja.CXXExecutable(*args, **kwargs)

Builds a C/C++ executable.

The task recognizes these source file types: .asm, .c, .cc, .cpp, .cxx, .h, .hh, .hpp, .hxx, .pch, .s, .S

Other file types can be supported through additional rules, see the Rule class.

On Linux, GCC/Binutils is the default toolchain used. The default toolchain can be overridden by setting the environment variables AR, CC, CXX and LD. The prefered method is to assign these variables through the artifact of a special task that you depend on.

On Windows, Visual Studio is the default toolchain and it must be present in the PATH. Run Jolt from a developer command prompt.

Additionally, these environment variables can be used to customize toolchain behavior on any platform:

• ASFLAGS - compiler flags used for assembly code

• CFLAGS - compiler flags used for C code

• CXXFLAGS - compiler flags used for C++ code

• LDFLAGS - linker flags

asflags = []

A list of compiler flags used when compiling assembler files.

binary = None

Name of the target binary. Defaults to the canonical task name.

cflags = []

A list of compiler flags used when compiling C files.

coverage = False

Enable code coverage instrumentation.

Only implemented for GCC/Clang toolchains.

When set, the –coverage flag is passed to the compiler. The compiler instruments the generated machine code and outputs coverage note files (.gcno), one for each translation unit, which are collected into the task artifact. Upon running the executable, coverage data files are generated.

Use the attributes.coverage_data() decorator to automatically collect and publish data files in tasks that run instrumented binaries. The attributes.coverage_report_gcov() decorator can then be used to process the notes and data files into human readable coverage information. There is also a attributes.coverage_report_lcov() decorator that will generate and publish an HTML coverage report.

Example

examples/code_coverage/coverage.jolt

from jolt import Runner, Task
from jolt.plugins import ninja


class Exe(ninja.CXXExecutable):
    """ Builds executable with code coverage instrumentation """
    coverage = True
    sources = ["main.cpp"]


@ninja.attributes.coverage_data()
class Run(Runner):
    """ Runs executable and collects coverage data """
    requires = ["exe"]


@ninja.attributes.coverage_report_lcov()
class LcovReport(Task):
    """ Generates HTML report from code coverage data """
    name = "report/lcov"
    requires = ["run"]


@ninja.attributes.coverage_report_gcov()
class GcovReport(Task):
    """ Generates gcov report from code coverage data """
    name = "report/gcov"
    requires = ["run"]

cstd = None

Compiler default

If the chosen standard is not supported, the nearest supported standard is selected.

Type:

C language standard to use (int). Default

cxxflags = []

A list of compiler flags used when compiling C++ files.

cxxstd = None

Compiler default

If the chosen standard is not supported, the nearest supported standard is selected.

Type:

C++ language standard to use (int). Default

incpaths = []

List of preprocessor include paths

incremental = True

Compile incrementally.

If incremental build is disabled, all intermediate files from a previous build will be removed before the execution begins.

ldflags = []

A list of linker flags to use.

libpaths = []

A list of library search paths used when linking.

libraries = []

A list of libraries to link with.

macros = []

List of preprocessor macros to set

optimize = 'release'

Compiler optimization level.

Supported values are:

• “none” / None

• “debug”

• “size”

• “release”

publishdir = 'bin/'

The artifact path where the binary is published.

selfsustained = True

Consume this executable independently from its requirements.

When self-sustained, all shared libraries listed as requirements are published toghether with the executable.

See Task.selfsustained for general information.

sources = []

A list of sources to compile.

Path names may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

Example

sources = ["src/*.cpp"]

source_influence = True

Let the contents of source files influence the identity of the task artifact.

When True, a source file listed in the sources attribute will cause a rebuild of the task if modified.

Source influence can hurt performance since every files needs to be hashed. It is safe to set this flag to False if all source files reside in a git repository listed as a dependency with the requires attribute or if the task uses the git.influence decorator.

Always use source_influence if you are unsure whether it is needed or not.

strip = True

Remove debug information from binary.

When using the GNU toolchain, debug information is kept in a separate binary which is either published or not depending on the value of this attribute. It’s found in a .debug directory if present.

Only applicable to shared libraries.

debugshell(deps, tools)

Invoked to start a debug shell.

The method prepares the environment with attributes exported by task requirement artifacts. The shell is entered by passing the -g flag to the build command.

For Ninja tasks, a special compile command is made available inside the shell. The command can be used to compile individual source files which is useful when troubleshooting compilation errors. Run compile -h for help.

Task execution resumes normally when exiting the shell.

publish(artifact, tools)

Publishes the linked executable.

By default, the executable is collected into a directory as specified by the publishdir class attribute. The relative path of the executable within the artifact is exported as a metadata string. It can be read by consumers by accessing artifact.strings.executable.

The method appends the PATH environment variable with the path to the executable to allow consumers to run it easily.

run(deps, tools)

Generates a Ninja build file and invokes Ninja to build the project.

The build file and all intermediate files are written to a build directory within the workspace. By default, the directory persists between different invokations of Jolt to allow projects to be built incrementally. The behavior can be changed with the incremental class attribute.

CXXLibrary

class jolt.plugins.ninja.CXXLibrary(*args, **kwargs)

Builds a C/C++ library.

The task recognizes these source file types: .asm, .c, .cc, .cpp, .cxx, .h, .hh, .hpp, .hxx, .pch, .s, .S

Other file types can be supported through additional rules, see the Rule class.

On Linux, GCC/Binutils is the default toolchain used. The default toolchain can be overridden by setting the environment variables AR, CC, CXX and LD. The prefered method is to assign these variables through the artifact of a special task that you depend on.

On Windows, Visual Studio is the default toolchain and it must be present in the PATH. Run Jolt from a developer command prompt.

Additionally, these environment variables can be used to customize toolchain behavior on any platform:

• ASFLAGS - compiler flags used for assembly code

• CFLAGS - compiler flags used for C code

• CXXFLAGS - compiler flags used for C++ code

• LDFLAGS - linker flags

asflags = []

A list of compiler flags used when compiling assembler files.

binary = None

Name of the target binary. Defaults to the canonical task name.

cflags = []

A list of compiler flags used when compiling C files.

coverage = False

Enable code coverage instrumentation.

Only implemented for GCC/Clang toolchains.

When set, the –coverage flag is passed to the compiler. The compiler instruments the generated machine code and outputs coverage note files (.gcno), one for each translation unit, which are collected into the task artifact. Upon running the executable, coverage data files are generated.

Use the attributes.coverage_data() decorator to automatically collect and publish data files in tasks that run instrumented binaries. The attributes.coverage_report_gcov() decorator can then be used to process the notes and data files into human readable coverage information. There is also a attributes.coverage_report_lcov() decorator that will generate and publish an HTML coverage report.

Example

examples/code_coverage/coverage.jolt

from jolt import Runner, Task
from jolt.plugins import ninja


class Exe(ninja.CXXExecutable):
    """ Builds executable with code coverage instrumentation """
    coverage = True
    sources = ["main.cpp"]


@ninja.attributes.coverage_data()
class Run(Runner):
    """ Runs executable and collects coverage data """
    requires = ["exe"]


@ninja.attributes.coverage_report_lcov()
class LcovReport(Task):
    """ Generates HTML report from code coverage data """
    name = "report/lcov"
    requires = ["run"]


@ninja.attributes.coverage_report_gcov()
class GcovReport(Task):
    """ Generates gcov report from code coverage data """
    name = "report/gcov"
    requires = ["run"]

cstd = None

Compiler default

If the chosen standard is not supported, the nearest supported standard is selected.

Type:

C language standard to use (int). Default

cxxflags = []

A list of compiler flags used when compiling C++ files.

cxxstd = None

Compiler default

If the chosen standard is not supported, the nearest supported standard is selected.

Type:

C++ language standard to use (int). Default

headers = []

List of public headers to be published with the artifact

incpaths = []

List of preprocessor include paths

incremental = True

Compile incrementally.

If incremental build is disabled, all intermediate files from a previous build will be removed before the execution begins.

ldflags = []

A list of linker flags to use.

libpaths = []

A list of library search paths used when linking.

libraries = []

A list of libraries to link with.

macros = []

List of preprocessor macros to set

optimize = 'release'

Compiler optimization level.

Supported values are:

• “none” / None

• “debug”

• “size”

• “release”

publishapi = 'include/'

The artifact path where public headers are published.

publishdir = 'lib/'

The artifact path where the library is published.

selfsustained = False

Consume this library independently from its requirements.

When self-sustained, all static libraries listed as requirements are merged into the final library. Merging can also be achieved by listing libraries as source files.

See Task.selfsustained for general information.

sources = []

A list of sources to compile.

Path names may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

Example

sources = ["src/*.cpp"]

source_influence = True

Let the contents of source files influence the identity of the task artifact.

When True, a source file listed in the sources attribute will cause a rebuild of the task if modified.

Source influence can hurt performance since every files needs to be hashed. It is safe to set this flag to False if all source files reside in a git repository listed as a dependency with the requires attribute or if the task uses the git.influence decorator.

Always use source_influence if you are unsure whether it is needed or not.

strip = True

Remove debug information from binary.

When using the GNU toolchain, debug information is kept in a separate binary which is either published or not depending on the value of this attribute. It’s found in a .debug directory if present.

Only applicable to shared libraries.

debugshell(deps, tools)

Invoked to start a debug shell.

The method prepares the environment with attributes exported by task requirement artifacts. The shell is entered by passing the -g flag to the build command.

For Ninja tasks, a special compile command is made available inside the shell. The command can be used to compile individual source files which is useful when troubleshooting compilation errors. Run compile -h for help.

Task execution resumes normally when exiting the shell.

publish(artifact, tools)

Publishes the library.

By default, the library is collected into a directory as specified by the publishdir class attribute. Library path metadata for this directory as well as linking metadata is automatically exported. The relative path of the library within the artifact is also exported as a metadata string. It can be read by consumers by accessing artifact.strings.library.

Public headers listed in the headers class attribute are collected into a directory as specified by the publishapi class attribute. Include path metadata for this directory is automatically exported.

run(deps, tools)

Generates a Ninja build file and invokes Ninja to build the project.

The build file and all intermediate files are written to a build directory within the workspace. By default, the directory persists between different invokations of Jolt to allow projects to be built incrementally. The behavior can be changed with the incremental class attribute.

Decorators

class jolt.plugins.ninja.attributes

static asflags(attrib, prepend=False)

Decorates a task with an alternative asflags attribute.

The new attribute will be concatenated with the regular asflags attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static cflags(attrib, prepend=False)

Decorates a task with an alternative cflags attribute.

The new attribute will be concatenated with the regular asflags attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static coverage_data(publish=True)

Task decorator collecting coverage data files (.gcda) from instrumented executables.

The decorator sets the GCOV_PREFIX environment variable during execution of the task. Data files generated by instrumented executable are then collected into a dedicated build directory and published upon completion of the task.

The decorator also republishes coverage note files found in dependency artifacts.

The task artifact is annotated with artifact.paths.coverage_data which points out the path to the data files within the artifact.

Parameters:

publish (boolean) – Publish coverage data with artifact. Default: True.

Example

examples/code_coverage/coverage.jolt

from jolt import Runner, Task
from jolt.plugins import ninja


class Exe(ninja.CXXExecutable):
    """ Builds executable with code coverage instrumentation """
    coverage = True
    sources = ["main.cpp"]


@ninja.attributes.coverage_data()
class Run(Runner):
    """ Runs executable and collects coverage data """
    requires = ["exe"]


@ninja.attributes.coverage_report_lcov()
class LcovReport(Task):
    """ Generates HTML report from code coverage data """
    name = "report/lcov"
    requires = ["run"]


@ninja.attributes.coverage_report_gcov()
class GcovReport(Task):
    """ Generates gcov report from code coverage data """
    name = "report/gcov"
    requires = ["run"]

static coverage_report_gcov(branches=True, demangle=True, coverage_data=False)

Decorator generating gcov reports from collected coverage data.

A gcov report file is generated for each instrumented source file in the executable. The reports consists of plain-text source code annotated with code coverage details.

The decorator can be used standalone or in combination with coverage_data(). In either case, coverage data is collected from dependency artifacts and processed together with any data generated by the task itself.

The following class attributes may be set to control the behavior of lcov:

• gcov_branches - Enable branch coverage. Passed as -b on the command line. Default: True

• gcov_demangle - Display demangled function names in output. Passed as -m on the command line. Default: True

The task artifact is annotated with artifact.paths.coverage_report_gcov which points out the path to the gcov reports within the artifact.

A gcov executable must exist in PATH. Set the GCOV environment variable to override its default name.

Parameters:

• branches (boolean) – Enable branch coverage. Default: True. Overridden by class attribute gcov_branches, if set.

• demangle (boolean) – Display demangled function names in output. Default: True. Overridden by class attribute gcov_demangle, if set.

• coverage_data (boolean) – Republish coverage data found in dependency artifacts. Default: False Overridden by class attribute gcov_coverage_data, if set.

Example

examples/code_coverage/coverage.jolt

from jolt import Runner, Task
from jolt.plugins import ninja


class Exe(ninja.CXXExecutable):
    """ Builds executable with code coverage instrumentation """
    coverage = True
    sources = ["main.cpp"]


@ninja.attributes.coverage_data()
class Run(Runner):
    """ Runs executable and collects coverage data """
    requires = ["exe"]


@ninja.attributes.coverage_report_lcov()
class LcovReport(Task):
    """ Generates HTML report from code coverage data """
    name = "report/lcov"
    requires = ["run"]


@ninja.attributes.coverage_report_gcov()
class GcovReport(Task):
    """ Generates gcov report from code coverage data """
    name = "report/gcov"
    requires = ["run"]

static coverage_report_lcov(branches=True, demangle=True, html=True, coverage_data=False)

Decorator generating HTML reports from collected coverage data.

A single lcov coverage information file is always generated and published. The corresponding HTML report is optional but enabled by default. Disabling can save time if the coverage information have to be merged with info from other tasks in order for an HTML report to be useful.

The decorator can be used standalone or in combination with coverage_data(). In either case, gcov coverage data as well as lcov coverage data is collected from dependency artifacts and processed together with data generated by the task itself.

The following class attributes may be set to control the behavior of lcov:

• lcov_branches - Enable branch coverage. Sets lcov configs branch_coverage=1 and no_exception_branch=1. Default: True

• lcov_configs - List of lcov configs to set. Passed as --rc <config> on the command line. Default: []

• lcov_demangle - Display demangled function names in output. Passed as --demangle-cpp on the command line. Default: True

• lcov_exclude - List of files to exclude from the report. Wildcards may be used. Passed as --exclude on the command line. Default: []

• lcov_filters - List of filters. Passed as --filter on the command line. Default: [brace, branch, range]

• lcov_html - Enable/disable HTML report generation. Default: True

• lcov_ignore_errors - List of errors to ignore. Sets lcov config ignore_errors. Default: [empty, mismatch, source, unused]

• lcov_coverage_data - Republish raw gcov coverage data. Default: False

The task artifact is annotated with:

• artifact.paths.coverage_report_lcov which points out the path to the resulting coverage.info file in the artifact.

• artifact.paths.coverage_report_html which points out the path to the resulting HTML files in the artifact.

A gcov and an lcov executable must exist in PATH. Set the GCOV and/or the LCOV environment variables to override their default names.

Parameters:

• branches (boolean) – Enable branch coverage. Default: True. Overridden by class attribute lcov_branches, if set.

• demangle (boolean) – Display demangled function names in output. Default: True. Overridden by class attribute lcov_demangle, if set.

• html (boolean) – Generate an HTML report. Default: True. Overridden by class attribute lcov_html, if set.

• coverage_data (boolean) – Republish coverage data found in dependency artifacts. Default: False Overridden by class attribute lcov_coverage_data, if set.

Example

examples/code_coverage/coverage.jolt

from jolt import Runner, Task
from jolt.plugins import ninja


class Exe(ninja.CXXExecutable):
    """ Builds executable with code coverage instrumentation """
    coverage = True
    sources = ["main.cpp"]


@ninja.attributes.coverage_data()
class Run(Runner):
    """ Runs executable and collects coverage data """
    requires = ["exe"]


@ninja.attributes.coverage_report_lcov()
class LcovReport(Task):
    """ Generates HTML report from code coverage data """
    name = "report/lcov"
    requires = ["run"]


@ninja.attributes.coverage_report_gcov()
class GcovReport(Task):
    """ Generates gcov report from code coverage data """
    name = "report/gcov"
    requires = ["run"]

static cxxflags(attrib, prepend=False)

Decorates a task with an alternative cxxflags attribute.

The new attribute will be concatenated with the regular cxxflags attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static incpaths(attrib, prepend=False)

Decorates a task with an alternative incpaths attribute.

The new attribute will be concatenated with the regular incpaths attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static ldflags(attrib, prepend=False)

Decorates a task with an alternative ldflags attribute.

The new attribute will be concatenated with the regular ldflags attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static libpaths(attrib, prepend=False)

Decorates a task with an alternative libpaths attribute.

The new attribute will be concatenated with the regular libpaths attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static libraries(attrib, prepend=False)

Decorates a task with an alternative libraries attribute.

The new attribute will be concatenated with the regular libraries attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static macros(attrib, prepend=False)

Decorates a task with an alternative macros attribute.

The new attribute will be concatenated with the regular macros attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

static sources(attrib, prepend=False)

Decorates a task with an alternative sources attribute.

The new attribute will be concatenated with the regular sources attribute.

Parameters:

• attrib (str) – Name of alternative attribute. Keywords are expanded.

• prepend (boolean) – Prepend the value of the alternative attribute. Default: false (append).

Rule

class jolt.plugins.ninja.Rule(command=None, infiles=None, outfiles=None, depfile=None, deps=None, variables=None, implicit=None, implicit_outputs=None, order_only=None, aggregate=False, phony=None)

A source transformation rule.

Rules are used to transform files from one type to another. An example is the rule that compiles a C/C++ file to an object file. Ninja tasks can be extended with additional rules beyond those already builtin and the builtin rules may also be overridden.

To define a new rule for a type of file, assign a Rule object to an arbitrary attribute of the compilation task being defined. Below is an example where a rule has been created to generate Qt moc source files from headers.

class MyQtProject(CXXExecutable):
    moc_rule = Rule(
        command="moc -o $out $in",
        infiles=[".h"],
        outfiles=["{outdir}/{in_path}/{in_base}_moc.cpp"])

    sources = ["myqtproject.h", "myqtproject.cpp"]

The moc rule will be run on all .h header files listed as sources, i.e. myqtproject.h. It takes the input header file and generates a corresponding moc source file, myqtproject_moc.cpp. The moc source file will then automatically be fed to the builtin compiler rule from which the output is an object file, myqtproject_moc.o.

__init__(command=None, infiles=None, outfiles=None, depfile=None, deps=None, variables=None, implicit=None, implicit_outputs=None, order_only=None, aggregate=False, phony=None)

Creates a new rule.

Parameters:

• command (str, optional) – The command that will be execute by the rule. It can use any of the variables created below.

• infiles (str, optional) – A list of file extensions that the rule should apply to.

• outfiles (str, optional) – A list of files created by the rule. Regular keyword expansion is done on the strings but additional keywords are supported, see variables below.

• variables (str, optional) –

  A dictionary of variables that should be available to Ninja when running the command. By default, only $in and $out will be set, where $in is a single input file and $out is the output file(s). Regular keyword expansion is done on the value strings, see jolt.Tools.expand(). These additional keywords are supported:

  • in_path - the path to the directory where the input file is located

  • in_base - the name of the input file, excluding file extension

  • in_ext - the input file extension

  Example

  Rule(command="echo $extension", variables={"extension": "{in_ext}"}, ...)
  

• aggregate (boolean, optional) –

  When this attribute is set, the Rule will aggregate all input

  files and transform them with a single command. This is useful, for example, when creating linking and archiving rules. In aggregating rules the $in Ninja variable expands to all matched input files, while the outfiles / $out variable is expanded using the first input in the set, if the in_* keywords are used at all.

  By default, a rule is applied once for each matched input file for improved parallelism.

  Example:

  In this example, the rule concatenates all header files into a single precompiled header.

  pch = Rule(
     command="cat $in > $out",
     infiles=["*.h"],
     outfiles=["{outdir}/all.pch"],
     aggregate=True)
  

  phony (boolean, optional):

  Emit a phony build target depending on all files generated by this rule. The phony build target becomes an implicit dependency in downstream rules that pick up the output from this rule.

  An example use-case is the compilation of protobuffers into C++ headers and source files. The C++ header files must be available before they can be included from other static C++ source files. With the phony target enabled, all protobuffers are compiled before any C++ file is compiled.

PkgConfig

jolt.plugins.pkgconfig.from_cxxinfo(package)

Decorator to write a pkg-config file for the given package based on the cxxinfo metadata of the artifact.

jolt.plugins.pkgconfig.to_cxxinfo(pkg: list | str, cflags: bool = True, cxxflags: bool = True, incpaths: bool = True, ldflags: bool = True, libpaths: bool = True, libraries: bool = True)

Decorator to add pkg-config information to cxxinfo metadata of an artifact.

The decorator enables interoperability between libraries built with Jolt’s Ninja plugin and external packages that provide pkg-config files.

It uses the pkg-config tool to query for compiler and linker flags, include paths, library paths, and libraries associated with a given package. If the relevant flags are found, they are appended to the corresponding fields in the artifact’s cxxinfo metadata.

Parameters:

• pkg (str) – The name of the pkg-config package to be added to cxxinfo.

• cflags (bool) – Whether to add C compiler flags from pkg-config.

• cxxflags (bool) – Whether to add C++ compiler flags from pkg-config.

• incpaths (bool) – Whether to add include paths from pkg-config.

• ldflags (bool) – Whether to add linker flags from pkg-config.

• libpaths (bool) – Whether to add library paths from pkg-config.

• libraries (bool) – Whether to add libraries from pkg-config.

Packages

The package tasks in jolt.pkgs, see Packages.

jolt.pkgs.abseil

class jolt.pkgs.abseil.Abseil

Bases: jolt.plugins.cmake.CMake

Abseil C++ Common Libraries

from jolt.pkgs import abseil

requires = ["abseil"]

name = 'abseil'

Name of the task.

version: Parameter = '20260817.0'

Abseil version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/abseil/abseil-cpp.git,rev={version}']

Sources of the package.

srcdir = '{git[abseil-cpp]}'

Source directory. If not set, the working directory of the task is used.

options = ['ABSL_MSVC_STATIC_RUNTIME=OFF', 'BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_CXX_STANDARD=17', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.alsa_lib

class jolt.pkgs.alsa_lib.AlsaLib

Bases: jolt.plugins.autotools.Autotools

Advanced Linux Sound Architecture library

from jolt.pkgs import alsa_lib

requires = ["alsa-lib"]

name = 'alsa-lib'

Name of the task.

version: Parameter = '1.2.16.1'

alsa-lib version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.alsa-project.org/files/pub/lib/alsa-lib-{version}.tar.bz2']

Sources of the package.

srcdir = '{fetch[src]}/alsa-lib-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-python', '--with-configdir=/usr/share/alsa', '--with-plugindir=/usr/lib/alsa-lib']

Options passed to the configure script. The configuration and plugins of the system are used at runtime.

jolt.pkgs.asio

class jolt.pkgs.asio.Asio

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import asio

requires = ["asio"]

name = 'asio'

Name of the task.

version: Parameter = '1.38.2'

Asio version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/chriskohlhoff/asio.git,rev=asio-{_version}']

Sources of the package.

srcdir = '{git[asio]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.autoconf

class jolt.pkgs.autoconf.Autoconf

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import autoconf

requires = ["autoconf"]

name = 'autoconf'

Name of the task.

version: Parameter = '2.73'

Autoconf version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/autoconf/autoconf-{version}.tar.gz']

Sources of the package.

requires_help2man = ['help2man']

Tasks required by the package.

requires_m4 = ['m4']

Tasks required by the package.

requires_texinfo = ['texinfo']

Tasks required by the package.

srcdir = '{fetch[src]}/autoconf-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.automake

class jolt.pkgs.automake.Automake

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import automake

requires = ["automake"]

name = 'automake'

Name of the task.

version: Parameter = '1.19'

Automake version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/automake/automake-{version}.tar.xz']

Sources of the package.

requires_texinfo = ['texinfo']

Tasks required by the package.

srcdir = '{fetch[src]}/automake-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

jolt.pkgs.b2

class jolt.pkgs.b2.B2

Bases: jolt.tasks.Task

from jolt.pkgs import b2

requires = ["b2"]

name = 'b2'

Name of the task.

version: Parameter = '5.6.1'

B2 version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/bfgroup/b2.git,rev={version}']

Sources of the package.

jolt.pkgs.binutils

class jolt.pkgs.binutils.Binutils

Bases: jolt.plugins.autotools.Autotools

GNU assembler, linker and binary tools

from jolt.pkgs import binutils

requires = ["binutils"]

name = 'binutils'

Name of the task.

version: Parameter = '2.47'

GNU Binutils version.

target: Parameter

Target of cross tools, such as arm-none-eabi. Native tools if not set.

requires_compiler = ['compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/binutils/binutils-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/binutils-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-nls', '--disable-werror', '--enable-plugins', '--with-system-zlib=no', 'MAKEINFO=true']

Options passed to the configure script.

options_cross = ['--target={target}']

Options passed to the configure script for cross tools.

options_native = []

Options passed to the configure script for native tools.

jolt.pkgs.bison

class jolt.pkgs.bison.Bison

Bases: jolt.plugins.autotools.Autotools

GNU parser generator

from jolt.pkgs import bison

requires = ["bison"]

name = 'bison'

Name of the task.

version: Parameter = '3.8.2'

GNU Bison version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_m4 = ['m4']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/bison/bison-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/bison-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-relocatable', 'M4=m4']

Options passed to the configure script. Bison finds its data files relative to its executable, and m4 in PATH.

jolt.pkgs.blake3

class jolt.pkgs.blake3.Blake3

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import blake3

requires = ["blake3"]

name = 'blake3'

Name of the task.

version: Parameter = '1.8.7'

BLAKE3 version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/BLAKE3-team/BLAKE3.git,rev={version}']

Sources of the package.

srcdir = '{git[BLAKE3]}/c'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.boost

class jolt.pkgs.boost.Boost

Bases: jolt.tasks.Task

from jolt.pkgs import boost

requires = ["boost"]

name = 'boost'

Name of the task.

version: Parameter = '1.92.0'

Boost version.

shared: BooleanParameter = 'false'

Build shared libraries.

icu: BooleanParameter = 'false'

Enable ICU support.

python: BooleanParameter = 'false'

Build Boost.Python.

bits: IntParameter = 64

Address model, in bits. Values: 32, 64

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/boostorg/boost.git,path={buildroot}/git-boost,rev=boost-{version},submodules=true']

Sources of the package.

requires_icu_on = ['icu']

Tasks required by the package when the icu parameter is enabled.

requires_python_on = ['cpython']

Tasks required by the package when the python parameter is enabled.

jolt.pkgs.boringssl

class jolt.pkgs.boringssl.BoringSSL

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import boringssl

requires = ["boringssl"]

name = 'boringssl'

Name of the task.

version: Parameter = '0.20261020.0'

BoringSSL version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/boringssl.git,rev={version}']

Sources of the package.

requires_nasm_windows = ['nasm']

Tasks required by the package on Windows.

srcdir = '{git[boringssl]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

options_linux = ['CMAKE_C_FLAGS=-Wno-error=stringop-overflow', 'CMAKE_CXX_FLAGS=-Wno-error=stringop-overflow']

Options passed to CMake on Linux.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.brotli

class jolt.pkgs.brotli.Brotli

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import brotli

requires = ["brotli"]

name = 'brotli'

Name of the task.

version: Parameter = '1.2.1'

Brotli version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/brotli.git,rev=v{version},submodules=true']

Sources of the package.

srcdir = '{git[brotli]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.busybox

class jolt.pkgs.busybox.BusyBox

Bases: jolt.tasks.Task

from jolt.pkgs import busybox

requires = ["busybox"]

name = 'busybox'

Name of the task.

defconfig: Parameter

BusyBox defconfig file.

version: Parameter = '1.38.0'

BusyBox version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=git://busybox.net/busybox.git,rev={version_tag}']

Sources of the package.

srcdir = '{git[busybox]}'

Source directory.

jolt.pkgs.bzip2

class jolt.pkgs.bzip2.LibBzip2

Bases: jolt.plugins.ninja.CXXLibrary

from jolt.pkgs import bzip2

requires = ["libbzip2"]

name = 'libbzip2'

Name of the task.

version: Parameter = '1.0.8'

bzip2 version.

pic: BooleanParameter = 'true'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

binary = 'bzip2'

Name of the target binary. Defaults to the canonical task name.

cstd = 90

C language standard to use (int). Default: Compiler default

If the chosen standard is not supported, the nearest supported standard is selected.

cflags_darwin_pic_on = ['-fPIC']

Compiler flags on macOS when building with position independent code.

cflags_linux_pic_on = ['-fPIC']

Compiler flags on Linux when building with position independent code.

incremental = False

Compile incrementally.

If incremental build is disabled, all intermediate files from a previous build will be removed before the execution begins.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://sourceware.org/pub/bzip2/bzip2-{version}.tar.gz']

Sources of the package.

source_influence = False

Let the contents of source files influence the identity of the task artifact.

When True, a source file listed in the sources attribute will cause a rebuild of the task if modified.

Source influence can hurt performance since every files needs to be hashed. It is safe to set this flag to False if all source files reside in a git repository listed as a dependency with the requires attribute or if the task uses the git.influence decorator.

Always use source_influence if you are unsure whether it is needed or not.

sources = ['{fetch[src]}/bzip2-{version}/blocksort.c', '{fetch[src]}/bzip2-{version}/bzlib.c', '{fetch[src]}/bzip2-{version}/bzlib.h', '{fetch[src]}/bzip2-{version}/compress.c', '{fetch[src]}/bzip2-{version}/crctable.c', '{fetch[src]}/bzip2-{version}/decompress.c', '{fetch[src]}/bzip2-{version}/huffman.c', '{fetch[src]}/bzip2-{version}/randtable.c']

A list of sources to compile.

Path names may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

Example:

sources = ["src/*.cpp"]

jolt.pkgs.cares

class jolt.pkgs.cares.CAres

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import cares

requires = ["c-ares"]

name = 'c-ares'

Name of the task.

version: Parameter = '1.34.9'

c-ares version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/c-ares/c-ares.git,rev=v{version}']

Sources of the package.

srcdir = '{git[c-ares]}'

Source directory. If not set, the working directory of the task is used.

options = ['CARES_SHARED={shared[ON,OFF]}', 'CARES_STATIC={shared[OFF,ON]}', 'CARES_BUILD_TESTS=OFF', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.catch2

class jolt.pkgs.catch2.Catch2

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import catch2

requires = ["catch2"]

name = 'catch2'

Name of the task.

version: Parameter = '3.16.1'

Catch2 version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/catchorg/Catch2.git,rev=v{version}']

Sources of the package.

srcdir = '{git[Catch2]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.catch2.Catch2Main

Bases: jolt.tasks.Task

from jolt.pkgs import catch2

requires = ["catch2/main"]

name = 'catch2/main'

Name of the task.

extends = 'catch2'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

jolt.pkgs.cbindgen

class jolt.pkgs.cbindgen.CBindgen

Bases: jolt.plugins.rust.Rust

from jolt.pkgs import cbindgen

requires = ["cbindgen"]

name = 'cbindgen'

Name of the task.

version: Parameter = '0.29.4'

cbindgen version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/mozilla/cbindgen.git,rev=v{version},hash=true']

Sources of the package.

requires_rust = ['rust']

Tasks required by the package.

srcdir = '{git[cbindgen]}'

Source directory for the Rust project.

If None, defaults to the task work directory (joltdir).

jolt.pkgs.ccache

class jolt.pkgs.ccache.Ccache

Bases: jolt.plugins.cmake.CMake

Compiler cache

from jolt.pkgs import ccache

requires = ["ccache"]

name = 'ccache'

Name of the task.

version: Parameter = '4.14.2'

ccache version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/ccache/ccache.git,rev=v{version}']

Sources of the package.

requires_libs = ['blake3', 'fmt', 'zstd']

Libraries used by ccache. Others are downloaded while configuring.

srcdir = '{git[ccache]}'

Source directory. If not set, the working directory of the task is used.

options = ['ENABLE_DOCUMENTATION=OFF', 'ENABLE_TESTING=OFF', 'REDIS_STORAGE_BACKEND=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.cista

class jolt.pkgs.cista.Cista

Bases: jolt.tasks.Task

from jolt.pkgs import cista

requires = ["cista"]

name = 'cista'

Name of the task.

version: Parameter = '0.16'

cista version.

requires_git = ['git:url=https://github.com/felixguendling/cista.git,rev=v{version}']

Sources of the package.

srcdir = '{git[cista]}'

Source directory.

jolt.pkgs.clang

class jolt.pkgs.clang.Clang

Bases: jolt.tasks.Task

from jolt.pkgs import clang

requires = ["clang"]

name = 'clang'

Name of the task.

version: Parameter = '23.1.4'

Clang version.

requires_llvm = ['llvm:version={version}']

Tasks required by the package.

class jolt.pkgs.clang.ClangFormat

Bases: jolt.pkgs.llvm.LLVMFromSrc

from jolt.pkgs import clang

requires = ["clang-format"]

name = 'clang-format'

Name of the task.

release: BooleanParameter = 'true'

Build a release version.

rtti: BooleanParameter = 'true'

Enable RTTI support.

version: Parameter = '23.1.4'

LLVM version.

projects = ['clang', 'clang-tools-extra']

LLVM projects to build.

targets = []

LLVM targets to build.

install = ['install-clang-format']

Targets built to install the project. If empty, install is built.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

requires_git = ['git:url=https://github.com/llvm/llvm-project.git,rev=llvmorg-{version}']

Sources of the package.

options = ['CMAKE_BUILD_TYPE={release[Release,Debug]}', "LLVM_ENABLE_PROJECTS='{_projects_str}'", "LLVM_TARGETS_TO_BUILD='{_targets_str}'", 'LLVM_ENABLE_RTTI={rtti[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

srcdir = '{git[llvm-project]}/llvm'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.clang.ClangTidy

Bases: jolt.pkgs.llvm.LLVMFromSrc

from jolt.pkgs import clang

requires = ["clang-tidy"]

name = 'clang-tidy'

Name of the task.

release: BooleanParameter = 'true'

Build a release version.

rtti: BooleanParameter = 'true'

Enable RTTI support.

version: Parameter = '23.1.4'

LLVM version.

projects = ['clang', 'clang-tools-extra']

LLVM projects to build.

targets = []

LLVM targets to build.

install = ['install-clang-tidy']

Targets built to install the project. If empty, install is built.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

requires_git = ['git:url=https://github.com/llvm/llvm-project.git,rev=llvmorg-{version}']

Sources of the package.

options = ['CMAKE_BUILD_TYPE={release[Release,Debug]}', "LLVM_ENABLE_PROJECTS='{_projects_str}'", "LLVM_TARGETS_TO_BUILD='{_targets_str}'", 'LLVM_ENABLE_RTTI={rtti[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

srcdir = '{git[llvm-project]}/llvm'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.cli11

class jolt.pkgs.cli11.CLI11

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import cli11

requires = ["cli11"]

name = 'cli11'

Name of the task.

version: Parameter = '2.7.2'

CLI11 version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/CLIUtils/CLI11/archive/refs/tags/v{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/CLI11-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['CLI11_BUILD_EXAMPLES=OFF', 'CLI11_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.cmake

class jolt.pkgs.cmake.CMake

Bases: jolt.tasks.Alias

from jolt.pkgs import cmake

requires = ["cmake"]

name = 'cmake'

Name of the task.

version: Parameter = '4.4.5'

CMake version.

requires = ['cmake/bin:version={version}']

List of dependencies to other tasks.

class jolt.pkgs.cmake.CMakeBin

Bases: jolt.tasks.Download

from jolt.pkgs import cmake

requires = ["cmake/bin"]

name = 'cmake/bin'

Name of the task.

version: Parameter = '4.4.5'

CMake version.

url = ['https://github.com/Kitware/CMake/releases/download/v{version}/cmake-{version}-{cmake_system}-{cmake_arch}{cmake_ext}']

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

collect = [{'files': '*', 'cwd': 'cmake-{version}-{cmake_system}-{cmake_arch}{cmake_contents}'}]

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

Example:

collect = [
    "*",                           # Collect all files
    ("*", "src/"),                 # Collect all files into the artifact's src/ directory
    {"files": "*", cwd="subdir"},  # Collect all files from the archive's subdir/ directory
]

jolt.pkgs.compiler

class jolt.pkgs.compiler.HostCCompiler

Bases: jolt.tasks.Task

The C compiler of the host.

The identity of the task depends on the operating system and architecture of the host, and on the version and target of the C compiler that builds use, the one in CC or the default. Packages that require it are built separately for each platform and compiler.

from jolt.pkgs import compiler

requires = ["compiler/c"]

name = 'compiler/c'

Name of the task.

class jolt.pkgs.compiler.HostCXXCompiler

Bases: jolt.tasks.Task

The C++ compiler of the host and its standard library.

The identity of the task depends on the operating system and architecture of the host, on the version and target of the C++ compiler that builds use, the one in CXX or the default, and on the version of its standard library: libstdc++, libc++ or the one of MSVC.

from jolt.pkgs import compiler

requires = ["compiler/cxx"]

name = 'compiler/cxx'

Name of the task.

class jolt.pkgs.compiler.CCompiler

Bases: jolt.tasks.Alias

The C compiler that packages are built with.

Packages require this alias rather than a specific compiler. It selects the compiler of the host, and can be overridden to build all packages with another compiler.

from jolt.pkgs import compiler

requires = ["virtual/compiler/c"]

name = 'virtual/compiler/c'

Name of the task.

requires = ['compiler/c']

List of dependencies to other tasks.

class jolt.pkgs.compiler.CXXCompiler

Bases: jolt.tasks.Alias

The C++ compiler that packages are built with.

Packages written in C++ require this alias in addition to virtual/compiler/c. It selects the compiler of the host, and can be overridden to build all packages with another compiler.

from jolt.pkgs import compiler

requires = ["virtual/compiler/cxx"]

name = 'virtual/compiler/cxx'

Name of the task.

requires = ['compiler/cxx']

List of dependencies to other tasks.

jolt.pkgs.cpython

class jolt.pkgs.cpython.CPython

Bases: jolt.tasks.Alias

Alias for CPython

from jolt.pkgs import cpython

requires = ["cpython"]

name = 'cpython'

Name of the task.

version: Parameter = '3.15.2'

CPython version.

requires_darwin = ['cpython/posix:version={version}']

Tasks required by the package on macOS.

requires_linux = ['cpython/posix:version={version}']

Tasks required by the package on Linux.

requires_windows = ['cpython/win32:version={version}']

Tasks required by the package on Windows.

class jolt.pkgs.cpython.CPythonEmbed

Bases: jolt.tasks.Task

from jolt.pkgs import cpython

requires = ["cpython/embed"]

name = 'cpython/embed'

Name of the task.

requires = ['cpython']

List of dependencies to other tasks.

selfsustained = True

Consume this task independently of its requirements.

Requirements of a self-sustained task will be pruned if the task artifact is present in a cache. In other words, if the task is not executed its requirements are considered unnecessary.

For example, consider the task graph A -> B -> C. If B is self-sustained and present in a cache, C will never be executed. C will also never be a transitive requirement of A. If A requires C, it should be listed as an explicit requirement.

Using this attribute speeds up execution and reduces network traffic by allowing the task graph to be reduced.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

class jolt.pkgs.cpython.CPythonExtend

Bases: jolt.tasks.Task

from jolt.pkgs import cpython

requires = ["cpython/extend"]

name = 'cpython/extend'

Name of the task.

requires = ['cpython']

List of dependencies to other tasks.

selfsustained = True

Consume this task independently of its requirements.

Requirements of a self-sustained task will be pruned if the task artifact is present in a cache. In other words, if the task is not executed its requirements are considered unnecessary.

For example, consider the task graph A -> B -> C. If B is self-sustained and present in a cache, C will never be executed. C will also never be a transitive requirement of A. If A requires C, it should be listed as an explicit requirement.

Using this attribute speeds up execution and reduces network traffic by allowing the task graph to be reduced.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

class jolt.pkgs.cpython.CPythonPosix

Bases: jolt.plugins.autotools.Autotools

Builds and publishes CPython libraries and headers.

from jolt.pkgs import cpython

requires = ["cpython/posix"]

name = 'cpython/posix'

Name of the task.

version: Parameter = '3.15.2'

CPython version.

libffi: BooleanParameter = 'true'

Enable libffi support.

sqlite: BooleanParameter = 'true'

Enable SQLite support.

ssl: BooleanParameter = 'true'

Enable SSL support.

zlib: BooleanParameter = 'true'

Enable zlib support.

zstd: BooleanParameter = 'true'

Enable Zstandard support.

xz: BooleanParameter = 'true'

Enable XZ Utils support.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/python/cpython.git,rev=v{version}']

Sources of the package.

requires_libffi_on = ['libffi']

Tasks required by the package when the libffi parameter is enabled.

requires_sqlite_on = ['sqlite']

Tasks required by the package when the sqlite parameter is enabled.

requires_ssl_on = ['virtual/ssl']

Tasks required by the package when the ssl parameter is enabled.

requires_zlib_on = ['virtual/zlib:pic=true']

Tasks required by the package when the zlib parameter is enabled.

requires_zstd_on = ['zstd']

Tasks required by the package when the zstd parameter is enabled.

requires_xz_on = ['xz:pic=true']

Tasks required by the package when the xz parameter is enabled.

srcdir = '{git[cpython]}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-optimizations', '--with-ensurepip=install']

Options passed to the configure script.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

class jolt.pkgs.cpython.CPythonWin32

Bases: jolt.tasks.Task

Builds and publishes CPython libraries and headers.

from jolt.pkgs import cpython

requires = ["cpython/win32"]

name = 'cpython/win32'

Name of the task.

version: Parameter = '3.15.2'

CPython version.

ssl: BooleanParameter = 'true'

Enable SSL support.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/python/cpython.git,rev=v{version}']

Sources of the package.

requires_ssl_on = ['virtual/ssl']

Tasks required by the package when the ssl parameter is enabled.

srcdir = '{git[cpython]}'

Source directory.

jolt.pkgs.crun

class jolt.pkgs.crun.CRun

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import crun

requires = ["crun"]

name = 'crun'

Name of the task.

version: Parameter = '1.30.1'

crun version.

caps: BooleanParameter = 'false'

Enable capabilities support.

systemd: BooleanParameter = 'false'

Enable systemd support.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/containers/crun.git,rev={version},submodules=true']

Sources of the package.

requires_json_c = ['json-c']

Tasks required by the package.

requires_libcap_on = ['libcap']

Tasks required by the package when the libcap parameter is enabled.

srcdir = '{git[crun]}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-criu', '--disable-seccomp', '{caps[,--disable-caps]}', '{systemd[,--disable-systemd]}']

Options passed to the configure script.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.curl

class jolt.pkgs.curl.Curl

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import curl

requires = ["curl"]

name = 'curl'

Name of the task.

version: Parameter = '8.23.0'

curl version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_brotli = ['brotli:pic={pic},shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/curl/curl.git,rev=curl-{_version_tag},submodules=true']

Sources of the package.

requires_ssl = ['virtual/ssl:pic={pic},shared={shared}']

Tasks required by the package.

requires_zlib = ['virtual/zlib:pic={pic},shared={shared}']

Tasks required by the package.

requires_zstd = ['zstd:pic={pic},shared={shared}']

Tasks required by the package.

srcdir = '{git[curl]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CURL_DISABLE_LDAP=ON', 'CURL_USE_LIBPSL=OFF', 'USE_LIBIDN2=OFF', 'OPENSSL_USE_STATIC_LIBS={shared[OFF,ON]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.cxxopts

class jolt.pkgs.cxxopts.Cxxopts

Bases: jolt.plugins.cmake.CMake

Command line option parser for C++

from jolt.pkgs import cxxopts

requires = ["cxxopts"]

name = 'cxxopts'

Name of the task.

version: Parameter = '3.3.1'

cxxopts version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/jarro2783/cxxopts.git,rev=v{version}']

Sources of the package.

srcdir = '{git[cxxopts]}'

Source directory. If not set, the working directory of the task is used.

options = ['CXXOPTS_BUILD_EXAMPLES=OFF', 'CXXOPTS_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.cyrus_sasl

class jolt.pkgs.cyrus_sasl.CyrusSasl

Bases: jolt.plugins.autotools.Autotools

Simple Authentication and Security Layer library

Only a static library is built, with the authentication mechanisms included, so that no plugins are loaded from the installation directory.

from jolt.pkgs import cyrus_sasl

requires = ["cyrus-sasl"]

name = 'cyrus-sasl'

Name of the task.

version: Parameter = '2.1.28'

Cyrus SASL version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_libs = ['krb5', 'openssl']

Libraries used by the GSSAPI and other mechanisms.

requires_src = ['fetch:alias=src,url=https://github.com/cyrusimap/cyrus-sasl/releases/download/cyrus-sasl-{version}/cyrus-sasl-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/cyrus-sasl-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-macos-framework', '--disable-sample', '--disable-shared', '--enable-gssapi', '--enable-static', '--with-configdir=/etc/sasl2', '--with-pic', '--without-authdaemond', '--without-saslauthd']

Options passed to the configure script. The configuration of the system is used at runtime.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.dbus

class jolt.pkgs.dbus.DBus

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import dbus

requires = ["dbus"]

name = 'dbus'

Name of the task.

version: Parameter = '1.16.2'

D-Bus version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/dbus/dbus.git,rev=dbus-{version}']

Sources of the package.

srcdir = '{git[dbus]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.doctest

class jolt.pkgs.doctest.Doctest

Bases: jolt.plugins.cmake.CMake

C++ testing framework

from jolt.pkgs import doctest

requires = ["doctest"]

name = 'doctest'

Name of the task.

version: Parameter = '2.5.3'

doctest version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/doctest/doctest.git,rev=v{version}']

Sources of the package.

srcdir = '{git[doctest]}'

Source directory. If not set, the working directory of the task is used.

options = ['DOCTEST_WITH_MAIN_IN_STATIC_LIB=OFF', 'DOCTEST_WITH_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.double_conversion

class jolt.pkgs.double_conversion.DoubleConversion

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import double_conversion

requires = ["double-conversion"]

name = 'double-conversion'

Name of the task.

version: Parameter = '3.4.0'

double-conversion version.

options = ['BUILD_SHARED_LIBS=ON']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/double-conversion.git,rev=v{version}']

Sources of the package.

srcdir = '{git[double-conversion]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.eigen

class jolt.pkgs.eigen.Eigen

Bases: jolt.plugins.cmake.CMake

C++ template library for linear algebra

from jolt.pkgs import eigen

requires = ["eigen"]

name = 'eigen'

Name of the task.

version: Parameter = '5.0.1'

Eigen version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.com/libeigen/eigen.git,rev={version}']

Sources of the package.

srcdir = '{git[eigen]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_TESTING=OFF', 'EIGEN_BUILD_DOC=OFF', 'EIGEN_BUILD_PKGCONFIG=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.fastfloat

class jolt.pkgs.fastfloat.FastFloat

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import fastfloat

requires = ["fastfloat"]

name = 'fastfloat'

Name of the task.

version: Parameter = '8.3.3'

fast_float version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/fastfloat/fast_float.git,rev=v{version}']

Sources of the package.

srcdir = '{git[fast_float]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.ffmpeg

class jolt.pkgs.ffmpeg.FFmpeg

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import ffmpeg

requires = ["ffmpeg"]

name = 'ffmpeg'

Name of the task.

version: Parameter = '9.0.2'

FFmpeg version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/FFmpeg/FFmpeg.git,rev=n{version}']

Sources of the package.

requires_linux_libx11 = ['libx11']

Tasks required by the package on Linux.

requires_nasm = ['nasm']

Tasks required by the package.

requires_xz = ['xz']

Tasks required by the package.

srcdir = '{git[FFmpeg]}'

Source directory. If not set, the working directory of the task is used.

options = ['--{shared[enable,disable]}-shared', '--{shared[disable,enable]}-static']

Options passed to the configure script.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.flatbuffers

class jolt.pkgs.flatbuffers.Flatbuffers

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import flatbuffers

requires = ["flatbuffers"]

name = 'flatbuffers'

Name of the task.

version: Parameter = '25.12.19'

FlatBuffers version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/flatbuffers.git,rev=v{version}']

Sources of the package.

srcdir = '{git[flatbuffers]}'

Source directory. If not set, the working directory of the task is used.

options = ['FLATBUFFERS_BUILD_FLATLIB={shared[OFF,ON]}', 'FLATBUFFERS_BUILD_SHAREDLIB={shared[ON,OFF]}', 'FLATBUFFERS_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.flex

class jolt.pkgs.flex.Flex

Bases: jolt.plugins.autotools.Autotools

Fast lexical analyzer generator

from jolt.pkgs import flex

requires = ["flex"]

name = 'flex'

Name of the task.

version: Parameter = '2.6.4'

flex version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_m4 = ['m4']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/westes/flex/releases/download/v{version}/flex-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/flex-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['M4=m4']

Options passed to the configure script. Flex finds m4 in PATH.

jolt.pkgs.fmt

class jolt.pkgs.fmt.Fmt

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import fmt

requires = ["fmt"]

name = 'fmt'

Name of the task.

version: Parameter = '12.2.0'

fmt version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/fmtlib/fmt.git,rev={version}']

Sources of the package.

srcdir = '{git[fmt]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'FMT_TEST=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.fontconfig

class jolt.pkgs.fontconfig.Fontconfig

Bases: jolt.plugins.meson.Meson

Font configuration and customization library

from jolt.pkgs import fontconfig

requires = ["fontconfig"]

name = 'fontconfig'

Name of the task.

version: Parameter = '2.18.3'

Fontconfig version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/fontconfig/fontconfig.git,rev={version}']

Sources of the package.

requires_libs = ['freetype:pic=true,shared={shared}', 'gperf', 'libexpat:pic=true,shared={shared}']

Libraries and tools used by Fontconfig.

srcdir = '{git[fontconfig]}'

Source directory. If not set, the working directory of the task is used.

options = ['cache-build=disabled', 'default_library={shared[shared,static]}', 'doc=disabled', 'localstatedir=/var', 'nls=disabled', 'sysconfdir=/etc', 'tests=disabled', 'tools=disabled', 'xml-backend=expat']

Options passed to Meson, as option=value. The configuration and font cache of the system are used at runtime.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.freetype

class jolt.pkgs.freetype.Freetype

Bases: jolt.plugins.cmake.CMake

Font rendering library

from jolt.pkgs import freetype

requires = ["freetype"]

name = 'freetype'

Name of the task.

version: Parameter = '2.15.0'

FreeType version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/freetype/freetype.git,rev=VER-{_version}']

Sources of the package.

requires_libs = ['libpng:pic={pic},shared={shared}', 'virtual/zlib:pic={pic},shared={shared}']

Libraries for PNG glyphs and compressed fonts.

srcdir = '{git[freetype]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'FT_DISABLE_BROTLI=ON', 'FT_DISABLE_BZIP2=ON', 'FT_DISABLE_HARFBUZZ=ON', 'FT_REQUIRE_PNG=ON', 'FT_REQUIRE_ZLIB=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.fstree

class jolt.pkgs.fstree.Fstree

Bases: jolt.tasks.Task

from jolt.pkgs import fstree

requires = ["fstree"]

name = 'fstree'

Name of the task.

version: Parameter = '26.10.203'

fstree version.

jolt.pkgs.gcc

class jolt.pkgs.gcc.Gcc

Bases: jolt.plugins.autotools.Autotools

GNU compilers

Native compilers find the assembler and linker at runtime, for example from the binutils package. Cross compilers are built for targets without an operating system, such as arm-none-eabi, and include binutils for their target. Since there is no C library, only the compilers and libgcc are built for them, without threads and shared libraries, not the runtime libraries of other languages. They can also build C libraries for Linux targets, such as glibc for aarch64-linux-gnu.

from jolt.pkgs import gcc

requires = ["gcc"]

name = 'gcc'

Name of the task.

version: Parameter = '16.2.0'

GCC version.

languages: ListParameter = ['c', 'cxx']

Languages to build compilers for. Values: c, cxx, fortran, go, m2, objc, objcxx

target: Parameter

Target of a cross compiler, such as arm-none-eabi. Native compilers if not set.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_cross = ['binutils:target={target}']

Assembler and linker of the target, included in the cross compiler.

requires_libs = ['gmp', 'mpc', 'mpfr']

Libraries used by the compilers.

requires_native = []

Native compilers use the assembler and linker found at runtime.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/gcc/gcc-{version}/gcc-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/gcc-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-bootstrap', '--disable-multilib', '--disable-nls', '--enable-languages={_languages}', '--with-gmp={_gmp}', '--with-mpc={_mpc}', '--with-mpfr={_mpfr}', '--without-isl', '--without-zstd', 'MAKEINFO=true']

Options passed to the configure script.

options_cross = ['--disable-shared', '--disable-threads', '--target={target}', '--with-newlib', '--without-headers']

Options passed to the configure script for cross compilers.

options_native = []

Options passed to the configure script for native compilers.

class jolt.pkgs.gcc.GccGlibc

Bases: jolt.pkgs.gcc.GccSysroot

GNU compilers with the GNU C library, for targets such as aarch64-linux-gnu

from jolt.pkgs import gcc

requires = ["gcc/glibc"]

name = 'gcc/glibc'

Name of the task.

target: Parameter

Target of the compilers, such as aarch64-linux-gnu.

version: Parameter = '16.2.0'

GCC version.

languages: ListParameter = ['c', 'cxx']

Languages to build compilers for. Values: c, cxx, fortran, go, m2, objc, objcxx

libc = 'glibc'

Name of the C library task, which must take a target parameter.

requires_sysroot = ['binutils:target={target}', '{libc}:target={target}']

Assembler, linker and C library of the target, included in the compilers.

options_sysroot = ['--target={target}', '--with-build-sysroot={_sysroot}', '--with-sysroot=/jolt-prefix/{target}/sysroot']

Options passed to the configure script.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_cross = ['binutils:target={target}']

Assembler and linker of the target, included in the cross compiler.

requires_libs = ['gmp', 'mpc', 'mpfr']

Libraries used by the compilers.

requires_native = []

Native compilers use the assembler and linker found at runtime.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/gcc/gcc-{version}/gcc-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/gcc-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-bootstrap', '--disable-multilib', '--disable-nls', '--enable-languages={_languages}', '--with-gmp={_gmp}', '--with-mpc={_mpc}', '--with-mpfr={_mpfr}', '--without-isl', '--without-zstd', 'MAKEINFO=true']

Options passed to the configure script.

options_cross = ['--disable-shared', '--disable-threads', '--target={target}', '--with-newlib', '--without-headers']

Options passed to the configure script for cross compilers.

options_native = []

Options passed to the configure script for native compilers.

class jolt.pkgs.gcc.GccMusl

Bases: jolt.pkgs.gcc.GccSysroot

GNU compilers with the musl C library, for targets such as aarch64-linux-musl

from jolt.pkgs import gcc

requires = ["gcc/musl"]

name = 'gcc/musl'

Name of the task.

target: Parameter

Target of the compilers, such as aarch64-linux-musl.

version: Parameter = '16.2.0'

GCC version.

languages: ListParameter = ['c', 'cxx']

Languages to build compilers for. Values: c, cxx, fortran, go, m2, objc, objcxx

libc = 'musl'

Name of the C library task, which must take a target parameter.

options_sysroot = ['--target={target}', '--with-build-sysroot={_sysroot}', '--with-sysroot=/jolt-prefix/{target}/sysroot', '--disable-libsanitizer']

Options passed to the configure script.

requires_sysroot = ['binutils:target={target}', '{libc}:target={target}']

Assembler, linker and C library of the target, included in the compilers.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_cross = ['binutils:target={target}']

Assembler and linker of the target, included in the cross compiler.

requires_libs = ['gmp', 'mpc', 'mpfr']

Libraries used by the compilers.

requires_native = []

Native compilers use the assembler and linker found at runtime.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/gcc/gcc-{version}/gcc-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/gcc-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-bootstrap', '--disable-multilib', '--disable-nls', '--enable-languages={_languages}', '--with-gmp={_gmp}', '--with-mpc={_mpc}', '--with-mpfr={_mpfr}', '--without-isl', '--without-zstd', 'MAKEINFO=true']

Options passed to the configure script.

options_cross = ['--disable-shared', '--disable-threads', '--target={target}', '--with-newlib', '--without-headers']

Options passed to the configure script for cross compilers.

options_native = []

Options passed to the configure script for native compilers.

jolt.pkgs.gflags

class jolt.pkgs.gflags.GFlags

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import gflags

requires = ["gflags"]

name = 'gflags'

Name of the task.

version: Parameter = '2.3.1'

gflags version.

options = ['BUILD_SHARED_LIBS=ON']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/gflags/gflags.git,rev=v{version}']

Sources of the package.

srcdir = '{git[gflags]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.glib

class jolt.pkgs.glib.GLib

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import glib

requires = ["glib"]

name = 'glib'

Name of the task.

version: Parameter = '2.90.1'

GLib version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.gnome.org/GNOME/glib.git,rev={version},submodules=true']

Sources of the package.

requires_libffi = ['libffi']

Tasks required by the package.

requires_pcre2 = ['pcre2:pic=true']

Tasks required by the package.

requires_zlib = ['zlib:pic=true']

Tasks required by the package.

srcdir = '{git[glib]}'

Source directory. If not set, the working directory of the task is used.

options = ['documentation=false', 'introspection=disabled', 'man-pages=disabled', 'tests=false', 'libelf=disabled', 'libmount=disabled', 'selinux=disabled', 'sysprof=disabled', 'wrap_mode=nofallback']

Options passed to meson setup.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.glibc

class jolt.pkgs.glibc.Glibc

Bases: jolt.tasks.Task

GNU C library

The library is installed as a system root, with headers in usr/include and libraries in usr/lib. It is built for the host with the host compiler, or for a target with the cross compiler for that target.

from jolt.pkgs import glibc

requires = ["glibc"]

name = 'glibc'

Name of the task.

version: Parameter = '2.44'

GNU C Library version.

target: Parameter

Target of the library, such as aarch64-linux-gnu. The host if not set.

requires_compiler = ['compiler/c']

Tasks required by the package.

requires_cross = ['gcc:target={target}', 'linux-headers:target={target}']

Cross compiler and kernel headers of the target.

requires_native = ['linux-headers']

Kernel headers of the host. The host compiler is used.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/glibc/glibc-{version}.tar.xz']

Sources of the package.

requires_tools = ['bison']

Tools used to build the library.

srcdir = '{fetch[src]}/glibc-{version}'

selfsustained = True

Consumers of the library don’t need the compiler that built it.

jolt.pkgs.glog

class jolt.pkgs.glog.Glog

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import glog

requires = ["glog"]

name = 'glog'

Name of the task.

version: Parameter = '0.7.1'

glog version.

options = ['CMAKE_CXX_STANDARD=14']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_gflags = ['gflags']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/glog.git,rev=v{version}']

Sources of the package.

srcdir = '{git[glog]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.glslang

class jolt.pkgs.glslang.Glslang

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import glslang

requires = ["glslang"]

name = 'glslang'

Name of the task.

version: Parameter = '16.6.0'

glslang version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/KhronosGroup/glslang.git,rev={version}']

Sources of the package.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.gmp

class jolt.pkgs.gmp.Gmp

Bases: jolt.plugins.autotools.Autotools

GNU multiple precision arithmetic library

from jolt.pkgs import gmp

requires = ["gmp"]

name = 'gmp'

Name of the task.

version: Parameter = '6.3.0'

GMP version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_m4 = ['m4']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/gmp/gmp-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/gmp-{version}'

Source directory. If not set, the working directory of the task is used.

options = ["CFLAGS='-O2 -std=gnu17'", '--disable-shared', '--enable-static', '--with-pic']

Options passed to the configure script.

jolt.pkgs.golang

class jolt.pkgs.golang.Golang

Bases: jolt.tasks.Download

from jolt.pkgs import golang

requires = ["golang"]

name = 'golang'

Name of the task.

version: Parameter = '1.27.3'

Go version.

url = 'https://go.dev/dl/go{version}.{system}-{go_arch}{go_ext}'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

jolt.pkgs.googlebenchmark

class jolt.pkgs.googlebenchmark.GoogleBenchmark

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import googlebenchmark

requires = ["google/benchmark"]

name = 'google/benchmark'

Name of the task.

version: Parameter = '1.10.0'

Google Benchmark version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/benchmark.git,rev=v{version},submodules=true']

Sources of the package.

options = ['BENCHMARK_ENABLE_TESTING=OFF']

Options passed to CMake, as option[:type]=value.

srcdir = '{git[benchmark]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.googletest

class jolt.pkgs.googletest.GmockMain

Bases: jolt.tasks.Task

from jolt.pkgs import googletest

requires = ["google/mock/main"]

name = 'google/mock/main'

Name of the task.

extends = 'google/test'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

class jolt.pkgs.googletest.GoogleTest

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import googletest

requires = ["google/test"]

name = 'google/test'

Name of the task.

version: Parameter = '1.18.0'

GoogleTest version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/googletest.git,rev=v{version}']

Sources of the package.

srcdir = '{git[googletest]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.googletest.GTestMain

Bases: jolt.tasks.Task

from jolt.pkgs import googletest

requires = ["google/test/main"]

name = 'google/test/main'

Name of the task.

extends = 'google/test'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

jolt.pkgs.gperf

class jolt.pkgs.gperf.GPerf

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import gperf

requires = ["gperf"]

name = 'gperf'

Name of the task.

version: Parameter = '3.3'

gperf version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=http://ftpmirror.gnu.org/gperf/gperf-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/gperf-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.grpc

class jolt.pkgs.grpc.Grpc

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import grpc

requires = ["grpc"]

name = 'grpc'

Name of the task.

version: Parameter = '1.85.1'

gRPC version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_abseil = ['abseil:pic={pic},shared={shared}']

Tasks required by the package.

requires_cares = ['c-ares:pic={pic},shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/grpc/grpc.git,path={buildroot}/git_grpc,rev=v{version},submodules=true']

Sources of the package.

requires_nasm_windows = ['nasm']

Tasks required by the package on Windows.

requires_protobuf = ['protobuf:pic={pic},shared={shared}']

Tasks required by the package.

requires_re2 = ['re2:pic={pic},shared={shared}']

Tasks required by the package.

requires_ssl = ['virtual/ssl:pic={pic},shared={shared}']

Tasks required by the package.

requires_zlib = ['virtual/zlib:pic={pic},shared={shared}']

Tasks required by the package.

srcdir = '{git[grpc]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'CMAKE_CXX_STANDARD=17', 'gRPC_ABSL_PROVIDER=package', 'gRPC_BUILD_TESTS=OFF', 'gRPC_CARES_PROVIDER=package', 'gRPC_MSVC_STATIC_RUNTIME=OFF', 'gRPC_PROTOBUF_PROVIDER=package', 'gRPC_RE2_PROVIDER=package', 'gRPC_SSL_PROVIDER=package', 'gRPC_ZLIB_PROVIDER=package', 'gRPC_USE_SYSTEMD=OFF']

Options passed to CMake, as option[:type]=value.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.grpc.GrpcC

Bases: jolt.tasks.Task

from jolt.pkgs import grpc

requires = ["grpc/c"]

name = 'grpc/c'

Name of the task.

extends = 'grpc'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

class jolt.pkgs.grpc.GrpcCXX

Bases: jolt.tasks.Task

from jolt.pkgs import grpc

requires = ["grpc/c++"]

name = 'grpc/c++'

Name of the task.

extends = 'grpc'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

jolt.pkgs.harfbuzz

class jolt.pkgs.harfbuzz.Harfbuzz

Bases: jolt.plugins.meson.Meson

Text shaping engine

from jolt.pkgs import harfbuzz

requires = ["harfbuzz"]

name = 'harfbuzz'

Name of the task.

version: Parameter = '15.0.0'

HarfBuzz version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_freetype = ['freetype:pic=true,shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/harfbuzz/harfbuzz.git,rev={version}']

Sources of the package.

srcdir = '{git[harfbuzz]}'

Source directory. If not set, the working directory of the task is used.

options = ['cairo=disabled', 'chafa=disabled', 'default_library={shared[shared,static]}', 'docs=disabled', 'freetype=enabled', 'glib=disabled', 'gobject=disabled', 'icu=disabled', 'introspection=disabled', 'tests=disabled', 'utilities=disabled']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.hdf5

class jolt.pkgs.hdf5.HDF5

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import hdf5

requires = ["hdf5"]

name = 'hdf5'

Name of the task.

version: Parameter = '2.2.0'

HDF5 version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/HDFGroup/hdf5.git,rev={version}']

Sources of the package.

srcdir = '{git[hdf5]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS=ON', 'HDF5_BUILD_EXAMPLES=OFF']

Options passed to CMake, as option[:type]=value.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.help2man

class jolt.pkgs.help2man.Help2Man

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import help2man

requires = ["help2man"]

name = 'help2man'

Name of the task.

version: Parameter = '1.49.3'

help2man version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=http://ftpmirror.gnu.org/help2man/help2man-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/help2man-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.icu

class jolt.pkgs.icu.Icu

Bases: jolt.plugins.autotools.Autotools

International Components for Unicode, the ICU4C libraries and their data

from jolt.pkgs import icu

requires = ["icu"]

name = 'icu'

Name of the task.

version: Parameter = '79.1'

ICU version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/unicode-org/icu/releases/download/release-{version}/icu4c-{version}-sources.tgz']

Sources of the package.

srcdir = '{fetch[src]}/icu/source'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-samples', '--disable-tests', '--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}', '{pic[CFLAGS=-fPIC CXXFLAGS=-fPIC,]}']

Options passed to the configure script.

jolt.pkgs.inja

class jolt.pkgs.inja.Inja

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import inja

requires = ["inja"]

name = 'inja'

Name of the task.

version: Parameter = '3.5.0'

Inja version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pantor/inja.git,rev=v{version}']

Sources of the package.

requires_json = ['nlohmann/json']

Tasks required by the package.

srcdir = '{git[inja]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_TESTING={tests[ON,OFF]}', 'INJA_USE_EMBEDDED_JSON=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.json_c

class jolt.pkgs.json_c.JsonC

Bases: jolt.plugins.cmake.CMake

JSON implementation in C

from jolt.pkgs import json_c

requires = ["json-c"]

name = 'json-c'

Name of the task.

version: Parameter = '0.19'

json-c version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://s3.amazonaws.com/json-c_releases/releases/json-c-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/json-c-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_APPS=OFF', 'BUILD_SHARED_LIBS={shared[ON,OFF]}', 'BUILD_STATIC_LIBS={shared[OFF,ON]}', 'BUILD_TESTING=OFF', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'DISABLE_WERROR=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.jsoncpp

class jolt.pkgs.jsoncpp.JsonCPP

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import jsoncpp

requires = ["jsoncpp"]

name = 'jsoncpp'

Name of the task.

version: Parameter = '1.9.8'

JsonCpp version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/open-source-parsers/jsoncpp.git,rev={version}']

Sources of the package.

srcdir = '{git[jsoncpp]}'

Source directory. If not set, the working directory of the task is used.

options = ['JSONCPP_WITH_TESTS={tests[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.krb5

class jolt.pkgs.krb5.Krb5

Bases: jolt.plugins.autotools.Autotools

MIT Kerberos

from jolt.pkgs import krb5

requires = ["krb5"]

name = 'krb5'

Name of the task.

version: Parameter = '1.22.2'

MIT Kerberos version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_bison = ['bison']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://kerberos.org/dist/krb5/{_major_minor}/krb5-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/krb5-{version}/src'

Source directory. If not set, the working directory of the task is used.

options = ['krb5_cv_cc_flag__dash_Werror_eq_discarded_dash_qualifiers=no', '--disable-rpath', '--localstatedir=/var', '--sysconfdir=/etc', '--with-crypto-impl=builtin', '--with-tls-impl=no', '--without-keyutils', '--without-libedit', '--without-lmdb']

Options passed to the configure script. The configuration of the system is used at runtime.

jolt.pkgs.libarchive

class jolt.pkgs.libarchive.Libarchive

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libarchive

requires = ["libarchive"]

name = 'libarchive'

Name of the task.

version: Parameter = '3.8.11'

libarchive version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_bzip2 = ['libbzip2']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libarchive/libarchive.git,rev=v{version}']

Sources of the package.

requires_expat = ['libexpat']

Tasks required by the package.

requires_lz4 = ['lz4']

Tasks required by the package.

requires_openssl = ['openssl']

Tasks required by the package.

requires_xz = ['xz']

Tasks required by the package.

requires_zlib = ['zlib']

Tasks required by the package.

requires_zstd = ['zstd']

Tasks required by the package.

srcdir = '{git[libarchive]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POLICY_VERSION_MINIMUM=3.5', 'BUILD_SHARED_LIBS={shared[ON,OFF]}', 'ENABLE_TEST=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libcap

class jolt.pkgs.libcap.Libcap

Bases: jolt.tasks.Task

from jolt.pkgs import libcap

requires = ["libcap"]

name = 'libcap'

Name of the task.

version: Parameter = '2.78'

libcap version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['git:url=https://git.kernel.org/pub/scm/libs/libcap/libcap.git,rev=libcap-{version}']

Sources of the package.

srcdir = '{git[libcap]}'

Source directory.

jolt.pkgs.libdrm

class jolt.pkgs.libdrm.Libdrm

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import libdrm

requires = ["libdrm"]

name = 'libdrm'

Name of the task.

version: Parameter = '2.4.134'

libdrm version.

amdgpu: BooleanParameter = 'true'

Enable AMD GPU support.

etnaviv: BooleanParameter = 'true'

Enable Etnaviv support.

exynos: BooleanParameter = 'true'

Enable Exynos support.

freedreno: BooleanParameter = 'true'

Enable Freedreno support.

intel: BooleanParameter = 'true'

Enable Intel support.

nouveau: BooleanParameter = 'true'

Enable Nouveau support.

omap: BooleanParameter = 'true'

Enable OMAP support.

radeon: BooleanParameter = 'true'

Enable Radeon support.

tegra: BooleanParameter = 'true'

Enable Tegra support.

vc4: BooleanParameter = 'true'

Enable VC4 support.

vmwgfx: BooleanParameter = 'true'

Enable VMware graphics support.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/mesa/drm.git,rev=libdrm-{version}']

Sources of the package.

requires_intel = ['libpciaccess']

Tasks required by the package.

srcdir = '{git[drm]}'

Source directory. If not set, the working directory of the task is used.

options = ['amdgpu={amdgpu[enabled,disabled]}', 'etnaviv={etnaviv[enabled,disabled]}', 'exynos={exynos[enabled,disabled]}', 'freedreno={freedreno[enabled,disabled]}', 'intel={intel[enabled,disabled]}', 'nouveau={nouveau[enabled,disabled]}', 'omap={omap[enabled,disabled]}', 'radeon={radeon[enabled,disabled]}', 'tegra={tegra[enabled,disabled]}', 'vc4={vc4[enabled,disabled]}', 'vmwgfx={vmwgfx[enabled,disabled]}']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.libedit

class jolt.pkgs.libedit.Libedit

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import libedit

requires = ["libedit"]

name = 'libedit'

Name of the task.

version: Parameter = '20260512-3.1'

libedit version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://thrysoee.dk/editline/libedit-{version}.tar.gz']

Sources of the package.

requires_ncurses = ['ncurses=ncurses:shared=true']

Tasks required by the package.

srcdir = '{fetch[src]}/libedit-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-examples', '--{shared[with,without]}-shared', '--enable-pc-files', '--with-pkg-config-libdir=/jolt-prefix/lib/pkgconfig']

Options passed to the configure script.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.libevent

class jolt.pkgs.libevent.LibEvent

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libevent

requires = ["libevent"]

name = 'libevent'

Name of the task.

version: Parameter = '2.1.13'

libevent version.

options = ['CMAKE_POLICY_VERSION_MINIMUM=3.5']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libevent/libevent.git,rev=release-{version}-stable']

Sources of the package.

requires_ssl = ['openssl']

Tasks required by the package.

srcdir = '{git[libevent]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libexpat

class jolt.pkgs.libexpat.Libexpat

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libexpat

requires = ["libexpat"]

name = 'libexpat'

Name of the task.

version: Parameter = '2.9.0'

Expat version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/libexpat/libexpat/releases/download/R_{version_tag}/expat-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/expat-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libfastjson

class jolt.pkgs.libfastjson.Libfastjson

Bases: jolt.plugins.autotools.Autotools

Builds and publishes liblibraries and headers.

from jolt.pkgs import libfastjson

requires = ["libfastjson"]

name = 'libfastjson'

Name of the task.

version: Parameter = '1.2609.0'

libfastjson version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/rsyslog/libfastjson.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libfastjson]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

jolt.pkgs.libffi

class jolt.pkgs.libffi.Libffi

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import libffi

requires = ["libffi"]

name = 'libffi'

Name of the task.

version: Parameter = '3.8.0'

libffi version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['git:clean=true,url=https://github.com/libffi/libffi.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libffi]}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.libglvnd

class jolt.pkgs.libglvnd.Libglvnd

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import libglvnd

requires = ["libglvnd"]

name = 'libglvnd'

Name of the task.

version: Parameter = '1.7.0'

libglvnd version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/NVIDIA/libglvnd.git,rev=v{version}']

Sources of the package.

requires_glproto = ['glproto']

Tasks required by the package.

requires_x11 = ['libx11']

Tasks required by the package.

requires_xext = ['libxext']

Tasks required by the package.

srcdir = '{git[libglvnd]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.libjpeg_turbo

class jolt.pkgs.libjpeg_turbo.LibjpegTurbo

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libjpeg_turbo

requires = ["libjpeg-turbo"]

name = 'libjpeg-turbo'

Name of the task.

version: Parameter = '3.2.1'

libjpeg-turbo version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libjpeg-turbo/libjpeg-turbo.git,rev={version}']

Sources of the package.

requires_nasm = ['nasm']

Tasks required by the package.

srcdir = '{git[libjpeg-turbo]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'ENABLE_SHARED={shared[ON,OFF]}', 'ENABLE_STATIC={shared[OFF,ON]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libogg

class jolt.pkgs.libogg.Libogg

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libogg

requires = ["libogg"]

name = 'libogg'

Name of the task.

version: Parameter = '1.3.6'

libogg version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/xiph/ogg.git,rev=v{version}']

Sources of the package.

srcdir = '{git[ogg]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POLICY_VERSION_MINIMUM=3.5']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libpciaccess

class jolt.pkgs.libpciaccess.Libpciaccess

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import libpciaccess

requires = ["libpciaccess"]

name = 'libpciaccess'

Name of the task.

version: Parameter = '0.19'

libpciaccess version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/xorg/lib/libpciaccess.git,rev=libpciaccess-{version}']

Sources of the package.

requires_zlib = ['zlib:pic=true']

Tasks required by the package.

srcdir = '{git[libpciaccess]}'

Source directory. If not set, the working directory of the task is used.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.libpng

class jolt.pkgs.libpng.Libpng

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libpng

requires = ["libpng"]

name = 'libpng'

Name of the task.

version: Parameter = '1.6.59'

libpng version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pnggroup/libpng.git,rev=v{version}']

Sources of the package.

requires_zlib = ['virtual/zlib:pic={pic},shared={shared}']

Tasks required by the package.

srcdir = '{git[libpng]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'PNG_SHARED={shared[ON,OFF]}', 'PNG_STATIC={shared[OFF,ON]}', 'PNG_TESTS=OFF', 'PNG_TOOLS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libseccomp

class jolt.pkgs.libseccomp.Libseccomp

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import libseccomp

requires = ["libseccomp"]

name = 'libseccomp'

Name of the task.

version: Parameter = '2.6.1'

libseccomp version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/seccomp/libseccomp.git,rev=v{version}']

Sources of the package.

requires_gperf = ['gperf']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

srcdir = '{git[libseccomp]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

jolt.pkgs.libsodium

class jolt.pkgs.libsodium.Libsodium

Bases: jolt.plugins.autotools.Autotools

Library for encryption, decryption, signatures and password hashing, including Argon2

from jolt.pkgs import libsodium

requires = ["libsodium"]

name = 'libsodium'

Name of the task.

version: Parameter = '1.0.22'

libsodium version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://download.libsodium.org/libsodium/releases/libsodium-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/libsodium-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}', '--{pic[with,without]}-pic']

Options passed to the configure script.

jolt.pkgs.libtiff

class jolt.pkgs.libtiff.Libtiff

Bases: jolt.plugins.cmake.CMake

TIFF image library

from jolt.pkgs import libtiff

requires = ["libtiff"]

name = 'libtiff'

Name of the task.

version: Parameter = '4.7.2'

LibTIFF version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.com/libtiff/libtiff.git,rev=v{version}']

Sources of the package.

requires_libs = ['libjpeg-turbo:pic={pic},shared={shared}', 'libwebp:pic={pic},shared={shared}', 'virtual/zlib:pic={pic},shared={shared}', 'xz:shared={shared}', 'zstd:pic={pic},shared={shared}']

Libraries of the supported compression methods.

srcdir = '{git[libtiff]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'jbig=OFF', 'jpeg=ON', 'lerc=OFF', 'libdeflate=OFF', 'lzma=ON', 'tiff-contrib=OFF', 'tiff-docs=OFF', 'tiff-tests=OFF', 'tiff-tools=OFF', 'webp=ON', 'zlib=ON', 'zstd=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libtirpc

class jolt.pkgs.libtirpc.Libtirpc

Bases: jolt.plugins.autotools.Autotools

Libtirpc package

from jolt.pkgs import libtirpc

requires = ["libtirpc"]

name = 'libtirpc'

Name of the task.

version: Parameter = '1.3.8'

libtirpc version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:clean=true,url=git://git.linux-nfs.org/projects/steved/libtirpc.git,rev=libtirpc-{_version}']

Sources of the package.

srcdir = '{git[libtirpc]}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-gssapi']

Options passed to the configure script.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.libtool

class jolt.pkgs.libtool.Libtool

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import libtool

requires = ["libtool"]

name = 'libtool'

Name of the task.

version: Parameter = '2.6.2'

Libtool version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=git://git.git.savannah.gnu.org/libtool.git,rev=v{version}']

Sources of the package.

requires_help2man = ['help2man']

Tasks required by the package.

requires_texinfo = ['texinfo']

Tasks required by the package.

srcdir = '{git[libtool]}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

jolt.pkgs.libudev_zero

class jolt.pkgs.libudev_zero.LibudevZero

Bases: jolt.tasks.Task

Daemonless replacement for libudev

from jolt.pkgs import libudev_zero

requires = ["libudev-zero"]

name = 'libudev-zero'

Name of the task.

version: Parameter = '1.0.5'

libudev-zero version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:clean=true,url=https://github.com/illiliti/libudev-zero.git,rev={version}']

Sources of the package.

srcdir = '{git[libudev-zero]}'

Source directory.

jolt.pkgs.libunwind

class jolt.pkgs.libunwind.LibUnwind

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import libunwind

requires = ["libunwind"]

name = 'libunwind'

Name of the task.

version: Parameter = '1.8.3'

libunwind version.

options = ['--disable-tests']

Options passed to the configure script.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libunwind/libunwind.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libunwind]}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.libusb

class jolt.pkgs.libusb.Libusb

Bases: jolt.plugins.autotools.Autotools

Library for access to USB devices

from jolt.pkgs import libusb

requires = ["libusb"]

name = 'libusb'

Name of the task.

version: Parameter = '1.0.30'

libusb version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/libusb/libusb/releases/download/v{version}/libusb-{version}.tar.bz2']

Sources of the package.

requires_udev = ['libudev-zero']

Tasks required by the package.

srcdir = '{fetch[src]}/libusb-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}', '--enable-udev']

Options passed to the configure script.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

jolt.pkgs.libuv

class jolt.pkgs.libuv.Libuv

Bases: jolt.plugins.cmake.CMake

Cross-platform asynchronous I/O

from jolt.pkgs import libuv

requires = ["libuv"]

name = 'libuv'

Name of the task.

version: Parameter = '1.53.0'

libuv version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libuv/libuv.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libuv]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_TESTING=OFF', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'LIBUV_BUILD_BENCH=OFF', 'LIBUV_BUILD_SHARED={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libva

class jolt.pkgs.libva.Libva

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import libva

requires = ["libva"]

name = 'libva'

Name of the task.

version: Parameter = '2.24.1'

libva version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/intel/libva.git,rev={version}']

Sources of the package.

requires_libdrm = ['libdrm']

Tasks required by the package.

srcdir = '{git[libva]}'

Source directory. If not set, the working directory of the task is used.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.libvorbis

class jolt.pkgs.libvorbis.Libvorbis

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libvorbis

requires = ["libvorbis"]

name = 'libvorbis'

Name of the task.

version: Parameter = '1.3.7'

libvorbis version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/xiph/vorbis.git,rev=v{version}']

Sources of the package.

requires_ogg = ['libogg']

Tasks required by the package.

srcdir = '{git[vorbis]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POLICY_VERSION_MINIMUM=3.5']

Options passed to CMake, as option[:type]=value.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libwebp

class jolt.pkgs.libwebp.Libwebp

Bases: jolt.plugins.cmake.CMake

WebP image codec

from jolt.pkgs import libwebp

requires = ["libwebp"]

name = 'libwebp'

Name of the task.

version: Parameter = '1.6.0'

libwebp version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/webmproject/libwebp.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libwebp]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'WEBP_BUILD_ANIM_UTILS=OFF', 'WEBP_BUILD_CWEBP=OFF', 'WEBP_BUILD_DWEBP=OFF', 'WEBP_BUILD_EXTRAS=OFF', 'WEBP_BUILD_GIF2WEBP=OFF', 'WEBP_BUILD_IMG2WEBP=OFF', 'WEBP_BUILD_VWEBP=OFF', 'WEBP_BUILD_WEBPINFO=OFF', 'WEBP_BUILD_WEBPMUX=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libxkbcommon

class jolt.pkgs.libxkbcommon.Libxkbcommon

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import libxkbcommon

requires = ["libxkbcommon"]

name = 'libxkbcommon'

Name of the task.

version: Parameter = '1.13.2'

libxkbcommon version.

x11: BooleanParameter = 'false'

Build the libxkbcommon-x11 library.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_bison = ['bison']

Tasks required by the package.

requires_git = ['git:url=https://github.com/xkbcommon/libxkbcommon.git,rev=xkbcommon-{version}']

Sources of the package.

requires_x11_on = ['xorg/libxcb']

Tasks required by the package when the x11 parameter is enabled.

srcdir = '{git[libxkbcommon]}'

Source directory. If not set, the working directory of the task is used.

options = ['enable-docs=false', 'enable-tools=false', 'enable-wayland=false', 'enable-x11={x11[true,false]}', 'enable-xkbregistry=false']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.libxml2

class jolt.pkgs.libxml2.Libxml2

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libxml2

requires = ["libxml2"]

name = 'libxml2'

Name of the task.

version: Parameter = '2.15.4'

libxml2 version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.gnome.org/GNOME/libxml2.git,rev=v{version}']

Sources of the package.

srcdir = '{git[libxml2]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'LIBXML2_WITH_ICONV=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.libxslt

class jolt.pkgs.libxslt.Libxslt

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libxslt

requires = ["libxslt"]

name = 'libxslt'

Name of the task.

version: Parameter = '1.1.45'

libxslt version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.gnome.org/GNOME/libxslt.git,rev=v{version}']

Sources of the package.

requires_libxml2 = ['libxml2']

Tasks required by the package.

srcdir = '{git[libxslt]}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.libyajl

class jolt.pkgs.libyajl.Libyajl

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import libyajl

requires = ["libyajl"]

name = 'libyajl'

Name of the task.

version: Parameter = '2.1.0'

YAJL version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/lloyd/yajl.git,rev={version}']

Sources of the package.

srcdir = '{git[yajl]}'

Source directory. If not set, the working directory of the task is used.

requires_cmake = ['cmake:version=3.31.1']

Tasks required by the package.

jolt.pkgs.libyaml

class jolt.pkgs.libyaml.Libyaml

Bases: jolt.plugins.autotools.Autotools

YAML parser and emitter in C

from jolt.pkgs import libyaml

requires = ["libyaml"]

name = 'libyaml'

Name of the task.

version: Parameter = '0.2.5'

LibYAML version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://pyyaml.org/download/libyaml/yaml-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/yaml-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}', '--{pic[with,without]}-pic']

Options passed to the configure script.

jolt.pkgs.linux_headers

class jolt.pkgs.linux_headers.LinuxHeaders

Bases: jolt.tasks.Task

Linux kernel headers for user space, such as for building C libraries

from jolt.pkgs import linux_headers

requires = ["linux-headers"]

name = 'linux-headers'

Name of the task.

version: Parameter = '7.3.1'

Linux version.

target: Parameter

Target of the headers, such as aarch64-linux-gnu. The host if not set.

requires_compiler = ['compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://cdn.kernel.org/pub/linux/kernel/v{_major}.x/linux-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/linux-{version}'

jolt.pkgs.llvm

class jolt.pkgs.llvm.LLVM

Bases: jolt.tasks.Alias

from jolt.pkgs import llvm

requires = ["llvm"]

name = 'llvm'

Name of the task.

version: Parameter = '23.1.4'

LLVM version.

requires = ['llvm/src:version={version},release=true']

List of dependencies to other tasks.

class jolt.pkgs.llvm.LLVMFromBin

Bases: jolt.tasks.Download

from jolt.pkgs import llvm

requires = ["llvm/bin"]

name = 'llvm/bin'

Name of the task.

version: Parameter = '23.1.4'

LLVM version.

url = ['https://github.com/llvm/llvm-project/releases/download/llvmorg-{version}/LLVM-{version}-Linux-X64.tar.xz']

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

collect = [{'files': '*', 'cwd': 'LLVM-{version}-Linux-X64'}]

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

Example:

collect = [
    "*",                           # Collect all files
    ("*", "src/"),                 # Collect all files into the artifact's src/ directory
    {"files": "*", cwd="subdir"},  # Collect all files from the archive's subdir/ directory
]

class jolt.pkgs.llvm.LLVMFromSrc

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import llvm

requires = ["llvm/src"]

name = 'llvm/src'

Name of the task.

projects: ListParameter = ['clang', 'clang-tools-extra', 'lld', 'libclc']

LLVM projects to build. Values: clang, clang-tools-extra, lld, libclc, libcxx, libcxxabi, compiler-rt, openmp, polly

release: BooleanParameter = 'true'

Build a release version.

rtti: BooleanParameter = 'true'

Enable RTTI support.

targets: ListParameter = ['X86', 'ARM', 'AArch64', 'RISCV', 'AMDGPU']

LLVM targets to build. Values: X86, AMDGPU, ARM, AArch64, RISCV, Mips, PowerPC, SystemZ

version: Parameter = '23.1.4'

LLVM version.

requires_compiler = ['compiler/c', 'compiler/cxx']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

requires_git = ['git:url=https://github.com/llvm/llvm-project.git,rev=llvmorg-{version}']

Sources of the package.

options = ['CMAKE_BUILD_TYPE={release[Release,Debug]}', "LLVM_ENABLE_PROJECTS='{_projects_str}'", "LLVM_TARGETS_TO_BUILD='{_targets_str}'", 'LLVM_ENABLE_RTTI={rtti[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

srcdir = '{git[llvm-project]}/llvm'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.lua

class jolt.pkgs.lua.Lua

Bases: jolt.plugins.ninja.CXXLibrary

from jolt.pkgs import lua

requires = ["lua"]

name = 'lua'

Name of the task.

version: Parameter = '5.5.1'

Lua version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/lua/lua.git,rev=v{version},hash=true']

Sources of the package.

requires_ninja = ['ninja']

Tasks required by the package.

sources = ['{git[lua]}/lapi.c', '{git[lua]}/lauxlib.c', '{git[lua]}/lbaselib.c', '{git[lua]}/lcode.c', '{git[lua]}/lcorolib.c', '{git[lua]}/lctype.c', '{git[lua]}/ldblib.c', '{git[lua]}/ldebug.c', '{git[lua]}/ldo.c', '{git[lua]}/ldump.c', '{git[lua]}/lfunc.c', '{git[lua]}/lgc.c', '{git[lua]}/linit.c', '{git[lua]}/liolib.c', '{git[lua]}/llex.c', '{git[lua]}/lmathlib.c', '{git[lua]}/lmem.c', '{git[lua]}/loadlib.c', '{git[lua]}/lobject.c', '{git[lua]}/lopcodes.c', '{git[lua]}/loslib.c', '{git[lua]}/lparser.c', '{git[lua]}/lstate.c', '{git[lua]}/lstring.c', '{git[lua]}/lstrlib.c', '{git[lua]}/ltable.c', '{git[lua]}/ltablib.c', '{git[lua]}/ltests.c', '{git[lua]}/ltm.c', '{git[lua]}/lundump.c', '{git[lua]}/lutf8lib.c', '{git[lua]}/lvm.c', '{git[lua]}/lzio.c']

A list of sources to compile.

Path names may contain simple shell-style wildcards such as ‘*’ and ‘?’. Note: files starting with a dot are not matched by these wildcards.

Example:

sources = ["src/*.cpp"]

jolt.pkgs.lz4

class jolt.pkgs.lz4.Lz4

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import lz4

requires = ["lz4"]

name = 'lz4'

Name of the task.

version: Parameter = '1.10.0'

LZ4 version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/lz4/lz4.git,rev=v{version}']

Sources of the package.

srcdir = '{git[lz4]}/build/cmake'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.m4

class jolt.pkgs.m4.M4

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import m4

requires = ["m4"]

name = 'm4'

Name of the task.

version: Parameter = '1.4.21'

GNU M4 version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=http://ftpmirror.gnu.org/m4/m4-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/m4-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.magic_enum

class jolt.pkgs.magic_enum.MagicEnum

Bases: jolt.plugins.cmake.CMake

Static reflection for enums in C++

from jolt.pkgs import magic_enum

requires = ["magic_enum"]

name = 'magic_enum'

Name of the task.

version: Parameter = '0.9.8'

magic_enum version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/Neargye/magic_enum.git,rev=v{version}']

Sources of the package.

srcdir = '{git[magic_enum]}'

Source directory. If not set, the working directory of the task is used.

options = ['MAGIC_ENUM_OPT_BUILD_EXAMPLES=OFF', 'MAGIC_ENUM_OPT_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.make

class jolt.pkgs.make.GnuMake

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import make

requires = ["make"]

name = 'make'

Name of the task.

version: Parameter = '4.4.1'

GNU Make version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/make/make-{version}.tar.gz']

Sources of the package.

requires_texinfo = ['texinfo']

Tasks required by the package.

srcdir = '{fetch[src]}/make-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

jolt.pkgs.mesa

class jolt.pkgs.mesa.Mesa

Bases: jolt.tasks.Task

from jolt.pkgs import mesa

requires = ["mesa"]

name = 'mesa'

Name of the task.

version: Parameter = '26.2.6'

Mesa version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_cbindgen = ['cbindgen']

Tasks required by the package.

requires_expat = ['libexpat:pic=true']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/mesa/mesa.git,rev=mesa-{version}']

Sources of the package.

requires_glslang = ['glslang']

Tasks required by the package.

requires_libdrm = ['libdrm']

Tasks required by the package.

requires_libglvnd = ['libglvnd']

Tasks required by the package.

requires_libx11_xcb = ['libx11-xcb']

Tasks required by the package.

requires_libxshmfence = ['libxshmfence']

Tasks required by the package.

requires_libxxf86vm = ['libxxf86vm']

Tasks required by the package.

requires_llvm = ['clang', 'llvm']

Tasks required by the package.

requires_libva = ['libva']

Tasks required by the package.

requires_meson = ['meson']

Tasks required by the package.

requires_rust = ['rust', 'rust-bindgen']

Tasks required by the package.

requires_spirv_llvm = ['spirv-llvm-translator']

Tasks required by the package.

requires_wayland = ['wayland', 'wayland-protocols']

Tasks required by the package.

requires_xrandr = ['libxrandr']

Tasks required by the package.

jolt.pkgs.meson

class jolt.pkgs.meson.Meson

Bases: jolt.tasks.Alias

Alias for the Meson build system.

Meson is included in the Python virtual environment task.

from jolt.pkgs import meson

requires = ["meson"]

name = 'meson'

Name of the task.

requires = ['python']

List of dependencies to other tasks.

jolt.pkgs.mpc

class jolt.pkgs.mpc.Mpc

Bases: jolt.plugins.autotools.Autotools

GNU multiple precision complex arithmetic library

from jolt.pkgs import mpc

requires = ["mpc"]

name = 'mpc'

Name of the task.

version: Parameter = '1.4.1'

GNU MPC version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_libs = ['gmp', 'mpfr']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/mpc/mpc-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/mpc-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-shared', '--enable-static', '--with-gmp={_gmp}', '--with-mpfr={_mpfr}', '--with-pic']

Options passed to the configure script.

jolt.pkgs.mpfr

class jolt.pkgs.mpfr.Mpfr

Bases: jolt.plugins.autotools.Autotools

GNU multiple precision floating-point library

from jolt.pkgs import mpfr

requires = ["mpfr"]

name = 'mpfr'

Name of the task.

version: Parameter = '4.2.2'

MPFR version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_gmp = ['gmp']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/mpfr/mpfr-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/mpfr-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-shared', '--enable-static', '--with-gmp={_gmp}', '--with-pic']

Options passed to the configure script.

jolt.pkgs.mstch

class jolt.pkgs.mstch.MSTCH

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import mstch

requires = ["mstch"]

name = 'mstch'

Name of the task.

version: Parameter = '1.0.2'

mstch version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_boost = ['boost']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/no1msd/mstch/archive/refs/tags/{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/mstch-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POLICY_VERSION_MINIMUM=3.5']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.musl

class jolt.pkgs.musl.Musl

Bases: jolt.tasks.Task

musl C library

The library is installed as a system root, with headers in usr/include and libraries in usr/lib. It is built for the host with the host compiler, or for a target with the cross compiler for that target.

from jolt.pkgs import musl

requires = ["musl"]

name = 'musl'

Name of the task.

version: Parameter = '1.2.6'

musl version.

target: Parameter

Target of the library, such as aarch64-linux-musl. The host if not set.

requires_compiler = ['compiler/c']

Tasks required by the package.

requires_cross = ['gcc:target={target}']

Cross compiler for the target.

requires_git = ['git:clean=true,url=https://git.musl-libc.org/git/musl,rev=v{version}']

Sources of the package.

requires_native = []

The host compiler is used.

srcdir = '{git[musl]}'

selfsustained = True

Consumers of the library don’t need the compiler that built it.

jolt.pkgs.mysql

class jolt.pkgs.mysql.LibMySQLClient

Bases: jolt.pkgs.mysql.MySQLBase

from jolt.pkgs import mysql

requires = ["libmysqlclient"]

name = 'libmysqlclient'

Name of the task.

shared: BooleanParameter = 'false'

Build shared libraries.

version: Parameter = '26.10.0'

MySQL version.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'WITH_CURL=system', 'WITH_EDITLINE=system', 'WITH_LZ4=system', 'WITH_RAPIDJSON=system', 'WITH_SSL=system', 'WITH_UNIT_TESTS=OFF', 'WITH_ZLIB=system', 'WITH_ZSTD=system', 'WITHOUT_SERVER=ON']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_curl = ['curl']

Tasks required by the package.

requires_darwin_libedit = ['libedit:shared=true']

Tasks required by the package on macOS.

requires_linux_krb5 = ['krb5']

Tasks required by the package on Linux.

requires_linux_ldap = ['cyrus-sasl', 'openldap']

Tasks required by the package on Linux.

requires_linux_libedit = ['libedit:shared=true']

Tasks required by the package on Linux.

requires_linux_libtirpc = ['libtirpc']

Tasks required by the package on Linux.

requires_linux_libudev = ['libudev-zero']

Tasks required by the package on Linux.

requires_lz4 = ['lz4']

Tasks required by the package.

requires_rapidjson = ['rapidjson']

Tasks required by the package.

requires_src = ['git:url=https://github.com/mysql/mysql-server,path={buildroot}/git-mysql,rev=mysql-{version},submodules=true']

Sources of the package.

requires_ssl = ['openssl']

Tasks required by the package.

requires_zlib = ['zlib']

Tasks required by the package.

requires_zstd = ['zstd']

Tasks required by the package.

srcdir = '{git[mysql-server]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.nasm

class jolt.pkgs.nasm.NASM

Bases: jolt.tasks.Task

from jolt.pkgs import nasm

requires = ["nasm"]

name = 'nasm'

Name of the task.

version: Parameter = '3.02'

NASM version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_autotools_darwin = ['autoconf', 'automake']

Tasks required by the package on macOS.

requires_autotools_linux = ['autoconf', 'automake']

Tasks required by the package on Linux.

requires_git = ['git:url=https://github.com/netwide-assembler/nasm.git,rev=nasm-{version}']

Sources of the package.

requires_zlib = ['zlib']

Tasks required by the package.

requires_perl = ['virtual/perl']

Tasks required by the package.

srcdir = '{git[nasm]}'

Source directory.

jolt.pkgs.ncurses

class jolt.pkgs.ncurses.Ncurses

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import ncurses

requires = ["ncurses"]

name = 'ncurses'

Name of the task.

version: Parameter = '6.6'

ncurses version.

widechar: BooleanParameter = 'false'

Build ncurses with wide character support.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://invisible-mirror.net/archives/ncurses/ncurses-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/ncurses-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--{widechar[enable,disable]}-widec', '--{shared[with,without]}-shared', '--enable-pc-files', '--with-pkg-config-libdir=/jolt-prefix/lib/pkgconfig']

Options passed to the configure script.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.ng_log

class jolt.pkgs.ng_log.NgLog

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import ng_log

requires = ["ng-log"]

name = 'ng-log'

Name of the task.

version: Parameter = '0.8.4'

ng-log version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/ng-log/ng-log.git,rev=v{version}']

Sources of the package.

srcdir = '{git[ng-log]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.nghttp2

class jolt.pkgs.nghttp2.Nghttp2

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import nghttp2

requires = ["nghttp2"]

name = 'nghttp2'

Name of the task.

version: Parameter = '1.70.0'

nghttp2 version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/nghttp2/nghttp2.git,rev=v{version}']

Sources of the package.

srcdir = '{git[nghttp2]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'BUILD_STATIC_LIBS={shared[OFF,ON]}', 'BUILD_TESTING=OFF', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'ENABLE_DOC=OFF', 'ENABLE_LIB_ONLY=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.ninja

class jolt.pkgs.ninja.Ninja

Bases: jolt.tasks.Alias

from jolt.pkgs import ninja

requires = ["ninja"]

name = 'ninja'

Name of the task.

version: Parameter = '1.13.2'

Ninja version.

requires = ['ninja/bin:version={version}']

List of dependencies to other tasks.

class jolt.pkgs.ninja.NinjaBin

Bases: jolt.tasks.Download

from jolt.pkgs import ninja

requires = ["ninja/bin"]

name = 'ninja/bin'

Name of the task.

version: Parameter = '1.13.2'

Ninja version.

url = ['https://github.com/ninja-build/ninja/releases/download/v{version}/ninja-{ninja_system}.zip']

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

collect = [{'files': '*', 'dest': 'bin/'}]

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

Example:

collect = [
    "*",                           # Collect all files
    ("*", "src/"),                 # Collect all files into the artifact's src/ directory
    {"files": "*", cwd="subdir"},  # Collect all files from the archive's subdir/ directory
]

class jolt.pkgs.ninja.NinjaSrc

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import ninja

requires = ["ninja/src"]

name = 'ninja/src'

Name of the task.

version: Parameter = '1.13.2'

Ninja version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/ninja-build/ninja.git,rev=v{version}']

Sources of the package.

requires_re2c = ['re2c']

Tasks required by the package.

srcdir = '{git[ninja]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_TESTING={tests[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.nlohmann_json

class jolt.pkgs.nlohmann_json.NlohmannJson

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import nlohmann_json

requires = ["nlohmann/json"]

name = 'nlohmann/json'

Name of the task.

version: Parameter = '3.12.0'

JSON for Modern C++ version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/nlohmann/json.git,rev=v{version}']

Sources of the package.

srcdir = '{git[json]}'

Source directory. If not set, the working directory of the task is used.

options = ['JSON_BuildTests={tests[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.nodejs

class jolt.pkgs.nodejs.NodeJS

Bases: jolt.tasks.Download

from jolt.pkgs import nodejs

requires = ["nodejs"]

name = 'nodejs'

Name of the task.

version: Parameter = '26.13.0'

Node.js version.

url = 'https://nodejs.org/dist/v{version}/node-v{version}-{os}-{arch}.{ext}'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

bin = 'node-v{version}-{os}-{arch}/bin'

Directory with the executables in the downloaded archive.

jolt.pkgs.numactl

class jolt.pkgs.numactl.Numactl

Bases: jolt.plugins.autotools.Autotools

NUMA policy library and tools

from jolt.pkgs import numactl

requires = ["numactl"]

name = 'numactl'

Name of the task.

version: Parameter = '2.0.19'

numactl version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/numactl/numactl/releases/download/v{version}/numactl-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/numactl-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}']

Options passed to the configure script.

jolt.pkgs.onetbb

class jolt.pkgs.onetbb.OneTbb

Bases: jolt.plugins.cmake.CMake

oneAPI Threading Building Blocks, a library for task parallelism

from jolt.pkgs import onetbb

requires = ["onetbb"]

name = 'onetbb'

Name of the task.

version: Parameter = '2023.2.0'

oneTBB version.

shared: BooleanParameter = 'true'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/uxlfoundation/oneTBB.git,rev=v{version}']

Sources of the package.

srcdir = '{git[oneTBB]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'TBB_DISABLE_HWLOC_AUTOMATIC_SEARCH=ON', 'TBB_STRICT=OFF', 'TBB_TEST=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.opencv

class jolt.pkgs.opencv.OpenCV

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import opencv

requires = ["opencv"]

name = 'opencv'

Name of the task.

version: Parameter = '5.0.0'

OpenCV version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/opencv/opencv.git,rev={version}']

Sources of the package.

srcdir = '{git[opencv]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_EXAMPLES=OFF', 'BUILD_TESTS=OFF', 'BUILD_PERF_TESTS=OFF', 'BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.openjdk

class jolt.pkgs.openjdk.OpenJDK

Bases: jolt.tasks.Download

from jolt.pkgs import openjdk

requires = ["openjdk"]

name = 'openjdk'

Name of the task.

version: Parameter = '25.0.1'

OpenJDK version.

collect_darwin = [{'files': '*', 'cwd': 'jdk-25.0.1.jdk/Contents/Home'}]

File publication instructions on macOS. See collect.

collect_linux = [{'files': '*', 'cwd': 'jdk-25.0.1'}]

File publication instructions on Linux. See collect.

collect_windows = [{'files': '*', 'cwd': 'jdk-25.0.1'}]

File publication instructions on Windows. See collect.

url_darwin = 'https://download.java.net/java/GA/jdk25.0.1/2fbf10d8c78e40bd87641c434705079d/8/GPL/openjdk-25.0.1_macos-x64_bin.tar.gz'

URL of the file to download on macOS.

url_linux = 'https://download.java.net/java/GA/jdk25.0.1/2fbf10d8c78e40bd87641c434705079d/8/GPL/openjdk-25.0.1_linux-x64_bin.tar.gz'

URL of the file to download on Linux.

url_windows = 'https://download.java.net/java/GA/jdk25.0.1/2fbf10d8c78e40bd87641c434705079d/8/GPL/openjdk-25.0.1_windows-x64_bin.zip'

URL of the file to download on Windows.

jolt.pkgs.openldap

class jolt.pkgs.openldap.OpenLDAP

Bases: jolt.plugins.autotools.Autotools

Lightweight Directory Access Protocol client libraries

from jolt.pkgs import openldap

requires = ["openldap"]

name = 'openldap'

Name of the task.

version: Parameter = '2.6.16'

OpenLDAP version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_libs = ['cyrus-sasl', 'openssl']

Libraries used for SASL authentication and TLS.

requires_src = ['fetch:alias=src,url=https://www.openldap.org/software/download/OpenLDAP/openldap-release/openldap-{version}.tgz']

Sources of the package.

srcdir = '{fetch[src]}/openldap-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--disable-slapd', '--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}', '--localstatedir=/var', '--sysconfdir=/etc', '--with-cyrus-sasl', '--with-pic', '--with-tls=openssl']

Options passed to the configure script. The configuration of the system is used at runtime.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.openssl

class jolt.pkgs.openssl.OpenSSL

Bases: jolt.tasks.Task

from jolt.pkgs import openssl

requires = ["openssl"]

name = 'openssl'

Name of the task.

version: Parameter = '4.1.0'

OpenSSL version.

shared: BooleanParameter = 'false'

Build shared libraries.

target: Parameter

OpenSSL configuration target. Detected by OpenSSL if not set. Values: BC-32, BC-64, BS2000-OSD, BSD-aarch64, BSD-armv4, BSD-generic32, BSD-generic64, BSD-ia64, BSD-nodef-generic32, BSD-nodef-generic64, BSD-nodef-ia64, BSD-nodef-sparc64, BSD-nodef-sparcv8, BSD-nodef-x86, BSD-nodef-x86-elf, BSD-nodef-x86_64, BSD-ppc, BSD-ppc64, BSD-ppc64le, BSD-riscv32, BSD-riscv64, BSD-sparc64, BSD-sparcv8, BSD-x86, BSD-x86-elf, BSD-x86_64, Cygwin, Cygwin-i386, Cygwin-i486, Cygwin-i586, Cygwin-i686, Cygwin-x86, Cygwin-x86_64, DJGPP, MPE/iX-gcc, OS390-Unix, UEFI, UEFI-x86, UEFI-x86_64, UWIN, VC-CE, VC-CLANG-WIN64-CLANGASM-ARM, VC-WIN32, VC-WIN32-ARM, VC-WIN32-ARM-UWP, VC-WIN32-HYBRIDCRT, VC-WIN32-ONECORE, VC-WIN32-UWP, VC-WIN64-ARM, VC-WIN64-ARM-UWP, VC-WIN64-CLANGASM-ARM, VC-WIN64A, VC-WIN64A-HYBRIDCRT, VC-WIN64A-ONECORE, VC-WIN64A-UWP, VC-WIN64A-masm, VC-WIN64I, aix-cc, aix-cc-solib, aix-clang, aix-gcc, aix64-cc, aix64-cc-solib, aix64-clang, aix64-gcc, aix64-gcc-as, android-arm, android-arm64, android-armeabi, android-mips, android-mips64, android-riscv64, android-x86, android-x86_64, android64, android64-aarch64, android64-mips64, android64-x86_64, bsdi-elf-gcc, cc, darwin-i386, darwin-i386-cc, darwin-ppc, darwin-ppc-cc, darwin64-arm64, darwin64-arm64-cc, darwin64-ppc, darwin64-ppc-cc, darwin64-x86_64, darwin64-x86_64-cc, darwin8-ppc-cc, darwin8-ppc64-cc, gcc, haiku-x86, haiku-x86_64, hpux-ia64-cc, hpux-ia64-gcc, hpux-parisc-cc, hpux-parisc-gcc, hpux-parisc1_1-cc, hpux-parisc1_1-gcc, hpux64-ia64-cc, hpux64-ia64-gcc, hpux64-parisc2-cc, hpux64-parisc2-gcc, hurd-generic32, hurd-generic64, hurd-x86, hurd-x86_64, ios-cross, ios-xcrun, ios64-cross, ios64-xcrun, iossimulator-arm64-xcrun, iossimulator-i386-xcrun, iossimulator-x86_64-xcrun, iossimulator-xcrun, iphoneos-cross, irix-mips3-cc, irix-mips3-gcc, irix64-mips4-cc, irix64-mips4-gcc, linux-aarch64, linux-alpha-gcc, linux-aout, linux-arm64ilp32, linux-arm64ilp32-clang, linux-armv4, linux-c64xplus, linux-elf, linux-generic32, linux-generic64, linux-ia64, linux-latomic, linux-mips32, linux-mips64, linux-ppc, linux-ppc64, linux-ppc64le, linux-sparcv8, linux-sparcv9, linux-x32, linux-x86, linux-x86-clang, linux-x86-latomic, linux-x86_64, linux-x86_64-clang, linux32-riscv32, linux32-s390x, linux64-loongarch64, linux64-mips64, linux64-riscv64, linux64-s390x, linux64-sparcv9, mingw, mingw64, mingwarm64, nonstop-nse, nonstop-nse_64, nonstop-nse_64_put, nonstop-nse_put, nonstop-nsv, nonstop-nsx, nonstop-nsx_64, nonstop-nsx_64_klt, nonstop-nsx_64_put, nonstop-nsx_g, nonstop-nsx_g_tandem, nonstop-nsx_put, sco5-cc, sco5-gcc, solaris-sparcv7-cc, solaris-sparcv7-gcc, solaris-sparcv8-cc, solaris-sparcv8-gcc, solaris-sparcv9-cc, solaris-sparcv9-gcc, solaris-x86-gcc, solaris64-sparcv9-cc, solaris64-sparcv9-gcc, solaris64-x86_64-cc, solaris64-x86_64-gcc, tru64-alpha-cc, tru64-alpha-gcc, uClinux-dist, uClinux-dist64, unixware-2.0, unixware-2.1, unixware-7, unixware-7-gcc, vms-alpha, vms-alpha-p32, vms-alpha-p64, vms-ia64, vms-ia64-p32, vms-ia64-p64, vms-x86_64, vms-x86_64-cross-ia64, vms-x86_64-p32, vms-x86_64-p64, vos-gcc

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/openssl/openssl.git,rev=openssl-{version}']

Sources of the package.

requires_perl = ['virtual/perl']

Tasks required by the package.

requires_windows_nasm = ['nasm']

Tasks required by the package on Windows.

jolt.pkgs.paho

class jolt.pkgs.paho.PahoMQTT_C

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import paho

requires = ["paho/mqtt-c"]

name = 'paho/mqtt-c'

Name of the task.

version: Parameter = '1.3.16'

Paho MQTT C version.

shared: BooleanParameter = 'false'

Build shared libraries.

ssl: BooleanParameter = 'true'

Enable SSL support.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/eclipse/paho.mqtt.c.git,rev=v{version}']

Sources of the package.

requires_ssl_on = ['openssl']

Tasks required by the package when the ssl parameter is enabled.

srcdir = '{git[paho.mqtt.c]}'

Source directory. If not set, the working directory of the task is used.

options = ['PAHO_BUILD_SHARED={shared[ON,OFF]}', 'PAHO_BUILD_STATIC={shared[OFF,ON]}', 'PAHO_WITH_SSL={ssl[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.paho.PahoMQTT_CXX

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import paho

requires = ["paho/mqtt-cxx"]

name = 'paho/mqtt-cxx'

Name of the task.

version: Parameter = '1.6.0'

Paho MQTT C++ version.

shared: BooleanParameter = 'false'

Build shared libraries.

ssl: BooleanParameter = 'true'

Enable SSL support.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/eclipse/paho.mqtt.cpp.git,rev=v{version}']

Sources of the package.

requires_mqtt_c = ['paho/mqtt-c:shared={shared},ssl={ssl}']

Tasks required by the package.

srcdir = '{git[paho.mqtt.cpp]}'

Source directory. If not set, the working directory of the task is used.

options = ['PAHO_BUILD_SHARED={shared[ON,OFF]}', 'PAHO_BUILD_STATIC={shared[OFF,ON]}', 'PAHO_WITH_SSL={ssl[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.paho.PahoMQTT_Embedded_C

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import paho

requires = ["paho/mqtt-embedded-c"]

name = 'paho/mqtt-embedded-c'

Name of the task.

version: Parameter = '1.1.0'

Paho MQTT Embedded C version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/eclipse/paho.mqtt.embedded-c.git,rev=v{version}']

Sources of the package.

srcdir = '{git[paho.mqtt.embedded-c]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POLICY_VERSION_MINIMUM=3.5']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.patchelf

class jolt.pkgs.patchelf.Patchelf

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import patchelf

requires = ["patchelf"]

name = 'patchelf'

Name of the task.

version: Parameter = '0.19.2'

PatchELF version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/NixOS/patchelf/archive/refs/tags/{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/patchelf-{version}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.pcre2

class jolt.pkgs.pcre2.Pcre2

Bases: jolt.plugins.cmake.CMake

Perl compatible regular expressions, for 8, 16 and 32-bit code units

from jolt.pkgs import pcre2

requires = ["pcre2"]

name = 'pcre2'

Name of the task.

version: Parameter = '10.49'

PCRE2 version.

jit: BooleanParameter = 'true'

Enable just-in-time compilation.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_bzip2 = ['libbzip2']

Compression library used by pcre2grep.

requires_src = ['fetch:alias=src,url=https://github.com/PCRE2Project/pcre2/releases/download/pcre2-{version}/pcre2-{version}.tar.bz2']

Sources of the package.

requires_zlib = ['zlib']

Compression library used by pcre2grep.

srcdir = '{fetch[src]}/pcre2-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'BUILD_STATIC_LIBS={shared[OFF,ON]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'PCRE2_BUILD_PCRE2_16=ON', 'PCRE2_BUILD_PCRE2_32=ON', 'PCRE2_BUILD_TESTS=OFF', 'PCRE2_SUPPORT_JIT={jit[ON,OFF]}', 'PCRE2_SUPPORT_LIBBZ2=ON', 'PCRE2_SUPPORT_LIBZ=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.perl

class jolt.pkgs.perl.HostPerl

Bases: jolt.tasks.Task

from jolt.pkgs import perl

requires = ["perl/host"]

name = 'perl/host'

Name of the task.

class jolt.pkgs.perl.StrawberryPerl

Bases: jolt.tasks.Download

from jolt.pkgs import perl

requires = ["perl/strawberry"]

name = 'perl/strawberry'

Name of the task.

version: Parameter = '5.42.3.1'

Strawberry Perl version.

url = 'https://github.com/StrawberryPerl/Perl-Dist-Strawberry/releases/download/SP_{version_compact}_64bit/strawberry-perl-{version}-64bit-portable.zip'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

class jolt.pkgs.perl.Perl

Bases: jolt.tasks.Alias

from jolt.pkgs import perl

requires = ["virtual/perl"]

name = 'virtual/perl'

Name of the task.

requires_darwin = ['perl/host']

Tasks required by the package on macOS.

requires_linux = ['perl/host']

Tasks required by the package on Linux.

requires_windows = ['perl/strawberry']

Tasks required by the package on Windows.

jolt.pkgs.pkgconfig

class jolt.pkgs.pkgconfig.PkgConf

Bases: jolt.tasks.Alias

Alias for pkgconf package.

from jolt.pkgs import pkgconfig

requires = ["pkgconf"]

name = 'pkgconf'

Name of the task.

version: Parameter = '3.0.10'

pkgconf version.

requires_darwin = ['pkgconf/posix:version={version}']

Tasks required by the package on macOS.

requires_linux = ['pkgconf/posix:version={version}']

Tasks required by the package on Linux.

requires_windows = ['pkgconf/win32:version={version}']

Tasks required by the package on Windows.

class jolt.pkgs.pkgconfig.PkgConfPosix

Bases: jolt.plugins.autotools.Autotools

Package that provides the ‘pkgconf’ binary, an alternative implementation of ‘pkg-config’.

from jolt.pkgs import pkgconfig

requires = ["pkgconf/posix"]

name = 'pkgconf/posix'

Name of the task.

version: Parameter = '3.0.10'

pkgconf version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pkgconf/pkgconf.git,rev=pkgconf-{version}']

Sources of the package.

srcdir = '{git[pkgconf]}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-static', '--disable-shared']

Options passed to the configure script.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.pkgconfig.PkgConfWin32

Bases: jolt.plugins.meson.Meson

Package that provides the ‘pkgconf’ binary, an alternative implementation of ‘pkg-config’.

from jolt.pkgs import pkgconfig

requires = ["pkgconf/win32"]

name = 'pkgconf/win32'

Name of the task.

version: Parameter = '3.0.10'

pkgconf version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pkgconf/pkgconf.git,rev=pkgconf-{version}']

Sources of the package.

srcdir = '{git[pkgconf]}'

Source directory. If not set, the working directory of the task is used.

options = ['default_library=static', 'tests=disabled']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.poco

class jolt.pkgs.poco.Poco

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import poco

requires = ["poco"]

name = 'poco'

Name of the task.

version: Parameter = '1.15.4'

POCO version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pocoproject/poco.git,rev=poco-{version}-release']

Sources of the package.

requires_ssl = ['virtual/ssl']

Tasks required by the package.

srcdir = '{git[poco]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'POCO_MT=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.protobuf

class jolt.pkgs.protobuf.Protobuf

Bases: jolt.plugins.cmake.CMake

Protocol buffers main package.

For linking, require protobuf/lib and friends.

from jolt.pkgs import protobuf

requires = ["protobuf"]

name = 'protobuf'

Name of the task.

version: Parameter = '36.2'

Protocol Buffers version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_abseil = ['abseil:pic={pic},shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/protocolbuffers/protobuf.git,rev=v{version}']

Sources of the package.

srcdir = '{git[protobuf]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_CXX_STANDARD=17', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'protobuf_BUILD_TESTS=OFF', 'protobuf_MSVC_STATIC_RUNTIME=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.protobuf.ProtobufLib

Bases: jolt.tasks.Task

Protobuf library

from jolt.pkgs import protobuf

requires = ["protobuf/lib"]

name = 'protobuf/lib'

Name of the task.

version: Parameter = '36.2'

Protocol Buffers version.

shared: BooleanParameter = 'false'

Build shared libraries.

extends = 'protobuf:version={version},shared={shared}'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

class jolt.pkgs.protobuf.ProtobufLibProtoc

Bases: jolt.tasks.Task

Protobuf compiler library (libprotoc)

from jolt.pkgs import protobuf

requires = ["protobuf/lib-compiler"]

name = 'protobuf/lib-compiler'

Name of the task.

version: Parameter = '36.2'

Protocol Buffers version.

shared: BooleanParameter = 'false'

Build shared libraries.

extends = 'protobuf:version={version},shared={shared}'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

class jolt.pkgs.protobuf.ProtobufLite

Bases: jolt.tasks.Task

Protobuf Lite library

from jolt.pkgs import protobuf

requires = ["protobuf/lib-lite"]

name = 'protobuf/lib-lite'

Name of the task.

version: Parameter = '36.2'

Protocol Buffers version.

shared: BooleanParameter = 'false'

Build shared libraries.

extends = 'protobuf:version={version},shared={shared}'

Name of extended task.

A task with this attribute set is called an extension. An extension is executed in the context of the extended task, immediately after the extended task has executed.

A common use-case for extensions is to produce additional artifacts from the output of another task. Also, for long-running tasks, it is sometimes beneficial to utilize the intermediate output from an extended task. The extension artifact can then be acquired more cheaply than if the extension had performed all of the work from scratch.

An extension can only extend one other task.

jolt.pkgs.pugixml

class jolt.pkgs.pugixml.PugiXML

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import pugixml

requires = ["pugixml"]

name = 'pugixml'

Name of the task.

version: Parameter = '1.16'

pugixml version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/zeux/pugixml.git,rev=v{version}']

Sources of the package.

srcdir = '{git[pugixml]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.pybind11

class jolt.pkgs.pybind11.Pybind11

Bases: jolt.plugins.cmake.CMake

Header-only library for exposing C++ to Python and Python to C++

from jolt.pkgs import pybind11

requires = ["pybind11"]

name = 'pybind11'

Name of the task.

version: Parameter = '3.1.0'

pybind11 version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/pybind/pybind11.git,rev=v{version}']

Sources of the package.

srcdir = '{git[pybind11]}'

Source directory. If not set, the working directory of the task is used.

options = ['PYBIND11_TEST=OFF', 'PYBIND11_NOPYTHON=ON']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.python

class jolt.pkgs.python.Python

Bases: jolt.plugins.python.PythonEnv

Builds and publishes a Python virtual environment with specified packages.

from jolt.pkgs import python

requires = ["python"]

name = 'python'

Name of the task.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requirements = ['setuptools', 'mako', 'meson', 'pyyaml']

List of Python packages to install in the virtual environment.

Each entry should be a string suitable for pip, e.g., “package==version”.

requires_python = ['cpython']

Tasks required by the package.

jolt.pkgs.qt

class jolt.pkgs.qt.Qt

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import qt

requires = ["qt"]

name = 'qt'

Name of the task.

version: Parameter = '6.12.0'

Qt version.

gl: BooleanParameter = 'true'

Enable OpenGL support.

webengine: BooleanParameter = 'false'

Enable WebEngine module.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_dbus_linux = ['dbus']

Tasks required by the package on Linux.

requires_git = ['git:path={buildroot}/git-qt,url=https://github.com/qt/qt5.git,rev=v{version},submodules=true']

Sources of the package.

requires_ninja = ['ninja']

Tasks required by the package.

requires_linux_gl_true = ['libglvnd']

Tasks required by the package on Linux.

requires_protobuf = ['protobuf']

Tasks required by the package.

srcdir = '{git[qt5]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_qtwebengine={webengine[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.rapidjson

class jolt.pkgs.rapidjson.RapidJSON

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import rapidjson

requires = ["rapidjson"]

name = 'rapidjson'

Name of the task.

version: Parameter = '24b5e7a'

RapidJSON version.

options = ['RAPIDJSON_BUILD_EXAMPLES=OFF', 'RAPIDJSON_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/Tencent/rapidjson.git,rev={version}']

Sources of the package.

srcdir = '{git[rapidjson]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.rapidyaml

class jolt.pkgs.rapidyaml.RapidYAML

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import rapidyaml

requires = ["rapidyaml"]

name = 'rapidyaml'

Name of the task.

version: Parameter = '0.16.0'

rapidyaml version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_src = ['git:url=https://github.com/biojppm/rapidyaml.git,rev=v{version}']

Sources of the package.

srcdir = '{git[rapidyaml]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'RYML_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.re2

class jolt.pkgs.re2.RE2

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import re2

requires = ["re2"]

name = 're2'

Name of the task.

version: Parameter = '2025-11-05'

RE2 version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_abseil = ['abseil:shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/google/re2.git,rev={version}']

Sources of the package.

srcdir = '{git[re2]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'RE2_BUILD_TESTING=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.re2c

class jolt.pkgs.re2c.Re2c

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import re2c

requires = ["re2c"]

name = 're2c'

Name of the task.

version: Parameter = '4.6'

re2c version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/skvadrik/re2c.git,rev={version}']

Sources of the package.

srcdir = '{git[re2c]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.readline

class jolt.pkgs.readline.Readline

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import readline

requires = ["readline"]

name = 'readline'

Name of the task.

version: Parameter = '8.3'

GNU Readline version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://ftpmirror.gnu.org/gnu/readline/readline-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/readline-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.rust

class jolt.pkgs.rust.Rust

Bases: jolt.tasks.Download

from jolt.pkgs import rust

requires = ["rust"]

name = 'rust'

Name of the task.

version: Parameter = '1.99.1'

Rust version.

url = 'https://static.rust-lang.org/dist/rust-{version}-{triple}.tar.xz'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

collect = [{'files': '*', 'cwd': 'rust-{version}-{triple}'}]

A list of file publication instructions.

Items in the list are passed directly to Artifact.collect() and can be either strings, tuples or dictionaries.

Example:

collect = [
    "*",                           # Collect all files
    ("*", "src/"),                 # Collect all files into the artifact's src/ directory
    {"files": "*", cwd="subdir"},  # Collect all files from the archive's subdir/ directory
]

components = ['cargo', 'rustc', 'rust-std-{triple}']

Components installed from the downloaded archive.

triple_linux_x86_64 = 'x86_64-unknown-linux-gnu'

Target triple on Linux x86-64.

triple_windows_x86_64 = 'x86_64-pc-windows-msvc'

Target triple on Windows x86-64.

triple_darwin_x86_64 = 'x86_64-apple-darwin'

Target triple on macOS x86-64.

triple_darwin_arm64 = 'aarch64-apple-darwin'

Target triple on macOS arm64.

triple_linux_aarch64 = 'aarch64-unknown-linux-gnu'

Target triple on Linux arm64.

triple_windows_arm64 = 'aarch64-pc-windows-msvc'

Target triple on Windows arm64.

class jolt.pkgs.rust.RustBindgen

Bases: jolt.plugins.rust.Rust

from jolt.pkgs import rust

requires = ["rust-bindgen"]

name = 'rust-bindgen'

Name of the task.

version: Parameter = '0.73.2'

rust-bindgen version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/rust-lang/rust-bindgen.git,rev=v{version}']

Sources of the package.

requires_rust = ['rust']

Tasks required by the package.

srcdir = '{git[rust-bindgen]}/bindgen-cli'

Source directory for the Rust project.

If None, defaults to the task work directory (joltdir).

jolt.pkgs.sccache

class jolt.pkgs.sccache.Sccache

Bases: jolt.tasks.Download

Shared compiler cache

from jolt.pkgs import sccache

requires = ["sccache"]

name = 'sccache'

Name of the task.

version: Parameter = '0.19.0'

sccache version.

url = 'https://github.com/mozilla/sccache/releases/download/v{version}/sccache-v{version}-{_triple}.{_ext}'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

jolt.pkgs.sdl

class jolt.pkgs.sdl.SDL

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import sdl

requires = ["sdl"]

name = 'sdl'

Name of the task.

version: Parameter = '3.4.18'

SDL version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/libsdl-org/SDL.git,rev=release-{version}']

Sources of the package.

requires_linux = ['alsa-lib', 'libusb:shared={shared}', 'xorg/libxtst']

Libraries that SDL is built against on Linux. ALSA and XTest are loaded at runtime.

srcdir = '{git[SDL]}'

Source directory. If not set, the working directory of the task is used.

options = ['SDL_HIDAPI_LIBUSB_SHARED={shared[ON,OFF]}', 'SDL_SHARED={shared[ON,OFF]}', 'SDL_STATIC={shared[OFF,ON]}', 'SDL_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.simdjson

class jolt.pkgs.simdjson.Simdjson

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import simdjson

requires = ["simdjson"]

name = 'simdjson'

Name of the task.

version: Parameter = '5.1.0'

simdjson version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/simdjson/simdjson.git,rev=v{version}']

Sources of the package.

srcdir = '{git[simdjson]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.soci

class jolt.pkgs.soci.Soci

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import soci

requires = ["soci"]

name = 'soci'

Name of the task.

version: Parameter = '4.1.4'

SOCI version.

shared: BooleanParameter = 'false'

Build shared libraries.

boost: BooleanParameter = 'false'

Enable Boost support.

mysql: BooleanParameter = 'true'

Enable MySQL support.

sqlite: BooleanParameter = 'true'

Enable SQLite support.

odbc: BooleanParameter = 'false'

Enable ODBC support.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_boost_on = ['boost']

Tasks required by the package when the boost parameter is enabled.

requires_fmt = ['fmt:shared={shared}']

Tasks required by the package.

requires_git = ['git:url=https://github.com/SOCI/soci.git,rev=v{version}']

Sources of the package.

requires_mysql_on = ['libmysqlclient']

Tasks required by the package when the mysql parameter is enabled.

requires_sqlite_on = ['sqlite']

Tasks required by the package when the sqlite parameter is enabled.

requires_odbc_on = ['unixodbc']

Tasks required by the package when the odbc parameter is enabled.

srcdir = '{git[soci]}'

Source directory. If not set, the working directory of the task is used.

options = ['SOCI_FMT_BUILTIN=OFF', 'SOCI_TESTS=OFF', 'SOCI_SHARED={shared[ON,OFF]}', 'SOCI_SQLITE3={sqlite[ON,OFF]}', 'SOCI_MYSQL={mysql[ON,OFF]}', 'SOCI_ODBC={odbc[ON,OFF]}', 'WITH_BOOST={boost[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.spdlog

class jolt.pkgs.spdlog.Spdlog

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import spdlog

requires = ["spdlog"]

name = 'spdlog'

Name of the task.

version: Parameter = '1.17.0'

spdlog version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/gabime/spdlog.git,rev=v{version}']

Sources of the package.

srcdir = '{git[spdlog]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'SPDLOG_BUILD_BENCH=OFF', 'SPDLOG_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.spirv_llvm

class jolt.pkgs.spirv_llvm.SpirvLLVM

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import spirv_llvm

requires = ["spirv-llvm-translator"]

name = 'spirv-llvm-translator'

Name of the task.

version: Parameter = '23.1.3'

SPIRV-LLVM-Translator version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/KhronosGroup/SPIRV-LLVM-Translator.git,rev=v{version}']

Sources of the package.

requires_llvm = ['llvm']

Tasks required by the package.

requires_spirv_tools = ['spirv-tools']

Tasks required by the package.

srcdir = '{git[SPIRV-LLVM-Translator]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.spirv_tools

class jolt.pkgs.spirv_tools.SpirvTools

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import spirv_tools

requires = ["spirv-tools"]

name = 'spirv-tools'

Name of the task.

version: Parameter = '2026.4'

SPIRV-Tools version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/KhronosGroup/SPIRV-Tools.git,rev=v{version}']

Sources of the package.

srcdir = '{git[SPIRV-Tools]}'

Source directory. If not set, the working directory of the task is used.

options = ['SPIRV_SKIP_TESTS={tests[OFF,ON]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.sqlite

class jolt.pkgs.sqlite.SQLite

Bases: jolt.tasks.Alias

from jolt.pkgs import sqlite

requires = ["sqlite"]

name = 'sqlite'

Name of the task.

version: Parameter = '3.54.1'

SQLite version.

shared: BooleanParameter = 'false'

Use shared libraries.

requires_darwin = ['sqlite/posix:shared={shared},version={version}']

Tasks required by the package on macOS.

requires_linux = ['sqlite/posix:shared={shared},version={version}']

Tasks required by the package on Linux.

requires_windows = ['sqlite/win32:shared={shared},version={version}']

Tasks required by the package on Windows.

class jolt.pkgs.sqlite.SQLitePosix

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import sqlite

requires = ["sqlite/posix"]

name = 'sqlite/posix'

Name of the task.

version: Parameter = '3.54.1'

SQLite version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/sqlite/sqlite.git,rev=version-{version}']

Sources of the package.

srcdir = '{git[sqlite]}'

Source directory. If not set, the working directory of the task is used.

options = ['--{shared[enable,disable]}-shared']

Options passed to the configure script.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.sqlite.SQLiteWin32

Bases: jolt.tasks.Task

from jolt.pkgs import sqlite

requires = ["sqlite/win32"]

name = 'sqlite/win32'

Name of the task.

version: Parameter = '3.54.1'

SQLite version.

shared: BooleanParameter = 'true'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:clean=true,url=https://github.com/sqlite/sqlite.git,rev=version-{version}']

Sources of the package.

srcdir = '{git[sqlite]}'

Source directory.

jolt.pkgs.ssl

class jolt.pkgs.ssl.VirtualSsl

Bases: jolt.tasks.Alias

from jolt.pkgs import ssl

requires = ["virtual/ssl"]

name = 'virtual/ssl'

Name of the task.

pic: BooleanParameter = 'false'

Use position independent code.

shared: BooleanParameter = 'false'

Use shared libraries.

requires = ['openssl:shared={shared}']

List of dependencies to other tasks.

jolt.pkgs.texinfo

class jolt.pkgs.texinfo.Texinfo

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import texinfo

requires = ["texinfo"]

name = 'texinfo'

Name of the task.

version: Parameter = '7.3'

Texinfo version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=http://ftpmirror.gnu.org/texinfo/texinfo-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/texinfo-{version}'

Source directory. If not set, the working directory of the task is used.

jolt.pkgs.tomlplusplus

class jolt.pkgs.tomlplusplus.TomlPlusPlus

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import tomlplusplus

requires = ["tomlplusplus"]

name = 'tomlplusplus'

Name of the task.

version: Parameter = '3.4.0'

toml++ version.

tests: BooleanParameter = 'false'

Build tests.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/marzer/tomlplusplus.git,rev=v{version}']

Sources of the package.

srcdir = '{git[tomlplusplus]}'

Source directory. If not set, the working directory of the task is used.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.unixodbc

class jolt.pkgs.unixodbc.UnixODBC

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import unixodbc

requires = ["unixodbc"]

name = 'unixodbc'

Name of the task.

version: Parameter = '2.3.14'

unixODBC version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://github.com/lurcher/unixODBC/releases/download/v{version}/unixODBC-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/unixODBC-{version}'

Source directory. If not set, the working directory of the task is used.

options = ['--enable-shared={shared[yes,no]}', '--enable-static={shared[no,yes]}']

Options passed to the configure script.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.vulkan_headers

class jolt.pkgs.vulkan_headers.VulkanHeaders

Bases: jolt.plugins.cmake.CMake

Vulkan header files and API registry

from jolt.pkgs import vulkan_headers

requires = ["vulkan-headers"]

name = 'vulkan-headers'

Name of the task.

version: Parameter = '1.4.367'

Vulkan-Headers version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/KhronosGroup/Vulkan-Headers.git,rev=v{version}']

Sources of the package.

srcdir = '{git[Vulkan-Headers]}'

Source directory. If not set, the working directory of the task is used.

options = ['VULKAN_HEADERS_ENABLE_MODULE=OFF', 'VULKAN_HEADERS_ENABLE_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.vulkan_loader

class jolt.pkgs.vulkan_loader.VulkanLoader

Bases: jolt.plugins.cmake.CMake

Vulkan ICD loader

from jolt.pkgs import vulkan_loader

requires = ["vulkan-loader"]

name = 'vulkan-loader'

Name of the task.

version: Parameter = '1.4.367'

Vulkan-Loader version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/KhronosGroup/Vulkan-Loader.git,rev=v{version}']

Sources of the package.

requires_headers = ['vulkan-headers:version={version}']

Tasks required by the package.

requires_linux = ['wayland', 'xorg/libx11', 'xorg/libxcb', 'xorg/libxrandr']

Libraries of the window systems that the loader supports on Linux.

srcdir = '{git[Vulkan-Loader]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_TESTS=OFF', 'SYSCONFDIR=/etc']

Options passed to CMake, as option[:type]=value. Drivers and layers are found in the directories of the system.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.wayland

class jolt.pkgs.wayland.Wayland

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import wayland

requires = ["wayland"]

name = 'wayland'

Name of the task.

version: Parameter = '1.26.0'

Wayland version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_expat = ['libexpat:pic=true']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/wayland/wayland.git,rev={version}']

Sources of the package.

requires_libffi = ['libffi']

Tasks required by the package.

requires_libxml2 = ['libxml2']

Tasks required by the package.

srcdir = '{git[wayland]}'

Source directory. If not set, the working directory of the task is used.

options = ['documentation=false', 'tests=false']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.wayland_protocols

class jolt.pkgs.wayland_protocols.WaylandProtocols

Bases: jolt.plugins.meson.Meson

from jolt.pkgs import wayland_protocols

requires = ["wayland-protocols"]

name = 'wayland-protocols'

Name of the task.

version: Parameter = '1.50'

wayland-protocols version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/wayland/wayland-protocols.git,rev={version}']

Sources of the package.

requires_wayland = ['wayland']

Tasks required by the package.

srcdir = '{git[wayland-protocols]}'

Source directory. If not set, the working directory of the task is used.

options = ['tests=false']

Options passed to Meson, as option=value.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

jolt.pkgs.x11

class jolt.pkgs.x11.GlProto

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["glproto"]

name = 'glproto'

Name of the task.

requires = ['xorg/glproto']

List of dependencies to other tasks.

class jolt.pkgs.x11.Libx11

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libx11"]

name = 'libx11'

Name of the task.

requires = ['xorg/libx11']

List of dependencies to other tasks.

class jolt.pkgs.x11.LibX11Xcb

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libx11-xcb"]

name = 'libx11-xcb'

Name of the task.

requires = ['xorg/libx11-xcb']

List of dependencies to other tasks.

class jolt.pkgs.x11.LibXcb

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libxcb"]

name = 'libxcb'

Name of the task.

requires = ['xorg/libxcb']

List of dependencies to other tasks.

class jolt.pkgs.x11.Libxext

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libxext"]

name = 'libxext'

Name of the task.

requires = ['xorg/libxext']

List of dependencies to other tasks.

class jolt.pkgs.x11.LibXrandr

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libxrandr"]

name = 'libxrandr'

Name of the task.

requires = ['xorg/libxrandr']

List of dependencies to other tasks.

class jolt.pkgs.x11.Libxshmfence

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libxshmfence"]

name = 'libxshmfence'

Name of the task.

requires = ['xorg/libxshmfence']

List of dependencies to other tasks.

class jolt.pkgs.x11.LibXxf86vm

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["libxxf86vm"]

name = 'libxxf86vm'

Name of the task.

requires = ['xorg/libxxf86vm']

List of dependencies to other tasks.

class jolt.pkgs.x11.Xproto

Bases: jolt.tasks.Alias

from jolt.pkgs import x11

requires = ["xproto"]

name = 'xproto'

Name of the task.

requires = ['xorg/xproto']

List of dependencies to other tasks.

jolt.pkgs.xerces_c

class jolt.pkgs.xerces_c.XercesC

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import xerces_c

requires = ["xerces-c"]

name = 'xerces-c'

Name of the task.

version: Parameter = '3.3.0'

Xerces-C++ version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/apache/xerces-c.git,rev=v{version}']

Sources of the package.

srcdir = '{git[xerces-c]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.xorg

class jolt.pkgs.xorg.Glproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/glproto"]

name = 'xorg/glproto'

Name of the task.

version: Parameter = '1.4.17'

glproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/glproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/glproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Inputproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/inputproto"]

name = 'xorg/inputproto'

Name of the task.

version: Parameter = '2.3.2'

inputproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/inputproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/inputproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Kbproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/kbproto"]

name = 'xorg/kbproto'

Name of the task.

version: Parameter = '1.0.7'

kbproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/kbproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/kbproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libx11

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libx11"]

name = 'xorg/libx11'

Name of the task.

version: Parameter = '1.8.14'

libX11 version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_inputproto = ['xorg/inputproto']

Tasks required by the package.

requires_kbproto = ['xorg/kbproto']

Tasks required by the package.

requires_libxau = ['xorg/libxau']

Tasks required by the package.

requires_libxcb = ['xorg/libxcb']

Tasks required by the package.

requires_libxdmcp = ['xorg/libxdmcp']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libX11-{version}.tar.gz']

Sources of the package.

requires_xextproto = ['xorg/xextproto']

Tasks required by the package.

requires_xorg_macros = ['xorg/macros']

Tasks required by the package.

requires_xproto = ['xorg/xproto']

Tasks required by the package.

requires_xtrans = ['xorg/xtrans']

Tasks required by the package.

srcdir = '{fetch[src]}/libX11-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.LibX11Xcb

Bases: jolt.tasks.Task

Republishes libx11 and libxcb as libx11-xcb for compatibility.

Mainly, prefix must be shared in order to build mesa.

from jolt.pkgs import xorg

requires = ["xorg/libx11-xcb"]

name = 'xorg/libx11-xcb'

Name of the task.

requires_libx11 = ['xorg/libx11']

Tasks required by the package.

requires_libxcb = ['xorg/libxcb']

Tasks required by the package.

selfsustained = True

Consume this task independently of its requirements.

Requirements of a self-sustained task will be pruned if the task artifact is present in a cache. In other words, if the task is not executed its requirements are considered unnecessary.

For example, consider the task graph A -> B -> C. If B is self-sustained and present in a cache, C will never be executed. C will also never be a transitive requirement of A. If A requires C, it should be listed as an explicit requirement.

Using this attribute speeds up execution and reduces network traffic by allowing the task graph to be reduced.

class jolt.pkgs.xorg.Xau

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxau"]

name = 'xorg/libxau'

Name of the task.

version: Parameter = '1.0.12'

libXau version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXau-{version}.tar.gz']

Sources of the package.

requires_xproto = ['xorg/xproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXau-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libxcb

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxcb"]

name = 'xorg/libxcb'

Name of the task.

version: Parameter = '1.17.0'

libxcb version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libxcb-{version}.tar.gz']

Sources of the package.

requires_xau = ['xorg/libxau']

Tasks required by the package.

requires_xorg_macros = ['xorg/macros']

Tasks required by the package.

requires_xcb_proto = ['xorg/xcb-proto']

Tasks required by the package.

srcdir = '{fetch[src]}/libxcb-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.LibXdmcp

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxdmcp"]

name = 'xorg/libxdmcp'

Name of the task.

version: Parameter = '1.1.5'

libXdmcp version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXdmcp-{version}.tar.gz']

Sources of the package.

requires_xproto = ['xorg/xproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXdmcp-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xext

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxext"]

name = 'xorg/libxext'

Name of the task.

version: Parameter = '1.3.7'

libXext version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXext-{version}.tar.gz']

Sources of the package.

requires_x11 = ['xorg/libx11']

Tasks required by the package.

requires_xextproto = ['xorg/xextproto']

Tasks required by the package.

requires_xproto = ['xorg/xproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXext-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libxfixes

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxfixes"]

name = 'xorg/libxfixes'

Name of the task.

version: Parameter = '6.0.2'

libXfixes version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXfixes-{version}.tar.xz']

Sources of the package.

requires_x11 = ['xorg/libx11']

Tasks required by the package.

requires_xorgproto = ['xorg/xorgproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXfixes-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libxi

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxi"]

name = 'xorg/libxi'

Name of the task.

version: Parameter = '1.8.4'

libXi version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXi-{version}.tar.xz']

Sources of the package.

requires_x11 = ['xorg/libx11']

Tasks required by the package.

requires_xext = ['xorg/libxext']

Tasks required by the package.

requires_xfixes = ['xorg/libxfixes']

Tasks required by the package.

requires_xorgproto = ['xorg/xorgproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXi-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xrandr

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxrandr"]

name = 'xorg/libxrandr'

Name of the task.

version: Parameter = '1.5.5'

libXrandr version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_randrproto = ['xorg/randrproto']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXrandr-{version}.tar.gz']

Sources of the package.

requires_xext = ['xorg/libxext']

Tasks required by the package.

requires_xrender = ['xorg/libxrender']

Tasks required by the package.

srcdir = '{fetch[src]}/libXrandr-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xrender

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxrender"]

name = 'xorg/libxrender'

Name of the task.

version: Parameter = '0.9.13'

libXrender version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_renderproto = ['xorg/renderproto']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXrender-{version}.tar.gz']

Sources of the package.

requires_x11 = ['xorg/libx11']

Tasks required by the package.

srcdir = '{fetch[src]}/libXrender-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libxshmfence

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxshmfence"]

name = 'xorg/libxshmfence'

Name of the task.

version: Parameter = '1.3.3'

libxshmfence version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libxshmfence-{version}.tar.gz']

Sources of the package.

requires_xproto = ['xproto']

Tasks required by the package.

requires_xorg_macros = ['xorg/macros']

Tasks required by the package.

srcdir = '{fetch[src]}/libxshmfence-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

class jolt.pkgs.xorg.Libxtst

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxtst"]

name = 'xorg/libxtst'

Name of the task.

version: Parameter = '1.2.6'

libXtst version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXtst-{version}.tar.xz']

Sources of the package.

requires_x11 = ['xorg/libx11']

Tasks required by the package.

requires_xext = ['xorg/libxext']

Tasks required by the package.

requires_xi = ['xorg/libxi']

Tasks required by the package.

requires_xorgproto = ['xorg/xorgproto']

Tasks required by the package.

srcdir = '{fetch[src]}/libXtst-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Libxxf86vm

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/libxxf86vm"]

name = 'xorg/libxxf86vm'

Name of the task.

version: Parameter = '1.1.7'

libXxf86vm version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/libXxf86vm-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/libXxf86vm-{version}'

Source directory. If not set, the working directory of the task is used.

requires_libx11 = ['xorg/libx11']

Tasks required by the package.

requires_xext = ['xorg/libxext']

Tasks required by the package.

requires_xextproto = ['xorg/xextproto']

Tasks required by the package.

requires_xf86vidmodeproto = ['xorg/xf86vidmodeproto']

Tasks required by the package.

requires_xorg_macros = ['xorg/macros']

Tasks required by the package.

requires_xproto = ['xorg/xproto']

Tasks required by the package.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.XorgMacros

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/macros"]

name = 'xorg/macros'

Name of the task.

version: Parameter = '1.20.2'

util-macros version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/xorg/util/macros.git,rev=util-macros-{version}']

Sources of the package.

srcdir = '{git[macros]}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Randrproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/randrproto"]

name = 'xorg/randrproto'

Name of the task.

version: Parameter = '1.5.0'

randrproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/randrproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/randrproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Renderproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/renderproto"]

name = 'xorg/renderproto'

Name of the task.

version: Parameter = '0.11.1'

renderproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/renderproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/renderproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.XcbKeysyms

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xcb-keysyms"]

name = 'xorg/xcb-keysyms'

Name of the task.

version: Parameter = '0.4.1'

xcb-util-keysyms version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/xcb-util-keysyms-{version}.tar.xz']

Sources of the package.

requires_xcb = ['xorg/libxcb']

Tasks required by the package.

srcdir = '{fetch[src]}/xcb-util-keysyms-{version}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.XcbProto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xcb-proto"]

name = 'xorg/xcb-proto'

Name of the task.

version: Parameter = '1.17.0'

xcb-proto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://gitlab.freedesktop.org/xorg/proto/xcbproto.git,rev=xcb-proto-{version}']

Sources of the package.

requires_xorg_macros = ['xorg/macros']

Tasks required by the package.

srcdir = '{git[xcbproto]}'

Source directory. If not set, the working directory of the task is used.

requires_pkgconf = ['pkgconf']

Tasks required by the package.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xextproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xextproto"]

name = 'xorg/xextproto'

Name of the task.

version: Parameter = '7.3.0'

xextproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/xextproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/xextproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xf86vidmodeproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xf86vidmodeproto"]

name = 'xorg/xf86vidmodeproto'

Name of the task.

version: Parameter = '2.3.1'

xf86vidmodeproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/xf86vidmodeproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/xf86vidmodeproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xorgproto

Bases: jolt.plugins.meson.Meson

Combined X.Org X11 protocol headers

from jolt.pkgs import xorg

requires = ["xorg/xorgproto"]

name = 'xorg/xorgproto'

Name of the task.

version: Parameter = '2026.1'

xorgproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/xorgproto-{version}.tar.xz']

Sources of the package.

srcdir = '{fetch[src]}/xorgproto-{version}'

Source directory. If not set, the working directory of the task is used.

requires_meson = ['meson']

Tasks required by the package.

requires_ninja = ['ninja']

Tasks required by the package.

class jolt.pkgs.xorg.Xproto

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xproto"]

name = 'xorg/xproto'

Name of the task.

version: Parameter = '7.0.31'

xproto version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/proto/xproto-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/xproto-{version}'

Source directory. If not set, the working directory of the task is used.

install_threads = 1

Number of parallel jobs used by make install.

If not set, make runs as many jobs as the build. Set to 1 for projects whose install scripts race when directories are created by parallel jobs.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

class jolt.pkgs.xorg.Xtrans

Bases: jolt.plugins.autotools.Autotools

from jolt.pkgs import xorg

requires = ["xorg/xtrans"]

name = 'xorg/xtrans'

Name of the task.

version: Parameter = '1.6.0'

xtrans version.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_macros = ['xorg/macros']

Tasks required by the package.

requires_src = ['fetch:alias=src,url=https://www.x.org/releases/individual/lib/xtrans-{version}.tar.gz']

Sources of the package.

srcdir = '{fetch[src]}/xtrans-{version}'

Source directory. If not set, the working directory of the task is used.

requires_autoconf = ['autoconf']

Tasks required by the package.

requires_automake = ['automake']

Tasks required by the package.

requires_libtool = ['libtool']

Tasks required by the package.

jolt.pkgs.xz

class jolt.pkgs.xz.Xz

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import xz

requires = ["xz"]

name = 'xz'

Name of the task.

version: Parameter = '5.8.4'

XZ Utils version.

pic: BooleanParameter = 'true'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/tukaani-project/xz.git,rev=v{version}']

Sources of the package.

srcdir = '{git[xz]}'

Source directory. If not set, the working directory of the task is used.

options_pic_on = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE=ON']

Options passed to CMake when building with position independent code.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.yamlcpp

class jolt.pkgs.yamlcpp.YamlCPP

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import yamlcpp

requires = ["yaml-cpp"]

name = 'yaml-cpp'

Name of the task.

version: Parameter = '0.9.0'

yaml-cpp version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/jbeder/yaml-cpp.git,rev=yaml-cpp-{version}']

Sources of the package.

srcdir = '{git[yaml-cpp]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POLICY_VERSION_MINIMUM=3.5', 'YAML_BUILD_SHARED_LIBS={shared[ON,OFF]}', 'YAML_BUILD_TOOLS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.zeromq

class jolt.pkgs.zeromq.Cppzmq

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import zeromq

requires = ["cppzmq"]

name = 'cppzmq'

Name of the task.

version: Parameter = '4.11.0'

cppzmq version.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/zeromq/cppzmq.git,rev=v{version}']

Sources of the package.

requires_libzmq = ['libzmq']

Tasks required by the package.

srcdir = '{git[cppzmq]}'

Source directory. If not set, the working directory of the task is used.

options = ['CPPZMQ_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.zeromq.Libzmq

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import zeromq

requires = ["libzmq"]

name = 'libzmq'

Name of the task.

version: Parameter = '4.3.5'

ZeroMQ version.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c', 'virtual/compiler/cxx']

Tasks required by the package.

requires_git = ['git:url=https://github.com/zeromq/libzmq.git,rev=v{version}']

Sources of the package.

requires_sodium = ['libsodium:pic=true,shared={shared}']

Library used for CURVE security.

srcdir = '{git[libzmq]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED={shared[ON,OFF]}', 'BUILD_STATIC={shared[OFF,ON]}', 'BUILD_TESTS=OFF', 'CMAKE_POLICY_VERSION_MINIMUM=3.5', 'ENABLE_CURVE=ON', 'WITH_TLS=OFF', 'WITH_LIBSODIUM=ON', 'WITH_LIBSODIUM_STATIC={shared[OFF,ON]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.zig

class jolt.pkgs.zig.Zig

Bases: jolt.tasks.Download

Zig compiler and C/C++ cross compiler

from jolt.pkgs import zig

requires = ["zig"]

name = 'zig'

Name of the task.

version: Parameter = '0.17.0'

Zig version.

url = 'https://ziglang.org/download/{version}/zig-{zig_arch}-{_os}-{version}.{_ext}'

URL(s) of file(s) to download.

A single URL string is accepted, as well as a list of URL strings.

jolt.pkgs.zlib

class jolt.pkgs.zlib.VirtualZlib

Bases: jolt.tasks.Alias

from jolt.pkgs import zlib

requires = ["virtual/zlib"]

name = 'virtual/zlib'

Name of the task.

pic: BooleanParameter = 'false'

Use position independent code.

shared: BooleanParameter = 'false'

Use shared libraries.

requires = ['zlib:pic={pic},shared={shared}']

List of dependencies to other tasks.

class jolt.pkgs.zlib.Zlib

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import zlib

requires = ["zlib"]

name = 'zlib'

Name of the task.

version: Parameter = '1.3.2'

zlib version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:clean=true,url=https://github.com/madler/zlib.git,rev=v{version}']

Sources of the package.

srcdir = '{git[zlib]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'ZLIB_BUILD_EXAMPLES=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

class jolt.pkgs.zlib.ZlibNg

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import zlib

requires = ["zlib-ng"]

name = 'zlib-ng'

Name of the task.

version: Parameter = '2.3.3'

zlib-ng version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/zlib-ng/zlib-ng.git,rev={version}']

Sources of the package.

srcdir = '{git[zlib-ng]}'

Source directory. If not set, the working directory of the task is used.

options = ['BUILD_SHARED_LIBS={shared[ON,OFF]}', 'BUILD_TESTING=OFF', 'CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.

jolt.pkgs.zstd

class jolt.pkgs.zstd.Zstd

Bases: jolt.plugins.cmake.CMake

from jolt.pkgs import zstd

requires = ["zstd"]

name = 'zstd'

Name of the task.

version: Parameter = 'ebc93b0'

Zstandard version.

pic: BooleanParameter = 'false'

Build with position independent code.

shared: BooleanParameter = 'false'

Build shared libraries.

requires_compiler = ['virtual/compiler/c']

Tasks required by the package.

requires_git = ['git:url=https://github.com/facebook/zstd.git,rev={version}']

Sources of the package.

srcdir = '{git[zstd]}'

Source directory. If not set, the working directory of the task is used.

options = ['CMAKE_POSITION_INDEPENDENT_CODE={pic[ON,OFF]}', 'ZSTD_BUILD_PROGRAMS={shared[OFF,ON]}', 'ZSTD_BUILD_SHARED={shared[ON,OFF]}', 'ZSTD_BUILD_STATIC={shared[OFF,ON]}', 'ZSTD_BUILD_TESTS=OFF']

Options passed to CMake, as option[:type]=value.

generator = 'Ninja'

Build file generator used by CMake, such as Ninja. If not set, the default of CMake is used.

requires_ninja = ['ninja']

Tasks required by the package.

requires_cmake = ['cmake']

Tasks required by the package.