Nixpkgs/Patching Nixpkgs - Revision history

Perchun: Link IFD column name to the Nix manual page

2026-05-21T10:19:37Z

Link IFD column name to the Nix manual page

← Older revision		Revision as of 10:19, 21 May 2026
Line 5:		Line 5:
	{\| class="wikitable" style="text-align: center; width: 500px;"		{\| class="wikitable" style="text-align: center; width: 500px;"
	\|-		\|-
	! Name !! Method !! IFD !! Requires Flakes		! Name !! Method !! [https://nixos.org/manual/nix/unstable/language/import-from-derivation IFD]!! Requires Flakes
	\|-		\|-
	\| applyPatch \|\| .patch files \|\| X \|\|		\| applyPatch \|\| .patch files \|\| X \|\|
Line 18:		Line 18:
	\|}		\|}

	Most of the solutions work on the <code>.patch</code> files, but those have a huge disadvantage - they quickly go out of date and have to be constantly rebased. This is especially true for solutions that use Git to apply patches. Another disadvantage may be [https://nixos.org/manual/nix/~~unstable~~/language/import-from-derivation IFD], which may result in [https://nixcademy.com/posts/what-is-ifd-ups-and-downs/ performance and runtime issues].		Most of the solutions work on the <code>.patch</code> files, but those have a huge disadvantage - they quickly go out of date and have to be constantly rebased. This is especially true for solutions that use Git to apply patches. Another disadvantage may be [https://nixos.org/manual/nix/stable/language/import-from-derivation IFD], which may result in [https://nixcademy.com/posts/what-is-ifd-ups-and-downs/ performance and runtime issues].

	== Usage ==		== Usage ==

Toastal: typos

2026-04-29T12:48:16Z

typos

← Older revision		Revision as of 12:48, 29 April 2026
Line 156:		Line 156:
	=== Using [https://nixtamal.toast.al/ Nixtamal] ===		=== Using [https://nixtamal.toast.al/ Nixtamal] ===

	Nixtamal uses both <code>~~fetchPatch2~~</code> & <code>applyPatches</code> under the hood, but lets users declare the remote or local patches in its <code>manifest.kdl</code> to be locked to any input — including Nixpkgs.		Nixtamal uses both <code>fetchpatch2</code> & <code>applyPatches</code> under the hood, but lets users declare the remote or local patches in its <code>manifest.kdl</code> to be locked to any input — including Nixpkgs.

	<syntaxhighlight lang="kdl">		<syntaxhighlight lang="kdl">
Line 179:		Line 179:
	</syntaxhighlight>		</syntaxhighlight>

	After patches are added, the user must relock.		After patches are added, the user must relock:

	<syntaxhighlight lang="console">		<syntaxhighlight lang="console">
Line 191:		Line 191:
	</syntaxhighlight>		</syntaxhighlight>

	Then the user can seemlessly access their patched Nixpkgs		Then the user can seemlessly access their patched Nixpkgs:

	<syntaxhighlight lang="console">		<syntaxhighlight lang="console">

Toastal: Add Nixtamal as declarative patching is a major feature

2026-04-29T12:40:23Z

Add Nixtamal as declarative patching is a major feature

@@ Line 14: / Line 14: @@
 |-
 | gh-cherry-pick  || git cherry-pick ||     ||
 |}
@@ Line 151: / Line 153: @@
 Very similar to [https://wiki.nixos.org/wiki/Nixpkgs/Patching_Nixpkgs#Using_nix-patcher nix-patcher], it maintains a fork of Nixpkgs and applies the patches on it sequentially. The main difference is that it doesn't operate on patch files, but runs <code>[https://git-scm.com/docs/git-cherry-pick git cherry-pick]</code> directly through GitHub API. This is a huge advantage, since Git can automatically rebase commits instead of forcing you to do that.
 == Resources ==

Perchun: nixpkgs -> Nixpkgs

2026-04-13T18:37:44Z

nixpkgs -> Nixpkgs

Perchun: Add multiple other options to choose from

2026-04-13T18:31:58Z

Add multiple other options to choose from

Show changes

N0099: replace importing nixpkgs: https://discourse.nixos.org/t/1000-instances-of-nixpkgs/17347 with existing NixOS module param `pkgs`, and replace fetchurl with fetchpatch2 that will do normalization on generated patch

2026-01-13T20:16:49Z

replace importing nixpkgs: https://discourse.nixos.org/t/1000-instances-of-nixpkgs/17347 with existing NixOS module param `pkgs`, and replace fetchurl with fetchpatch2 that will do normalization on generated patch

← Older revision		Revision as of 20:16, 13 January 2026
Line 12:		Line 12:


	First you will need to apply the Nixpkgs PR patch to some copy of Nixpkgs. In this example we will assume a ~~Flake (<code>flake.nix</code>) that~~ has ~~an input~~ <code>~~nixpkgs-unstable~~</code> pointing to <code>nixos-unstable</code>:		First you will need to apply the Nixpkgs PR patch to some copy of Nixpkgs. In this example we will assume a NixOS modules has parameter <code>pkgs</code> pointing to <code>nixos-unstable</code>.

	~~<syntaxHighlight lang=nix>~~
	~~inputs = {~~
	~~# ...~~
	~~nixpkgs-unstable~~.~~url = "github:NixOS/nixpkgs/nixos-unstable";~~
	~~# ...~~
	};
	~~</syntaxHighlight>~~

	We will use the [https://noogle.dev/f/pkgs/applyPatches <code>applyPatches</code>] function to apply the unmerged PR changes to		We will use the [https://noogle.dev/f/pkgs/applyPatches <code>applyPatches</code>] function to apply the unmerged PR changes to
	<code>nixpkgs-unstable</code>. First we need to covert the PR to a patch, which can be done by appending		<code>nixpkgs-unstable</code>. First we need to covert the PR to a patch, which can be done by appending
	<code>.patch</code> to the github PR		<code>.patch</code> to the github PR
	url. This will redirect to another link, for example https://github.com/NixOS/nixpkgs/pull/344917.patch will		url. This will redirect to another link, for example https://github.com/NixOS/nixpkgs/pull/344917.patch will
	redirect to https://patch-diff.githubusercontent.com/raw/NixOS/nixpkgs/pull/344917.patch. We can use ~~the latter~~.		redirect to https://patch-diff.githubusercontent.com/raw/NixOS/nixpkgs/pull/344917.patch. Then we can use <code>[https://nixos.org/manual/nixpkgs/stable/#fetchpatch fetchpatch]</code> or <code>[https://noogle.dev/f/pkgs/fetchpatch2 fetchpatch2]</code> to normalize this patch that generated by GitHub:

	<syntaxhighlight lang="nix">		<syntaxhighlight lang="nix">
			{ pkgs, ... }:

	let		let
	nixpkgs-~~unstable' =~~		nixpkgs-344917-drv =
	~~((import nixpkgs~~-~~unstable {~~		pkgs.applyPatches {
	~~system~~ = ~~"x86_64-linux";~~		src = pkgs.path;
	}).applyPatches		patches = [
	{		(pkgs.fetchpatch2 {
	~~name = "nixpkgs-unstable-patched";~~		url = "https://github.com/NixOS/nixpkgs/pull/344917.patch";
	src = ~~inputs~~.~~nixpkgs-unstable~~;		sha256 = "sha256-aws9J5ZNUyz4Z2RqPVEovBTNng4AdhzS03Bqg8jejWQ=";
	patches = [		})
	(~~builtins~~.~~fetchurl~~ {		];
	url = "https://~~patch-diff.githubusercontent~~.com~~/raw~~/NixOS/nixpkgs/pull/344917.patch";		};
	sha256 = "sha256-aws9J5ZNUyz4Z2RqPVEovBTNng4AdhzS03Bqg8jejWQ=";		nixpkgs-344917 = import nixpkgs-344917-drv { inherit (pkgs.stdenv) system; };
	})		in
	];
	});
	~~lib =~~ nixpkgs-~~unstable'.src.lib;~~
	~~pkgs-unstable-patched~~ = import nixpkgs-~~unstable'~~ {
	system ~~= "x86_64-linux"~~;
	};
	# ...		# ...
	</syntaxhighlight>		</syntaxhighlight>

	In the above example we create a derivation with the patch applied, called <code>nixpkgs-~~unstable'~~</code>. Pay attention we take the <code>src</code> attribute to get back the ~~top-level~~ (unpatched) nixpkgs~~. We can then access <code>lib</code> functions normally~~. We then import that new		In the above example we create a derivation with the patch applied, called <code>nixpkgs-344917-drv</code>. Pay attention we take the <code>src</code> attribute to get back the original (unpatched) nixpkgs. We then import that new derivation which we assign to <code>nixpkgs-344917</code>. Now we can use <code>nixpkgs-344917</code> to access the
	derivation which we assign to <code>~~pkgs-unstable~~-~~patched~~</code>. Now we can use <code>~~pkgs-unstable~~-~~patched~~</code> to access the
	Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.		Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.

Hustlerone: oops 2

2026-01-05T11:41:17Z

oops 2

← Older revision		Revision as of 11:41, 5 January 2026
Line 43:		Line 43:
	})		})
	];		];
	})~~.src~~;		});
	lib = nixpkgs-unstable'.lib;		lib = nixpkgs-unstable'.src.lib;
	pkgs-unstable-patched = import nixpkgs-unstable' {		pkgs-unstable-patched = import nixpkgs-unstable' {
	system = "x86_64-linux";		system = "x86_64-linux";

Hustlerone: oops

2026-01-05T11:38:48Z

oops

← Older revision		Revision as of 11:38, 5 January 2026
Line 44:		Line 44:
	];		];
	}).src;		}).src;
	~~patched~~ = nixpkgs-unstable'.lib;		lib = nixpkgs-unstable'.lib;
	pkgs-unstable = import nixpkgs-unstable' {		pkgs-unstable-patched = import nixpkgs-unstable' {
	system = "x86_64-linux";		system = "x86_64-linux";
	};		};
