Because hitting 'q' closes the search mode ;)

I was trying to find why a derivation was taking up so much space. The best way I could figure out how to do it, with any tools, was to use nix-tree --derivation (without derivation I got basically no information). Unfortunately, when I use --derivation, the sizes nix-tree displays are the size of the .drv files, not the size of the outputs they correspond to, so I had to go through the tree and manually check each one with nix path-info -sh. I would really like it if there was a feature where I could see all derivations needed by a particular derivations, and how big their closures were.

please add a command to check for the package version (--version)

Utku,

First off, thank you for having built nix-tree; I have found it very valuable in the past for verifying that certain dependencies have been completely updated (or purged).

Second, regarding flakes support: while I know there may have been no way for you to know this, fyi, I had been relying on flakes support in nix-tree and in fact, I had chosen nix-tree from among competing tools in part because it supported flakes — and so you can imagine I was somewhat caught by surprise yesterday when I found that 415a0ac had removed this capability.

Anyway, regarding what to do: in the short term, I and any other flakes users who run into this will be fine since we can simply nix run github:utdemir/nix-tree?rev=e313e84e474d03b29ff63d05ba813994da2f6a1e and move on with our day — and I completely understand if flakes are too burdensome to support, in which case documenting a workaround like this may be the best move.

Alternatively, though, if you’re open to it: have you given thought to what would it take to bring back flakes support in a way that was comfortable and sustainable for you (and for any other relevant maintainers)?

Thanks in advance for considering,

Michael

steps to reproduce

1. open nix-tree
2. type ? to get help window
3. type q to exit the help window

Expected: help window(modal) is closed
What actually happens: Nothing happens

relevenat source code

By studying the source code I found this https://github.com/utdemir/nix-tree/blob/main/src/App.hs#L287 so it seems that q should close the help window but it never does

Would it be possible to track 3 sizes: the package size and closure size like now, and the "single-owner" closure size?

Right now, if two packages depend on the same thing, the ownership is muddled. So I wonder if it would be more obvious if we could see the closure size of things that are not shared with other closures at the same or closer distance from the root?

Given this tree:

A -> D
B -> D
C -> A, E
D
E -> D
F -> A,C
root -> F,B

the sizes would be

This would show us that F is the biggest package, and while C has a big closure, removing it will only remove E

It's rather complicated to find the menu if you are not aware of its existence. Therefore I propose that we add shortcuts which could hint at the existence of such menu in the lower right corner of nix-tree.

Something similar to gitui's approach could prove to be helpful: (forgive the horrible theming)

This utility does not support an --impure argument, like other flake commands.

Would be very cool if nix-tree would allow to quickly view the selected derivation. Right now it can be done by switching to a different terminal to run nix show-derivation manually, but that's not so convenient.

1. Open nix-tree
2. Press q to exit
3. Observe no more cursor in my shell

Reproduced using bash in mlterm and xterm.

nix-tree 0.4.0

Atemu/nixpkgs@ae92c82
Atemu/nixos-config@8a269a5

If you want to included this in a nix flake for example, or if you build packages via a different machine, you would need to be able to inject system to sources.nixpkgs { }. See this for example: nmattia/niv#95 (comment)

Or provide an overlay that don't refer to any specific nixpkgs could be used instead.

It would be nice if nix-tree would also display meta information for each package, like for example the license.

Hi, it would be nice if you offered to use nix-tree as a library as follows:

• move the other-modules to a library
• have the executable only contain the main module

Thanks in advance :)

Some dependencies show up blue. What does the blue text mean?

I am unable to use the tool with the pandoc development flake.

Here's the error message:

user@host ~/pandoc (main) [1]> nix-tree --derivation '.#'

error: attribute 'pandoc' missing

       at /nix/store/rw4gbrv5y2m59am2m1zc253hv1mbw1fs-source/flake.nix:42:28:

           41|         # Default package.
           42|         packages.default = self'.packages.pandoc;
             |                            ^
           43|
(use '--show-trace' to show detailed location information)
nix-tree: Received ExitFailure 1 when running
Raw command: nix path-info --json --derivation --extra-experimental-features "nix-command flakes" .#

