{
  inputs = {
    fenix-flake = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
  outputs =
    {
      self,
      fenix-flake,
      flake-utils,
      nixpkgs,
    }:
    flake-utils.lib.eachSystem
      [
        "aarch64-linux"
        "x86_64-linux"
      ]
      (
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          fenix = fenix-flake.packages.${system};

          arches = import ./nix/arches.nix;

          python = pkgs.python3.withPackages (ps: [ ps.ninja ]);
          rust-toolchain = fenix.combine (
            [
              fenix.stable.cargo
              fenix.stable.rustc
              fenix.stable.clippy
            ]
            ++ (builtins.map ({ rust-target, ... }: fenix.targets.${rust-target}.stable.rust-std) (
              builtins.attrValues arches
            ))
          );

          packages = rec {
            kernel = import ./boards {
              inherit
                arches
                libkernel
                nixpkgs
                pkgs
                python
                system
                ;
            };
            libkernel = import ./crates {
              inherit
                arches
                fenix
                nixpkgs
                system
                ;
            };
          };

          run-qemu-virt = pkgs.writeShellApplication {
            name = "run-qemu-virt";

            runtimeInputs = [ pkgs.qemu ];

            text = ''
              set -x
              qemu-system-riscv64 \
                -machine virt \
                -m 1G \
                -nographic \
                -bios none \
                -kernel ${packages.kernel.qemu-virt}/vernos_kernel.elf \
                "$@"
            '';
          };
        in
        {
          apps = {
            default = {
              type = "app";
              program = pkgs.lib.getExe run-qemu-virt;
            };

            run = {
              type = "app";
              program = pkgs.lib.getExe run-qemu-virt;
            };

            debug = {
              type = "app";
              program = pkgs.lib.getExe (
                pkgs.writeShellApplication {
                  name = "run-vm-debug";
                  runtimeInputs = [ run-qemu-virt ];
                  text = ''
                    port=$(( 1000 * ("$(id -u)" - 990) ))
                    run-qemu-virt -gdb tcp::$port -S "$@"
                  '';
                }
              );
            };

            gdb = {
              type = "app";
              program = pkgs.lib.getExe (
                pkgs.writeShellApplication {
                  name = "gdb";
                  text = ''
                    port=$(( 1000 * ("$(id -u)" - 990) ))
                    rust-gdb ${packages.kernel.qemu-virt}/vernos_kernel.elf \
                      -ex "symbol-file ${packages.kernel.qemu-virt}/vernos_kernel.sym" \
                      -ex "target remote 127.0.0.1:$port" \
                      -ex "set riscv use-compressed-breakpoints yes" \
                      -ex "layout asm" \
                      -ex "layout regs" \
                      -ex "focus cmd" \
                      -ex "(\$sp < (char*)hart0_initial_stack+8)" \
                      -ex "tbreak hart0_early_boot" \
                      -ex "c"
                  '';
                }
              );
            };
          };

          devShells.default = pkgs.mkShell {
            nativeBuildInputs =
              [
                (pkgs.callPackage ./nix/miri.nix { inherit fenix; })
                pkgs.cargo-watch
                pkgs.qemu
                python
                rust-toolchain
              ]
              ++ (builtins.map (
                { crossSystem, ... }:
                (import nixpkgs {
                  inherit system;
                  crossSystem.config = crossSystem;
                }).stdenv.cc.bintools.bintools
              ) (builtins.attrValues arches));
          };

          packages = flake-utils.lib.flattenTree packages;
        }
      );
}