Line 52:		Line 52:

	In the above example we create a derivation with the patch applied, called <code>nixpkgs-unstable'</code>. Pay attention we take the <code>src</code> attribute to get back the top-level (unpatched) nixpkgs. We can then access <code>lib</code> functions normally. We then import that new		In the above example we create a derivation with the patch applied, called <code>nixpkgs-unstable'</code>. Pay attention we take the <code>src</code> attribute to get back the top-level (unpatched) nixpkgs. We can then access <code>lib</code> functions normally. We then import that new
	derivation which we assign to <code>pkgs-unstable</code>. Now we can use <code>pkgs-unstable</code> to access the		derivation which we assign to <code>pkgs-unstable-patched</code>. Now we can use <code>pkgs-unstable-patched</code> to access the
	Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.		Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.

Hustlerone: nixpkgs-unstable'.src leads you back to nixpkgs-unstable. Might as well just use nixpkgs-unstable.

2026-01-05T11:38:04Z

nixpkgs-unstable'.src leads you back to nixpkgs-unstable. Might as well just use nixpkgs-unstable.

← Older revision		Revision as of 11:38, 5 January 2026
Line 44:		Line 44:
	];		];
	}).src;		}).src;
	patched~~-lib~~ = nixpkgs-unstable'.lib;		patched = nixpkgs-unstable'.lib;
	pkgs-unstable = import nixpkgs-unstable' {		pkgs-unstable = import nixpkgs-unstable' {
	system = "x86_64-linux";		system = "x86_64-linux";
Line 51:		Line 51:
	</syntaxhighlight>		</syntaxhighlight>

	In the above example we create a derivation with the patch applied, called <code>nixpkgs-unstable'</code>. Pay attention we take the <code>src</code> attribute to get back the top-level nixpkgs. We can then access <code>lib</code> functions normally. We then import that new		In the above example we create a derivation with the patch applied, called <code>nixpkgs-unstable'</code>. Pay attention we take the <code>src</code> attribute to get back the top-level (unpatched) nixpkgs. We can then access <code>lib</code> functions normally. We then import that new
	derivation which we assign to <code>pkgs-unstable</code>. Now we can use <code>pkgs-unstable</code> to access the		derivation which we assign to <code>pkgs-unstable</code>. Now we can use <code>pkgs-unstable</code> to access the
	Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.		Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.

Ibizaman: Add more versatile way of using applyPatches.

2025-07-27T19:53:55Z

Add more versatile way of using applyPatches.

← Older revision		Revision as of 19:53, 27 July 2025
Line 28:		Line 28:
	redirect to https://patch-diff.githubusercontent.com/raw/NixOS/nixpkgs/pull/344917.patch. We can use the latter.		redirect to https://patch-diff.githubusercontent.com/raw/NixOS/nixpkgs/pull/344917.patch. We can use the latter.

	<~~syntaxHighlight~~ lang=nix>		<syntaxhighlight lang="nix">
	let		let
	~~pkgs~~-unstable' =		nixpkgs-unstable' =
	(import nixpkgs-unstable {		((import nixpkgs-unstable {
	system = "x86_64-linux";		system = "x86_64-linux";
	}).applyPatches		}).applyPatches
Line 43:		Line 43:
	})		})
	];		];
	};		}).src;
	pkgs-unstable = import ~~pkgs~~-unstable' {		patched-lib = nixpkgs-unstable'.lib;
			pkgs-unstable = import nixpkgs-unstable' {
	system = "x86_64-linux";		system = "x86_64-linux";
	};		};
	# ...		# ...
	</~~syntaxHighlight~~>		</syntaxhighlight>

	In the above example we create a derivation with the patch applied, called <code>~~pkgs~~-unstable'</code>. We then import that new		In the above example we create a derivation with the patch applied, called <code>nixpkgs-unstable'</code>. Pay attention we take the <code>src</code> attribute to get back the top-level nixpkgs. We can then access <code>lib</code> functions normally. We then import that new
	derivation which we assign to <code>pkgs-unstable</code>. Now we can use <code>pkgs-unstable</code> to access the		derivation which we assign to <code>pkgs-unstable</code>. Now we can use <code>pkgs-unstable</code> to access the
	Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.		Ghidra 11.2 package, as well as any other packages normally available in nixpkgs.

