# Mobile NixOS: NixOS Software Support for Mobile Devices > Mobile NixOS extends NixOS, Nixpkgs, and Nix to mobile hardware, with device-specific modules and examples organized in this repository. It suits users who can build against Nixpkgs unstable, but the documentation does not provide published installation artifacts. **mobile-nixos/mobile-nixos** — 📱 (rebooting... please wait...) - Repository: https://github.com/mobile-nixos/mobile-nixos - Website: https://mobile-nixos.github.io/ - Stars: 1,393 · Forks: 247 - Language: C - License: MIT - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/mobile-nixos-mobile-nixos ## What Mobile NixOS adds to NixOS Mobile NixOS is a project-specific extension of the NixOS ecosystem. The README describes it as a superset of NixOS Linux, Nixpkgs, and Nix whose purpose is to abstract away differences between mobile devices. In practical terms, the repository is concerned with adapting NixOS concepts to hardware that is not treated as an ordinary desktop target. The phrase “NixOS, on your phone” summarizes the intended result, but the repository is not presented as a separate general-purpose Linux distribution. The intended audience is developers and technically experienced users who already understand NixOS or are prepared to use the NixOS Manual, the Nixpkgs Manual, and the Nix Package Manager Manual. Mobile NixOS does not remove the need to understand Nix expressions, package selection, modules, and the wider NixOS configuration model. Its value is the device-facing layer and the project examples, rather than a separate user interface for installing Linux on a phone. The repository layout supports that interpretation. Directories such as `devices/`, `modules/`, `boot/`, and `support/` indicate separate areas for supported-device definitions, NixOS modules, boot-related work, and supporting infrastructure. The `examples/` directory contains projects including `hello/`, `installer/`, `phosh/`, `target-disk-mode/`, and `testing/`. These names suggest that Mobile NixOS is both a device-support effort and a collection of buildable configurations. The exact device matrix and the contents of every example are not listed in the README, so those parts must be checked in the documentation and repository files before selecting a target. ## Nix-based device abstraction and build flow The documented architecture starts with NixOS and its package ecosystem. Mobile NixOS builds on Nixpkgs and the Nix package manager, then adds project logic for mobile hardware. The repository contains `default.nix`, `pkgs.nix`, `release.nix`, and `shell.nix`, which indicate that device support and example builds are expressed through the normal Nix build model. The `lib/` and `modules/` directories hold reusable implementation pieces, while `devices/` appears to connect those pieces to individual targets. This structure is important because a mobile system is not only an operating-system image. It also needs boot support and device-specific configuration. The presence of `boot/`, `support/`, and `devices/` shows that the project separates these concerns instead of treating every target as a single monolithic image. The README does not document the internal function of each file, so it would be inaccurate to claim that a particular kernel option, bootloader, partition layout, or boot command is universally supported. The `npins/` directory is also visible in the repository. Its presence indicates a structured location for pinned inputs, although the README does not explain the current pinning format or provide a command for changing pins. Likewise, the `overlay/` directory signals project-specific package adjustments, but the README does not list the packages affected. Engineers should therefore treat the repository as a NixOS configuration layer whose exact behavior depends on the selected device, example, package inputs, and documentation. ## Installing Mobile NixOS and building a first example The README does not provide a complete installation tutorial or a single build command for a new user. It explicitly states that there are no published artifacts for the time being and directs readers to the Mobile NixOS website and its documentation. It also warns that Mobile NixOS is only expected to build successfully against the unstable branch of Nixpkgs. Consequently, there is no documented command in the README that can be copied here as a universal first install step. A first practical step is to open the project documentation linked from the README: ```text https://mobile-nixos.github.io/ ``` That site is described as hosting the rendered `doc/` folder. From there, identify whether the intended device is supported and locate the documentation for the relevant example or target. The repository includes `examples/hello/`, which is the most clearly named starting point, and `examples/hello-but-squashfs/`, `examples/installer/`, and `examples/testing/`, which indicate separate build or testing paths. The README does not state which one is appropriate for a particular phone, so the selection must come from the documentation rather than assumption. After locating the target instructions, use the exact commands from that documentation. The repository also includes `examples/common-configuration.nix`, which appears to be shared configuration for examples, but the README does not explain its contents or how it is referenced. No command, device image, build profile, or installation target should be inferred from the directory name alone. The first successful step should be a documented build for a supported device, followed by installation instructions for that same device. ## Supported-device boundary and practical limitations The largest limitation is the gap between the project's ambition and the information available to an adopter. Mobile NixOS aims to abstract away differences between mobile devices, but the README does not claim that every mobile device works. It also does not provide a compatibility table, a guaranteed installation path, or published artifacts. A user cannot infer support merely because a device runs Android or because it has a bootloader. The unstable Nixpkgs requirement adds another constraint. NixOS configuration and package availability can change as Nixpkgs changes, so a configuration that builds against one input set may not build unchanged against another. The project explicitly expects the unstable branch, which makes reproducibility dependent on retaining or identifying the relevant package inputs. The repository's `npins/` directory may help with this, but the README does not explain its operational workflow. The examples also indicate that Mobile NixOS is not limited to a single user experience. `phosh/` suggests a configuration associated with that example, while `target-disk-mode/` and `installer/` describe distinct target concepts. The README does not state whether these examples are production-ready, mutually compatible, or suitable for daily use. They should be treated as documented examples until the associated documentation says otherwise. ## Mobile NixOS and ordinary NixOS builds The real alternative is to use the upstream NixOS, Nixpkgs, and Nix documentation and tooling directly, without the Mobile NixOS layer. That approach is appropriate when the goal is to learn NixOS configuration, maintain a conventional Linux system, or use packages that do not depend on mobile-device support. It avoids Mobile NixOS's device-specific abstraction and its unstable-Nixpkgs expectation. Mobile NixOS takes a different approach because it adds support for the differences between mobile devices, organizes device-related work in dedicated repository areas, and provides mobile-oriented examples. The choice is therefore not simply “NixOS versus another package manager.” It is whether the target requires Mobile NixOS's device and boot abstractions enough to justify working inside its device-specific build structure. A user whose device is documented as unsupported, or whose requirement is limited to ordinary Nix package management, may gain little from adding this project. The upstream manuals listed by the README remain applicable because Mobile NixOS is described as a superset rather than a replacement. That makes the learning cost explicit: users need both the general NixOS model and the project's mobile-device documentation. ## Maintenance signals, upgrades, and licensing The repository is not archived, and its last push was on 2026-07-13. That is a recent development signal based on the repository metadata, but it is not the same as a release or compatibility guarantee. The repository has no GitHub releases, so there is no published release history to use as an upgrade baseline. The README identifies the unstable branch of Nixpkgs as the expected build target. This makes upgrade planning a project-specific concern: users need to know which Nixpkgs state was used for their build and whether the selected device, modules, and packages still evaluate successfully. The README does not document rollback, device migration, release channels, or a supported upgrade procedure. The repository files are licensed under the MIT License. The README also gives an important boundary: the MIT license applies to repository files such as expressions, scripts, and modules, while built packages retain their respective licenses. Patches and derivative works are covered by the licenses of their respective packages. Anyone assembling a distribution image must therefore account for package and patch licensing separately from the repository's own license. ## Conclusion Adopt Mobile NixOS if you want to build a NixOS-based system for a device covered by its support and can work with unstable Nixpkgs. Do not treat it as a ready-made phone image or a general Android replacement, because the repository publishes no artifacts and does not document a universal installation path. Before adopting it, check the device documentation, confirm that the required build inputs are available, and verify the licensing of every package and patch included in the resulting system. ## FAQ ### What is Mobile NixOS? Mobile NixOS is described as a superset of NixOS Linux, Nixpkgs, and Nix that aims to abstract away differences between mobile devices. Its goal is summarized as “NixOS, on your phone.” ### Does Mobile NixOS provide a ready-made installer or published artifacts? The README states that there are no published artifacts for the time being. It directs users to the Mobile NixOS website and documentation for supported-device resources. ### Which Nixpkgs branch should Mobile NixOS use? The README says Mobile NixOS is only expected to build successfully against the unstable branch of Nixpkgs. It does not document a stable-branch build path. ### What license applies to Mobile NixOS? The repository files are licensed under the MIT License. The README clarifies that the license does not automatically apply to built packages, patches, or derivative works, which retain their respective licenses. ## Sources - [Issues](https://github.com/mobile-nixos/mobile-nixos/issues) - [License: MIT](https://github.com/mobile-nixos/mobile-nixos/blob/development/LICENSE) - [mobile-nixos/mobile-nixos on GitHub](https://github.com/mobile-nixos/mobile-nixos) - [Project website](https://mobile-nixos.github.io/) - [README](https://github.com/mobile-nixos/mobile-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/mobile-nixos-mobile-nixos