FAQ - Revision history

DHCP: replace with to unbreak formatting


2026-05-20T22:36:20Z
replace <code> with <pre> to unbreak formatting

				
				
				
				
				
				← Older revision
				Revision as of 22:36, 20 May 2026
				
Line 103:
Line 103:
</translate> </translate>



<code> <pre>
q0yi2nr8i60gm2zap46ryysydd2nhzhp-automake-1.11.1/ q0yi2nr8i60gm2zap46ryysydd2nhzhp-automake-1.11.1/
vbi4vwwidvd6kklq2kc0kx3nniwa3acl-automake-1.11.1/ vbi4vwwidvd6kklq2kc0kx3nniwa3acl-automake-1.11.1/
Line 113:
Line 113:
j714mv53xi2j4ab4g2i08knqr137fd6l-nixos-build-vms/ j714mv53xi2j4ab4g2i08knqr137fd6l-nixos-build-vms/
xvs7y09jf7j48p6l0p87iypgpq470jqw-nixos-build-vms/ xvs7y09jf7j48p6l0p87iypgpq470jqw-nixos-build-vms/
</code> </pre>



<translate> <translate>

=== I've updated my channel and something is broken, how can I rollback to an earlier channel? === <!--T:5--> === I've updated my channel and something is broken, how can I rollback to an earlier channel? === <!--T:5-->



DHCP: prefix shell commands with "$"; use proper syntax highlighting; various formatting fixes
2026-05-20T22:06:19Z
prefix shell commands with "$"; use proper syntax highlighting; various formatting fixes
Show changes


Daanturo: Fix typo: relase -> release
2026-04-08T05:14:09Z
Fix typo: relase -> release

				
				
				
				
				
				← Older revision
				Revision as of 05:14, 8 April 2026
				
Line 402:
Line 402:



<!--T:83--> <!--T:83-->
So in short, the <code>relase-XX.YY</code> branches have not been run through Hydra yet, whereas the <code>nixos-XX.YY</code> ones have. So in short, the <code>release-XX.YY</code> branches have not been run through Hydra yet, whereas the <code>nixos-XX.YY</code> ones have.



=== There's an updated version for $software on nixpkgs but not in channels, how can I use it? === <!--T:13--> === There's an updated version for $software on nixpkgs but not in channels, how can I use it? === <!--T:13-->





Henriquekirchheck: I changed the user script to one with a minor fix to correctly redirect search pages.
2025-12-25T05:33:23Z
I changed the user script to one with a minor fix to correctly redirect search pages.

				
				
				
				
				
				← Older revision
				Revision as of 05:33, 25 December 2025
				
Line 28:
Line 28:
Also see: Also see:
* https://wiki.nixos.org/wiki/User:Winny/WikiRisks * https://wiki.nixos.org/wiki/User:Winny/WikiRisks
* https://greasyfork.org/en/scripts/495011-redirect-to-wiki-nixos-org (trivial userscript to redirect nixos.wiki links here) * https://greasyfork.org/en/scripts/560152-redirect-to-wiki-nixos-org (trivial userscript to redirect nixos.wiki links here)



=== Why is Nix written in C++ rather than a functional language like Haskell? === <!--T:2--> === Why is Nix written in C++ rather than a functional language like Haskell? === <!--T:2-->
Line 771:
Line 771:



<translate> <translate>

== References == <!--T:134--> == References == <!--T:134-->








Ardenet: Marked this version for translation
2025-11-20T16:23:48Z
Marked this version for translation

				
				
				
				
				
				← Older revision
				Revision as of 16:23, 20 November 2025
				
Line 415:
Line 415:



<translate> <translate>
=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? === === There's an updated version for $software on the unstable branch, but I use stable, how can I use it? === <!--T:143-->



<!--T:144-->
Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.   Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.  



<!--T:145-->
Secondly, while you're less likely to run into issues on NixOS than on, for example, Debian when installing packages from different releases, it's not impossible. Secondly, while you're less likely to run into issues on NixOS than on, for example, Debian when installing packages from different releases, it's not impossible.



