{
  description = "Syndicate utilities";

  inputs.rust.url = "github:oxalica/rust-overlay";

  outputs = { self, nixpkgs, rust }: {
    lib = nixpkgs.lib.extend (import ./lib.nix);

    overlays.default = final: prev:
      let rust' = (prev.extend rust.overlay).rust-bin.nightly.latest.default;
      in {
        inherit (self) lib;

        nimPackages = prev.nimPackages.overrideScope' (final': prev': {
          preserves = final'.callPackage ./preserves-nim { };
          syndicate = final'.callPackage ./syndicate-nim { };
          syndicate_utils = final'.callPackage ./syndicate_utils-nim { };
          xdg_open_ng = final'.callPackage ./xdg_open_ng { };
        });

        python3Packages = prev.python3Packages.override {
          overrides = final': prev': {
            preserves = final'.callPackage ./preserves-py { };
            syndicate = final'.callPackage ./syndicate-py { };
          };
        };

        preserves-tools = final.callPackage ./preserves-tools { rust = rust'; };

        squeak = final.callPackage ./squeak { };
        squeaker = final.python3Packages.callPackage ./squeaker { };

        syndicate-server =
          final.callPackage ./syndicate-server { rust = rust'; };
      };

    legacyPackages =
      self.lib.mapAttrs (system: pkgs: pkgs.extend self.overlays.default)
      (builtins.removeAttrs nixpkgs.legacyPackages [ "mipsel-linux" ]);

    packages = self.lib.mapAttrs (system: pkgs:
      with pkgs; {
        inherit preserves-tools squeak squeaker syndicate-server;
        inherit (nimPackages) syndicate_utils xdg_open_ng;
        preserves-nim = nimPackages.preserves;
        preserves-py = python3Packages.preserves;
        syndicate-nim = nimPackages.syndicate;
        syndicate-py = python3Packages.syndicate;
      }) self.legacyPackages;

    nixosModules.default = self.nixosModules.syndicate-server;
    nixosModules.syndicate-server =
      # A little hack to apply our overlay to this module only.
      { config, lib, pkgs, ... }:
      (import ./nixos/syndicate-server.nix) {
        inherit config lib;
        pkgs = pkgs.extend self.overlays.default;
      };

    devShells = self.lib.mapAttrs (system: pkgs:
      with pkgs; {
        default =
          mkShell { packages = builtins.attrValues self.packages.${system}; };
      }) self.legacyPackages;

    checks = self.lib.mapAttrs (system: pkgs':
      with import (nixpkgs + "/nixos/lib/testing-python.nix") {
        inherit system;
        pkgs = pkgs';
      }; {
        http = simpleTest {
          nodes.machine = { config, pkgs, ... }: {
            imports = [ self.nixosModules.syndicate-server ];

            nixpkgs.pkgs = pkgs';

            services.syndicate.http = {
              enable = true;
              user = "nobody";
              config = [
                (pkgs.writeText "http.pr" ''
                  <require-service <daemon http_translator>>

                  <daemon http_translator {
                    argv: [ "${pkgs.nimPackages.syndicate_utils}/bin/http_translator" ]
                    protocol: text/syndicate
                  }>

                  let ?other = dataspace
                  $other [
                    ? <http ?handle GET ?headers ?path ?body> [
                      <http $handle 200 {} "Hello world!">
                    ]
                  ]

                  ? <service-object <daemon http_translator> ?cap> $cap [
                    <listen 8888>
                    <handler #{GET} [ "greeting" ] $other>
                  ]
                '')
              ];
            };

          };
          testScript = ''
            machine.wait_for_job("syndicate-http")
            machine.wait_for_open_port(8888)
            machine.succeed("curl --fail http://localhost:8888/greeting")
          '';
        };
      }) { inherit (self.legacyPackages) x86_64-linux; };
  };
}