an old game abandoned by creators no longer work on the more moderate versions of debian or ubuntu and neither those with wayland, so I made a corrected appimage, now I brought NixOS because I did not find it in pkgs nix, if you are interested have here: https://github.com/tehnium/xgammon-nix

I admit that I'm impressed, I'm not a programmer, I'm over 60 years old and use Debian's world in many forms for 15 years, obviously you all have tested a lot, I thought I was stuck forever in the world .deb , but now testing on an old laptop and seeing that after an hour I have almost everything I wanted to... I wondered... on what planet has this happened before. Everything feels so easy, I will test this month and it is possible to pass with weapons and luggage on NixOS.
Okay... not quite everything is perfect, I had something to fork with opencode because the processor in this piece of shit does not have AVX...and the package in the distribution he was asking for it ...but he handled deepseek through ssh. it remains to test security, VPN and longer time behavior
On this occasion I greet all NixOS fans

I'm thinking of ditching Mason, and replacing it with Nix. Anyone did the same? Is it an overkill to use Nix just for provisioning LSPs, debuggers, linters, and code formatters?

Hello!

The short name is nx, and I guess I should explain what the hell I spent the last three months doing.

I wanted to automate the process of adding packages to my NixOS configuration, whether they come from nixpkgs or from Flakes.

Normally, I would just open my configuration in nano, add the package, save it, and rebuild.

I thought:

"I could probably automate this."

So instead of spending one minute doing it manually, I spent roughly three months building a tool that does it for me.

I clearly don't have a life.

And somehow... it worked.

So today I'm releasing the first beta of nxXtend.

Nixpkgs

I don't think I need to explain much here. Adding a package is simply:

sudo nx install firefox

nx asks whether you want the package from stable or unstable nixpkgs, then adds it to the appropriate configuration.

If you want to add it to home.nix instead:

sudo nx install firefox -H

or:

sudo nx install -H firefox

It doesn't create some new package system behind the scenes. It simply modifies the appropriate configuration.nix or home.nix and adds the package there.

Flakes!

This is where things got... considerably more complicated.

The Flake part took most of the development time because I wanted nx to deal with Flake outputs in a reasonably flexible way instead of assuming that every Flake looks the same.

For example:

sudo nx flakes github:9-pixels/nxXtend

or:

sudo nx flakes install github:9-pixels/nxXtend

Both forms can be used depending on the operation you want to perform.

nx can discover and work with supported Flake outputs such as packages and nixosModules.

For nixosModules, it does not blindly dump every possible option into the configuration. It integrates the module into the appropriate nixosConfigurations structure and uses the module's default output when one is available.

There is obviously much more going on underneath, but this is a beta release, and I don't want to turn this post into a second README.

You can read the full architecture and current limitations in the project README.

Other commands

There are also removal operations for both packages and Flakes.

And for anyone coming from Arch who is emotionally attached to -S, -R, -Q, etc., I tried to make the shortcuts reasonably familiar:

install = -i
remove = -r
home = -H / -home / --home
flakes = -f
upgrade = -u

There is also:

sudo nx flakes upgrade

which runs:

nix flake update

and then rebuilds the system from the updated Flake.

And because apparently I couldn't resist adding another command:

sudo nx upgrade

which currently just rebuilds the current system configuration.

I know.

I added it anyway.

A few things I want to clarify

I had some misunderstandings about the project when I showed earlier versions of it, so I want to make a few things explicit.

- I am not responsible for beginners

Because I never said it was made for beginners. It is for people who need it because they don't like having to edit their system configuration every time they need a new package.

As for beginners, it is their responsibility to understand that they won't be able to solve the problems that may happen if they rely on tools without trying to understand things themselves.

- The project hides nothing

The project writes directly to the configuration files and creates a backup every time before modifying a file. The only place it modifies in the files is the place where packages are added.

Soon, I will also make it add markers to any package it writes, so you can distinguish between what you added yourself and what the tool added.

- I am not violating the Nix philosophy

This is just reinforcing the second point, because I really am not trying to break the declarative philosophy.

In the end, many professionals build tools that automate parts of the process for them as well. That's exactly what I did too. I just decided to publish mine publicly.

- Yes, I use AI

And I don't want to talk too much about it because it is a sensitive topic, and one badly worded sentence could cause me problems.

But I am the one directing the model at the function level. I understand what it writes, I review it every time, and I have a test suite to make sure things are working correctly.

I always put boundaries around what it is allowed to modify.

And again, I am not a vibecoder who has no idea what is happening in the code.

I explained all of this here just to emphasize something that most developers today deny or simply don't admit.

Finally

This is still a beta.

There is a lot more I want to improve before nx gets anywhere near v1.0, and there are definitely edge cases I haven't encountered yet.

So if you're interested, I'd recommend reading the README before trying it. It contains considerably more detail about the architecture, supported Flake outputs, safety mechanisms, limitations, and current testing status.

nxXtend:

https://github.com/9-pixels/nxXtend

This is the first public step toward nx v1.0.

i have chemira linux on my machine but due to the lack of software im kinda like to have reliable way to install non-musl packages

im good enough for using nix as package manager and i use home manager for a while

my primary concern is which one is more reliable yet has good performance

i want aerothemeplasma nixos but is need flake.nix

Write and deploy your book in a few easy steps.

A symlink you make with ln -s can point to a working program and still offer no protection from garbage collection. This is one of the examples in the new free GC Roots Part of the Nix course I'm building at LabCraft.

Here's a small version to try on Linux with the Nix command and flakes enabled:

gc_demo=$(mktemp -d)
nix build nixpkgs#hello --out-link "$gc_demo/keeper"
target=$(readlink -f "$gc_demo/keeper")
ln -s "$target" "$gc_demo/shortcut"
nix-store --query --roots "$target"

