The dream
The dream of modifying your local machine configuration based on whatever it is
that you are doing is here. No matter if you are changing the Linux Kernel or
just writing a small reminder document, nix has got you covered. The only thing
you need to do is nix develop ENV_NAME and you are ready to go.
Flake first
I will not give a master class on what flakes are and how to use them; because I do not know yet :). But what I will do is to give an explanation on how I am using them to orchestrate the going in and coming out of specific shell environments. Let me try to explain it through specific dummy example
{
# Be sure to have some string that describes your flake
description = "dummy flake";
# This is where you define all the dependencies
inputs = {
# Bring in the packages from nix official source
nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
# Also bring in some special personal dependencies of your own
dep0.url = "github:GithubUser/nix_envs?dir=dep0";
};
# This is where you define what the flake will provide
outputs = { self, nixpkgs, dep0, ... }:
let
# Be sure to define it for your system architecture
pkgs = import nixpkgs { system = "x86_64-linux"; };
system = "x86_64-linux";
in {
# This is where you tell it to what you want available in your
# development shell
devShells.${system}.default = pkgs.mkShell {
# Include a list of packages from both nixos and your own dep0
packages = with pkgs [ git ]
++ dep0.devShells.${system}.default.shellPkgs ;
# Execute any special commands. You can even use the dep0 ones
shellHook = '' echo "Entering dummy environment" ''
+ dep0.devShells.${system}.default.shellHook
;
};
};
}
Dependencies
The URL lines in the inputs section point to a source; they don’t necessarily
need to be from github. You have everything that is provided by these
“packages” available in your flake. Two things to note:
1. A flake.nix file is expected to reside on the root path of the pointed
repository.
2. You can point to a directory within the repo (instead of just the root)
with the “?dir=/PATH” suffix.
Shell Environment
I use devShells to do two things
1. Define a set of packages that are available when I enter the environment
2. Define a set of actions that are run when I enter the environment
Worth noting here is that you can actually use elements from the “packages” that
you have in the input section.
Public is best
When you are using github repositories it has only worked for me when they are public.
Run Flake
You usually put your dummy flake.nix under a directory; let us say it is under
“dummy”. Then, to run the flake, you simply do nix develop /path/to/dummy.
Then you packages will be available and your shell script defined in the hook
will be run. Your environment is now personalized!!! And to get out of it, you
simply do an exit and you are back to your base system.
Register Flake
Typing nix develop /PATH/TO/dummy might be a bit too much. Especially when you
want to quickly go in and out of these environments. So I do two things:
1. Use an alias -> "alias nd=“nix develop”
2. Register the flake environments locally. Which requires you to copy a
list of all your beautiful flakes in the form of a registry template [1]
into ~/.config/nix/registry.json.
Self-referencing Nix Env Repo
I like to keep things in one place, so I added everything to one repository [2] and use different directories for different environments. I reference these with the “?dir=PATH” trick.
A word on Locking
A flake.lock file gets generated when I run nix develop. This has the -very
enjoyable- consequence of locking the “version”; its more like a git reference
hash. Which means that no matter how much I change [2], I will always have the
same version of my environment (until I regenerate my register file).
Conclusion
In conclusion, leveraging Nix flakes to manage development environments offers a
powerful and flexible approach to configuring your environments. By structuring
dependencies, defining shell environments, and utilizing registry files, you can
seamlessly switch between customized environments with minimal effort. Whether
you’re modifying the Linux kernel or working on small projects, Nix provides a
consistent and reproducible environment, ensuring that your development process
remains efficient and reliable.
[1] https://raw.githubusercontent.com/Joelgranados/nix_envs/refs/heads/master/registry.tmpl [2] https://github.com/Joelgranados/nix_envs
Joel's Blog 