<!--T:146-->
Nix ensures that libraries and (usually) runtime dependencies of packages are kept separate, so that you can trivially have many versions of those dependencies installed, without affecting the versions of said dependencies used by important system components. This ensures that you cannot accidentally break your package manager by, say, updating Python, as is quite common on other distros. Nix ensures that libraries and (usually) runtime dependencies of packages are kept separate, so that you can trivially have many versions of those dependencies installed, without affecting the versions of said dependencies used by important system components. This ensures that you cannot accidentally break your package manager by, say, updating Python, as is quite common on other distros.



<!--T:147-->
Nix cannot however ensure that there will be no incompatibilities with services of which there can inherently be only one running instance. As an example, if you try to use a package from unstable on a stable system that requires a feature in systemd that is not yet present in the systemd version on stable, this package will not work; it's simply not possible to run two different versions of systemd simultaneously. Nix cannot however ensure that there will be no incompatibilities with services of which there can inherently be only one running instance. As an example, if you try to use a package from unstable on a stable system that requires a feature in systemd that is not yet present in the systemd version on stable, this package will not work; it's simply not possible to run two different versions of systemd simultaneously.



<!--T:148-->
Nonetheless, it's quite uncommon that end-user facing applications rely on such singleton services, or at the very least they will typically have internal backwards compatibility. As such, mixing channels is usually unproblematic in practice, and even if not, NixOS' rollback features make it trivial to recover from problems should they occur. Nonetheless, it's quite uncommon that end-user facing applications rely on such singleton services, or at the very least they will typically have internal backwards compatibility. As such, mixing channels is usually unproblematic in practice, and even if not, NixOS' rollback features make it trivial to recover from problems should they occur.



==== Using channels ==== ==== Using channels ==== <!--T:149-->



<!--T:150-->
First we need to add the unstable channel to our system channels: First we need to add the unstable channel to our system channels:



<!--T:151-->
{{Warning|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}} {{Warning|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}
</translate> </translate>
Line 440:
Line 447:



<translate> <translate>
<!--T:152-->
Then we can import this channel using the angle-bracket notation to refer to it: Then we can import this channel using the angle-bracket notation to refer to it:
</translate> </translate>
Line 462:
Line 470:



<translate> <translate>
==== Using flakes ==== ==== Using flakes ==== <!--T:153-->



<!--T:154-->
We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>: We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:
</translate> </translate>
Line 498:
Line 507:



<translate> <translate>
<!--T:155-->
Using this in <code>configuration.nix</code> then looks as follows: Using this in <code>configuration.nix</code> then looks as follows:
</translate> </translate>





Ardenet: Adjust the position of page translation tags
2025-11-20T16:23:01Z
Adjust the position of page translation tags

				
				
				
				
				
				← Older revision
				Revision as of 16:23, 20 November 2025
				
Line 413:
Line 413:
NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software
</syntaxhighlight> </syntaxhighlight>

<translate> <translate>
=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? ===



=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? === 
Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.   Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.  



Line 427:
Line 428:



==== Using channels ==== ==== Using channels ====

First we need to add the unstable channel to our system channels: First we need to add the unstable channel to our system channels:

{{Warning|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}} {{Warning|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}
</translate> </translate>

<syntaxhighlight lang="console"> <syntaxhighlight lang="console">
$ sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos-unstable $ sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos-unstable
$ sudo nix-channel --update $ sudo nix-channel --update
</syntaxhighlight> </syntaxhighlight>

<translate> <translate>
Then we can import this channel using the angle-bracket notation to refer to it: Then we can import this channel using the angle-bracket notation to refer to it:
</translate> </translate>

<syntaxhighlight lang="nixos"># configuration.nix <syntaxhighlight lang="nixos"># configuration.nix
{   {  
Line 454:
Line 460:
   ];    ];
}</syntaxhighlight> }</syntaxhighlight>

<translate> <translate>
==== Using flakes ====



==== Using flakes ==== 
We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>: We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:
</translate> </translate>

<syntaxhighlight lang="nix"> <syntaxhighlight lang="nix">
# flake.nix # flake.nix
Line 488:
Line 496:
} }
</syntaxhighlight> </syntaxhighlight>

<translate> <translate>
Using this in <code>configuration.nix</code> then looks as follows: Using this in <code>configuration.nix</code> then looks as follows:
</translate> </translate>

