• Stars
    star
    547
  • Rank 79,220 (Top 2 %)
  • Language
    Nix
  • License
    Mozilla Public Li...
  • Created over 3 years ago
  • Updated 3 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Rust toolchains and rust-analyzer nightly for Nix [maintainer=@figsoda]

fenix

Fenix provides the minimal, default, and complete profile of rust toolchains, latest profile of nightly toolchains, nightly version of rust analyzer and its vscode extension. It aims to be a replacement for rustup and the rust overlay provided by nixpkgs-mozilla.

Binary cache is available for x86_64-darwin and x86_64-linux on cachix

cachix use nix-community

Note: The nixpkgs from your system will be used when fenix is being used as an overlay, which may not be cached if you are using a stable/older version of nixpkgs. To fix this, use the packages directly or use the following workaround (see #79)

{
  nixpkgs.overlays = [
    (_: super: let pkgs = fenix.inputs.nixpkgs.legacyPackages.${super.system}; in fenix.overlays.default pkgs pkgs)
  ];
}

Usage

As a flake (recommended)
{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, nixpkgs }: {
    packages.x86_64-linux.default = fenix.packages.x86_64-linux.minimal.toolchain;
    nixosConfigurations.nixos = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      modules = [
        ({ pkgs, ... }: {
          nixpkgs.overlays = [ fenix.overlays.default ];
          environment.systemPackages = with pkgs; [
            (fenix.complete.withComponents [
              "cargo"
              "clippy"
              "rust-src"
              "rustc"
              "rustfmt"
            ])
            rust-analyzer-nightly
          ];
        })
      ];
    };
  };
}
As a set of packages
let
  fenix = import (fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz") { };
in
fenix.minimal.toolchain
As an overlay
# configuration.nix
{ pkgs, ... }: {
  nixpkgs.overlays = [
    (import "${fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz"}/overlay.nix")
  ];
  environment.systemPackages = with pkgs; [
    (fenix.complete.withComponents [
      "cargo"
      "clippy"
      "rust-src"
      "rustc"
      "rustfmt"
    ])
    rust-analyzer-nightly
  ];
}

Following is a list of outputs, examples are prefixed with:

  • with fenix.packages.<system>; (flakes), or
  • with import (fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz") { };

Some outputs are toolchains, a rust toolchain in fenix is structured like this:

{
  # components
  cargo = <derivation>;
  rustc = <derivation>; # rustc with rust-std
  rustc-unwrapped = <derivation>; # rustc without rust-std, same as rustc.unwrapped
  rustfmt = <derivation>; # alias to rustfmt-preview
  rust-src = <derivation>; # RUST_SRC_PATH = "${fenix.complete.rust-src}/lib/rustlib/src/rust/library"
  # ...

  # derivation with all the components
  toolchain = <derivation>;

  # not available in nightly toolchains
  # derivation with all the components from a profile
  minimalToolchain = <derivation>;
  defaultToolchain = <derivation>;
  completeToolchain = <derivation>;

  # withComponents : [string] -> derivation
  # creates a derivation with the given list of components from the toolchain
  withComponents = <function>;
}
combine : [derivation] -> derivation

Combines a list of components into a derivation. If the components are from the same toolchain, use withComponents instead.

combine [
  minimal.rustc
  minimal.cargo
  targets.wasm32-unknown-unknown.latest.rust-std
]
fromManifest : attrs -> toolchain

Creates a toolchain from a rustup manifest

fromManifest (lib.importTOML ./channel-rust-nightly.toml)
fromManifestFile : path -> toolchain

Creates a toolchain from a rustup manifest file

fromManifestFile ./channel-rust-nightly.toml
toolchainOf : attrs -> toolchain

Creates toolchain from given arguments:

argument default description
root "https://static.rust-lang.org/dist" root url from downloading manifest, usually left as default
channel "nightly" rust channel, one of "stable", "beta", "nightly", and version number
date null date of the toolchain, latest if unset
sha256 null sha256 of the manifest, required in pure evaluation mode, set to lib.fakeSha256 to get the actual sha256 from the error message
toolchainOf {
  channel = "beta";
  date = "2021-08-29";
  sha256 = "0dkmjil9avba6l0l9apmgwa8d0h4f8jzgxkq3gvn8d2xc68ks5a5";
}
fromToolchainFile : attrs -> derivation

Creates a derivation from a rust toolchain file, accepts the following arguments:

argument description
file path to the rust toolchain file, usually either ./rust-toolchain or ./rust-toolchain.toml, conflicts with dir
dir path to the directory that has rust-toolchain or rust-toolchain.toml, conflicts with file
sha256 sha256 of the manifest, required in pure evaluation mode, set to lib.fakeSha256 to get the actual sha256 from the error message
fromToolchainFile {
  file = ./rust-toolchain.toml;
  sha256 = lib.fakeSha256;
}
fromToolchainFile { dir = ./.; }
fromToolchainName : attrs -> toolchain

Creates a toolchain from a toolchain name, accepts the following arguments:

argument description
name rust channel, one of "stable", "beta", "nightly", and date.
sha256 sha256 of the manifest, required in pure evaluation mode, set to lib.fakeSha256 to get the actual sha256 from the error message
fromToolchainName { name = "nightly-2023-08-07"; sha256 = "Ho2/rJSi6KiHbxgDpdvYE0dwrEUD3psnyYyLmFNYKII="; }
fromToolchainName { name = (lib.importTOML ./rust-toolchain.toml).toolchain.channel; }
stable : toolchain

The stable toolchain

beta : toolchain

The beta toolchain

minimal : toolchain

The minimal profile of the nightly toolchain

default : toolchain

The default profile of the nightly toolchain, sometimes lags behind the minimal profile

complete : toolchain

The complete profile of the nightly toolchain, usually lags behind the minimal and default profile

latest : toolchain

A custom toolchain that contains all the components from the complete profile but not from necessarily the same date. Unlike the complete profile, you get the latest version of the components, but risks a larger chance of incompatibility.

targets.${target}.* : toolchain

Toolchains for supported targets, everything mentioned above except for combine is supported

targets.wasm32-unknown-unknown.latest.rust-std
rust-analyzer : derivation

Nightly version of rust-analyzer, also available with overlay as rust-analyzer-nightly

# configuration.nix with overlay
{ pkgs, ... }: {
  environment.systemPackages = with pkgs; [ rust-analyzer-nightly ];
}
rust-analyzer-vscode-extension : derivation

Nightly version of vscode-extensions.rust-lang.rust-analyzer, also available with overlay as vscode-extensions.rust-lang.rust-analyzer-nightly

# with overlay
with pkgs; vscode-with-extensions.override {
  vscodeExtensions = [
    vscode-extensions.rust-lang.rust-analyzer-nightly
  ];
}

Monthly branch

Fenix has a monthly branch that is updated on the 1st of every month, for cases where you want to use rust nightly but don't need it to be updated very often.

{
  inputs = {
    fenix.url = "github:nix-community/fenix/monthly";
  };

  outputs = { self, fenix }: {
    packages.x86_64-linux.default = fenix.packages.x86_64-linux.default.toolchain;
  };
}

Supported platforms and targets

platform target
aarch64-darwin aarch64-apple-darwin
aarch64-linux aarch64-unknown-linux-gnu
i686-linux i686-unknown-linux-gnu
x86_64-darwin x86_64-apple-darwin
x86_64-linux x86_64-unknown-linux-gnu
only rust-std (for cross compiling)
  • aarch64-apple-darwin
  • aarch64-apple-ios
  • aarch64-linux-android
  • aarch64-pc-windows-msvc
  • aarch64-unknown-fuchsia
  • aarch64-unknown-linux-musl
  • arm-linux-androideabi
  • arm-unknown-linux-gnueabi
  • arm-unknown-linux-gnueabihf
  • arm-unknown-linux-musleabi
  • arm-unknown-linux-musleabihf
  • armv5te-unknown-linux-gnueabi
  • armv7-linux-androideabi
  • armv7-unknown-linux-gnueabihf
  • armv7-unknown-linux-musleabihf
  • asmjs-unknown-emscripten
  • i586-pc-windows-msvc
  • i586-unknown-linux-gnu
  • i586-unknown-linux-musl
  • i686-linux-android
  • i686-pc-windows-gnu
  • i686-pc-windows-msvc
  • i686-unknown-freebsd
  • i686-unknown-linux-musl
  • mips-unknown-linux-gnu
  • mips-unknown-linux-musl
  • mips64-unknown-linux-gnuabi64
  • mips64el-unknown-linux-gnuabi64
  • mipsel-unknown-linux-gnu
  • mipsel-unknown-linux-musl
  • powerpc-unknown-linux-gnu
  • powerpc64-unknown-linux-gnu
  • powerpc64le-unknown-linux-gnu
  • s390x-unknown-linux-gnu
  • sparc64-unknown-linux-gnu
  • sparcv9-sun-solaris
  • wasm32-unknown-emscripten
  • wasm32-unknown-unknown
  • x86_64-apple-ios
  • x86_64-linux-android
  • x86_64-pc-windows-gnu
  • x86_64-pc-windows-msvc
  • x86_64-rumprun-netbsd
  • x86_64-sun-solaris
  • x86_64-unknown-freebsd
  • x86_64-unknown-fuchsia
  • x86_64-unknown-illumos
  • x86_64-unknown-linux-gnux32
  • x86_64-unknown-linux-musl
  • x86_64-unknown-netbsd
  • x86_64-unknown-redox

Examples

building with makeRustPlatform
{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, flake-utils, nixpkgs }:
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default =
        let
          toolchain = fenix.packages.${system}.minimal.toolchain;
          pkgs = nixpkgs.legacyPackages.${system};
        in

        (pkgs.makeRustPlatform {
          cargo = toolchain;
          rustc = toolchain;
        }).buildRustPackage {
          pname = "example";
          version = "0.1.0";

          src = ./.;

          cargoLock.lockFile = ./Cargo.lock;
        };
    });
}
building with crane
{
  inputs = {
    crane = {
      url = "github:ipetkov/crane";
      inputs = {
        flake-utils.follows = "flake-utils";
        nixpkgs.follows = "nixpkgs";
      };
    };
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, crane, fenix, flake-utils, nixpkgs }:
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default =
        let
          craneLib = crane.lib.${system}.overrideToolchain
            fenix.packages.${system}.minimal.toolchain;
        in

        craneLib.buildPackage {
          src = ./.;
        };
    });
}
cross compiling with naersk
{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    naersk = {
      url = "github:nix-community/naersk";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, flake-utils, naersk, nixpkgs }:
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default =
        let
          pkgs = nixpkgs.legacyPackages.${system};
          target = "aarch64-unknown-linux-gnu";
          toolchain = with fenix.packages.${system}; combine [
            minimal.cargo
            minimal.rustc
            targets.${target}.latest.rust-std
          ];
        in

        (naersk.lib.${system}.override {
          cargo = toolchain;
          rustc = toolchain;
        }).buildPackage {
          src = ./.;
          CARGO_BUILD_TARGET = target;
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER =
            let
              inherit (pkgs.pkgsCross.aarch64-multiplatform.stdenv) cc;
            in
            "${cc}/bin/${cc.targetPrefix}cc";
        };
    });
}
pinning to a specific version of rust without using IFD
{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable";
    rust-manifest = {
      url = "https://static.rust-lang.org/dist/2022-02-06/channel-rust.toml";
      flake = false;
    };
  };

  outputs = { self, fenix, nixpkgs, rust-manifest }: {
    packages.x86_64-linux.default =
      (fenix.packages.x86_64-linux.fromManifestFile rust-manifest).minimalToolchain;
  };
}

