# Jovian NixOS, a NixOS configuration set for the Steam Deck and other x86 handhelds > Jovian NixOS is a set of packages and configurations for running NixOS on the Steam Deck, built as a Nix flake with a pinned nixpkgs, an overlay, NixOS modules and support scripts. It is a community project whose contributors are also active in the nixpkgs ecosystem, and it is designed to keep the Deck useful as a gaming machine while gaining the NixOS package model. **Jovian-Experiments/Jovian-NixOS** — Discussions: https://matrix.to/#/#Jovian-Experiments:matrix.org - Repository: https://github.com/Jovian-Experiments/Jovian-NixOS - Website: https://jovian-experiments.github.io/Jovian-NixOS/ - Stars: 1,036 · Forks: 91 - Language: Nix - License: MIT - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/jovian-experiments-jovian-nixos ## What the project is, and what it is not The one-line description is precise: a set of packages and configurations for running NixOS on the Steam Deck, and the repository is also stated to be useful for obtaining a Steam Deck-like experience on other x86 devices. That second clause is the one to notice, because it defines the project's real shape. This is not a Linux distribution and it is not a fork of NixOS. It is a layer of Nix expressions that sits on top of a standard NixOS configuration, supplying the pieces that make a generic x86 system behave like a Deck: the handheld form factor, the controls, the display and power behaviour that make a Steam Deck pleasant to use rather than merely portable. The homepage of the project is a documentation site, and the README doubles as the index page for that site, which is a small sign of how the project is organised: the repository is the source and the website is generated from it. ## A flake on top of a pinned nixpkgs The repository layout is the standard modern Nix arrangement and it tells you most of the technical story. At the top there is a `flake.nix` with a matching `flake.lock`, which is the modern way to declare and pin a Nix package set, together with a `default.nix` for the traditional entry point, an `nixpkgs.nix` and an `overlay.nix`. The presence of both `nixpkgs.nix` and `flake.lock` is the interesting part, because it means the project pins its package source in two places. The `flake.lock` records the exact revisions of the flake inputs, which is what makes a build reproducible: a user who builds the flake gets the same nixpkgs revision the project locked, not whatever nixpkgs happens to be current. The `nixpkgs.nix` file then names the source the configuration is built against, and the overlay is the layer where the project's own packages are added on top of the upstream ones. Nothing in the visible documentation explains the difference between the two pinning mechanisms, which is a fair thing to want answered before you rely on either. ## The tree, module by module The directory names describe a normal Nix project layout and each one has a job. `modules/` holds the NixOS modules, which is where the actual system configuration lives: the options a user sets and the code that turns them into a system. `pkgs/` is where the packages the project builds itself are defined, and `overlay.nix` is the entry point that exposes them to the rest of the package set. `support/` holds supporting scripts and helpers, `docs/` holds the documentation including the getting started and configuration pages, and `artwork/` holds the images used by that documentation. There is a `.ci/` directory for continuous integration, a `.gitignore`, and an `.envrc` file, which is the direnv entry that loads a development environment when you enter the directory. The default branch is development rather than main, which for a Nix project is a reasonable convention but worth knowing before you clone, since the branch you get decides which revision of the pinned inputs you build against. The top level of the tree looks like this. ```text flake.nix flake.lock nixpkgs.nix overlay.nix default.nix modules/ pkgs/ support/ docs/ ``` ## Who works on it, and how to reach them The people behind the project are described in one line that says more than a list of names would: most of the contributors are also contributors to the nixpkgs and NixOS Linux ecosystem. That is the relevant fact for an adopter, because it means the project is not a collection of patches held together outside the ecosystem but a group of people who already work in it. The stated motivation is equally plain: they are a few people who want to keep their Steam Deck useful as a gaming device while also benefiting from NixOS. That framing matters for scope, because it explains the project's priorities, which are the handheld experience rather than a general purpose NixOS distribution. Support has three channels, and they are distinct: bugs go to the issue tracker, questions go to the discussions page, and the Matrix room at `#Jovian-Experiments:matrix.org` is where the chat happens. The README also points to a contributing page, and the project asks that people filing issues look there first. ## Where the project will not help you The limits are structural, and they are visible in the description rather than hidden. This is a configuration set, not an operating system, so there is no installer, no image and no default user experience: you need to know how to assemble NixOS configurations before the project becomes useful to you. If your goal is to get a working Linux on a handheld with a desktop environment and some games, a mainstream distribution image will get you there in an evening, and this project will not. The second limit is hardware coverage. The documentation is structured around the Steam Deck, and the note that the repository is also useful for other x86 devices implies that other devices need you to supply the parts that are Deck specific, which is the opposite of the project doing the work for you. The third is the maturity question. The repository has no GitHub releases, so there is no version to pin in the release sense, and the pinned nixpkgs revision in the lock file is the only stability guarantee on offer. The last push was on 2026-10-14, so the work is current even if the packaging is not formalised. ## Conclusion Adopt Jovian NixOS if you own a Steam Deck or another x86 handheld and want the NixOS package model on it without assembling the hardware support yourself, and skip it if you are comfortable writing NixOS modules for your own device profile, because that is what this repository is. Verify three things before you install it: that the getting started page in the docs directory matches the device you have, since the repository is also usable for non Deck x86 machines and the hardware handling differs; which nixpkgs revision the flake is pinned to, because the pinned input determines the package versions you get; and that you read the configuration page, because the project describes itself as a set of packages and configurations rather than a complete operating system image. ## FAQ ### What is Jovian NixOS? It is a set of packages and configurations for running NixOS on the Steam Deck, and the repository is also described as useful for obtaining a Steam Deck-like experience on other x86 devices. The project is a layer of Nix expressions on top of NixOS rather than a distribution of its own. ### What files does the Jovian NixOS repository contain? A flake.nix with a flake.lock, a default.nix, a nixpkgs.nix and an overlay.nix, plus directories for modules, packages, support scripts, documentation and artwork, along with a .ci directory, a .envrc and a COPYING file. The default branch is development. ### Who maintains Jovian NixOS and how do you contact them? Most of the contributors are also contributors to the nixpkgs and NixOS Linux ecosystem. Bugs go to the issue tracker, questions to the discussions page, and chat happens in the Matrix room at #Jovian-Experiments:matrix.org, with e-mail for anything else. ### Is Jovian NixOS a full operating system image? No. It is described as a set of packages and configurations, so there is no installer or image. Using it means assembling a NixOS configuration yourself, with the project supplying the handheld specific parts. ## Sources - [Issues](https://github.com/Jovian-Experiments/Jovian-NixOS/issues) - [Jovian-Experiments/Jovian-NixOS on GitHub](https://github.com/Jovian-Experiments/Jovian-NixOS) - [License: MIT](https://github.com/Jovian-Experiments/Jovian-NixOS/blob/development/LICENSE) - [Project website](https://jovian-experiments.github.io/Jovian-NixOS/) - [README](https://github.com/Jovian-Experiments/Jovian-NixOS/blob/development/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jovian-experiments-jovian-nixos