<syntaxhighlight lang="nixos"> <syntaxhighlight lang="nixos">
# configuration.nix # configuration.nix
Line 503:
Line 513:
} }
</syntaxhighlight> </syntaxhighlight>

<translate> <translate>

=== How do I install a specific version of a package for build reproducibility etc.? === <!--T:14--> === How do I install a specific version of a package for build reproducibility etc.? === <!--T:14-->








TLATER: Add FAQ entry on mixing stable/unstable
2025-10-31T05:19:27Z
Add FAQ entry on mixing stable/unstable

				
				
				
				
				
				← Older revision
				Revision as of 05:19, 31 October 2025
				
Line 413:
Line 413:
NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software
</syntaxhighlight> </syntaxhighlight>
<translate>

=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? ===
Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package. 

Secondly, while you're less likely to run into issues on NixOS than on, for example, Debian when installing packages from different releases, it's not impossible.

Nix ensures that libraries and (usually) runtime dependencies of packages are kept separate, so that you can trivially have many versions of those dependencies installed, without affecting the versions of said dependencies used by important system components. This ensures that you cannot accidentally break your package manager by, say, updating Python, as is quite common on other distros.

Nix cannot however ensure that there will be no incompatibilities with services of which there can inherently be only one running instance. As an example, if you try to use a package from unstable on a stable system that requires a feature in systemd that is not yet present in the systemd version on stable, this package will not work; it's simply not possible to run two different versions of systemd simultaneously.

Nonetheless, it's quite uncommon that end-user facing applications rely on such singleton services, or at the very least they will typically have internal backwards compatibility. As such, mixing channels is usually unproblematic in practice, and even if not, NixOS' rollback features make it trivial to recover from problems should they occur.

==== Using channels ====
First we need to add the unstable channel to our system channels:
{{Warning|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}
</translate>
<syntaxhighlight lang="console">
$ sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos-unstable
$ sudo nix-channel --update
</syntaxhighlight>
<translate>
Then we can import this channel using the angle-bracket notation to refer to it:
</translate>
<syntaxhighlight lang="nixos"># configuration.nix
{ 
  config,
  pkgsUnstable,
  ...
}: {
  # We add a new `pkgsUnstable` to the module arguments; this allows
  # us to easily use `pkgsUnstable` in other modules as well, without
  # having to evaluate it again.
  _module.args.pkgsUnstable = import <nixos-unstable> { inherit (config.nixpkgs) config; };



  environment.systemPackages = [
    # Once we have created our `pkgsUnstable`, we can easily use
    # packages from it wherever NixOS modules expect derivations
    pkgsUnstable.hello
  ];
}</syntaxhighlight>
<translate> <translate>

==== Using flakes ====
We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:
</translate>
<syntaxhighlight lang="nix">
# flake.nix
{
  inputs = {
    nixpkgs.url = "https://channels.nixos.org/nixos-25.05/nixexprs.tar.xz";
    nixpkgs-unstable.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz";
  };

  outputs = { nixpkgs, ... } @ inputs: {
    # Note that the hostname "nixos" and the system tuple used here are
    # examples.
    nixosConfigurations."nixos" = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";

      modules = [
        ./configuration.nix
      ];

      # Any attributes of `specialArgs` will be added to our NixOS module
      # arguments.
      #
      # We've bound `nixpkgs-unstable` to the `inputs` variable using the `@`
      # syntax; if we add any other flake inputs in the future those will also
      # be added to our module arguments.
      specialArgs.flake-inputs = inputs;
    };
  };
}
</syntaxhighlight>
<translate>
Using this in <code>configuration.nix</code> then looks as follows:
</translate>
<syntaxhighlight lang="nixos">
# configuration.nix
{
  pkgs,
  flake-inputs,
  ...
}: {
  environment.systemPackages = [
    flake-inputs.nixpkgs-unstable.legacyPackages.${pkgs.system}.hello
  ];
}
</syntaxhighlight>
<translate>

=== How do I install a specific version of a package for build reproducibility etc.? === <!--T:14--> === How do I install a specific version of a package for build reproducibility etc.? === <!--T:14-->








Ardenet: Marked this version for translation
2025-10-10T15:43:35Z
Marked this version for translation

				
				
				
				
				
				← Older revision
				Revision as of 15:43, 10 October 2025
				
