Shinra

森羅万象 — shinra banshō: all things, everything under the sun.

One declarative substrate. Every computer you own.

Shinra is an open NixOS ecosystem for declaring your entire computing
environment — not one machine at a time, but all of them, in one repository you
control. A desktop, a server, a TV, a console, a router: each is a different
composition of the same foundation.

Change the declaration, push it, and every machine converges on the new
generation atomically, with a rollback that works.

Coherence without captivity. Opinionated defaults at the surface, ordinary
NixOS underneath. No mandatory cloud, account, central server, or hosted Git.

Principles

• Locally autonomous — connectivity enhances a machine; it does not complete it.
• User-owned — you keep authority over configuration, hardware, data, keys,
  software, and infrastructure.
• Declarative and inspectable — change the system through reviewable
  declarations, builds, and generations, never accumulated mutations.
• Composable — classes give defaults, capabilities add functionality,
  profiles supply workflows. Host decisions stay yours.
• Compose before inventing — use the good software that exists; invent only
  the missing abstractions.
• Honest about safety — controlled change reduces accidental breakage. It
  does not make every valid configuration safe, or backups optional.

What is here

Pillar	Contents
Device classes	desktop, server, tv, console, router (+ phone/tablet stubs)
Capabilities	26 capability modules: ai, wireguard, secure-boot, comin, camera, …
Packages	4 curated additions to nixpkgs
Library	munix microVMs, OCI containers, docs builders

Plus a 67-model AI catalogue with pinned revisions, Fleet host discovery, and a
generated option reference built from evaluated Nix metadata.

Use Shinra

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    shinra.url = "git+https://git.hydrar.de/shinra/shinra";
  };

  outputs = { nixpkgs, shinra, ... }@inputs: {
    nixosConfigurations.workstation = nixpkgs.lib.nixosSystem {
      specialArgs = { inherit inputs; };
      modules = [
        shinra.nixosModules.desktop
        shinra.nixosModules.dev
        shinra.nixosModules.ssh
        ./hardware-configuration.nix
        {
          nixpkgs.hostPlatform = "x86_64-linux";
          profiles.desktop.enable = true;
          profiles.ssh.enable = true;
          profiles.dev = {
            enable = true;
            useRust = true;
          };
          system.stateVersion = "25.05";
        }
        ./configuration.nix
      ];
    };
  };
}

A composition example, not an installer: bring your own users, boot and storage
configuration, and host settings. Keep an existing machine's system.stateVersion
unchanged. Importing a module only declares its options; each one waits for its
enable, and a class turns on the capabilities it is built from.

Documentation

Built with Zensical. Class and module reference pages are generated from
evaluated Nix option metadata — types, defaults, examples, and source links.

• Getting started and device classes
• Concepts and architecture
• Vision
• One push, every device
• Fleet, Live, and AI
• Status and roadmap
• Building the docs

nix build .#docs           # static site in result/
nix develop
just docs-serve            # generate reference, then preview locally

Public surfaces

Export	Purpose
nixosModules	Device classes, capabilities, and workflow profiles
darwinModules.comin	macOS deployment; Shinra is otherwise Linux-oriented
flakeModules.fleet / flakeModules.default	Host discovery via shinra.fleet
packages.<system>	Curated packages, docs, and docs-reference
overlays.default	The same packages as an ordinary nixpkgs overlay
lib	System, container, munix/microVM, and documentation helpers
nixosConfigurations.live	Live ISO entry point
checks	Formatting, docs, fleet API, and Linux module evaluation

Flake systems: x86_64-linux, aarch64-linux, aarch64-darwin. NixOS
configurations target Linux; a listed package system is not a support guarantee
for every package.

Related project: Edgecore

Edgecore is a sibling project: a
declarative device agent exposing capabilities through W3C Web of Things,
with HTTP interactions and local discovery.

Shinra describes what a computer should be. Edgecore describes how to
interact with what a device provides. Neither requires the other — see
the architectural relationship.

Development

nix develop
just fmt
nix flake check
just build-live

Source layout: crates/ — the model, the command and the app, in
Rust; nix/modules/ — classes, capabilities, roles and
the system every class builds on; nix/packages/,
nix/lib/, nix/fleet/, nix/hosts/live/,
nix/templates/solo/ and nix/tests/; assets/ — the mark, which the
docs, the boot splash and the app share; and docs/.

The Shinra app is the graphical face of the shinra command. On the
live ISO it opens as the guided install: five screens that produce a
declaration and hand it to shinra install run. The system
app is what it shows, and its design is where it is going.

Shinra is alpha. The roadmap says exactly what is built and
what is not.