❄️ Unixverse

Unixverse is an opinionated Nix ecosystem for building one coherent personal computing environment across devices, apps, services, containers, microVMs, and live systems.

The idea is one open computing substrate: a system that can become a desktop, server, console, TV box, router, live ISO, local AI machine, or isolated app runtime while staying reproducible, inspectable, and yours.

Unixverse aims for the feel of a unified personal operating environment — something quietly Navi-like — but open, local-first, and built from plain NixOS modules instead of a closed platform.

What it is

Unixverse is a flake with a few cooperating layers:

Layer	Purpose	Examples
Device classes	Define what a machine is	desktop, server, console, tv, router
Feature modules	Add what a machine can do	ai, camera, wireguard, wlan, podman, secure_boot
General profiles	Bundle workflow/tooling defaults	dev, gaming, media, sysadmin, ger
Library helpers	Reuse system/app/container patterns	munix microVM apps, docs builders, SPA containers
Packages	Curated tools used by the ecosystem	dioxus-cli, zensical, qq, wrapped rga
Hosts	Concrete systems built from the layers	nixosConfigurations.live

The goal is coherence without lock-in: import a device class, layer on features, keep escape hatches available, and let plain NixOS remain the source of truth.

Principles

• Local first — prefer local services, local models, local state, and local control.
• Open and inspectable — no required closed control plane or opaque management layer.
• Composable — systems are built from reusable device classes, features, and profiles.
• User-owned — secrets, keys, hardware choices, and final authority stay with the machine owner.
• Reproducible — a system should be rebuildable, portable, and understandable from its declarations.
• Escape hatches — abstractions should make common paths clean without hiding NixOS.

What this flake exports

• nixosModules — device classes, feature modules, and general profiles.
• darwinModules — currently shared deployment support for macOS via comin.
• flakeModules — flake-parts modules, including myverse.flakeModules.fleet for auto-exposed NixOS fleets.
• packages — curated packages from ./pkgs.
• checks — formatting and Linux module-evaluation checks.
• lib — reusable functions for systems, munix, docs, and containers.
• nixosConfigurations.live — a buildable live ISO configuration.

Supported flake systems are:

• x86_64-linux
• aarch64-linux
• aarch64-darwin

Repository structure

• profiles/ — device classes, features, and workflow profiles
• lib/ — reusable Nix helpers and builders
• pkgs/ — curated package index
• hosts/live/ — the live ISO host configuration
• assets/ — static assets used by profiles and modules
• flake.nix — public exports, checks, packages, and supported systems
• justfile — small local workflow shortcuts

Basic usage

Use Unixverse as a flake input, then import the modules you need:

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    myverse.url = "github:your-org/myverse";
  };

  outputs = { nixpkgs, myverse, ... }@inputs: {
    nixosConfigurations.workstation = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      specialArgs = { inherit inputs; };
      modules = [
        myverse.nixosModules.desktop
        myverse.nixosModules.dev
        myverse.nixosModules.bluetooth
        myverse.nixosModules.sound
        myverse.nixosModules.ssh
        ./hosts/workstation/configuration.nix
      ];
    };
  };
}

Fleet auto-discovery

For flake-parts based fleet repos, myverse.flakeModules.fleet can auto-expose NixOS hosts from ./machines/<name>/configuration.nix:

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    flake-parts.url = "github:hercules-ci/flake-parts";
    myverse.url = "github:your-org/myverse";
  };

  outputs = inputs@{ flake-parts, myverse, ... }:
    flake-parts.lib.mkFlake { inherit inputs; } {
      imports = [ myverse.flakeModules.fleet ];
      systems = [ "x86_64-linux" ];

      myverse.fleet.enable = true;
    };
}

With this layout:

machines/
  gato/configuration.nix
  opium/configuration.nix

Unixverse emits:

nixosConfigurations.gato
nixosConfigurations.opium

Override globally or per host when conventions are not enough:

myverse.fleet = {
  enable = true;
  defaultSystem = "x86_64-linux";
  defaultModules = [ inputs.home-manager.nixosModules.default ];

  hosts.opium = {
    system = "aarch64-linux";
    extraModules = [ ./overrides/opium.nix ];
  };
};

Each host may also provide an optional machines/<name>/fleet.nix returning host metadata such as system, modules, extraModules, specialArgs, or tags.

A typical system stack looks like:

1. Start with one device class: desktop, server, console, tv, or router.
2. Add features for specific capabilities.
3. Add general profiles for workflow and tooling.
4. Keep host-specific hardware, users, disks, secrets, and final overrides in your own host module.

Example stacks

Workstation

modules = [
  myverse.nixosModules.desktop
  myverse.nixosModules.dev
  myverse.nixosModules.media
  myverse.nixosModules.bluetooth
  myverse.nixosModules.wlan
];

profiles.desktop.enable = true;
profiles.dev = {
  enable = true;
  useNix = true;
  useRust = true;
  useZed = true;
};
profiles.wlan.enable = true;

Local AI box

modules = [
  myverse.nixosModules.server
  myverse.nixosModules.ai
  myverse.nixosModules.ssh
];

profiles.ai = {
  enable = true;
  acceleration = "vulkan";
  models."qwen3.6-27b".enable = true;
};

Router

modules = [
  myverse.nixosModules.router
  myverse.nixosModules.ssh
];

profiles.router = {
  enable = true;
  wanInterface = "eth0";
  lanInterface = "eth1";
};

Live ISO

The included live ISO is a portable entry point into the ecosystem. It combines the minimal installer image with the desktop profile, base tools, German locale, zram, Podman, guest tools, browser/editor utilities, and a shadow user for auto-login.

Build it with either just:

just build-live

or directly with nixos-generators:

nix-shell -p nixos-generators --run "nixos-generate --format iso --flake .#live -o result"

Development workflow

Enter the dev shell:

nix develop

Format Nix files:

just fmt

Run flake checks:

nix flake check

The checks include nixfmt --check plus cheap evaluation checks for exported Linux nixosModules, which helps catch module breakage after input bumps.