Contributing

All pull requests should target staging branch instead of the default main branch

More Repositories

1

home-manager

Manage a user environment using Nix [maintainer=@rycee]
Nix
6,134
star
2

awesome-nix

😎 A curated list of the best resources in the Nix community [maintainer=@cyntheticfox]
2,546
star
3

nixos-generators

Collection of image builders [maintainer=@Lassulus]
Nix
1,338
star
4

NixOS-WSL

NixOS on WSL(2) [maintainer=@nzbr]
Nix
1,236
star
5

disko

Declarative disk partitioning and formatting using nix [maintainer=@Lassulus]
Nix
1,232
star
6

nix-direnv

A fast, persistent use_nix/use_flake implementation for direnv [maintainer=@Mic92 / @bbenne10]
Nix
1,170
star
7

nixvim

Configure Neovim with Nix! [maintainer=@pta2002, @traxys, @GaetanLepage]
Nix
1,060
star
8

nix-on-droid

Nix-enabled environment for your Android device. [maintainers=@t184256,@Gerschtli]
Nix
1,038
star
9

nixos-anywhere

install nixos everywhere via ssh [maintainer=@numtide]
Shell
1,029
star
10

impermanence

Modules to help you handle persistent state on systems with ephemeral root storage [maintainer=@talyz]
Nix
950
star
11

