Standard
Ship today.
Standard is a nifty DevOps framework that enables an efficient Software Development Life Cycle (SDLC) with the power of Nix via Flakes.
It organizes and disciplines your Nix and thereby speeds you up. It also comes with great horizontal integrations of high quality vertical DevOps tooling crafted by the Nix Ecosystem.
Stack
Integrations
The Standard Story
Once your nix
code has evolved into a giant
ball of spaghetti and nobody else except a few
select members of your tribe can still read it
with ease; and once to the rest of your colleagues
it has grown into an impertinence, then std
brings the overdue order to your piece of art
through a well-defined folder structure and
disciplining generic interfaces.
With std
, you'll learn how to organize your nix
flake outputs ('Targets') into Cells and
Cell Blocks — folded into a useful
CLI & TUI to also make the lives of your
colleagues easier.
Through more intuition and less documentation, your team and community will finally find a canonical answer to the everlasting question: What can I do with this repository?
The Standard NixOS Story (in case you wondered)
Once you got fed up with divnix/digga
or a disorganized personal configuration,
please head straight over to divnix/hive
and join the chat, there. It's work in progress.
But hey! It means: we can progress together!
Getting Started
# flake.nix
{
description = "Description for the project";
inputs = {
std.url = "github:divnix/std";
nixpkgs.follows = "std/nixpkgs";
};
outputs = { std, self, ...} @ inputs: std.growOn {
inherit inputs;
# 1. Each folder inside `cellsFrom` becomes a "Cell"
# Run for example: 'mkdir nix/mycell'
# 2. Each <block>.nix or <block>/default.nix within it becomes a "Cell Block"
# Run for example: '$EDITOR nix/mycell/packages.nix' - see example content below
cellsFrom = ./nix;
# 3. Only blocks with these names [here: "packages" & "shells"] are picked up by Standard
# It's a bit like the output type system of your flake project (hint: CLI & TUI!!)
cellBlocks = with std.blockTypes; [
(installables "packages" {ci.build = true;})
(devshells "shells" {ci.build = true;})
];
}
# 4. Run 'nix run github:divnix/std'
# 'growOn' ... Soil:
# - here, compat for the Nix CLI
# - but can use anything that produces flake outputs (e.g. flake-parts or flake-utils)
# 5. Run: nix run .
{
devShells = std.harvest self ["mycell" "shells"];
packages = std.harvest self ["mycell" "packages"];
};
}
# nix/mycell/packages.nix
{inputs, cell}: {
inherit (inputs.nixpkgs) hello;
default = cell.packages.hello;
}
This Repository
This repository combines the above mentioned stack components into the ready-to-use Standard framework. It adds a curated collection of Block Types for DevOps use cases. It further dogfoods itself and implements utilities in its own Cells.
Dogfooding
Only renders in the Documentation.
inputs: let
inherit (inputs) incl std;
inherit (inputs.paisano) pick harvest;
in
std.growOn {
inherit inputs;
cellsFrom = incl ./src ["local" "tests"];
nixpkgsConfig = {allowUnfree = true;};
cellBlocks = with std.blockTypes; [
## For local use in the Standard repository
# local
(devshells "shells" {ci.build = true;})
(nixago "configs")
(containers "containers")
(namaka "checks" {ci.check = true;})
];
}
{
devShells = harvest inputs.self ["local" "shells"];
checks = harvest inputs.self ["tests" "checks" "snapshots" "check"];
}
(std.grow {
inherit inputs;
cellsFrom = incl ./src ["std" "lib" "data"];
cellBlocks = with std.blockTypes; [
## For downstream use
# std
(runnables "cli" {ci.build = true;})
(functions "devshellProfiles")
(functions "errors")
(data "templates")
# lib
(functions "dev")
(functions "ops")
(anything "cfg")
(data "configs")
];
})
{
packages = harvest inputs.self [["std" "cli"] ["std" "packages"]];
templates = pick inputs.self ["std" "templates"];
}
That's it. std.grow
is a "smart" importer of your nix
code and is designed to keep boilerplate at bay. In the so called "Soil" compatibility layer, you can do whatever your heart desires. For example put flake-utils
or flake-parts
patterns here. Or, as in the above example, just make your stuff play nicely with the Nix CLI.
TIP:
- Clone this repo
git clone https://github.com/divnix/std.git
- Install
direnv
& inside the repo, do:direnv allow
(first time takes a little longer)- Run the TUI by entering
std
(first time takes a little longer)What can I do with this repository?
Documentation
The Documentation is here.
And here is the Book, a very good walk-trough. Start here!
Video Series
Examples in the Wild
This GitHub search query holds a pretty good answer.
Why?
Contributions
Please enter the contribution environment:
direnv allow || nix develop -c "$SHELL"
Licenses
What licenses are used? → ./.reuse/dep5
.
And the usual copies? → ./LICENSES
.