Julia Bazel rules

Rules

• julia_artifact
• julia_binary
• julia_format_test
• julia_library
• julia_standalone_binary
• julia_sysimage
• julia_test
• julia_toolchain

Aspects

• julia_format_aspect

julia_artifact

load("@rules_julia//julia:defs.bzl", "julia_artifact")

julia_artifact(name, srcs, out, artifact_name, files, lazy, platform_tags, strip_prefix, url)

Build a Julia artifact from Bazel targets.

Julia distributes binaries and data as artifacts: gzipped tarballs identified by the git tree hash of their contents and listed in a package's Artifacts.toml with a download URL and SHA-256. This rule produces both halves: the tarball, packed with the same Tar and 7z Julia itself uses, and an Artifacts.toml holding the entry for it, with both hashes computed by the code Pkg uses to verify downloads. Upload the tarball to the URL and merge the entry into the package's Artifacts.toml; Pkg and artifact"name" then install it like any other artifact.

Files from srcs keep their path relative to the package (or strip_prefix below it); files places outputs from anywhere at an explicit path. Directories (tree artifacts) are copied whole.

Platform specific artifacts set platform_tags. The values are taken from the target platform (os, arch) and the @rules_julia//julia/settings flags (libgfortran_version and cxxstring_abi from the toolchain; libc is assumed glibc on Linux), so building the same target under several --platforms yields one entry per platform, ready to be concatenated. Platform independent artifacts (data, models, ...) leave it empty.

Example:

julia_artifact(
    name = "libfoo",
    srcs = ["include/foo.h"],
    files = {":libfoo_shared": "lib/libfoo.so"},
    platform_tags = ["os", "arch", "libc"],
    url = "https://github.com/me/Foo.jl/releases/download/v1.0.0/{file}",
)

produces libfoo.tar.gz and libfoo.Artifacts.toml:

[[libfoo]]
arch = "x86_64"
git-tree-sha1 = "..."
libc = "glibc"
os = "linux"

    [[libfoo.download]]
    sha256 = "..."
    url = "https://github.com/me/Foo.jl/releases/download/v1.0.0/libfoo.tar.gz"

ATTRIBUTES

julia_binary

load("@rules_julia//julia:defs.bzl", "julia_binary")

julia_binary(name, deps, srcs, data, env, julia_flags, main)

A Julia executable.

ATTRIBUTES

julia_format_test

load("@rules_julia//julia:defs.bzl", "julia_format_test")

julia_format_test(name, config, target)

A rule for running JuliaFormatter on a Julia target.

ATTRIBUTES

julia_library

load("@rules_julia//julia:defs.bzl", "julia_library")

julia_library(name, deps, srcs, data, precompile)

A sharable Julia library or module.

ATTRIBUTES

julia_standalone_binary

load("@rules_julia//julia:defs.bzl", "julia_standalone_binary")

julia_standalone_binary(name, binary, cpu_target, precompile_statements)

Build a Julia package and its dependencies into a custom system image and produce an executable that starts Julia with it.

The system image is produced in two actions: julia --output-o emits the object archive of the image, which is then linked into a shared library. By default the link uses the lld bundled with Julia, the same way Julia links its own package images; --@rules_julia//julia/settings:linker=cc selects the C++ toolchain instead. The executable is the regular Julia wrapper started with --sysimage, so all code is loaded precompiled and startup is immediate. No network access or host tools outside the Bazel toolchains are involved.

The target in binary must be a Julia package: its entry point is src/<name>.jl defining module <name> with a julia_main()::Cint function, which is called with the command line arguments in ARGS.

Example:

julia_binary(
    name = "my_app_bin",
    srcs = ["src/my_app_bin.jl"],
    deps = ["//my/lib"],
)

julia_standalone_binary(
    name = "my_app",
    binary = ":my_app_bin",
)

ATTRIBUTES

julia_sysimage

load("@rules_julia//julia:defs.bzl", "julia_sysimage")

julia_sysimage(name, deps, cpu_target, precompile_statements)

Compile Julia packages and their dependencies into a system image.

A system image is Julia's own ahead-of-time format: the shared library that julia --sysimage loads in place of the stock one, with every included module already compiled. The image is produced in two actions: julia --output-o emits the object archive, which is then linked into a shared library. By default the link uses the lld bundled with Julia, the same way Julia links its own package images; --@rules_julia//julia/settings:linker=cc selects the C++ toolchain instead. No network access or host tools outside the Bazel toolchains are involved, and the image is rebuilt only when its inputs change.

Every target in deps must be a Julia package: its entry point is src/<name>.jl defining module <name>. The output is the shared library; the object archive is available in the archive output group. For a self-contained executable around a package with a julia_main function, see julia_standalone_binary, which builds on the same actions.

Example:

julia_sysimage(
    name = "image",
    deps = ["@deps//:JSON", "//my/lib"],
)

julia --sysimage=$(bazel cquery --output=files //:image) -e 'using JSON'

ATTRIBUTES

julia_test

load("@rules_julia//julia:defs.bzl", "julia_test")

julia_test(name, deps, srcs, data, env, julia_flags, main)

A Julia test executable.

ATTRIBUTES

julia_toolchain

load("@rules_julia//julia:defs.bzl", "julia_toolchain")

julia_toolchain(name, check_bounds, cpu_target, cxxstring_abi, debug_info, julia,
                libgfortran_version, link_files, linker, opt_level, sysimage, version)

A toolchain for building Julia targets.

ATTRIBUTES

julia_format_aspect

load("@rules_julia//julia:defs.bzl", "julia_format_aspect")

julia_format_aspect()

An aspect for running JuliaFormatter on targets with Julia sources.

ASPECT ATTRIBUTES

ATTRIBUTES