nixos

Overlays allow any modification you can think of, not just limited to what packages have as "override options". You could say firefox = final.hello and then building pkgs.firefox would then result in hello. You could also say firefox = final.callPackage { } ... to inject a whole new derivation you've written yourself. You could make firefox = "foo" if you wanted to (not that that'd make any sense to do).

firefox = prev.firefox.override { ... } is just the specific case where you set the firefox package to its overridden variant (.override returns a new derivation).

That's everything as far as overlays are concerned.

The other piece to this puzzle are overrides. Overrides are a function of each derivation that returns a modified version of the derivation. You can override parameters (a package definition is usually a function) or the attributes of the mkDerivation call. The former obviously relies on the derivation having some flags you could change in its parameters while the latter can do anything you could do in a mkDerivation call (adding additional patches, using a different src, running some more commands preInstall etc.).

You can use overrides without overlays. If all you want is a leaf package but slightly different in your systemPackages, you could do that directly where you set it:

environment.systemPackages = [
  (firefox.override { ... })
  hello
  whatever
  ...
];

Overlays come into play when you want to have dependants of the package to also use the overridden variant without having to explicitly inject it via another override every time or need to modify some service's package that you didn't set yourself (most offer an option to change the package used but some don't).

You can override derivation inputs and derivation attributes. Let's take for example the nano editor.

You can enable tidy support by overriding the enableTidy input like so:

(final: prev: { nano = prev.nano.override { enableTidy = true; }; })

You can also override build steps, eg. if you want to apply an upstream patch because you don't want to wait for the next release version, you'd do it like this.

(final: prev: { nano = prev.nano.overrideAttrs ( old: { patches = (old.patches or [] ) ++ [ ./filename.patch ]; }); })

Now the thing about overlays is this: if you change a package in an overlay, all packages depending on that package, either directly or indirectly, will pull in that modified version, which is an extremely powerful tool as you can probably imagine.