Topics

Language breakdown

No language data available.

▸ Files click to expand

README

Standard

Ship today.

[Standard][std] is a nifty DevOps framework that enables an efficient Software Development Life Cycle (SDLC) with the power of [Nix][nix] via [Flakes][nix-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][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][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][blocktypes] for DevOps use cases. It further dogfoods itself and implements utilities in its own [Cells][cells].

Dogfooding

_{Only renders in the [Documentation][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:

>

1. Clone this repo git clone https://github.com/divnix/std.git

2. Install direnv & inside the repo, do: direnv allow (first time takes a little longer)

3. Run the TUI by entering std (first time takes a little longer)

>

What can I do with this repository?

Documentation

The [Documentation][documentation] is here.

And here is the [Book][book], a very good walk-trough. Start here!

Video Series

Examples in the Wild

This GitHub search query holds a pretty good answer.

Why?

[Why nix?][why-nix]
[Why std?][why-std]

Contributions

Please enter the contribution environment:

direnv allow || nix develop -c "$SHELL"

Licenses

What licenses are used? → [./.reuse/dep5][licensing].

And the usual copies? → [./LICENSES][licenses].

[cells]: https://github.com/divnix/std/tree/main/cells [documentation]: https://std.divnix.com [book]: https://jmgilman.github.io/std-book/ [licensing]: https://github.com/divnix/std/blob/main/.reuse/dep5 [licenses]: https://github.com/divnix/std/tree/main/LICENSES [blocktypes]: https://github.com/divnix/std/blob/main/src/blocktypes.nix [nix-flakes]: https://nixos.wiki/wiki/Flakes [nix]: https://nixos.org/manual/nix/unstable [std]: https://github.com/divnix/std [why-std]: https://std.divnix.com/explain/why-std.html [why-nix]: https://std.divnix.com/explain/why-nix.html [ecosystem]: https://discourse.nixos.org [hive]: https://github.com/divnix/hive

🔗 More in this category