I’m starting to have a lot of flake inputs in my flake.nix file, and it’s starting to get really cluttered. I’m wondering if there’s a way to separate my inputs into multiple files so it looks cleaner. I’ve tried to look it up but couldn’t really find anything abt it

Edit: Well as it turns out it’s not something possible yet, apparently the flake.nix file isn’t parsed like regular nix files and doesn’t support stuff like import

  • algernon@lemmy.ml
    English
    2·
    1 day ago

    The way I solved this problem is that I write my flake.nix in a literate-programming style using Org Roam. I have a code block that tangles out into out/flake.nix, which has a <<flake-inputs>> placeholder. I can have any number of code blocks, in any number of Org files that all reference flake-inputs. Thus, my inputs are near other code (& documentation) that uses them, split across dozens of files.

    The downside is that you no longer write Nix directly, but have to tangle it out.

    • claymorwan@lemmy.blahaj.zoneOPEnglish
      1·
      12 hours ago

      first time im earing of Org Roam, but i think i kinda understand, do ya got a repo where i can see how u did it im kinda interested

        • claymorwan@lemmy.blahaj.zoneOPEnglish
          1·
          3 hours ago

          o thanks, i’ll take a closer look but for what i’ve seen so far it kinda looks complex I also flake-part mentioned in some of the commits,i remember seeing it a few times and apparently it can modularize flakes or sum like that, can it modularize inputs too outta curiosity

          • algernon@lemmy.ml
            English
            1·
            7 minutes ago

            It’s complex, because it does a lot of things, and it evolved over the past few years. The basics are very, very simple:

            #+begin_src nix :tangle out/flake.nix :noweb no-export :noweb-prefix no :mkdirp t
{
  inputs = {
    <<flake-inputs>>
  };

  outputs = { self, nixpkgs, ... }@inputs: {
    <<flake-outputs>>
  };
}
#+end_src

            In some other file, you can then do:

            #+begin_src nix :noweb-ref flake-inputs
nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";
#+end_src

            And voila, you now have:

            {
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.11";
  };

  // ...rest of the flake
}

            How you organize your org documents, is entirely up to you. The trick is that this lets you split it up as you see fit, and you are no longer restricted by what the language or any framework built on top of it can provide.

  • hallettj@leminal.spaceEnglish
    2·
    2 days ago

    I think you can use import to load the expression from each file, and the // operator to combine imported attribute sets. Like this:

    Edit: This doesn’t work - see replies

    # flake.nix
{
  inputs =
    import ./inputs/nixpkgs.nix //
    import ./inputs/nix-index.nix;

  # ...
}

    # inputs/nixpkgs.nix
{
  nixpkgs.url = "github:nixos/nixpkgs/nixos-25.11";
  nixpkgs-unstable.url = "github:nixos/nixpkgs/nixos-unstable";
}

    # inputs/nix-index.nix
{
  nix-index-database = {
    url = "github:Mic92/nix-index-database";
    inputs.nixpkgs.follows = "nixpkgs";
  };
}
    • claymorwan@lemmy.blahaj.zoneOPEnglish
      2·
      2 days ago

      I followed how u did it but it doesn’t seem to work, i keep getting hit with this error:

      error: expected a set but got a thunk at /home/claymorwan/.dotfiles/NixOS/flake.nix:4:3
      • hallettj@leminal.spaceEnglish
        1·
        2 days ago

        Whoops! Guess I was wrong. After some experimenting it looks like the flake system parses, but does not evaluate flake.nix to read inputs. I also experimented with string concatenation, and that failed with the same error:

        nixpkgs.url = "github:nixos/nixpkgs" ++ "/nixos-25.05"; # error: expected a string or path, but got a thunk

        A “thunk” is an expression whose evaluation has been delayed. It’s a key piece of lazy evaluation. Remember that every expression in Nix is lazily evaluated.

        It looks only literal attribute set, string, and path expressions will work in inputs. I think that means it is not possible to split inputs over multiple files.

        • claymorwan@lemmy.blahaj.zoneOPEnglish
          2·
          2 days ago

          yea i think it may just not be possible yet, looking it up more i’ve seen people talking abt how a big con of flakes is that flake.nix is not parsed like regular nix files. I’m not sure why they made it work like that but it gets changed eventually cuz that’s really too bad we can’t do things as simple as imports

    • Klaymore@sh.itjust.worksEnglish
      2·
      2 days ago

      One note about // is that it doesn’t deep combine attribute sets, so if you set the .url in one and .inputs.nixpkgs.follows in another then it will only use the second one. I don’t think that matters here but it’s tripped me up before. I think lib.mkMerge is the deep recursive alternative.