Need help with naersk?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

nmattia
181 Stars 31 Forks MIT License 251 Commits 27 Opened issues

Description

Build rust crates in Nix. No configuration, no code generation, no IFD. Sandbox friendly.

Services available

!
?

Need anything else?

Contributors list

# 99,846
ionic
Terrafo...
talk
nix
149 commits
# 155,519
nix
Haskell
OpenCV
ghcjs
22 commits
# 213,209
Gradle
root
roboroc...
Ansible
8 commits
# 12,244
Angular
nix
angular...
declara...
4 commits
# 78,386
Discord
assembl...
microke...
nix
4 commits
# 438,883
Shell
perf
crates
rust-la...
3 commits
# 45,259
nix
Windows
vte
Zsh
3 commits
# 165,047
Ansible
tls-cer...
gRPC
Flask
2 commits
# 282,249
gtk
travis-...
wasi
yield
2 commits
# 170,927
nix
PureScr...
generat...
ami
2 commits
# 23,721
Nette
gtk
nix
nixos
2 commits
# 355,790
Chrome
Shell
terrain
rpg
2 commits
# 30,028
pypi
aho-cor...
elastic...
linked-...
1 commit
# 184,613
PureScr...
Gradle
Amazon ...
gce
1 commit
# 312,891
nix
nixpkgs
graphic...
Emacs
1 commit
# 271,359
homomor...
Shell
nix
isolati...
1 commit
# 208,563
hammers...
osx
macvim
nix
1 commit
# 76,935
nix
Zsh
shell-e...
declara...
1 commit

Naersk

GitHub Actions

Nix support for building cargo crates.

Install

Use niv:

$ niv add nmattia/naersk

And then

let
    pkgs = import  {};
    sources = import ./nix/sources.nix;
    naersk = pkgs.callPackage sources.naersk {};
in naersk.buildPackage ./path/to/rust

NOTE:

./path/to/rust/
should contain a
Cargo.lock
.

Configuration

The

buildPackage
function also accepts an attribute set. The attributes are described below. Any attribute that is not listed below will be forwarded as is to
stdenv.mkDerivation
. When the argument passed in not an attribute set, e.g.
naersk.buildPackage theArg

it is converted to an attribute set equivalent to

{ root = theArg; }
.

| Attribute | Description | | - | - | |

name
| The name of the derivation. | |
version
| The version of the derivation. | |
src
| Used by
naersk
as source input to the derivation. When
root
is not set,
src
is also used to discover the
Cargo.toml
and
Cargo.lock
. | |
root
| Used by
naersk
to read the
Cargo.toml
and
Cargo.lock
files. May be different from
src
. When
src
is not set,
root
is (indirectly) used as
src
. | |
cargoBuild
| The command to use for the build. The argument must be a function modifying the default value.
Default:
''cargo $cargo_options build $cargo_build_options >> $cargo_build_output_json''
| |
cargoBuildOptions
| Options passed to cargo build, i.e.
cargo build 
. These options can be accessed during the build through the environment variable
cargo_build_options
.
Note: naersk relies on the
--out-dir out
option and the
--message-format
option. The
$cargo_message_format
variable is set based on the cargo version.
Note: these values are not (shell) escaped, meaning that you can use environment variables but must be careful when introducing e.g. spaces.
The argument must be a function modifying the default value.
Default:
[ "$cargo_release" ''-j "$NIX_BUILD_CORES"'' "--out-dir" "out" "--message-format=$cargo_message_format" ]
| |
remapPathPrefix
| When
true
, rustc remaps the (
/nix/store
) source paths to
/sources
to reduce the number of dependencies in the closure. Default:
true
| |
cargoTestCommands
| The commands to run in the
checkPhase
. Do not forget to set
doCheck
. The argument must be a function modifying the default value.
Default:
[ ''cargo $cargo_options test $cargo_test_options'' ]
| |
cargoTestOptions
| Options passed to cargo test, i.e.
cargo test 
. These options can be accessed during the build through the environment variable
cargo_test_options
.
Note: these values are not (shell) escaped, meaning that you can use environment variables but must be careful when introducing e.g. spaces.
The argument must be a function modifying the default value.
Default:
[ "$cargo_release" ''-j "$NIX_BUILD_CORES"'' ]
| |
nativeBuildInputs
| Extra
nativeBuildInputs
to all derivations. Default:
[]
| |
buildInputs
| Extra
buildInputs
to all derivations. Default:
[]
| |
cargoOptions
| Options passed to all cargo commands, i.e.
cargo  ...
. These options can be accessed during the build through the environment variable
cargo_options
.
Note: these values are not (shell) escaped, meaning that you can use environment variables but must be careful when introducing e.g. spaces.
The argument must be a function modifying the default value.
Default:
[ "-Z" "unstable-options" ]
| |
doDoc
| When true,
cargo doc
is run and a new output
doc
is generated. Default:
false
| |
release
| When true, all cargo builds are run with
--release
. The environment variable
cargo_release
is set to
--release
iff this option is set. Default:
true
| |
override
| An override for all derivations involved in the build. Default:
(x: x)
| |
overrideMain
| An override for the top-level (last, main) derivation. If both
override
and
overrideMain
are specified, both will be applied to the top-level derivation. Default:
(x: x)
| |
singleStep
| When true, no intermediary (dependency-only) build is run. Enabling
singleStep
greatly reduces the incrementality of the builds. Default:
false
| |
targets
| The targets to build if the
Cargo.toml
is a virtual manifest. | |
copyBins
| When true, the resulting binaries are copied to
$out/bin
.
Note: this relies on cargo's
--message-format
argument, set in the default
cargoBuildOptions
. Default:
true
| |
copyLibs
| When true, the resulting binaries are copied to
$out/lib
.
Note: this relies on cargo's
--message-format
argument, set in the default
cargoBuildOptions
. Default:
false
| |
copyBinsFilter
| A
jq
filter for selecting which build artifacts to release. This is run on cargo's
--message-format
JSON output.
The value is written to the
cargo_bins_jq_filter
variable. Default:
''select(.reason == "compiler-artifact" and .executable != null and .profile.test == false)''
| |
copyLibsFilter
| A
jq
filter for selecting which build artifacts to release. This is run on cargo's
--message-format
JSON output.
The value is written to the
cargo_libs_jq_filter
variable. Default:
''select(.reason == "compiler-artifact" and ((.target.kind | contains(["staticlib"])) or (.target.kind | contains(["cdylib"]))) and .filenames != null and .profile.test == false)''
Default:
''select(.reason == "compiler-artifact" and ((.target.kind | contains(["staticlib"])) or (.target.kind | contains(["cdylib"]))) and .filenames != null and .profile.test == false)''
| |
copyDocsToSeparateOutput
| When true, the documentation is generated in a different output,
doc
. Default:
true
| |
doDocFail
| When true, the build fails if the documentation step fails; otherwise the failure is ignored. Default:
false
| |
removeReferencesToSrcFromDocs
| When true, references to the nix store are removed from the generated documentation. Default:
true
| |
compressTarget
| When true, the build output of intermediary builds is compressed with
Zstandard
. This reduces the size of closures. Default:
true
| |
copyTarget
| When true, the
target/
directory is copied to
$out
. Default:
false
| |
usePureFromTOML
| Whether to use the
fromTOML
built-in or not. When set to
false
the python package
remarshal
is used instead (in a derivation) and the JSON output is read with
builtins.fromJSON
. This is a workaround for old versions of Nix. May be used safely from Nix 2.3 onwards where all bugs in
builtins.fromTOML
seem to have been fixed. Default:
true
|

