Nix / NixOS

Here are the basic steps though:

• package the target in a derivation aka a recipe to package the thing you like
• test it in a nix-shell or add it straight to your configuration.nix

I know it sounds a lot like , but a few pointers:

Derivation basics: This wiki page is the one that helped me understand the basics of derivations. It explains how to package stuff without extra tooling. stdenv.mkDerivation from nixpkgs adds a bunch of stuff, but the wiki linked doesn't explain it (yet?). You might find more information elsewhere.

There's documentation for stdenv.mkDerivation and I apologize in advance for putting this evil upon you, but right now I don't have any other useful bookmarks. I learned it the hard way, but if you can contribute to the https://nixlang.wiki with what you learned, you could make it easier for the next person.

As for nix-shell, once you've written your default.nix, you can wrap it in a shell.nix and execute nix-shell in the same directory.

default.nix

{ pkgs ? import <nixpkgs> {} }:
pkgs.stdenv.mkDerivation {
  pname = "chameleon";
  version = "0.0.1"; # Update this to the real version of the package
  buildInputs = with pkgs; [ gnumake ]; # Add more necessary inputs here

  # While testing, your default.nix can reside in the checked out git repo
  src = ./.;
  # You can of course also start out like this straight away, up to you
  # Once testing is done, you can point this to a git repo pulled by nix
  # src = pkgs.fetchFromGitHub {
  #   owner = "GideonWolfe";
  #   repo = "Chameleon";
  #   rev = "SOME GIT REVISION";
  #   hash = "";  # Start with an empty string and let nix complain with the real one, the use it
  #  };

  # There's a chance an install phase isn't necessary, but this is a skeleton
  # The contents are run in bash
  installPhase = ''
   runHook preInstall
   
   # Do non-standard installation stuff
   # See https://nixos.org/manual/nixpkgs/stable/#ssec-install-phase
   # for what is done by default

   runHook postInstall
  '';
}

shell.nix

{ pkgs ? import <nixpkgs> {} }:
let
  my-package = (import ./default.nix) { pkgs = pkgs; };
in
pkgs.mkShell {
  inputsFrom = [ my-package ];
}

Then you can run nix-shell and see if your expected binary is in PATH. Once that is confirmed, you can add your package to your configuration.nix

{ config, pkgs, ... }:

{
  # The rest of your configuration.nix

  environment.systemPackages = with pkgs; [
    # Import and call your derivation
    ((import /path/to/your/default.nix) { inherit pkgs; })
  ];
}

Hopefully that helped a little.

Anti Commercial-AI license

You write a nix derivation that decares it needs python and then runs the makefile. Then you can add the derivation to your configuration.nix (or temporary request it in a nix-shell).

I'm also fairly new to NixOS and also nix flakes, but there isn't much to be daunted by. A nix flakes config and a normal nixos config are identical except for the inclusion of a flake.nix file which declares what inputs (sources) you're using, otherwise it's identical. I'd recommend taking a look at this video which covers NixOS configuration as well as switching to nix flakes. The timestamp I included drops you off at the nix flake section of the video.

Once you've got that understood you can either find or write a nix flake for the program you want and include it in your config and use the modules from it. If you write it you'll need to make a derivation as verstra has said in another comment, which just says how to get the source files, what dependencies are needed for building, what dependencies are needed for installing and how to build and install it. This video goes into some details about derivations which may help.

It's a lot more involved than other distros but it gives you more control. I'm not fully switched over yet but i do want to switch over as soon as i can.

I would probably just ignore the Makefile provided by upstream. It just copies files and installs dependencies.

I would take a look at existing python derivations in nixpkgs (ex a random one I picked) and try to modify it to work with your package. Once you have it working well you could even submit it to nixpkgs!