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.
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?
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!
# 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 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.
Only renders in the Documentation.
{{#include ../dogfood.nix}}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:
What can I do with this repository?
- 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)
The Documentation is here.
And here is the Book, a very good walk-trough. Start here!
This GitHub search query holds a pretty good answer.
Please enter the contribution environment:
direnv allow || nix develop -c "$SHELL"What licenses are used? → ./.reuse/dep5.
And the usual copies? → ./LICENSES.