Here's the nix-info output:

 - system: `"x86_64-linux"`
 - host os: `Linux 6.1.26, NixOS, 23.05 (Stoat), 23.05.20230430.da45bf6`
 - multi-user?: `no`
 - sandbox: `yes`
 - version: `nix-env (Nix) 2.13.3`
 - channels(root): `""`
 - nixpkgs: `not found`

And here are the steps to reproduce:

git clone https://github.com/jgm/pandoc
cd pandoc
nix-tree --derivation '.#'

To mention it, this is something I try in order to fix jgm/pandoc#8818. There's also a nixpkgs update request for pandoc: NixOS/nixpkgs#221165

I've run into a specific case where nix-tree will lock up.
What I'm doing is:

• run nix-shell -p nix-tree --run "nix-tree --derivation /nix/store/aq69wwnfqb5c62kk6vaafc3x9kj37cjp-newsboat-2.28-vendor.tar.gz.drv"
• use / to search for headers
• select the second linux-headers-5.18.drv entry
• press w

The process becomes unresponsive. This is repeatable.
I'm not sure what's specific about that dependency - others open the "why-depends" window without issues.

Flakes is an experimental feature, so it would be nice to also support standard features.

https://github.com/edolstra/flake-compat is an easy way to do that.

Currently the search modal searches case-sensitively, and I think case-insensitive search is more convenient.

Hello,

is it possible to search for a certain package without to navigate through the tree?
like libspatialindex

• and it would go directly to that/those packages found in that hierarchy

and / or
searching for libspatialindex it would get me python3.7-rtree-0.9.3 and other which use it as dependency

I have the problem that I have been executing nix builds in many different directories over time and therefore there are tons of result files and corresponding gcroots in /nix/var/nix/gcroots/auto.

I know there is nix-du for gcroot visualization. I have never really used it, but as I understand it, you have to execute the program, pipe it into a renderer, inspect the graph and then execute command manually to free the space. Sounds still quite inconvenient to me.

I have the feeling, a UI like the one of nix-tree would be perfectly suited. It's already possible to inspect individual gcroots via nix-tree.
I can, for example execute nix-tree /nix/var/nix/gcroots/auto/0k6bnn1z76mfddabj8b1pmfkvygms6m3 which will show me the tree and closure size of that single gcroot.

It would be nice if I could zoom out one more step and see all my gcroots listed (preferably sorted by closure size).
Then I can conveniently scroll through them and hit the delete button on the ones which I'd like to delete.

I'm aware of the fact, that finding out how much space a gcroot can actually free is not trivial, since some of it's dependencies could also be blocked by another root.
But I'd guess that the total closure size would already give a good enough estimate.

Why would this help improve the project?

Reason: to shed light on the new terminology for someone who has previously not encountered these terms prior to their first interaction with nix-tree.

Also, a man-page similar to nix would be appreciated. That is to say that nix-tree --help redirects the user to the man-page itself.

Alternative solution: create a "man page" that an be accessed inside the application through ? + m or something of that sort.

Please add a --file flag, such as is supported by nix path-info, so I can view the tree for things that haven't been flakeified yet.

see https://nixos.org/manual/nix/stable/release-notes/rl-2.19 for details

Currently nix-tree fails with nix-tree: user error (Failed parsing nix path-info output.)

Whenever I use the yank function, the store path is copied to the clipboard correctly, but nix-tree stops responding to any further input. I'm not sure how to debug any further, any suggestions?

is there a way to change the squence of listing in nix-tree

• the size is default, but less helpfull if I would like to check for certain packages

I often need to examine what an output directory contains and what an input source directory contains. Would be nice to also be able to nix show-derivation ... for a .drv under the cursor.

nix-tree

error: --- Error --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nix
experimental Nix feature 'nix-command' is disabled; use '--experimental-features nix-command' to override
nix-tree: Received ExitFailure 1 when running
Raw command: nix path-info --recursive --json /nix/store/qs3lsq6ggyii84hpi4k6mkczqw713ipp-user-environment /nix/store/y8kc459plbj2g3s50mbz1nlxcv104zcy-nixos-system-nixosP33-20.03.2652.076c67fdea6