NUR

Nix User Repository: User contributed nix packages [maintainer=@Mic92]
Python
882
star
12

dream2nix

Simplified nix packaging for various programming language ecosystems [maintainer=@DavHau]
Nix
839
star
13

comma

Comma runs software without installing it. [maintainers=@Artturin,@burke,@DavHau]
Rust
831
star
14

poetry2nix

Convert poetry projects to nix automagically [maintainer=@adisbladis]
Nix
762
star
15

nix-index

Quickly locate nix packages with specific files [maintainers=@bennofs @figsoda @raitobezarius]
Rust
760
star
16

rnix-lsp

WIP Language Server for Nix! [maintainer=@aaronjanse]
Rust
701
star
17

lanzaboote

Secure Boot for NixOS [maintainers=@blitz @raitobezarius @nikstur]
Rust
696
star
18

nixd

Nix language server, based on nix libraries [maintainer=@inclyc]
C++
693
star
19

nix-init

Generate Nix packages from URLs with hash prefetching, dependency inference, license detection, and more [maintainer=@figsoda]
Rust
692
star
20

naersk

Build Rust projects in Nix - no configuration, no code generation, no IFD, sandbox friendly.
Nix
643
star
21

lorri

Your project’s nix-env [maintainer=@Profpatsch,@nyarly]
Rust
617
star
22