← Older revision		Revision as of 18:37, 13 April 2026
Line 1:		Line 1:
	Sometimes it may be required to patch a copy of ~~nixpkgs~~ directly, rather than use an overlay to patch an individual package. One scenario of where this might happen is if ~~nixpkgs~~ doesn't contain a change you need, but you find some		Sometimes it may be required to patch a copy of Nixpkgs directly, rather than use an overlay to patch an individual package. One scenario of where this might happen is if Nixpkgs doesn't contain a change you need, but you find some
	existing PR that has yet to be merged, and so want to leverage those changes prior to them being merged.		existing PR that has yet to be merged, and so want to leverage those changes prior to them being merged.

	There are many ways to patch ~~nixpkgs~~, each with its own advantages and disadvantages. We will go through the most popular ones:		There are many ways to patch Nixpkgs, each with its own advantages and disadvantages. We will go through the most popular ones:
	{\| class="wikitable" style="text-align: center; width: 500px;"		{\| class="wikitable" style="text-align: center; width: 500px;"
	\|-		\|-
Line 21:		Line 21:

	For the sake of example, let's say you are using the software package [https://ghidra-sre.org/ Ghidra], and the latest version available on		For the sake of example, let's say you are using the software package [https://ghidra-sre.org/ Ghidra], and the latest version available on
	~~nixpkgs~~ unstable is [https://search.nixos.org/packages?channel=unstable&from=0&size=50&sort=relevance&type=packages&query=ghidra 11.1.2].		Nixpkgs unstable is [https://search.nixos.org/packages?channel=unstable&from=0&size=50&sort=relevance&type=packages&query=ghidra 11.1.2].
	You know that the Ghidra developers have recently released 11.2, and want to use it before it's in ~~nixpkgs~~. You could try to create an overlay and manually update the package, but maybe in the process, you realize it is not a		You know that the Ghidra developers have recently released 11.2, and want to use it before it's in Nixpkgs. You could try to create an overlay and manually update the package, but maybe in the process, you realize it is not a
	trivial update. You may find there is already a pending PR to ~~nixpkgs~~ with the updated version and		trivial update. You may find there is already a pending PR to Nixpkgs with the updated version and
	changes you want, such as [https://github.com/NixOS/nixpkgs/pull/344917 this PR]. If you didn't		changes you want, such as [https://github.com/NixOS/nixpkgs/pull/344917 this PR]. If you didn't
	want to wait for that PR to be merged into ~~nixpkgs~~, you could apply the PR patch directly to your ~~nixpkgs~~ instead. There are, of course, other reasons you may wish to use a patched ~~nixpkgs~~, and the method applies to any of those cases.		want to wait for that PR to be merged into Nixpkgs, you could apply the PR patch directly to your Nixpkgs instead. There are, of course, other reasons you may wish to use a patched Nixpkgs, and the method applies to any of those cases.

	To get your patch, you will usually need to find a list of commits from the desired PR and fetch them. Try to avoid fetching something like https://github.com/NixOS/nixpkgs/pull/344917.diff, as it can change if the PR is still open. If you are fetching from GitHub, don't forget to add <code>?full_index=1</code> at the end of the URL for better reproducibility.		To get your patch, you will usually need to find a list of commits from the desired PR and fetch them. Try to avoid fetching something like https://github.com/NixOS/nixpkgs/pull/344917.diff, as it can change if the PR is still open. If you are fetching from GitHub, don't forget to add <code>?full_index=1</code> at the end of the URL for better reproducibility.
Line 50:		Line 50:
	=== Using <code>[https://github.com/NixOS/nixpkgs/blob/f6e07eb0e1e42c38f8e0b6ffc221b7bf73bece4b/pkgs/build-support/trivial-builders/default.nix#L981 applyPatches]</code> function ===		=== Using <code>[https://github.com/NixOS/nixpkgs/blob/f6e07eb0e1e42c38f8e0b6ffc221b7bf73bece4b/pkgs/build-support/trivial-builders/default.nix#L981 applyPatches]</code> function ===

	<code>applyPatches</code> is a ~~nixpkgs~~ function that applies a list of patches to a source directory. Internally, it just creates a new derivation via <code>stdenv.mkDerivation</code> and passes all of the patches to the usual <code>[https://github.com/NixOS/nixpkgs/blob/12c894cb74171bcec130756cc0f77720fca6587d/pkgs/stdenv/generic/setup.sh#L1371-L1404 patchPhase]</code>.		<code>applyPatches</code> is a Nixpkgs function that applies a list of patches to a source directory. Internally, it just creates a new derivation via <code>stdenv.mkDerivation</code> and passes all of the patches to the usual <code>[https://github.com/NixOS/nixpkgs/blob/12c894cb74171bcec130756cc0f77720fca6587d/pkgs/stdenv/generic/setup.sh#L1371-L1404 patchPhase]</code>.

	<syntaxhighlight lang="nix">		<syntaxhighlight lang="nix">
	let		let
	# to access the `applyPatches` function, you will need		# to access the `applyPatches` function, you will need
	# to import unpatched ~~nixpkgs~~ first		# to import unpatched Nixpkgs first
	pkgs = import <nixpkgs> {		pkgs = import <nixpkgs> {
	# with flakes, you may also need to hardcode the system		# with flakes, you may also need to hardcode the system
Line 75:		Line 75:
	</syntaxhighlight>		</syntaxhighlight>

	In the above example, we create a derivation with the patch applied, called <code>nixpkgs-344917-drv</code>. Pay attention, we take the <code>src</code> attribute to get back the original (unpatched) ~~nixpkgs~~. We then import that new derivation, which we assign to <code>nixpkgs-344917</code>. Now we can use <code>nixpkgs-344917</code> to access the Ghidra 11.2 package, as well as any other packages normally available in ~~nixpkgs~~.		In the above example, we create a derivation with the patch applied, called <code>nixpkgs-344917-drv</code>. Pay attention, we take the <code>src</code> attribute to get back the original (unpatched) Nixpkgs. We then import that new derivation, which we assign to <code>nixpkgs-344917</code>. Now we can use <code>nixpkgs-344917</code> to access the Ghidra 11.2 package, as well as any other packages normally available in Nixpkgs.

	=== Using [https://github.com/gepbird/nixpkgs-patcher nixpkgs-patcher] ===		=== Using [https://github.com/gepbird/nixpkgs-patcher nixpkgs-patcher] ===
Line 113:		Line 113:
	=== Using [https://github.com/katrinafyi/nix-patcher nix-patcher] ===		=== Using [https://github.com/katrinafyi/nix-patcher nix-patcher] ===

	nix-patcher is a script that automatically gets a list of patches from your <code>flake.nix</code> and applies them to your ~~nixpkgs~~ fork sequentially.		nix-patcher is a script that automatically gets a list of patches from your <code>flake.nix</code> and applies them to your Nixpkgs fork sequentially.

	<syntaxhighlight lang="nix"># flake.nix		<syntaxhighlight lang="nix"># flake.nix
Line 150:		Line 150:
	</syntaxhighlight>		</syntaxhighlight>

	Very similar to [https://wiki.nixos.org/wiki/Nixpkgs/Patching_Nixpkgs#Using_nix-patcher nix-patcher], it maintains a fork of ~~nixpkgs~~ and applies the patches on it sequentially. The main difference is that it doesn't operate on patch files, but runs <code>[https://git-scm.com/docs/git-cherry-pick git cherry-pick]</code> directly through GitHub API. This is a huge advantage, since Git can automatically rebase commits instead of forcing you to do that.		Very similar to [https://wiki.nixos.org/wiki/Nixpkgs/Patching_Nixpkgs#Using_nix-patcher nix-patcher], it maintains a fork of Nixpkgs and applies the patches on it sequentially. The main difference is that it doesn't operate on patch files, but runs <code>[https://git-scm.com/docs/git-cherry-pick git cherry-pick]</code> directly through GitHub API. This is a huge advantage, since Git can automatically rebase commits instead of forcing you to do that.

	== Resources ==		== Resources ==