Thanks for nix-tree! It's great. I love these tools that take advantage of all the great information available from the Nix packaging system.

One thing I'd really like to use nix-tree for is to help better understand file collisions (in particular, when building Python environments).

From time to time I accidentally build a Python environment that includes two derivations of the same Python package. Sometimes this is because two upstream versions of the Python package are being included but more often the upstream version is the same and something about the Nix derivation has changed (eg, versions of dependencies).

If I use nix-tree to inspect this situation then I don't learn much because nix-tree convenient chops off the output hash portion of the store object name. Thus, I see that my Python environment includes "python3.7-autobahn-21.3.1.drv" and "python3.7-autobahn-21.3.1.drv".

It would be great if I could tell these apart in nix-tree. Perhaps if nix-tree notices there are duplicates after constructing the short versions of the names, it could append the minimum hash prefix necessary to disambiguate? For example, if one python3.7-autobahn-21.3.1.drv has an output path of /nix/store/z7zhlhp2jqiza7kwa3kdbw7vvd918gyz-python3.7-autobahn-21.3.1 and the other has an output path of /nix/store/z86hmnd5hiyqy4y2p96macy2v6qz84bn-python3.7-autobahn-21.3.1 then they could be displayed in nix-tree as "python3.7-autobahn-21.3.1.drv (z7)" and "python3.7-autobahn-21.3.1.drv (z8)".

Currently, passing a symlink to a store path only works if it is a an output, rather than a derivation (*.drv). This is because we pass a special flag to nix path-info to handle derivations (see the commit 321d213 for details), and we only do that if the given path ends with .drv; which is not the case if it is hidden behind a symlink.

We should resolve the symlinks and check if the symlink target ends with .drv instead.

Hi!

Thank you for developing this tool!

I was wondering if it is feasible to include a way to inspect reverse dependencies? Specifially, I was thinking about a way to add information obtained from nix-store --query --referrers. I need this command quite often, and it is very long (and hard to remember).

Thanks for you input!

Dominik

Hello,
how can I export the whole hierarchy?

When hitting a bound key like / before the progress bar starts crashes the application.

$ nix-tree
    <----- hit / here
[================================================================] 100/1000
Segmentation fault (core dumped)

$ coredumpctl info
           PID: 940334 (nix-tree)
           UID: 1000 (sandro)
           GID: 100 (users)
        Signal: 11 (SEGV)
     Timestamp: Wed 2023-10-11 21:07:43 CEST (10min ago)
  Command Line: nix-tree
    Executable: /nix/store/yzx1qnx565xf503d5dl8i2jaxdjmrm8k-nix-tree-0.3.1/bin/nix-tree
 Control Group: /user.slice/user-1000.slice/[email protected]/app.slice/app-org.wezfurlong.wezterm-e1338bfae42347a4a4856fe3dfe4e330.scope
          Unit: [email protected]
     User Unit: app-org.wezfurlong.wezterm-e1338bfae42347a4a4856fe3dfe4e330.scope
         Slice: user-1000.slice
     Owner UID: 1000 (sandro)
       Boot ID: ee11cac9e3a3481fb94c71275e6636df
    Machine ID: 8e73d0d11fdd49d7978013517a64a46f
      Hostname: magnesium
       Storage: /var/lib/systemd/coredump/core.nix-tree.1000.ee11cac9e3a3481fb94c71275e6636df.940334.1697051263000000.zst (present)
  Size on Disk: 13.1M
       Message: Process 940334 (nix-tree) of user 1000 dumped core.
                
                Module libffi.so.8 without build-id.
                Module libgmp.so.10 without build-id.
                Module libncursesw.so.6 without build-id.
                Module nix-tree without build-id.
                Stack trace of thread 940344:
                #0  0x00007f681a882dfe free (libc.so.6 + 0x95dfe)
                #1  0x00007f681aab61fe really_free_termtype (libncursesw.so.6 + 0x401fe)
                #2  0x00007f681aab6ad5 del_curterm_sp (libncursesw.so.6 + 0x40ad5)
                #3  0x00000000007b3ac7 n/a (nix-tree + 0x3b3ac7)
                #4  0x00000000007b3d61 n/a (nix-tree + 0x3b3d61)
                #5  0x00000000007aae1d n/a (nix-tree + 0x3aae1d)
                #6  0x00000000007ac37c n/a (nix-tree + 0x3ac37c)
                #7  0x00000000007b155c n/a (nix-tree + 0x3b155c)
                #8  0x00007f681a872dd4 start_thread (libc.so.6 + 0x85dd4)
                #9  0x00007f681a8f49b0 __clone3 (libc.so.6 + 0x1079b0)
                
                Stack trace of thread 940335:
                #0  0x00007f681a8e374c read (libc.so.6 + 0xf674c)
                #1  0x00000000007caaae n/a (nix-tree + 0x3caaae)
                #2  0x00007f681a872dd4 start_thread (libc.so.6 + 0x85dd4)
                #3  0x00007f681a8f49b0 __clone3 (libc.so.6 + 0x1079b0)
                
                Stack trace of thread 940334:
                #0  0x00000000006daeac n/a (nix-tree + 0x2daeac)
                ELF object binary architecture: AMD x86-64