nixGL

A wrapper tool for nix OpenGL application [maintainer=@guibou]
Nix
611
star
23

robotnix

Build Android (AOSP) using Nix [maintainer=@danielfullmer,@Atemu]
Nix
558
star
24

nixpkgs-fmt

Nix code formatter for nixpkgs [maintainer=@zimbatm]
Rust
503
star
25

nixpkgs-wayland

Automated, pre-built packages for Wayland (sway/wlroots) tools for NixOS. [maintainers=@colemickens, @Artturin]
Nix
467
star
26

emacs-overlay

Bleeding edge emacs overlay [maintainer=@adisbladis]
Nix
465
star
27

vulnix

Vulnerability (CVE) scanner for Nix/NixOS.
Python
417
star
28

nixpkgs-update

Updating nixpkgs packages since 2018
Haskell
387
star
29

nixos-vscode-server

Visual Studio Code Server support in NixOS
Nix
360
star
30

nurl

Generate Nix fetcher calls from repository URLs [maintainer=@figsoda]
Rust
360
star
31

crate2nix

rebuild only changed crates in CI with crate2nix and nix
Nix
329
star
32

rnix-parser

A Nix parser written in Rust [maintainer=@oberblastmeister]
Nix
328
star
33

terraform-nixos

A set of Terraform modules that are designed to deploy NixOS [maintainer=@adrian-gierakowski]
HCL
313
star
34

srvos

NixOS profiles for servers [maintainer=@numtide]
Nix
297
star
35

nixbox