Line 198:
Line 198:
} }
</syntaxhighlight></li> </syntaxhighlight></li>
<li><p><translate>Install all specified packages using this command:</translate></p> <li><p><translate><!--T:137--> Install all specified packages using this command:</translate></p>
<syntaxhighlight lang="bash">nix-env -iA userPackages -f '<nixpkgs>'</syntaxhighlight></li></ol> <syntaxhighlight lang="bash">nix-env -iA userPackages -f '<nixpkgs>'</syntaxhighlight></li></ol>



Line 208:
Line 208:
Another way is using [[Home Manager]]. Another way is using [[Home Manager]].



<!--T:9--> === I've downloaded a binary, but I can't run it, what can I do? === <!--T:9-->
=== I've downloaded a binary, but I can't run it, what can I do? === 



<!--T:138-->
Binaries normally do not work out of the box when you download them because they normally just assume that libraries can be found in hardcoded paths such as <code>/lib</code>. However this assumption is incorrect on NixOS systems due to the inner workings of <code>nix</code> - there is no default path, everything gets set to the corresponding version on compile time. Binaries normally do not work out of the box when you download them because they normally just assume that libraries can be found in hardcoded paths such as <code>/lib</code>. However this assumption is incorrect on NixOS systems due to the inner workings of <code>nix</code> - there is no default path, everything gets set to the corresponding version on compile time.



Line 324:
Line 324:
If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries. If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.



<!--T:136--> === What are channels and how do they get updated? === <!--T:136-->
=== What are channels and how do they get updated? === 
</translate> </translate>



Line 368:
Line 367:
<ol start="2" style="list-style-type: decimal;"> <ol start="2" style="list-style-type: decimal;">
<li><translate><!--T:76--> Once the job succeeds at a particular nixpkgs commit, '''cache.nixos.org''' will download binaries from '''hydra.nixos.org'''.</translate></li> <li><translate><!--T:76--> Once the job succeeds at a particular nixpkgs commit, '''cache.nixos.org''' will download binaries from '''hydra.nixos.org'''.</translate></li>
<li><translate>Once the above download completes, the channel updates.</translate></li> <li><translate><!--T:139--> Once the above download completes, the channel updates.</translate></li>
</ol> </ol>



Line 390:
Line 389:
To know the commit, open the .version-suffix file in the nixpkgs location. The hash after the dot is the git commit. To know the commit, open the .version-suffix file in the nixpkgs location. The hash after the dot is the git commit.



<!--T:12--> === Nixpkgs branches === <!--T:12-->
=== Nixpkgs branches === 



<!--T:140-->
Branches on the nixpkgs repo have a relationship with channels, but that relationship is not 1:1. Branches on the nixpkgs repo have a relationship with channels, but that relationship is not 1:1.



Line 589:
Line 588:



<translate> <translate>
<!--T:141-->
Note that this will rebuild all packages depending on the overlaid package, which may be a lot. Some modules offer a <code>services.foo.package</code> to change the actual derivation used by the module without and overlay, and without recompiling dependencies ([https://nixos.org/manual/nixos/stable/options.html#opt-services.gvfs.package example]). Note that this will rebuild all packages depending on the overlaid package, which may be a lot. Some modules offer a <code>services.foo.package</code> to change the actual derivation used by the module without and overlay, and without recompiling dependencies ([https://nixos.org/manual/nixos/stable/options.html#opt-services.gvfs.package example]).



Line 634:
Line 634:
The name <code>Nix</code> comes from the Dutch word [https://en.wiktionary.org/wiki/nix niks] which means ''nothing''. It reflects the fact that Nix derivations do not have access to anything that has not been explicitly declared as an input.<ref>Eelco Dolstra et al. “Nix: A Safe and Policy-Free System for Software Deployment.” LiSA (2004), https://pdfs.semanticscholar.org/5fd8/8f89bd8738816e62808a1b7fb12d3ab14a2f.pdf</ref> The name <code>Nix</code> comes from the Dutch word [https://en.wiktionary.org/wiki/nix niks] which means ''nothing''. It reflects the fact that Nix derivations do not have access to anything that has not been explicitly declared as an input.<ref>Eelco Dolstra et al. “Nix: A Safe and Policy-Free System for Software Deployment.” LiSA (2004), https://pdfs.semanticscholar.org/5fd8/8f89bd8738816e62808a1b7fb12d3ab14a2f.pdf</ref>



<!--T:127--> === What does it mean to say that NixOS is "immutable" === <!--T:127-->
=== What does it mean to say that NixOS is "immutable" === 



<!--T:142-->
Immutability is a property of data, in general, which means that the data cannot be modified after it is created. In the context of an operating system, it really means that certain parts of the system have this property. In the case of Nix and NixOS, that includes the Nix store, where files can be created but not modified after the time they are created. It does not apply to every part of the operating system, in that users can still modify their own files in their home directory, for example. Immutability is a property of data, in general, which means that the data cannot be modified after it is created. In the context of an operating system, it really means that certain parts of the system have this property. In the case of Nix and NixOS, that includes the Nix store, where files can be created but not modified after the time they are created. It does not apply to every part of the operating system, in that users can still modify their own files in their home directory, for example.








Ardenet: Adjust tranlate tag's placement
2025-10-10T15:41:04Z
Adjust tranlate tag's placement
Show changes


Ardenet: Marked this version for translation
2025-10-07T21:14:42Z
Marked this version for translation

				
				
				
				
				
				← Older revision
				Revision as of 21:14, 7 October 2025
				
Line 281:
Line 281:
If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries. If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.



<!--T:136-->
=== What are channels and how do they get updated? === === What are channels and how do they get updated? ===
{{main|Channel branches}} {{main|Channel branches}}

← Older revision		Revision as of 22:36, 20 May 2026
Line 103:		Line 103:
	</translate>		</translate>

	<~~code~~>		<pre>
	q0yi2nr8i60gm2zap46ryysydd2nhzhp-automake-1.11.1/		q0yi2nr8i60gm2zap46ryysydd2nhzhp-automake-1.11.1/
	vbi4vwwidvd6kklq2kc0kx3nniwa3acl-automake-1.11.1/		vbi4vwwidvd6kklq2kc0kx3nniwa3acl-automake-1.11.1/
Line 113:		Line 113:
	j714mv53xi2j4ab4g2i08knqr137fd6l-nixos-build-vms/		j714mv53xi2j4ab4g2i08knqr137fd6l-nixos-build-vms/
	xvs7y09jf7j48p6l0p87iypgpq470jqw-nixos-build-vms/		xvs7y09jf7j48p6l0p87iypgpq470jqw-nixos-build-vms/
	</~~code~~>		</pre>

	<translate>		<translate>

	=== I've updated my channel and something is broken, how can I rollback to an earlier channel? === <!--T:5-->		=== I've updated my channel and something is broken, how can I rollback to an earlier channel? === <!--T:5-->

← Older revision		Revision as of 05:14, 8 April 2026
Line 402:		Line 402:

	<!--T:83-->		<!--T:83-->
	So in short, the <code>~~relase~~-XX.YY</code> branches have not been run through Hydra yet, whereas the <code>nixos-XX.YY</code> ones have.		So in short, the <code>release-XX.YY</code> branches have not been run through Hydra yet, whereas the <code>nixos-XX.YY</code> ones have.

	=== There's an updated version for $software on nixpkgs but not in channels, how can I use it? === <!--T:13-->		=== There's an updated version for $software on nixpkgs but not in channels, how can I use it? === <!--T:13-->

← Older revision		Revision as of 05:33, 25 December 2025
Line 28:		Line 28:
	Also see:		Also see:
	* https://wiki.nixos.org/wiki/User:Winny/WikiRisks		* https://wiki.nixos.org/wiki/User:Winny/WikiRisks
	* https://greasyfork.org/en/scripts/~~495011~~-redirect-to-wiki-nixos-org (trivial userscript to redirect nixos.wiki links here)		* https://greasyfork.org/en/scripts/560152-redirect-to-wiki-nixos-org (trivial userscript to redirect nixos.wiki links here)

	=== Why is Nix written in C++ rather than a functional language like Haskell? === <!--T:2-->		=== Why is Nix written in C++ rather than a functional language like Haskell? === <!--T:2-->
Line 771:		Line 771:

	<translate>		<translate>

	== References == <!--T:134-->		== References == <!--T:134-->

← Older revision		Revision as of 16:23, 20 November 2025
Line 415:		Line 415:

	<translate>		<translate>
	=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? ===		=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? === <!--T:143-->

			<!--T:144-->
	Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.		Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.

			<!--T:145-->
	Secondly, while you're less likely to run into issues on NixOS than on, for example, Debian when installing packages from different releases, it's not impossible.		Secondly, while you're less likely to run into issues on NixOS than on, for example, Debian when installing packages from different releases, it's not impossible.

			<!--T:146-->
	Nix ensures that libraries and (usually) runtime dependencies of packages are kept separate, so that you can trivially have many versions of those dependencies installed, without affecting the versions of said dependencies used by important system components. This ensures that you cannot accidentally break your package manager by, say, updating Python, as is quite common on other distros.		Nix ensures that libraries and (usually) runtime dependencies of packages are kept separate, so that you can trivially have many versions of those dependencies installed, without affecting the versions of said dependencies used by important system components. This ensures that you cannot accidentally break your package manager by, say, updating Python, as is quite common on other distros.

			<!--T:147-->
	Nix cannot however ensure that there will be no incompatibilities with services of which there can inherently be only one running instance. As an example, if you try to use a package from unstable on a stable system that requires a feature in systemd that is not yet present in the systemd version on stable, this package will not work; it's simply not possible to run two different versions of systemd simultaneously.		Nix cannot however ensure that there will be no incompatibilities with services of which there can inherently be only one running instance. As an example, if you try to use a package from unstable on a stable system that requires a feature in systemd that is not yet present in the systemd version on stable, this package will not work; it's simply not possible to run two different versions of systemd simultaneously.

			<!--T:148-->
	Nonetheless, it's quite uncommon that end-user facing applications rely on such singleton services, or at the very least they will typically have internal backwards compatibility. As such, mixing channels is usually unproblematic in practice, and even if not, NixOS' rollback features make it trivial to recover from problems should they occur.		Nonetheless, it's quite uncommon that end-user facing applications rely on such singleton services, or at the very least they will typically have internal backwards compatibility. As such, mixing channels is usually unproblematic in practice, and even if not, NixOS' rollback features make it trivial to recover from problems should they occur.

	==== Using channels ====		==== Using channels ==== <!--T:149-->

			<!--T:150-->
	First we need to add the unstable channel to our system channels:		First we need to add the unstable channel to our system channels:

			<!--T:151-->
	{{Warning\|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}		{{Warning\|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}
	</translate>		</translate>
Line 440:		Line 447:

	<translate>		<translate>
			<!--T:152-->
	Then we can import this channel using the angle-bracket notation to refer to it:		Then we can import this channel using the angle-bracket notation to refer to it:
	</translate>		</translate>
Line 462:		Line 470:

	<translate>		<translate>
	==== Using flakes ====		==== Using flakes ==== <!--T:153-->

			<!--T:154-->
	We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:		We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:
	</translate>		</translate>
Line 498:		Line 507:

	<translate>		<translate>
			<!--T:155-->
	Using this in <code>configuration.nix</code> then looks as follows:		Using this in <code>configuration.nix</code> then looks as follows:
	</translate>		</translate>

← Older revision		Revision as of 16:23, 20 November 2025
Line 413:		Line 413:
	NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software		NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/release-17.09.tar.gz nix-shell -p $software
	</syntaxhighlight>		</syntaxhighlight>

	<translate>		<translate>
			=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? ===

	~~=== There's an updated version for $software on the unstable branch, but I use stable, how can I use it? ===~~
	Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.		Before going ahead with this, note that firstly, this likely means that the package you intend to update has had a major version change. If you have used it previously, there is a chance that your existing data either will not work with the new version or will need to be migrated; If in doubt, consult the upstream documentation of the package.

Line 427:		Line 428:

	==== Using channels ====		==== Using channels ====

	First we need to add the unstable channel to our system channels:		First we need to add the unstable channel to our system channels:

	{{Warning\|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}		{{Warning\|`nixos-rebuild --upgrade` will by default only update the channel named `nixos`, which this new channel is not. Use `nixos-rebuild --upgrade-all` instead.}}
	</translate>		</translate>

	<syntaxhighlight lang="console">		<syntaxhighlight lang="console">
	$ sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos-unstable		$ sudo nix-channel --add https://nixos.org/channels/nixos-unstable nixos-unstable
	$ sudo nix-channel --update		$ sudo nix-channel --update
	</syntaxhighlight>		</syntaxhighlight>

	<translate>		<translate>
	Then we can import this channel using the angle-bracket notation to refer to it:		Then we can import this channel using the angle-bracket notation to refer to it:
	</translate>		</translate>

	<syntaxhighlight lang="nixos"># configuration.nix		<syntaxhighlight lang="nixos"># configuration.nix
	{		{
Line 454:		Line 460:
	];		];
	}</syntaxhighlight>		}</syntaxhighlight>

	<translate>		<translate>
			==== Using flakes ====

	~~==== Using flakes ====~~
	We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:		We simply add the unstable branch to our flake inputs, and pass them into the NixOS module system using <code>specialArgs</code>:
	</translate>		</translate>

	<syntaxhighlight lang="nix">		<syntaxhighlight lang="nix">
	# flake.nix		# flake.nix
Line 488:		Line 496:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	<translate>		<translate>
	Using this in <code>configuration.nix</code> then looks as follows:		Using this in <code>configuration.nix</code> then looks as follows:
	</translate>		</translate>

	<syntaxhighlight lang="nixos">		<syntaxhighlight lang="nixos">
	# configuration.nix		# configuration.nix
Line 503:		Line 513:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	<translate>		<translate>

	=== How do I install a specific version of a package for build reproducibility etc.? === <!--T:14-->		=== How do I install a specific version of a package for build reproducibility etc.? === <!--T:14-->

← Older revision		Revision as of 15:43, 10 October 2025
Line 198:		Line 198:
	}		}
	</syntaxhighlight></li>		</syntaxhighlight></li>
	<li><p><translate>Install all specified packages using this command:</translate></p>		<li><p><translate><!--T:137--> Install all specified packages using this command:</translate></p>
	<syntaxhighlight lang="bash">nix-env -iA userPackages -f '<nixpkgs>'</syntaxhighlight></li></ol>		<syntaxhighlight lang="bash">nix-env -iA userPackages -f '<nixpkgs>'</syntaxhighlight></li></ol>

Line 208:		Line 208:
	Another way is using [[Home Manager]].		Another way is using [[Home Manager]].

	~~<!--T:9-->~~		=== I've downloaded a binary, but I can't run it, what can I do? === <!--T:9-->
	=== I've downloaded a binary, but I can't run it, what can I do? ===

			<!--T:138-->
	Binaries normally do not work out of the box when you download them because they normally just assume that libraries can be found in hardcoded paths such as <code>/lib</code>. However this assumption is incorrect on NixOS systems due to the inner workings of <code>nix</code> - there is no default path, everything gets set to the corresponding version on compile time.		Binaries normally do not work out of the box when you download them because they normally just assume that libraries can be found in hardcoded paths such as <code>/lib</code>. However this assumption is incorrect on NixOS systems due to the inner workings of <code>nix</code> - there is no default path, everything gets set to the corresponding version on compile time.

Line 324:		Line 324:
	If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.		If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.

	~~<!--T:136-->~~		=== What are channels and how do they get updated? === <!--T:136-->
	=== What are channels and how do they get updated? ===
	</translate>		</translate>

Line 368:		Line 367:
	<ol start="2" style="list-style-type: decimal;">		<ol start="2" style="list-style-type: decimal;">
	<li><translate><!--T:76--> Once the job succeeds at a particular nixpkgs commit, '''cache.nixos.org''' will download binaries from '''hydra.nixos.org'''.</translate></li>		<li><translate><!--T:76--> Once the job succeeds at a particular nixpkgs commit, '''cache.nixos.org''' will download binaries from '''hydra.nixos.org'''.</translate></li>
	<li><translate>Once the above download completes, the channel updates.</translate></li>		<li><translate><!--T:139--> Once the above download completes, the channel updates.</translate></li>
	</ol>		</ol>

Line 390:		Line 389:
	To know the commit, open the .version-suffix file in the nixpkgs location. The hash after the dot is the git commit.		To know the commit, open the .version-suffix file in the nixpkgs location. The hash after the dot is the git commit.

	<!--T:12-->		=== Nixpkgs branches === <!--T:12-->
	~~=== Nixpkgs branches ===~~

			<!--T:140-->
	Branches on the nixpkgs repo have a relationship with channels, but that relationship is not 1:1.		Branches on the nixpkgs repo have a relationship with channels, but that relationship is not 1:1.

Line 589:		Line 588:

	<translate>		<translate>
			<!--T:141-->
	Note that this will rebuild all packages depending on the overlaid package, which may be a lot. Some modules offer a <code>services.foo.package</code> to change the actual derivation used by the module without and overlay, and without recompiling dependencies ([https://nixos.org/manual/nixos/stable/options.html#opt-services.gvfs.package example]).		Note that this will rebuild all packages depending on the overlaid package, which may be a lot. Some modules offer a <code>services.foo.package</code> to change the actual derivation used by the module without and overlay, and without recompiling dependencies ([https://nixos.org/manual/nixos/stable/options.html#opt-services.gvfs.package example]).

Line 634:		Line 634:
	The name <code>Nix</code> comes from the Dutch word [https://en.wiktionary.org/wiki/nix niks] which means ''nothing''. It reflects the fact that Nix derivations do not have access to anything that has not been explicitly declared as an input.<ref>Eelco Dolstra et al. “Nix: A Safe and Policy-Free System for Software Deployment.” LiSA (2004), https://pdfs.semanticscholar.org/5fd8/8f89bd8738816e62808a1b7fb12d3ab14a2f.pdf</ref>		The name <code>Nix</code> comes from the Dutch word [https://en.wiktionary.org/wiki/nix niks] which means ''nothing''. It reflects the fact that Nix derivations do not have access to anything that has not been explicitly declared as an input.<ref>Eelco Dolstra et al. “Nix: A Safe and Policy-Free System for Software Deployment.” LiSA (2004), https://pdfs.semanticscholar.org/5fd8/8f89bd8738816e62808a1b7fb12d3ab14a2f.pdf</ref>

	~~<!--T:127-->~~		=== What does it mean to say that NixOS is "immutable" === <!--T:127-->
	=== What does it mean to say that NixOS is "immutable" ===

			<!--T:142-->
	Immutability is a property of data, in general, which means that the data cannot be modified after it is created. In the context of an operating system, it really means that certain parts of the system have this property. In the case of Nix and NixOS, that includes the Nix store, where files can be created but not modified after the time they are created. It does not apply to every part of the operating system, in that users can still modify their own files in their home directory, for example.		Immutability is a property of data, in general, which means that the data cannot be modified after it is created. In the context of an operating system, it really means that certain parts of the system have this property. In the case of Nix and NixOS, that includes the Nix store, where files can be created but not modified after the time they are created. It does not apply to every part of the operating system, in that users can still modify their own files in their home directory, for example.

← Older revision		Revision as of 21:14, 7 October 2025
Line 281:		Line 281:
	If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.		If your target application can't find shared libraries inside buildFHSUserEnv, you may run [https://github.com/lexleogryfon/de-generate nix-de-generate] for target application inside FHS, which will generate newenv.nix file, an nix-expression of buildFHSUserEnv with resolved dependencies for shared libraries.

			<!--T:136-->
	=== What are channels and how do they get updated? ===		=== What are channels and how do they get updated? ===
	{{main\|Channel branches}}		{{main\|Channel branches}}

FAQ - Revision history

DHCP: replace with to unbreak formatting

DHCP: prefix shell commands with "$"; use proper syntax highlighting; various formatting fixes

Daanturo: Fix typo: relase -> release

Henriquekirchheck: I changed the user script to one with a minor fix to correctly redirect search pages.

Ardenet: Marked this version for translation

Ardenet: Adjust the position of page translation tags

TLATER: Add FAQ entry on mixing stable/unstable

Ardenet: Marked this version for translation

Ardenet: Adjust tranlate tag's placement

Ardenet: Marked this version for translation

DHCP: replace `with to unbreak formatting`