# This Nix flake packages AI tools that are awkward to install by hand

> The nixified-ai flake packages ComfyUI and other generative AI applications for NixOS and Linux, with a binary cache so the builds are substitutable, and a WSL path that borrows the Windows host GPU. Its InvokeAI and textgen outputs are marked deprecated for lack of funding, and its licence is mid-transition from AGPL to MIT.

**nixified-ai/flake** — A Nix flake for many AI projects

- Repository: https://github.com/nixified-ai/flake
- Stars: 841 · Forks: 95
- Language: Nix
- License: AGPL-3.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/nixified-ai-flake

## The packaging problem it takes off your hands

The stated goal of nixified.ai is to simplify and make available a large repository of AI executable code that would otherwise be impractical to run yourself, due to package management and complexity issues.

That is a fair characterisation of what these applications are like. A generative AI web interface is usually a Python application with a specific set of pinned packages, a GPU driver stack, a set of custom nodes and a directory of model weights, and the instructions assume a particular Linux distribution. Nix exists to describe that whole environment declaratively, and this flake is the place where somebody else has already done that description for a set of projects.

The outputs run primarily on NixOS or Linux, and the README notes they can also run on Windows through NixOS-WSL, using the GPU of the Windows host automatically because the wrapper script sets LD_LIBRARY_PATH to point at the host drivers. That is a genuinely useful trick for people who want a working GPU stack on a machine that is not a clean Linux install.

The primary language of the repository is Nix, and the top level is thin: flake.nix, flake.lock, a flake-modules directory, a .gitmodules file, an AUTHORS file, an AGENTS.md file and the two licence files. The structure of the work is in flake-modules, which is where the project-specific packaging lives.

## Running ComfyUI, and the warning that comes with it

ComfyUI, a modular node based Stable Diffusion WebUI, is the current main output of the flake, and the README gives the exact invocation with a pinned commit hash.

```
$ nix repl
nix-repl> :lf github:nixified-ai/flake
Added 26 variables.

nix-repl>
```

That is the recommended way to explore what the flake offers, and the note about tab completion is the practical advice. Loading the flake in the repl adds 26 variables, which is how you discover the output names and their attributes without leaving your terminal.

The run commands look like this.

```
- `nix run github:nixified-ai/flake/2aeb76f52f72c7a242f20e9bc47cfaa2ed65915d#invokeai-nvidia`
- `nix run github:nixified-ai/flake/2aeb76f52f72c7a242f20e9bc47cfaa2ed65915d#invokeai-amd` (Broken due to lack of Nixpkgs ROCm support)
```

Note the commit hash in the URL. The flake reference is pinned to a specific revision rather than to a branch, which is what makes a run reproducible, and it is the same revision for both the working and the broken output.

The warning attached to the ComfyUI section is the part a first-time user must not miss. The output will give you an empty ComfyUI without custom nodes or models, and the README points to flake-modules/projects/comfyui/README.md for how to configure and use it. In other words, the flake delivers the application environment, not the model weights or the community node ecosystem, and those are large enough to be a separate problem with its own instructions.

## The binary cache is what turns this from a build project into a download

Running an AI application from source is slow, and the flake's answer to that is a binary cache. The README explains that to make binary substitution work and save time building packages, you have to tell nix to trust nixified-ai's binary cache.

On NixOS that means two lines in the system configuration, followed by a rebuild.

```
    nix.settings.trusted-substituters = ["https://ai.cachix.org"];
    nix.settings.trusted-public-keys = ["ai.cachix.org-1:N9dzRK+alWwoKXQlnn0H6aUx0lU/mspIoz8hMvGvbbc="];
```

On another distribution the same two lines go into /etc/nix/nix.conf. The README adds a useful detail, that the trusted-public-keys line will usually already be there and you only need to append the ai.cachix.org key, so you are not replacing your existing cache configuration.

```
    trusted-substituters = https://ai.cachix.org
    trusted-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= ai.cachix.org-1:N9dzRK+alWwoKXQlnn0H6aUx0lU/mspIoz8hMvGvbbc=