NixOS Vagrant boxes [maintainer=@zimbatm]
HCL
276
star
36

neovim-nightly-overlay

[maintainer=@Kranzes]
Nix
267
star
37

trustix

Trustix: Distributed trust and reproducibility tracking for binary caches [maintainer=@adisbladis]
Go
248
star
38

vscode-nix-ide

Nix language support for VSCode editor [maintainer: @jnoortheen]
TypeScript
248
star
39

nix-user-chroot

Install & Run nix without root permissions [maintainer=@Mic92]
Rust
243
star
40

nix-index-database

Weekly updated nix-index database [maintainer=@Mic92]
Nix
237
star
41

haumea

Filesystem-based module system for Nix [maintainer=@figsoda]
Nix
235
star
42

nix-zsh-completions

ZSH Completions for Nix
Shell
217
star
43

dconf2nix

🐾 Convert dconf files (e.g. GNOME Shell) to Nix, as expected by Home Manager [maintainer=@jtojnar]
Nix
212
star
44

NixNG

A linux distribution based on Nix [maintainer=@MagicRB]
Nix
210
star
45

gomod2nix

Convert applications using Go modules to Nix expressions [maintainer=@adisbladis]
Nix
204
star
46

noogle

https://noogle.dev - nix function exploring. [maintainer=@hsjobeki]
Nix
194
star
47

nix-melt

A ranger-like flake.lock viewer [maintainer=@figsoda]
Rust
190
star
48

pypi2nix

Abandoned! Generate Nix expressions for Python packages
Python
189
star
49

todomvc-nix

Example on how to nixify a project [maintainer=@Rizary]
Nix
164
star
50

pip2nix

Freeze pip-installable packages into Nix expressions [maintainer=@datakurre]
Python
159
star
51

flakelight

Framework for simplifying flake setup [maintainer=@accelbread]
Nix
159
star
52

nix-environments

Repository to maintain out-of-tree shell.nix files (maintainer=@mic92)
Nix
156
star
53

tree-sitter-nix

Nix grammar for tree-sitter [maintainer=@cstrahan]
JavaScript
148
star
54

docker-nixpkgs

docker images from nixpkgs [maintainer=@zimbatm]
Nix
137
star
55

linuxkit-nix

An easy to use Linux builder for macOS [maintainer=@nicknovitski]
Nix
133
star
56

nix-vscode-extensions

Nix expressions for VSCode and OpenVSX extensions [maintainers: @deemp, @AmeerTaweel]
Haskell
132
star
57

nix-eval-jobs

Parallel nix evaluator with a streamable json output [maintainers @Mic92, @adisbladis]
C++
125
star
58

npmlock2nix

nixify npm based packages [maintainer=@andir]
Nix
125
star
59

yarn2nix

Generate nix expressions from a yarn.lock file [maintainer=???]
Nix
123
star
60

nixos-install-scripts

collection of one-shot scripts to install NixOS on various server hosters and other hardware. [maintainer=@happysalada]
Shell
122
star
61

nixago

Generate configuration files using Nix [maintainer=@jmgilman]
Nix
118
star
62

nixdoc

Tool to generate documentation for Nix library functions [maintainer=@infinisil]
Nix
113
star
63

dns.nix

A Nix DSL for DNS zone files [maintainers=@raitobezarius @kirelagin @Tom-Hubrecht]
Nix
105
star
64

nix-unstable-installer

A place to host Nix unstable releases [maintainer=@lilyinstarlight]
Ruby
105
star
65

wiki

Nixos wiki [maintainer=@samueldr]
104
star
66

go-nix

Elements of Nix re-implemented as Go libraries [maintainer=@flokli]
Go
102
star
67

nixpkgs-lint

A fast semantic linter for Nix using tree-sitter 🌳 + ❄️. [maintainers=@Artturin,@siraben]
Rust
101
star
68

namaka

Snapshot testing for Nix based on haumea [maintainer=@figsoda]
Rust
96
star
69

nur-combined

