aiolabs/omnixient
9
0
Fork 0
Code Issues 5 Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: aiolabs:a31369fea86aae4024f144cdd614b16059384532
Branches Tags
aiolabs:main
..
compare: aiolabs:1238703d9fb4e612883df99076f93f667111f08b
Branches Tags
aiolabs:main

No commits in common. "a31369fea86aae4024f144cdd614b16059384532" and "1238703d9fb4e612883df99076f93f667111f08b" have entirely different histories.
a31369fea8 ... 1238703d9f

15 changed files with 207 additions and 488 deletions
Download patch file Download diff file Expand all files Collapse all files

8
README.md
View file

@ -4,7 +4,7 @@ Transform your NixOS installation into a fully-configured, beautiful, and modern
## 🌀 aiolabs/omnixient
This repository is **derived from** [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) and **evolves independently** at [git.atitlan.io/aiolabs/omnixient](https://git.atitlan.io/aiolabs/omnixient). It keeps the desktop layer that OmniXY ships (Hyprland, themes, ISO builder, dev shells) and adds infrastructure for managing a multi-project Bitcoin/Lightning development workflow on top of it.
This repository is **derived from** [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) and **evolves independently** at [git.atitlan.io/aiolabs/omnixient](https://git.atitlan.io/aiolabs/omnixient). It keeps the desktop layer that omni ships (Hyprland, themes, ISO builder, dev shells) and adds infrastructure for managing a multi-project Bitcoin/Lightning development workflow on top of it.
We're not actively syncing changes from TheArctesian/omnixy — the diff has grown large enough that the two projects serve different audiences now. If you only want the polished desktop, the original is the right place. If you want the dev environment, fleet deploy story, and aiolabs-specific tooling, this is.
@ -418,7 +418,7 @@ The ISO includes:
Issues + PRs at [git.atitlan.io/aiolabs/omnixient/issues](https://git.atitlan.io/aiolabs/omnixient/issues).
This repo evolves independently of TheArctesian/omnixy — we don't sync changes upstream and you don't need to send the same fix to two places. If you want to contribute to the original OmniXY desktop project instead, head to [github.com/TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) directly; the two are now separate projects sharing common ancestry.
This repo evolves independently of TheArctesian/omnixy — we don't sync changes upstream and you don't need to send the same fix to two places. If you want to contribute to the original omni desktop project instead, head to [github.com/TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) directly; the two are now separate projects sharing common ancestry.
For aiolabs/omnixient contributions, the dev-env module ships an upstream-PR helper for sending PRs to OUR upstream OSS dependencies (lnbits, lamassu, nix-bitcoin, etc.) — see [`modules/dev-env/docs/upstream-prs.md`](modules/dev-env/docs/upstream-prs.md).
@ -428,7 +428,7 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
## 🙏 Acknowledgments
- [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) — the original OmniXY project this is derived from. Desktop, themes, ISO, hyprland config all originate there. We've evolved independently since.
- [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) — the original Omnixient project this is derived from. Desktop, themes, ISO, hyprland config all originate there. We've evolved independently since.
- Inspired by [Omakub](https://omakub.org/) and [Omarchy](https://omarchy.org/) by DHH — the original opinionated desktop setups
- The dev-env mksystem pattern is adapted from [mitchellh/nixos-config](https://github.com/mitchellh/nixos-config) — see `lib/mksystem.nix`
- The dev-env cross-level option forwarding pattern is inspired by [henrysipp/omarchy-nix](https://github.com/henrysipp/omarchy-nix), another NixOS port of omarchy
@ -479,7 +479,7 @@ per-author characterizations as summary, not gospel.)*
- [Hyprland Wiki](https://wiki.hyprland.org/) - Hyprland configuration reference
- [Nix Package Search](https://search.nixos.org/) - Search available packages
- [aiolabs/omnixient issues](https://git.atitlan.io/aiolabs/omnixient/issues) — issues + PRs for this repo
- [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) — the original OmniXY project (separate, no longer tracked for syncing)
- [TheArctesian/omnixy](https://github.com/TheArctesian/omnixy) — the original omni project (separate, no longer tracked for syncing)
## 📚 Learning Resources

30
configuration.nix
View file

@ -15,14 +15,28 @@ let
in
{
imports = [
# Omnixient core module aggregate (modules/default.nix) — the same set
# exposed as nixosModules.omni for external consumers, so there's a
# single source of truth for the core module list. The active theme
# is selected inside it from settings.theme.
#
# hardware-configuration.nix is imported per-host from
# hosts/<name>/default.nix (machine-specific), not here.
./modules
# NOTE: hardware-configuration.nix is imported per-host from
# hosts/<name>/default.nix (it's machine-specific), not here.
# Omnixient modules
./modules/lib.nix
./modules/core.nix
./modules/colors.nix
./modules/boot.nix
./modules/security.nix
./modules/secrets.nix
./modules/fastfetch.nix
./modules/walker.nix
./modules/scripts.nix
./modules/menus.nix
./modules/desktop/hyprland.nix
./modules/packages.nix
./modules/development.nix
./modules/mcp.nix
./modules/themes/${currentTheme}.nix
./modules/users.nix
./modules/services.nix
./modules/hardware
];
# --- Per-host settings (edit these) ---

318
docs/getting-started.md
View file

@ -1,243 +1,201 @@
# Getting Started — adopting Omnixient
# Getting Started — adopting Omnixient on your machine
Omnixient is a Hyprland desktop you build on top of, not a turnkey installer.
There are **two ways to adopt it**:
Omnixient is a personal NixOS config published as a starting point, not a
turnkey distro installer. Adopting it means **forking it and making it
yours**. Almost everything you need to change is funnelled through one
file (`settings.nix`) plus your machine's hardware scan.
1. **As a flake input (recommended)** — your own small repo pins Omnixient as
a dependency. You never edit Omnixient's files, so `nix flake update omni`
pulls upstream changes with zero merge conflicts. This is the path below.
2. **By forking** — clone Omnixient and edit it directly. More control over
Omnixient internals, but you maintain a fork. See
[Forking instead](#forking-instead) at the end.
This guide assumes you already have a working NixOS install (or are
installing from the official NixOS ISO). If you don't know NixOS at all,
read [the NixOS manual](https://nixos.org/manual/nixos/stable/) and
[NixOS & Flakes Book](https://nixos-and-flakes.thiscute.world/) first.
This guide assumes a working NixOS install (or the official NixOS ISO). New
to NixOS? Read the [NixOS manual](https://nixos.org/manual/nixos/stable/)
and the [NixOS & Flakes Book](https://nixos-and-flakes.thiscute.world/)
first.
> **Heads-up:** the `omni` host (`hosts/omni/`) is the maintainer's
> actual machine — a Framework Desktop with WireGuard, the aiolabs dev
> environment, and a Bitcoin/Lightning workflow. You'll want your own
> host directory rather than inheriting all of that. See
> [Step 4](#4-make-it-your-host).
---
## What's yours vs. what's Omnixient's
## The two things that are truly yours
In the dependency model your repo is tiny and owns only **your** stuff:
1. **`settings.nix`** — identity, hostname, timezone, theme, SSH keys, and
the all-important `stateVersion`. One file, fully commented.
2. **`hosts/<yourhost>/hardware-configuration.nix`** — the scan of your
actual hardware. Generated by `nixos-generate-config`; never copy
someone else's.
- `flake.nix` — pins Omnixient + your `settings` (identity, hostname, theme…).
- `hosts/<host>/default.nix` — which packs/options you want.
- `hosts/<host>/hardware-configuration.nix` — your real hardware scan.
Omnixient (the desktop, theming, packs, modules) comes from the pinned input.
You update it like any dependency; it never touches your files.
Everything else (the desktop, theming, packs) is shared and opt-in.
---
## 1. Scaffold your config
## 1. Get the repo
```bash
nix flake init -t git+https://git.atitlan.io/aiolabs/omnixient # writes flake.nix + hosts/myhost/
cd <your-config>
git clone https://git.atitlan.io/aiolabs/omnixient.git ~/omni
cd ~/omni
```
This drops a starter that already wires `omni.lib.mkSystem` +
`omni.nixosModules.omni`. Open `flake.nix` and:
- set `omni.url` to the real repo (pin a tag for reproducibility, e.g.
`git+https://git.atitlan.io/aiolabs/omnixient?ref=v1.0.0`);
- fill in the `settings` block:
```nix
settings = {
user = "alice";
gitName = "Alice Example";
gitEmail = "alice@example.com";
hostName = "myhost";
timeZone = "America/New_York";
theme = "tokyo-night"; # any module under Omnixient's modules/themes/
sshKeys = [ ]; # e.g. [ "ssh-ed25519 AAAA… alice@myhost" ]
stateVersion = "24.11"; # ⚠ the release you FIRST installed — never change
};
```
> **`stateVersion`** is the field that bites people: it is *not* your
> current NixOS version. It pins stateful defaults from your original
> install; changing it on a live system can break data.
You can put it anywhere; `/etc/nixos` and `~/omni` both work. Rebuild
commands below use `--flake .#<host>` from inside the clone.
## 2. Generate your hardware scan
```bash
sudo nixos-generate-config --show-hardware-config \
> hosts/myhost/hardware-configuration.nix
sudo nixos-generate-config --show-hardware-config > /tmp/hardware-configuration.nix
```
This captures your disks, filesystems, kernel modules, and CPU microcode.
The template ships a placeholder — replace it before building on real
hardware.
Review it (it captures your disks, filesystems, kernel modules, CPU
microcode). You'll place it into your host directory in step 4.
## 3. Choose packs and options
> A stray `hardware-configuration.nix` at the repo root is gitignored on
> purpose — the tracked copy belongs in your host directory.
Edit `hosts/myhost/default.nix`. Core (base system + Hyprland desktop +
theming) is always on; everything else is opt-in:
## 3. Fill in `settings.nix`
Open `settings.nix` and set every field for your machine:
```nix
omni = {
enable = true;
desktop.enable = true;
user = settings.user;
theme = settings.theme;
{
user = "alice"; # your Linux username
gitName = "Alice Example";
gitEmail = "alice@example.com";
hostName = "nimbus"; # your machine's hostname
timeZone = "America/New_York";
theme = "tokyo-night"; # any of modules/themes/*.nix
sshKeys = [
"ssh-ed25519 AAAAC3Nza... alice@nimbus"
];
stateVersion = "24.05"; # ⚠ the release you FIRST installed — never change later
}
```
packs.development.enable = true; # editors, LSPs, compilers, container CLIs
packs.media.enable = true; # gimp, inkscape, mpv, obs, …
# packs.gaming.enable = true; # Steam, Lutris, Wine
# packs.bitcoin.enable = true; # a real bitcoind + lightning node
The comments in the file explain each field. The **`stateVersion`**
warning is the one that bites people: it is *not* your current NixOS
version — it pins stateful defaults from your original install, and
changing it on a live system can break data.
## 4. Make it your host
The cleanest path is your own host directory, and there's a ready-made
template to copy — **`hosts/example/`** (a minimal, generic host, kept
build-checked in `flake.nix` so it never rots):
```bash
cp -r hosts/example hosts/nimbus # name it your host
cp /tmp/hardware-configuration.nix \
hosts/nimbus/hardware-configuration.nix # your real scan (step 2)
```
`hosts/example/default.nix` imports your hardware scan + the shared Omnixient
base and enables a sensible starter set of packs — edit it to taste (it's
fully commented). Then register the host in `flake.nix` (copy the
`example` block, rename it):
```nix
# flake.nix → nixosConfigurations
nimbus = mkSystem "nimbus" {
inherit system;
user = settings.user; # add `devEnv = true;` if you want the dev-env
extraSpecialArgs = { inherit settings; };
extraHmArgs = { inherit settings; };
modules = [
{ home-manager.sharedModules = [
inputs.nix-colors.homeManagerModules.default
inputs.lazyvim.homeManagerModules.default
inputs.walker.homeManagerModules.default
];
}
];
};
```
The full catalog is in **[docs/packs.md](packs.md)**.
If your username differs from the template's, also create
`users/<youruser>/home-manager.nix` — copy `users/user/home-manager.nix`,
a one-line shim to the shared `home.nix`.
## 4. Track your files, then build
**What's maintainer-specific in `hosts/omni/` — leave it out of yours:**
the `framework-desktop-*` hardware module, `wireguard.nix` (a private
tunnel), `omni.packs.aiolabs.enable` and the whole `dev-env { … }` block
(the aiolabs Lightning workflow), and the Framework `fwupd`/polkit rule.
Flakes only see **git-tracked** files, so stage everything first:
> Prefer the absolute-minimum change? You *can* skip renaming: replace
> `hosts/omni/hardware-configuration.nix` with your scan, strip the
> maintainer-specific lines from `hosts/omni/default.nix`, set
> `settings.hostName`, and build `.#omni`. The flake attribute name and
> your machine's hostname are independent. A dedicated host dir is just
> tidier once you have more than one machine.
```bash
git init && git add .
sudo nixos-rebuild switch --flake .#myhost
## 5. Choose your packs
Core (base system + Hyprland desktop + theming) is always on. Everything
else is opt-in via `omni.packs.<name>.enable`. The full catalog and the
standalone-import story are in **[docs/packs.md](packs.md)**.
```nix
omni.packs.media.enable = true; # gimp, inkscape, mpv, obs, …
omni.packs.development.enable = true; # editors, LSPs, compilers, container CLIs
omni.packs.gaming.enable = true; # Steam, Lutris, Wine
# omni.packs.bitcoin.enable = true; # a real bitcoind + lightning node (opt-in import)
```
> **Flakes not enabled yet?** On a stock NixOS install the first command
> fails with `experimental Nix feature 'nix-command' is disabled` — flakes
> are opt-in. Bootstrap the first build with a one-shot flag:
## 6. Build and switch
```bash
sudo nixos-rebuild switch --flake .#<host>
```
> **Flakes not enabled yet?** If your existing NixOS install hasn't
> turned on flakes, this first command fails with something like
> `experimental Nix feature 'nix-command' is disabled` — flakes are
> opt-in on stock NixOS. Bootstrap the first build with a one-shot flag:
>
> ```bash
> sudo nixos-rebuild switch --flake .#myhost \
> sudo nixos-rebuild switch --flake .#<host> \
> --extra-experimental-features "nix-command flakes"
> ```
>
> Your `hosts/myhost/default.nix` enables flakes permanently, so later
> rebuilds don't need the flag.
> You only need this **once** — Omnixient's own config enables
> `nix-command` and `flakes` (`configuration.nix`), so every later
> `nixos-rebuild` / `omni-rebuild` works without the flag.
> (Alternatively, add
> `nix.settings.experimental-features = [ "nix-command" "flakes" ];`
> to your *current* `/etc/nixos/configuration.nix`, run
> `sudo nixos-rebuild switch`, then come back to this step.)
On the next boot you'll have the Omnixient desktop, plus the bundled helpers
(`omni-rebuild`, `omni-update`, `omni-theme`; `omni-help` lists them).
On the next boot you'll have the Omnixient desktop. After that, the bundled
helpers take over (`omni-rebuild`, `omni-update`, `omni-theme`,
`omni-help` lists them all — note they're individual `omni-*`
commands, not a single dispatcher).
## 5. Set your password
## 7. Set your password
The default is `initialPassword = "omni"`. Change it after first login:
The template ships `initialPassword = "omni"` (`modules/users.nix`).
Change it immediately after first login:
```bash
passwd
```
For a declarative password, use `hashedPasswordFile` with a sops secret
(see [Secrets](#secrets-optional)).
---
## Already on NixOS?
Adopting Omnixient on a machine you already run is the same flow, with three
differences — because you're protecting a working system:
1. **Enable flakes first** (if you're on channels): add
`nix.settings.experimental-features = [ "nix-command" "flakes" ];` to your
current `/etc/nixos/configuration.nix` and `sudo nixos-rebuild switch`.
2. **Reuse what you have** — copy your existing
`hardware-configuration.nix` into `hosts/myhost/`, and carry your
**existing `stateVersion` across verbatim** (never bump it).
3. **Preview before you switch** — Omnixient is a full opinionated desktop
(Hyprland + greetd login manager + services), so it *will* change your
desktop:
```bash
sudo nixos-rebuild build --flake .#myhost # build only, catch errors
sudo nixos-rebuild build-vm --flake .#myhost && ./result/bin/run-*-vm # try it in a VM
```
When happy, `switch`. If it's not what you want, roll back instantly from
the boot menu or `sudo nixos-rebuild switch --rollback` — your old
generation is untouched.
> If you currently run GNOME/KDE/another login manager, expect overlap with
> greetd + Hyprland; preview in the VM first and disable the old desktop in
> the same switch.
---
## Updating
```bash
nix flake update omni # pull the latest Omnixient
sudo nixos-rebuild switch --flake .#myhost
```
This **can't** conflict with your config — Omnixient is a pinned dependency,
not a checkout. Roll back by reverting `flake.lock`; pin a release with
`omni.url = "git+https://git.atitlan.io/aiolabs/omnixient?ref=v1.0.0"`.
---
## Secrets (optional)
Secrets are **off by default** — a fresh config builds with zero secret
setup. Enable them only if you turn on something that needs one (e.g. an
MCP server) or add your own. Omnixient ships the sops-nix *module*; you supply
the *data*, with **your own** age key:
```bash
# 1. your master key (back this up!)
nix-shell -p age --run 'age-keygen -o ~/.config/sops/age/keys.txt' # prints age1…
# 2. declare yourself the recipient (copy Omnixient's .sops.yaml.example)
$EDITOR .sops.yaml # paste your age1… public key
# 3. create + encrypt your secrets (copy secrets/omni.yaml.example)
nix-shell -p sops --run 'sops secrets/omni.yaml'
# 4. TRACK the encrypted file — flakes only see git-tracked files
git add .sops.yaml secrets/omni.yaml
```
Then enable it in `hosts/myhost/default.nix` and rebuild:
```nix
omni.secrets.enable = true;
```
`modules/secrets.nix` reads `/home/<user>/.config/sops/age/keys.txt`, and
only activates when the flag is set *and* `secrets/omni.yaml` exists — so
it never gets in your way until you ask for it.
For a permanent declarative password, switch to
`hashedPasswordFile` with a sops-managed secret (see
`modules/secrets.nix` and `.sops.yaml`).
---
## Building a custom ISO (optional)
From an Omnixient checkout (or `nix build git+https://git.atitlan.io/aiolabs/omnixient#omni-iso`):
```bash
nix build .#omni-iso # → result/iso/nixos-*.iso
```
A live Omnixient environment for installing onto new hardware.
---
## Forking instead
If you want to modify Omnixient's own modules/themes rather than just consume
them, fork the repo and edit in place:
```bash
git clone https://git.atitlan.io/aiolabs/omnixient.git ~/omni && cd ~/omni
```
Then model a host on **`hosts/example/`** (copy it to `hosts/<yourhost>/`,
drop in your hardware scan, register it in `flake.nix`), and edit
`settings.nix`. The trade-off is the usual fork one: to get upstream
changes you `git pull` / rebase and resolve conflicts in any files you've
edited. The dependency model above avoids that entirely, which is why it's
recommended for most adopters.
---
The ISO is a live Omnixient environment for installing onto new hardware.
## Where to go next
- **[docs/packs.md](packs.md)** — the pack catalog, enabling/disabling, and
reusing packs on a non-Omnixient NixOS.
- **[docs/ARCHITECTURE.md](ARCHITECTURE.md)** — how the flake, `mkSystem`,
- **[docs/ARCHITECTURE.md](ARCHITECTURE.md)** — how the flake, `mksystem`,
modules, and theming fit together.
- **[docs/system-map.md](system-map.md)** — a file-by-file map of the repo.

2
docs/packs.md
View file

@ -93,7 +93,7 @@ flake as an input and import just the pack you want:
```nix
# your own flake.nix
inputs.omni.url = "git+https://git.atitlan.io/aiolabs/omnixient";
inputs.omni.url = "git+ssh://forgejo@git.atitlan.io/aiolabs/omnixient";
# your host's modules
{

45
flake.nix
View file

@ -218,19 +218,6 @@
};
in
{
# Reusable library for external consumers. Use this flake as an
# input and build a host with the Omnixient conventions from your own
# repo, without forking:
#
# omni.lib.mkSystem "myhost" {
# settings = { ... }; # your identity (see settings.nix)
# modules = [ ./hosts/myhost ];
# };
#
# mkSystem bakes in Omnixient's nixpkgs, overlays, and inputs
# (home-manager, sops-nix, …), so you don't redeclare them.
lib.mkSystem = mkSystem;
# NixOS configurations.
#
# This public template ships the `example` host (copy-me starter) and
@ -245,13 +232,20 @@
# that won't match real hardware, so don't `switch` to it. Adopters
# copy hosts/example → hosts/<name> and rename this block. See
# hosts/example/default.nix and docs/getting-started.md.
# nix-colors/lazyvim/walker home-manager modules are injected by
# mkSystem now, so hosts no longer wire them by hand.
example = mkSystem "example" {
inherit system;
user = settings.user;
extraSpecialArgs = { inherit settings; };
extraHmArgs = { inherit settings; };
modules = [
{
home-manager.sharedModules = [
inputs.nix-colors.homeManagerModules.default
inputs.lazyvim.homeManagerModules.default
inputs.walker.homeManagerModules.default
];
}
];
};
# ISO image for live USB/DVD. This is a variant rather than a
@ -304,18 +298,6 @@
# / bitcoin packs are standalone-importable — usable on a non-omni
# NixOS without enabling omni core.
nixosModules = {
# Omnixient core, as a single importable module. A consumer using
# this flake as an input builds a host with:
# omni.lib.mkSystem "myhost" {
# settings = { ... };
# modules = [ omni.nixosModules.omni ./hosts/myhost ];
# };
# mkSystem also injects packs + home-manager; this provides the
# desktop/system core (option namespace + behavior). Theme is
# chosen from settings.theme.
omni = import ./modules;
default = import ./modules;
lnbits = import ./modules/packs/lnbits.nix;
aiolabs = import ./modules/packs/aiolabs.nix;
bitcoin = import ./modules/packs/bitcoin.nix;
@ -326,15 +308,6 @@
containers = import ./modules/packs/containers.nix;
};
# Starter config for adopters: `nix flake init -t github:<org>/omni`
# scaffolds a consumer flake that uses Omnixient as an input (dependency
# model) — see templates/default/README.md.
templates.default = {
path = ./templates/default;
description = "Starter Omnixient consumer config (Omnixient as a flake input)";
};
templates.omni = self.templates.default;
# Flake checks — run by `nix flake check`. Lightweight targets
# that exercise the dev-env module schema end-to-end without
# loading the full omni system. Each check renders a small

57
lib/mksystem.nix
View file

@ -56,10 +56,6 @@ name:
user,
devEnv ? false,
modules ? [ ],
# Home-manager config for `user`, as a PATH. External consumers pass
# their own (e.g. `home = ./home.nix`). When null, fall back to this
# repo's users/<user>/home-manager.nix, then to Omnixient's home.nix.
home ? null,
# Extra args merged into the system-level specialArgs. Used by hosts
# whose configuration.nix expects values beyond the defaults (e.g.
# omni's configuration.nix takes `settings` from settings.nix).
@ -74,35 +70,19 @@ let
# fall back to a flat `hosts/<name>.nix`.
hostDir = ../hosts/${name};
hostFile = ../hosts + "/${name}.nix";
# Internal hosts (this repo's hosts/<name>/) are imported automatically.
# External consumers using this flake as an input have no host dir here,
# so they pass their host config through `modules` and we add nothing.
hostConfigModules =
hostConfig =
if builtins.pathExists hostDir then
[ hostDir ]
hostDir
else if builtins.pathExists hostFile then
[ hostFile ]
else if modules != [ ] then
[ ]
hostFile
else
throw "mksystem: no host config for '${name}' — add hosts/${name}/ or pass one via `modules` (looked at ${toString hostDir} and ${toString hostFile})";
throw "mksystem: no host config for '${name}' (looked at ${toString hostDir} and ${toString hostFile})";
userNixosConfig = ../users/${user}/nixos.nix;
hasUserNixosConfig = builtins.pathExists userNixosConfig;
userHMConfig = ../users/${user}/home-manager.nix;
# Home-manager config for `user`, resolved in priority order so both
# internal hosts and external consumers get a working home:
# 1. caller-supplied `home` (consumer override), else
# 2. this repo's users/<user>/home-manager.nix (internal hosts), else
# 3. Omnixient's default home.nix (consumer whose user isn't in this tree).
internalUserHM = ../users/${user}/home-manager.nix;
userHMConfig =
if home != null then
home
else if builtins.pathExists internalUserHM then
internalUserHM
else
../home.nix;
hasUserNixosConfig = builtins.pathExists userNixosConfig;
hasUserHMConfig = builtins.pathExists userHMConfig;
in
nixpkgs.lib.nixosSystem {
@ -121,10 +101,10 @@ nixpkgs.lib.nixosSystem {
{ nixpkgs.hostPlatform = system; }
{ nixpkgs.overlays = overlays; }
{ nixpkgs.config.allowUnfree = true; }
# Per-host configuration.
hostConfig
]
# Per-host configuration: this repo's hosts/<name>/ when present;
# external consumers supply their host through `modules`.
++ hostConfigModules
# Per-user system-level config (account, shell, sudo) — only if the
# user file exists. Skipping silently is fine; some hosts share users
# defined elsewhere (e.g. omni's users.nix).
@ -155,15 +135,6 @@ nixpkgs.lib.nixosSystem {
currentSystemUser = user;
}
// extraHmArgs;
# Omnixient's home.nix depends on these home-manager modules
# (colorScheme via nix-colors, programs.lazyvim, programs.walker).
# Inject them for every host so consumers don't wire them by hand;
# re-importing the same module from a host's `modules` is a no-op.
home-manager.sharedModules = [
inputs.nix-colors.homeManagerModules.default
inputs.lazyvim.homeManagerModules.default
inputs.walker.homeManagerModules.default
];
}
# Pre-create the home-manager activation script's expected
# directory tree. See modules/home-manager-bootstrap.nix for
@ -173,11 +144,9 @@ nixpkgs.lib.nixosSystem {
# bootstrap.
../modules/home-manager-bootstrap.nix
]
++ [
# Home config for `user` — always wired now that userHMConfig always
# resolves (caller `home`, internal shim, or Omnixient's home.nix).
{ home-manager.users.${user} = import userHMConfig; }
]
++ nixpkgs.lib.optional hasUserHMConfig {
home-manager.users.${user} = import userHMConfig;
}
# dev-env is opt-in.
++ nixpkgs.lib.optional devEnv ../modules/dev-env
# Caller-supplied extras.

48
modules/default.nix
View file

@ -1,48 +0,0 @@
# Omnixient core module aggregate.
#
# The reusable Omnixient module set as a single importable module, used from
# one source of truth in two places:
# - configuration.nix imports it for this repo's own hosts;
# - it's exposed as `nixosModules.omni` (flake.nix) so an external
# consumer can `imports = [ omni.nixosModules.omni ]` from their
# own flake without forking.
#
# Deliberately NOT here:
# - modules/packs and modules/dev-env — injected separately by
# lib/mksystem.nix (packs unconditionally, dev-env opt-in);
# - hardware-configuration.nix — per-host;
# - the sops-nix / home-manager modules — injected by mkSystem.
#
# The active theme is selected from `settings.theme` (a specialArg
# provided by mkSystem), matching the prior configuration.nix behavior.
{
imports = [
./lib.nix
./core.nix
./colors.nix
./boot.nix
./security.nix
./secrets.nix
./fastfetch.nix
./walker.nix
./scripts.nix
./menus.nix
./desktop/hyprland.nix
./packages.nix
./development.nix
./mcp.nix
./users.nix
./services.nix
./hardware
# Theme: import the colorscheme module named by settings.theme. Kept
# as a settings-driven dynamic import (rather than importing all 12
# and guarding each) so the closure stays minimal.
(
{ settings, ... }:
{
imports = [ ./themes/${settings.theme}.nix ];
}
)
];
}

23
modules/fastfetch.nix
View file

@ -31,7 +31,7 @@ in
cat /etc/omni/branding/about.txt
echo
echo "Theme: ${cfg.theme}"
echo "Preset: ${if cfg.preset == null then "custom" else cfg.preset}"
echo "Preset: ${cfg.preset or "custom"}"
echo "User: ${cfg.user}"
echo "NixOS Version: $(nixos-version)"
echo
@ -42,18 +42,29 @@ in
# Create Omnixient branding directory
environment.etc."omni/branding/logo.txt".text = ''
▟▛ omnixient
███████╗███╗ ███╗███╗ ██╗██╗██╗ ██╗██╗ ██╗
██╔════╝████╗ ████║████╗ ██║██║╚██╗██╔╝╚██╗ ██╔╝
██║ ██╔████╔██║██╔██╗ ██║██║ ╚███╔╝ ╚████╔╝
██║ ██║╚██╔╝██║██║╚██╗██║██║ ██╔██╗ ╚██╔╝
███████╗██║ ╚═╝ ██║██║ ╚████║██║██╔╝ ██╗ ██║
╚══════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝╚═╝ ╚═╝ ╚═╝
Declarative NixOS Configuration
'';
environment.etc."omni/branding/about.txt".text = ''
╭───────────────────────────────────────────╮
╭─────────────────────────────────────────────────────╮
│ │
│ ██████╗ ███╗ ███╗███╗ ██╗██╗██╗ ██╗██╗ ██╗│
│ ██╔═══██╗████╗ ████║████╗ ██║██║╚██╗██╔╝╚██╗ ██╔╝│
│ ██║ ██║██╔████╔██║██╔██╗ ██║██║ ╚███╔╝ ╚████╔╝ │
│ ██║ ██║██║╚██╔╝██║██║╚██╗██║██║ ██╔██╗ ╚██╔╝ │
│ ╚██████╔╝██║ ╚═╝ ██║██║ ╚████║██║██╔╝ ██╗ ██║ │
│ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝╚═╝ ╚═╝ ╚═╝ │
│ │
│ omnixient │
│ 🚀 Declarative • 🎨 Beautiful • ⚡ Fast │
│ │
╰───────────────────────────────────────────╯
╰─────────────────────────────────────────────────────╯
'';
# Create fastfetch configuration
@ -154,7 +165,7 @@ in
},
{
"type": "custom",
"format": " 󰣇 Preset: ${if cfg.preset == null then "custom" else cfg.preset}",
"format": " 󰣇 Preset: ${cfg.preset or "custom"}",
"keyColor": "magenta"
},
{

4
modules/lib.nix
View file

@ -148,7 +148,7 @@ in
environment.variables = {
OMNI_USER = cfg.user;
OMNI_THEME = cfg.theme;
OMNI_PRESET = if cfg.preset == null then "custom" else cfg.preset;
OMNI_PRESET = cfg.preset or "custom";
OMNI_CONFIG_DIR = helpers.paths.config;
OMNI_CACHE_DIR = helpers.paths.cache;
};
@ -174,7 +174,7 @@ in
echo "Configuration:"
echo " User: ${cfg.user}"
echo " Theme: ${cfg.theme}"
echo " Preset: ${if cfg.preset == null then "none" else cfg.preset}"
echo " Preset: ${cfg.preset or "none"}"
echo ""
echo "Colors (base16 scheme):"
echo " Background: ${helpers.colors.bg}"

2
modules/menus.nix
View file

@ -44,7 +44,7 @@ in
echo -e "''${WHITE} 🚀 Declarative • 🎨 Beautiful • ⚡ Fast''${NC}"
echo
echo -e "''${BLUE}═══════════════════════════════════════════════════════''${NC}"
echo -e "''${WHITE} Theme: ''${YELLOW}${cfg.theme}''${WHITE} │ User: ''${GREEN}${cfg.user}''${WHITE} │ Preset: ''${PURPLE}${if cfg.preset == null then "custom" else cfg.preset}''${NC}"
echo -e "''${WHITE} Theme: ''${YELLOW}${cfg.theme}''${WHITE} │ User: ''${GREEN}${cfg.user}''${WHITE} │ Preset: ''${PURPLE}${cfg.preset or "custom"}''${NC}"
echo -e "''${BLUE}═══════════════════════════════════════════════════════''${NC}"
echo
}

2
modules/scripts.nix
View file

@ -25,7 +25,7 @@ in
echo "│ 🐧 OS: NixOS $(nixos-version)"
echo "│ 🎨 Theme: ${cfg.theme}"
echo "│ 👤 User: ${cfg.user}"
echo "│ 🏠 Preset: ${if cfg.preset == null then "custom" else cfg.preset}"
echo "│ 🏠 Preset: ${cfg.preset or "custom"}"
echo "│"
echo "│ 🔧 Uptime: $(uptime -p)"
echo "│ 💾 Memory: $(free -h | awk 'NR==2{printf "%.1f/%.1fGB (%.0f%%)", $3/1024/1024, $2/1024/1024, $3*100/$2}')"

41
templates/default/README.md
View file

@ -1,41 +0,0 @@
# My Omnixient config
Generated from Omnixient's starter template (`nix flake init -t git+https://git.atitlan.io/aiolabs/omnixient`).
You consume Omnixient as a flake **input** — you do not fork it — so
`nix flake update omni` pulls upstream changes without ever touching
your files.
## Setup
1. **Edit `flake.nix`** — set the `omni.url` to the real repo, and fill
in the `settings` block (user, hostName, timeZone, theme, stateVersion).
2. **Generate your hardware scan:**
```bash
sudo nixos-generate-config --show-hardware-config \
> hosts/myhost/hardware-configuration.nix
```
(Rename `hosts/myhost` to your hostname if you like; keep `flake.nix` in sync.)
3. **Pick packs / options** in `hosts/myhost/default.nix`.
4. **`git add` everything** — flakes only see git-tracked files.
5. **Build & switch** (first build on a flakes-disabled system needs the flag):
```bash
sudo nixos-rebuild switch --flake .#myhost \
--extra-experimental-features "nix-command flakes"
```
## Updating
```bash
nix flake update omni # pull latest Omnixient (a pinned dependency)
sudo nixos-rebuild switch --flake .#myhost
```
This can't conflict with your config — Omnixient is an input, not a checkout.
Roll back by reverting `flake.lock`. Pin a release with
`omni.url = "git+https://git.atitlan.io/aiolabs/omnixient?ref=v1.0.0"`.
## Secrets (optional)
Off by default. To enable, set `omni.secrets.enable = true` and provide
your own age key + `secrets/omni.yaml` — see Omnixient's
`docs/getting-started.md`.

41
templates/default/flake.nix
View file

@ -1,41 +0,0 @@
{
description = "My NixOS machine(s), built on Omnixient";
inputs = {
# Pin Omnixient. Point this at the canonical repo or your own fork, and
# ideally pin a release tag (…/omni/v1.0.0) for reproducible updates:
# nix flake update omni # pull the latest Omnixient, never touches your config
omni.url = "git+https://git.atitlan.io/aiolabs/omnixient";
# Reuse Omnixient's nixpkgs so you evaluate a single package set.
nixpkgs.follows = "omni/nixpkgs";
};
outputs =
{ omni, ... }:
let
# Your identity + machine settings. Omnixient core reads `settings.theme`;
# the home config reads the rest. Edit these.
settings = {
user = "alice";
gitName = "Alice Example";
gitEmail = "alice@example.com";
hostName = "myhost";
timeZone = "America/New_York";
theme = "tokyo-night"; # any module under Omnixient's modules/themes/
sshKeys = [ ]; # e.g. [ "ssh-ed25519 AAAA… alice@myhost" ]
stateVersion = "24.11"; # release you first installed — never change
};
in
{
nixosConfigurations.${settings.hostName} = omni.lib.mkSystem settings.hostName {
system = "x86_64-linux";
user = settings.user;
extraSpecialArgs = { inherit settings; };
extraHmArgs = { inherit settings; };
modules = [
omni.nixosModules.omni # Omnixient desktop/system core
./hosts/myhost # your hardware + option choices
];
};
};
}

33
templates/default/hosts/myhost/default.nix
View file

@ -1,33 +0,0 @@
# Your host. Replace hardware-configuration.nix with your real scan:
# sudo nixos-generate-config --show-hardware-config \
# > hosts/myhost/hardware-configuration.nix
{ settings, ... }:
{
imports = [ ./hardware-configuration.nix ];
# Omnixient behavior. See Omnixient's docs/packs.md for the full pack catalog.
omni = {
enable = true;
desktop.enable = true;
user = settings.user;
theme = settings.theme;
packs.development.enable = true;
packs.media.enable = true;
# packs.gaming.enable = true;
# packs.office.enable = true;
# Opt into sops-nix secrets only if you need them (see Omnixient's
# docs/getting-started.md "Enabling secrets"). Off by default.
# secrets.enable = true;
};
# System basics Omnixient core leaves to you:
networking.hostName = settings.hostName;
time.timeZone = settings.timeZone;
nix.settings.experimental-features = [
"nix-command"
"flakes"
];
system.stateVersion = settings.stateVersion;
}

43
templates/default/hosts/myhost/hardware-configuration.nix
View file

@ -1,43 +0,0 @@
# PLACEHOLDER hardware scan — REPLACE before building on real hardware:
# sudo nixos-generate-config --show-hardware-config > hardware-configuration.nix
#
# This generic stub only lets the template evaluate. The by-label devices
# below will NOT match your machine — a real scan captures your actual
# disks, filesystems, kernel modules, and CPU microcode.
#
# hostPlatform is set by Omnixient's mkSystem; the bootloader (systemd-boot)
# by Omnixient core — so this file only needs filesystems.
{
config,
lib,
modulesPath,
...
}:
{
imports = [ (modulesPath + "/installer/scan/not-detected.nix") ];
boot.initrd.availableKernelModules = [
"xhci_pci"
"nvme"
"ahci"
"usbhid"
"sd_mod"
];
boot.initrd.kernelModules = [ ];
boot.kernelModules = [ ];
boot.extraModulePackages = [ ];
fileSystems."/" = {
device = "/dev/disk/by-label/nixos";
fsType = "ext4";
};
fileSystems."/boot" = {
device = "/dev/disk/by-label/boot";
fsType = "vfat";
};
swapDevices = [ ];
networking.useDHCP = lib.mkDefault true;
}