The store path is not always "/nix/store". Nix has the default value set via a compilation option:

nix = prev.nix.override {
  storeDir = "/path/to/nix/store";
  stateDir = "/path/to/nix/var";
};

And can be overridden at runtime by setting the NIX_STORE_DIR environment variable.

The current value can be learned by running

# nix eval --raw '(builtins.storeDir)'
/path/to/nix/store

I get constant ~10% CPU usage, even though the application is idling in background.

Hi! I don't know if nix-tree would be an appropriate place for this kind of a "generic" feature, but I think it'd be lovely to be able to do something like this:

❯ nix shell nixpkgs#nix-du nixpkgs#xdot
❯ nix-tree --derivation .#nixosConfigurations.$(hostname).config.system.build.toplevel --graphviz | xdot -i

...and nix-tree already provides the convenient interface of "installables" for the task of enumerating the full closure

❯ nix-du -s=500MB | xdot -

I have a long dependency chain, and I can't get to its start. Please allow for some arrow-key scrolling in why-depends mode.

I'd like to be able to see the packages that depend on e.g. Perl, and their parents.

Ideally, you'd be able to search for "perl", and then the tree makes it obvious which packages transitively and which directly depend on it. Perhaps just don't show the ones that don't depend?

Hello, first of all: thanks for this tool, it's really nice to get some insight on a derivation :)

It's been some time that I switched completely to flakes, and recently I tried to run:
nix run unstable#python3.pkgs.ipython
which downloaded a lot of packages before working.

I wanted to get some insight with nix-tree and intuitively tried to do:
nix-tree unstable#python3.pkgs.ipython
⚠️ but that didn't work, basically saying that it's not a store path.

Would it be possible to add support for that?

The latest stable release of Nix doesn't recognize the --derivation option passed to path-info. I assume this is only available in Nix 3.0?

$ nix-tree $(nix-instantiate --expr "let pkgs = import <nixpkgs> {}; in pkgs.hello")
warning: you did not specify '--add-root'; the result might be removed by the garbage collector
error: unrecognised flag '--derivation'
Try 'nix --help' for more information.
nix-tree: Received ExitFailure 1 when running
Raw command: nix path-info --recursive --json --derivation /nix/store/ivs7c8av0mpy3j6mwdd7z7gikips17m2-hello-2.10.drv

$ nix --version
nix (Nix) 2.3.10

I would like to have the sizes displayed in ISO/base 10 units (MB, GB, TB). All programs on my system use these units and it would be nice if i could set nix-tree to do the same, so that i have a homogenous display.

Could you please add a flag for that?

Hey there! I sometimes use nix-tree to solve issues with duplicate Python dependencies, and it can be quite hard to keep track of which specific versions of a dependency I've already checked out (especially if there are many different versions in the closure).

It would be great if there was a keybind to hide/"cross out" the currently selected closure for the remainder of the session (or perhaps until restored through a keybind) so that it or anything it closes over does not show up in search results anymore. That would really help a lot!