chore: remove legacy params - system (#254)

Author: ryan4yin

docs/en/development/cross-platform-compilation.md

@@ -74,7 +74,7 @@ pkgsCross.mmix
 If you want to set `pkgs` to a cross-compilation toolchain globally in a flake, you only
 need to add a Module in `flake.nix`, as shown below:
 
-```nix{15-20}
+```nix{12-17}
 {
   description = "NixOS running on LicheePi 4A";
 
@@ -84,16 +84,14 @@ need to add a Module in `flake.nix`, as shown below:
 
   outputs = inputs@{ self, nixpkgs, ... }: {
     nixosConfigurations.lp4a = nixpkgs.lib.nixosSystem {
-      # native platform
-      system = "x86_64-linux";
       modules = [
-
-        # add this module, to enable cross-compilation.
         {
-          nixpkgs.crossSystem = {
-            # target platform
-            system = "riscv64-linux";
-          };
+          # the platform that performs the build-step
+          nixpkgs.localSystem.system = "x86_64-linux"; 
+
+          # the platform that will execute the resulting binaries
+          # add this to enable cross-compilation.
+          nixpkgs.crossSystem.system = "riscv64-linux";
         }
 
         # ...... other modules
@@ -131,7 +129,7 @@ your NixOS Module to enable the simulated build system of `aarch64-linux` and
 As for `flake.nix`, its setting method is very simple, even simpler than the setting of
 cross-compilation, as shown below:
 
-```nix{11}
+```nix{13}
 {
   description = "NixOS running on LicheePi 4A";
 
@@ -141,17 +139,18 @@ cross-compilation, as shown below:
 
   outputs = inputs@{ self, nixpkgs, ... }: {
     nixosConfigurations.lp4a = nixpkgs.lib.nixosSystem {
-      # native platform
-      system = "riscv64-linux";
       modules = [
+        # the native platform
+        # usually this is already set in the generated `hardware-configuration.nix` and can be omit.
+        { nixpkgs.hostPlatform = "riscv64-linux"; }
         # ...... other modules
       ];
     };
   };
 }
 ```
 
-You do not need to add any additional modules, just specify `system` as `riscv64-linux`.
+You do not need to add any additional modules, just specify `nixpkgs.hostPlatform` as `riscv64-linux`.
 Nix will automatically detect whether the current system is `riscv64-linux` during the
 build. If not, it will automatically build through the emulated system(QEMU). For users,
 these underlying operations are completely transparent.
@@ -223,20 +222,20 @@ Loading installable ''...
 Added 17755 variables.
 
 # replace gcc through overlays, this will create a new instance of nixpkgs
-nix-repl> a = import <nixpkgs> { crossSystem = { config = "riscv64-unknown-linux-gnu"; }; overlays = [ (self: super: { gcc = self.gcc12; }) ]; }
+nix-repl> a = import <nixpkgs> { crossSystem = "riscv64-linux"; overlays = [ (self: super: { gcc = self.gcc13; }) ]; }
 
 # check the gcc version, it is indeed changed to 12.2
 nix-repl> a.pkgsCross.riscv64.stdenv.cc
-«derivation /nix/store/jjvvwnf3hzk71p65x1n8bah3hrs08bpf-riscv64-unknown-linux-gnu-stage-final-gcc-wrapper-12.2.0.drv»
+«derivation /nix/store/kdi3g7px1bxz2r1jmjnr4pahscw8jj96-riscv64-unknown-linux-gnu-gcc-wrapper-13.4.0.drv»
 
 # take a look at the default pkgs, it is still 11.3
 nix-repl> pkgs.pkgsCross.riscv64.stdenv.cc
-«derivation /nix/store/pq3g0wq3yfc4hqrikr03ixmhqxbh35q7-riscv64-unknown-linux-gnu-stage-final-gcc-wrapper-11.3.0.drv»
+«derivation /nix/store/xd8s47j71z3lym5f2j9zy3v9r0ifw209-riscv64-unknown-linux-gnu-gcc-wrapper-14.3.0.drv»
 ```
 
 So how to use this method in Flakes? The example `flake.nix` is as follows:
 
-```nix{13-20}
+```nix{20-21}
 {
   description = "NixOS running on LicheePi 4A";
 
@@ -247,15 +246,17 @@ So how to use this method in Flakes? The example `flake.nix` is as follows:
   outputs = { self, nixpkgs, ... }:
   {
     nixosConfigurations.lp4a = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       modules = [
         {
-          nixpkgs.crossSystem = {
-            config = "riscv64-unknown-linux-gnu";
-          };
+          # the platform that performs the build-step
+          nixpkgs.localSystem.system = "x86_64-linux"; 
 
-          # replace gcc with gcc12 through overlays
-          nixpkgs.overlays = [ (self: super: { gcc = self.gcc12; }) ];
+          # the platform that will execute the resulting binaries
+          # add this to enable cross-compilation.
+          nixpkgs.crossSystem.system = "riscv64-linux";
+
+          # replace gcc with gcc13 through overlays
+          nixpkgs.overlays = [ (self: super: { gcc = self.gcc13; }) ];
         }
 
         # other modules ......
@@ -273,7 +274,7 @@ To avoid this problem, a better way is to create a new `pkgs` instance, and only
 instance when building the packages we want to modify. The example `flake.nix` is as
 follows:
 
-```nix{10-19,34-37}
+```nix{10-17,32}
 {
   description = "NixOS running on LicheePi 4A";
 
@@ -283,33 +284,29 @@ follows:
 
   outputs = { self, nixpkgs, ... }: let
     # create a new pkgs instance with overlays
-    pkgs-gcc12 = import nixpkgs {
+    pkgs-gcc13 = import nixpkgs {
       localSystem = "x86_64-linux";
-      crossSystem = {
-        config = "riscv64-unknown-linux-gnu";
-      };
+      crossSystem = "riscv64-linux";
 
       overlays = [
-        (self: super: { gcc = self.gcc12; })
+        (self: super: { gcc = self.gcc13; })
       ];
     };
   in {
     nixosConfigurations.lp4a = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       specialArgs = {
         # pass the new pkgs instance to the module
-        inherit pkgs-gcc12;
+        inherit pkgs-gcc13;
       };
       modules = [
         {
-          nixpkgs.crossSystem = {
-            config = "riscv64-unknown-linux-gnu";
-          };
+          nixpkgs.localSystem.system = "x86_64-linux"; 
+          nixpkgs.crossSystem.system = "riscv64-linux";
         }
 
-        ({pkgs-gcc12, ...}: {
+        ({pkgs-gcc13, ...}: {
           # use the custom pkgs instance to build the package hello
-          environment.systemPackages = [ pkgs-gcc12.hello ];
+          environment.systemPackages = [ pkgs-gcc13.hello ];
         })
 
         # other modules ......

docs/en/nix-store/add-binary-cache-servers.md

@@ -113,7 +113,7 @@ The second method is to configure `substituters` and `trusted-public-keys` using
 > As mentioned earlier, it is essential to configure `nix.settings.trusted-users` in this
 > configuration. Otherwise, the `substituters` we set here will not take effect.
 
-```nix{5-23,43-47}
+```nix{5-23,42-46}
 {
   description = "NixOS configuration of Ryan Yin";
 
@@ -151,7 +151,6 @@ The second method is to configure `substituters` and `trusted-public-keys` using
   }: {
     nixosConfigurations = {
       my-nixos = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ./hardware-configuration.nix
           ./configuration.nix
@@ -207,7 +206,7 @@ the value of `extra-xxx` will be appended to the end of the `xxx` parameter:
 
 In other words, you can use it like this:
 
-```nix{7,13,37-60}
+```nix{7,13,36-58}
 {
   description = "NixOS configuration of Ryan Yin";
 
@@ -239,7 +238,6 @@ In other words, you can use it like this:
   }: {
     nixosConfigurations = {
       my-nixos = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ./hardware-configuration.nix
           ./configuration.nix
@@ -266,7 +264,6 @@ In other words, you can use it like this:
                 "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY="
               ];
             };
-
           }
           # omitting several configurations...
        ];

docs/en/nixos-with-flakes/downgrade-or-upgrade-packages.md

@@ -8,7 +8,7 @@ modify the package version, you need to lock the git commit of the flake input.
 Here's an example of how you can add multiple nixpkgs inputs, each using a different git
 commit or branch:
 
-```nix{8-13,19-20,27-44}
+```nix{8-13,19-20,27-42}
 {
   description = "NixOS configuration of Ryan Yin";
 
@@ -33,8 +33,6 @@ commit or branch:
   }: {
     nixosConfigurations = {
       my-nixos = nixpkgs.lib.nixosSystem rec {
-        system = "x86_64-linux";
-
         # The `specialArgs` parameter passes the
         # non-default nixpkgs instances to other nix modules
         specialArgs = {

docs/en/nixos-with-flakes/modularize-the-configuration.md

@@ -281,15 +281,13 @@ shorthand for `lib.mkOrder 1500`.
 To test the usage of `lib.mkBefore` and `lib.mkAfter`, let's create a simple Flake
 project:
 
-```nix{10-38}
+```nix{8-36}
 # flake.nix
 {
   inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
   outputs = {nixpkgs, ...}: {
     nixosConfigurations = {
       "my-nixos" = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
-
         modules = [
           ({lib, ...}: {
             programs.bash.shellInit = lib.mkBefore ''

docs/en/nixos-with-flakes/nixos-flake-and-module-system.md

@@ -106,7 +106,7 @@ for use in user configuration files.
 Suppose you want to pass a certain dependency to a submodule for use. You can use the
 `specialArgs` parameter to pass the `inputs` to all submodules:
 
-```nix{13}
+```nix{11}
 {
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
@@ -115,8 +115,6 @@ Suppose you want to pass a certain dependency to a submodule for use. You can us
 
   outputs = inputs@{ self, nixpkgs, another-input, ... }: {
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
-
       # Set all inputs parameters as special arguments for all submodules,
       # so you can directly use all dependencies in inputs in submodules
       specialArgs = { inherit inputs; };
@@ -130,15 +128,14 @@ Suppose you want to pass a certain dependency to a submodule for use. You can us
 
 Or you can achieve the same effect using the `_module.args` option:
 
-```nix{14}
+```nix{13}
 {
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
     another-input.url = "github:username/repo-name/branch-name";
   };
   outputs = inputs@{ self, nixpkgs, another-input, ... }: {
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       modules = [
         ./configuration.nix
         {
@@ -185,7 +182,7 @@ of Helix directly.
 
 First, add the helix input data source to `flake.nix`:
 
-```nix{6,12,18}
+```nix{6,11,17}
 {
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-25.05";
@@ -196,7 +193,6 @@ First, add the helix input data source to `flake.nix`:
 
   outputs = inputs@{ self, nixpkgs, ... }: {
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       specialArgs = { inherit inputs; };
       modules = [
         ./configuration.nix

docs/en/nixos-with-flakes/nixos-flake-configuration-explained.md

@@ -40,7 +40,7 @@ Now let's look at `outputs`. It is a function that takes the dependencies from `
 its parameters, and its return value is an attribute set, which represents the build
 results of the flake:
 
-```nix{11-19}
+```nix{9-16}
 {
   description = "A simple NixOS flake";
 
@@ -52,7 +52,6 @@ results of the flake:
   outputs = { self, nixpkgs, ... }@inputs: {
     # The host with the hostname `my-nixos` will use this configuration
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       modules = [
         ./configuration.nix
       ];
@@ -138,7 +137,7 @@ From the source code of the Nixpkgs repository, we can see that its flake output
 definition includes the `lib` attribute, and in our example, we use the `lib` attribute's
 `nixosSystem` function to configure our NixOS system:
 
-```nix{8-13}
+```nix{8-12}
 {
   inputs = {
     # NixOS official package source, here using the nixos-25.05 branch
@@ -147,7 +146,6 @@ definition includes the `lib` attribute, and in our example, we use the `lib` at
 
   outputs = { self, nixpkgs, ... }@inputs: {
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       modules = [
         ./configuration.nix
       ];

docs/en/nixos-with-flakes/nixos-with-flakes-enabled.md

@@ -73,7 +73,7 @@ Referencing this template, create the file `/etc/nixos/flake.nix` and write the
 configuration content. All subsequent system modifications will be taken over by Nix
 Flakes. Here's an example of the content:
 
-```nix{16}
+```nix{15}
 {
   description = "A simple NixOS flake";
 
@@ -85,7 +85,6 @@ Flakes. Here's an example of the content:
   outputs = { self, nixpkgs, ... }@inputs: {
     # Please replace my-nixos with your hostname
     nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
       modules = [
         # Import the previous configuration.nix we used,
         # so the old configuration file still takes effect

docs/en/nixos-with-flakes/start-using-home-manager.md

@@ -199,7 +199,6 @@ After adjusting the parameters, the content of `/etc/nixos/flake.nix` is as foll
     nixosConfigurations = {
       # TODO please change the hostname to your own
       my-nixos = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ./configuration.nix
 

docs/en/nixpkgs/overlays.md

@@ -88,7 +88,6 @@ One example of importing the above configuration as a NixOS module is as follows
   outputs = inputs@{ nixpkgs, ... }: {
     nixosConfigurations = {
       my-nixos = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ./configuration.nix
 

docs/en/other-usage-of-flakes/module-system.md

@@ -223,7 +223,6 @@ Let's start with a simple example:
   outputs = {nixpkgs, ...}: {
     nixosConfigurations = {
       "test" = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ({config, lib, ...}: {
             options = {
@@ -337,7 +336,6 @@ The first thought might be to directly use `imports` in `config = { ... };`, lik
   outputs = {nixpkgs, ...}: {
     nixosConfigurations = {
       "test" = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         modules = [
           ({config, lib, ...}: {
             options = {
@@ -402,7 +400,6 @@ Let's look at an example directly:
   outputs = {nixpkgs, ...}: {
     nixosConfigurations = {
       "test" = nixpkgs.lib.nixosSystem {
-        system = "x86_64-linux";
         specialArgs = { enableFoo = true; };
         modules = [
           ({config, lib, enableFoo ? false, ...}: {