Templates for language needs

[sofiedotcafe]

Hey,

Could you add templates such as those for Rust, Python and CMAKE build environments?

[tsandrini]

@sofiedotcafe Hi! This is definitely something that would be neat with this project and I do have some private parts (python and rust related) that I use around, but I haven't been completely sure how to "correctly" implement this for other people as well.

Let's take Rust for example

• first thing, regarding Rust you could potentially use packages, devshells and overlays parts just to start with
• Rust in nix projects is usually setup in a few different ways
  1. Fenix
  2. Directly from nixpkgs
  3. rust-overlay
  4. I've also seen some projects using rustup from nix, but thats a bit dirty
• then there is the nature of the project
  • for simple CLIs this could be all
  • but for stuff like services and APIs, you would also use something like process-compose (and/or maybe even devenv)

This is also reflected in the fact, that there are a bunch of Rust related nix flake templates around that people use and I don't want to be enforcing any particular style onto the user so this begs the question, how should I design this so its useful for the largest possible set of people? The same analysis applies for python and C and other lang projects as well.

So I am not sure how to design this, should it be a bunch of general parts? Or more concrete parts reflecting fenix, nixpkgs, rust-overlay? Maybe decoupling it into a lot of granular parts and then aggregate them together into collection parts like +rust-fenix-cli, +rust-overlay-cli, +rust-overlay-service?

I'd be glad to hear what you think about this! I definitely want to implement this, just want to do it properly.

[TakodaS]

I have just discovered flake-parts-builder and am currently using it for a new project. So far it is miles better than the competition nix-std, snowfall and plain old flake-parts just because the function loadParts is so versatile. I recently was thinking something like this would be amazing to have, so huge thanks for building it!

An example of how I am using your tool should help answer your questions. My repo looks as follows:

flake.nix
flake.lock
flake-parts/
components/
    |_ python-component/
        |_ default.nix
        |_shell.nix
        |_overlays.nix
        |_package.nix
    |_ rust-component/
   ...

then I simply add

#flake.nix
imports = (loadParts ./flake-parts) ++ (loadParts ./components);

and it all works beautifully! The only tricky part are the shells since I generally specify a default shell in flake-parts/ and then override this in *-component/shell.nix to get a *-oriented shell when I cd into the corresponding directory, which is admittedly a bit ugly.

Overall, it doesn't really matter as long as *-component/default.nix is a flake-part module it will get picked up by loadParts. Thus I see no problem for point 1 as long as defaults are handled manually.

For point 2, I think directly from nixpkgs is the way to go to minimize external dependencies. It shouldn't be too hard for people to substitute in Fenix/rust-overlay or whatever else. I think this project has enough potential that one day remote flake-part stores will be provided by external flakes in lieu of templates so a simple example that only has nixpkgs as a dependency should do the trick!

For point 3, I think there is no way around manual configuration by the user, especially if external flake-parts are incorporated. Maybe provide a commented out example in process-compose and devenv?

I think you can offload a lot of this work onto the community if it is easy to create and integrate your own flake-parts. Right now, I see guidelines for writing the meta file but not much else.