Using naersk with nixpkgs-mozilla

The nixpkgs-mozilla overlay provides nightly versions of

rustc
and
cargo
. Below is an example setup for using it with naersk:
let
  sources = import ./nix/sources.nix;
  nixpkgs-mozilla = import sources.nixpkgs-mozilla;
  pkgs = import sources.nixpkgs {
    overlays =
      [
        nixpkgs-mozilla
        (self: super:
            {
              rustc = self.latest.rustChannels.nightly.rust;
              cargo = self.latest.rustChannels.nightly.rust;
            }
        )
      ];
  };
  naersk = pkgs.callPackage sources.naersk {};
in
naersk.buildPackage ./my-package

Using with Nix Flakes

Copy this

flake.nix
into your repo.
{
  inputs = {
    utils.url = "github:numtide/flake-utils";
    naersk.url = "github:nmattia/naersk";
  };

outputs = { self, nixpkgs, utils, naersk }: utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages."${system}"; naersk-lib = naersk.lib."${system}"; in rec { # nix build packages.my-project = naersk-lib.buildPackage { pname = "my-project"; root = ./.; }; defaultPackage = packages.my-project;

  # `nix run`
  apps.my-project = utils.lib.mkApp {
    drv = packages.my-project;
  };
  defaultApp = apps.my-project;

  # `nix develop`
  devShell = pkgs.mkShell {
    nativeBuildInputs = with pkgs; [ rustc cargo ];
  };
});

}

If you want to use a specific toolchain version instead of the latest stable available in nixpkgs, you can use mozilla's nixpkgs overlay in your flake.

{
  inputs = {
    utils.url = "github:numtide/flake-utils";
    naersk.url = "github:nmattia/naersk";
    mozillapkgs = {
      url = "github:mozilla/nixpkgs-mozilla";
      flake = false;
    };
  };

outputs = { self, nixpkgs, utils, naersk, mozillapkgs }: utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages."${system}";

  # Get a specific rust version
  mozilla = pkgs.callPackage (mozillapkgs + "/package-set.nix") {};
  rust = (mozilla.rustChannelOf {
    date = "2020-01-01"; # get the current date with `date -I`
    channel = "nightly";
    sha256 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
  }).rust;

  # Override the version used in naersk
  naersk-lib = naersk.lib."${system}".override {
    cargo = rust;
    rustc = rust;
  };
in rec {
  # `nix build`
  packages.my-project = naersk-lib.buildPackage {
    pname = "my-project";
    root = ./.;
  };
  defaultPackage = packages.my-project;

  # `nix run`
  apps.my-project = utils.lib.mkApp {
    drv = packages.my-project;
  };
  defaultApp = apps.my-project;

  # `nix develop`
  devShell = pkgs.mkShell {
    # supply the specific rust version
    nativeBuildInputs = [ rust ];
  };
});

}

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.