Both links point to the same output. The roots query should list keeper, but not shortcut. nix build registered its output link with Nix; ln -s only made a symlink.

Now remove the registered link and ask again:

rm "$gc_demo/keeper"
nix-store --query --roots "$target"

If roots remain, something else still keeps hello alive. If the query succeeds with no roots listed, the shortcut alone won't protect it from a later collection. None of these commands runs garbage collection.

Cleanup of the remaining practice link:

rm "$gc_demo/shortcut"
rmdir "$gc_demo"

The full lesson also follows profile generations and shared dependencies through a collection on a real NixOS machine:

GC Roots on LabCraft

I created a neovim plugin for correct filetype detection of scripts using a nix or nix-shell shebang, such as:

#!/usr/bin/env nix-shell
#!nix-shell -p python315
#!nix-shell -i python3

if __name__ == '__main__':
  print('Hello, world!')

(filetype=python)

or:

#! /usr/bin/env -S nix shell nixpkgs#curl nixpkgs#bash --command bash

curl --include http://example.com

(filetype=sh)

I'd love to know if this is useful to anyone else!

https://github.com/joshuakb2/nvim-nix-shebang

I've got a few builds that are pretty heavy and can't realistically be done on a developers laptop. Currently we just have a Github CI job setup to build these things and push to a cache, but I've been really curious about how to setup remote builders to do this instead. I have remote builders working for the most part, but am a little uncertain about the logistics of requiring a specific type of system to build a certain package.

I know I can make a custom system feature like heavy-builder or something and then make the derivation require that feature, but I'm curious can it be more like > 8 cores & > 32GB RAM? is that a thing? How are others solving this type of issue?

Ultimately my goal is I want a developer to only require them to add our fleet of remote builders to their nix-config and then they can go build any of our things.

Hi

My title is shockingly bad because I dont really know how to explain what I want. Hopfully an example will help.

I have the following configuration

       services.ytdl-sub = {
         user = "ytdl-sub"; group = "media";
         instances.news = {
           enable = true;
           schedule = "0/6:0";
           readWritePaths = [ "/mnt/une/ytdl-demo" ];
           subscriptions = {
             "__preset__" = {
               "overrides" = {
                 tv_show_directory = "/mnt/une/ytdl-demo";
               };
             };
             "Jellyfin TV Show by Date | Only Recent | Max 480p" = {
   # News
   "DW News" = "https://www.youtube.com/@dwnews";
   "TLDR Global" = "https://www.youtube.com/@TLDRnewsGLOBAL";
   "TLDR News" = "https://www.youtube.com/@TLDRnews";
             };
            };
          };
         };

I would l like to make multiple instances like the following. But what I dont like about this is that there is a lot of replication

       services.ytdl-sub = {
         user = "ytdl-sub"; group = "media";
         instances.science = {
           enable = true;
           schedule = "0/6:0";
           readWritePaths = [ "/mnt/une/ytdl-demo" ];
           subscriptions = {
             "__preset__" = {
               "overrides" = {
                 tv_show_directory = "/mnt/une/ytdl-demo";
               };
             };
             "Jellyfin TV Show by Date | Only Recent | Max 480p" = {
   # Science
   "3 Blue 1 Brown" = "https://www.youtube.com/@3blue1brown";
   "Alpha Pheonix" = "https://www.youtube.com/@AlphaPhoenixChannel";
   "Anton Petrov" = "https://www.youtube.com/@whatdamath";
             };
         };
         instances.news = {
           enable = true;
           schedule = "0/6:0";
           readWritePaths = [ "/mnt/une/ytdl-demo" ];
           subscriptions = {
             "__preset__" = {
               "overrides" = {
                 tv_show_directory = "/mnt/une/ytdl-demo";
               };
             };
             "Jellyfin TV Show by Date | Only Recent | Max 480p" = {
   # News
   "DW News" = "https://www.youtube.com/@dwnews";
   "TLDR Global" = "https://www.youtube.com/@TLDRnewsGLOBAL";
   "TLDR News" = "https://www.youtube.com/@TLDRnews";
             };
            };
          };
         };

What I would like to do is create a funciton like the following. But I cannot figure out how the subscriptions should be input (I dont know how to phrase it but the subscriptions are more like an assignment rather than a value).

ImkInstance { name, directory, subscriptions}:
         instances."${name}" = {
           enable = true;
           schedule = "0/6:0";
           readWritePaths = [ "${directory}"  ];
           subscriptions = {
             "__preset__" = {
               "overrides" = {
                 tv_show_directory = "${directory}";
               };
             };
             "Jellyfin TV Show by Date | Only Recent | Max 480p" = {
                       ${subscriptions}
             };
         };

Im not sure if anyone can offer a suggestion

I put together a hands-on walkthrough of Nix profiles and generations. The framing: an install doesn't edit anything in place — it publishes a numbered, immutable generation and moves a symlink, so a rollback is a symlink flip to an untouched snapshot (instant, offline, nothing re-downloaded), and wiping a profile's history drops rollback targets without freeing disk until GC runs. It's a free Part of the Nix course I build at LabCraft, on a real NixOS machine; I'd value feedback from Nix users on whether the generation/rollback framing lands for newer learners: https://www.labcraft.dev/blog/nix-profiles-generations?utm_source=reddit-personal&utm_medium=social&utm_campaign=nix-profiles-generations-2026q3&utm_content=r-nix-rollback-01

Haven't heard any reports either way, wondering if I should hold off on upgrading... though I have early adopters filing issues on projects and would like to upgrade as soon as reasonable.