A repository of NUR that combines all repositories [maintainer=@Mic92]
Nix
92
star
70

napalm

Support for building npm packages in Nix and lightweight npm registry [maintainer @jtojnar]
Nix
91
star
71

nixos-images

Automatically build (netboot) images for NixOS [maintainer=@Mic92]
Nix
90
star
72

nix-ld-rs

Run unpatched dynamic binaries on NixOS [maintainer=@zhaofengli @Mic92]
Rust
90
star
73

vgo2nix

Convert go.mod files to nixpkgs buildGoPackage compatible deps.nix files [maintainer=@adisbladis]
Nix
88
star
74

nixt

Simple unit-testing for Nix [maintainer=@Lord-Valen]
TypeScript
87
star
75

nur-packages-template

A template for NUR repositories: [maintainer=@fgaz]
Nix
84
star
76

pyproject.nix

A collection of Nix utilities to work with Python projects [maintainer=@adisbladis]
Nix
81
star
77

pnpm2nix

Load pnpm lock files into nix :) [maintainer=@adisbladis]
Nix
80
star
78

mineflake

Declarative Minecraft server in NixOS [unmaintained]
Rust
75
star
79

infra

nix-community infrastructure [maintainer=@Mic92]
Nix
74
star
80

nix-data-science

Standard set of packages and overlays for data-scientists [maintainer=@tbenst]
Nix
70
star
81

kde2nix

Provisional, experimental Plasma 6 (and friends) pre-release packaging [maintainer=@K900]
Nix
69
star
82

nixpkgs.lib

nixpkgs lib for cheap instantiation [maintainer=@github-action] (with initial help from @blaggacao)
Nix
66
star
83

ethereum.nix

Nix packages and NixOS modules for the Ethereum ecosystem. [maintainers=@aldoborrero,@brianmcgee,@selfuryon]
Nix
65
star
84

setup.nix

Nixpkgs based build tools for declarative Python packages [maintainer=@datakurre]
Nix
64
star
85

nix-installers

Nix installers for legacy distributions (rpm & deb & pacman) [maintainer=@adisbladis]
Nix
62
star
86

nix-github-actions

A library to turn Nix Flake attribute sets into Github Actions matrices [maintainer=@adisbladis]
Nix
60
star
87

hydra-check

check hydra for the build status of a package [maintainer=@makefu,@Artturin]
Python
60
star
88

zon2nix

Convert the dependencies in `build.zig.zon` to a Nix expression [maintainer=@figsoda]
Zig
58
star
89

redoxpkgs

Cross-compile to Redox using Nix [maintainer=@aaronjanse]
Nix
51
star
90

patsh

A command-line tool for patching shell scripts inspired by resholve [maintainer=@figsoda]
Rust
46
star
91

mavenix

Deterministic Maven builds using Nix [maintainer=@icetan]
Nix
45
star
92

nix-unit

Unit testing for Nix code [maintainer=@adisbladis]
C++
42
star
93

nixpkgs-pytools

Tools for removing the tedious nature of creating nixpkgs derivations [maintainer=@costrouc]
Python
42
star
94

docker-nix

Docker image for nix [maintainer=@zimbatm] [status=deprecated]
Dockerfile
38
star
95

nix-ts-mode

An Emacs major mode for editing Nix expressions, powered by tree-sitter.
Emacs Lisp
37
star
96

builtwithnix.org

Share the love of Nix [maintainer=@zimbatm]
HTML
37
star
97

nixpkgs-terraform-providers-bin

auto-updating terraform providers for nix [maintainer=@zimbatm]
Nix
35
star
98

nixops-libvirtd

NixOps libvirtd backend plugin [maintainer=@AmineChikhaoui]
Python
34
star
99

flake-nimble

Nimble packages Nix flake [maintainer=?]
Nix
33
star
100

authentik-nix

Nix flake with package, NixOS module and basic VM test for authentik. Trying to provide an alternative deployment mode to the officially supported docker-compose approach. Not affiliated with or officially supported by the authentik project [maintainer=@willibutz]
Nix
31
star