```

This is the mechanism that makes the flake worth the trust decision. Without the cache, every user rebuilds the same dependency closure. With it, the closure is downloaded and verified against the public key, and the trust you are extending is to the cache operator rather than to a build you ran yourself.

## Two outputs are marked deprecated for lack of funding

The InvokeAI and textgen outputs sit inside a details block titled Deprecated Packages, with the reason given as lack of funding. Both carry the same warning, that they are unmaintained and you have to use the last working commit in order to use them.

InvokeAI is a Stable Diffusion WebUI, and textgen is oobabooga's text-generation-webui, described as a web interface for LLMs and LoRA training. Their commands are given in the same pinned form, with the hash.

```
- `github:nixified-ai/flake/2aeb76f52f72c7a242f20e9bc47cfaa2ed65915d .#textgen-amd`
- `github:nixified-ai/flake/2aeb76f52f72c7a242f20e9bc47cfaa2ed65915d .#textgen-nvidia`
```

This is the most useful thing the README says, because it is a signal about the project rather than about the software. The package descriptions here are unmaintained, and the reason is funding rather than technical difficulty, which means the same fate is plausible for the others.

The release history supports the point. The two published releases, named 1 and 2, are both dated 2023-10-19, and the commands in the README still reference the 2023 era commit hash. The last push to the repository was on 2026-10-20, so the flake itself is being touched, but the tagged releases have not moved in three years.

## A licence that is deliberately in motion

The licence section is the most unusual paragraph in the README, and it deserves a careful reading rather than a summary.

The code was initially published under the AGPL licence, apart from the code in flake-modules/packages, which was published under MIT. Then on February 3rd 2026 a transition to the MIT licence was initiated. Contributions from that date are licensed under both AGPL and MIT, in the LICENSE and LICENSE-MIT files, until all significant past contributors agree to re-licensing their contributions as MIT, from which point all further contributions are licensed under the MIT licence alone.

That is a re-licensing process with an explicit condition, and the condition is social rather than technical. It requires the agreement of the people who wrote the code. The dual licensing of new contributions is the bridge: a contributor who cannot agree to the re-licensing has their work available under AGPL terms in the meantime.

GitHub's classification of the repository licence is recorded as AGPL-3.0, which is accurate for the current state and will change when the process completes. If you are building something on this flake and your own compliance process cares about copyleft, read both licence files and check the AUTHORS file, which is the natural place to look for the significant past contributors the process refers to.

## When this flake is the wrong answer

Four cases rule it out.

The first is AMD hardware. The invokeai-amd output is marked as broken due to a lack of Nixpkgs ROCm support, and that is a structural problem, since it lives in the package set the flake is built on rather than in the flake itself.

The second is a project that needs a maintained upstream. The two older outputs are deprecated, and the reason given is funding. If you need InvokeAI or textgen to keep working as those projects evolve, a flake whose packaging is frozen at a 2023 commit will drift away from the software, and the drift is on the flake's side.

The third is a user who does not want to extend trust to a third party cache. The binary cache is the difference between a quick install and a long build, but it means trusting ai.cachix.org and its key. The alternative is to build locally, which is exactly the situation the cache exists to avoid.

The fourth is a Windows user without WSL. The README is specific that Windows works through NixOS-WSL, with the host GPU used via LD_LIBRARY_PATH in the wrapper. That is a workable route, but it is a route, not native support.

For a Linux user on NVIDIA hardware who wants a working ComfyUI today, the flake with the cache is a strong answer, and the pinned commit hash in the run command is what makes it reproducible.

## Conclusion

The nixified-ai flake fits a Linux or NixOS user who wants to run ComfyUI or similar tools without fighting Python environments, CUDA or ROCm libraries and model directories, since the flake plus its binary cache turns a multi hour build into a download. It is the wrong choice for an AMD user, since the README marks the invokeai-amd output as broken for lack of Nixpkgs ROCm support, and it is a poor base for anything that needs a maintained upstream, because the two older outputs are explicitly deprecated for lack of funding. Before adopting it, read the empty install warning for ComfyUI, add the cache keys to your nix configuration, and check the licence files, since the project is partway through a switch from AGPL to MIT.

## FAQ

### What does the nixified-ai flake provide?

It is a Nix flake that packages AI executable code, currently ComfyUI as the main output, with InvokeAI and textgen deprecated for lack of funding. The stated goal is to make such applications available without the package management and complexity problems of installing them by hand.

### How do I run ComfyUI from the nixified-ai flake?

Use a pinned revision and the output name, for example nix run github:nixified-ai/flake/2aeb76f52f72c7a242f20e9bc47cfaa2ed65915d#invokeai-nvidia. The README warns that this gives you an empty ComfyUI without custom nodes or models, and points to the project README in flake-modules for configuration.

### How do I enable the nixified-ai binary cache?

Add https://ai.cachix.org to trusted-substituters and the ai.cachix.org public key to trusted-public-keys, in /etc/nixos/configuration.nix on NixOS or in /etc/nix/nix.conf elsewhere. The README notes that the public keys line is usually already present and only needs the ai.cachix.org key appended.

### Can I run these AI tools on Windows?

Yes, through NixOS-WSL. The wrapper script sets LD_LIBRARY_PATH so the Windows host GPU drivers are used, so the tools can take advantage of the host GPU automatically.

### What license is the nixified-ai flake under?

The code was initially published under AGPL, apart from flake-modules/packages which was MIT. A transition to MIT began on February 3rd 2026, with contributions from that date dual licensed under both AGPL and MIT until the significant past contributors agree to re-licensing.

## Sources

- [Issues](https://github.com/nixified-ai/flake/issues)
- [License: AGPL-3.0](https://github.com/nixified-ai/flake/blob/master/LICENSE)
- [nixified-ai/flake on GitHub](https://github.com/nixified-ai/flake)
- [README](https://github.com/nixified-ai/flake/blob/master/README.md)
- [Releases](https://github.com/nixified-ai/flake/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nixified-ai-flake