Home | Blog

Scripting is More Fun With Nushell

Sun, 31 Aug 2025 00:00:00 GMT

There are multiple ways to improve your experience in the terminal. You can get a nice prompt with starship. On Linux and macOS, you can switch to the fish shell. A lot of nice things like syntax highlighting, tab completion with help text and inline suggestions simply work out of the box.

However, I went for Nushell. Unlike fish, Nu also works on Windows. Nu’s interactive experience is nearly as nice as fish’s out-of-the-box and just as nice with a few configuration tweaks. Since I don’t use Windows as my daily driver that shouldn’t matter all that much to me, but it can be an extra benefit.

Another common way of use case of shells is for scripting. After experimenting with commands in your terminal, you put the very same commands in a text file. In the case of Nu, you then execute that script with nu script.nu. This is the workflow where shells shine, and Nu is a prime example for that.

So let’s take a look at the pitch on Nu’s homepage:

Nu pipelines use structured data so you can safely select, filter, and sort the same way every time. Stop parsing strings and start solving problems.

When I first read this, it didn’t really resonate with me. Maybe I didn’t write enough shell scripts at that time.

Extract the Top Issues From a Repository

Let’s look at a non-trivial example to find out why it’s a big deal that Nu deals with structured data. Some GitHub repositories like Zed’s have an issue that shows the issues with the highest number of 👍 reactions created within in the last week.

We will now do the same with the help of Nushell.

I will use the Pixi repository, but any other repository with enough community engagement will do as well.

let repo = "prefix-dev/pixi"

Many modern CLI tools have a JSON interface and gh is not different. We need the following fields:

createdAt so we only take the ones from last week
reactionGroups so we can extract the 👍 reactions
title and url to display them later

In the end we will get a list of records also known as a table. Each record represents one issue, and we pick one in order to get familiar with the structure. Please note that this will return a different issue for you, since more issues will have been opened on this repo by the time you read this.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| get 1

╭────────────────┬────────────────────────────────────────────────────────────╮
│ createdAt      │ 2025-08-29T13:11:13Z                                       │
│                │ ╭───┬───────────┬────────────────────╮                     │
│ reactionGroups │ │ # │  content  │       users        │                     │
│                │ ├───┼───────────┼────────────────────┤                     │
│                │ │ 0 │ THUMBS_UP │ ╭────────────┬───╮ │                     │
│                │ │   │           │ │ totalCount │ 1 │ │                     │
│                │ │   │           │ ╰────────────┴───╯ │                     │
│                │ ╰───┴───────────┴────────────────────╯                     │
│ title          │ Ability to split pixi.lock (not toml!) into multiple files │
│ url            │ https://github.com/prefix-dev/pixi/issues/4467             │
╰────────────────┴────────────────────────────────────────────────────────────╯

Notice that Nu pretty prints the record per default.

Only take Issues From Last Week

Nu also has first class support for datetime objects. This makes it easy to only take the rows of our table where createdAt falls within the last week.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| get createdAt
| last 5

╭───┬──────────────────────╮
│ 0 │ 2025-08-25T11:28:37Z │
│ 1 │ 2025-08-25T10:19:22Z │
│ 2 │ 2025-08-25T10:07:58Z │
│ 3 │ 2025-08-25T07:21:52Z │
│ 4 │ 2025-08-24T17:00:35Z │
╰───┴──────────────────────╯

We took the last 5 elements. Considering that this blog has been written on August 31st, these results seem pretty reasonable.

Extract the 👍 Reactions

We don’t have a nice way to extract the 👍 reactions yet, so let’s work on that. As a reminder, that’s how reactionGroup value looks like for the issue we looked at originally.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| get 1
| get reactionGroups

╭───┬───────────┬────────────────────╮
│ # │  content  │       users        │
├───┼───────────┼────────────────────┤
│ 0 │ THUMBS_UP │ ╭────────────┬───╮ │
│   │           │ │ totalCount │ 1 │ │
│   │           │ ╰────────────┴───╯ │
╰───┴───────────┴────────────────────╯

This issue, however, does not have reactions at all.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| get 0
| get reactionGroups

╭────────────╮
│ empty list │
╰────────────╯

Let’s insert a new column thumbsUp, which is based on the column reactionGroup. Of this reaction table, it only takes rows with THUMBS_UP reaction. Rows that don’t have any THUMBS_UP reactions will result in an empty list.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
}
| get thumbsUp
| first 5

╭───┬────────────────────────────────────────╮
│ 0 │ [list 0 items]                         │
│ 1 │ ╭───┬───────────┬────────────────────╮ │
│   │ │ # │  content  │       users        │ │
│   │ ├───┼───────────┼────────────────────┤ │
│   │ │ 0 │ THUMBS_UP │ ╭────────────┬───╮ │ │
│   │ │   │           │ │ totalCount │ 1 │ │ │
│   │ │   │           │ ╰────────────┴───╯ │ │
│   │ ╰───┴───────────┴────────────────────╯ │
│ 2 │ [list 0 items]                         │
│ 3 │ [list 0 items]                         │
│ 4 │ ╭───┬───────────┬────────────────────╮ │
│   │ │ # │  content  │       users        │ │
│   │ ├───┼───────────┼────────────────────┤ │
│   │ │ 0 │ THUMBS_UP │ ╭────────────┬───╮ │ │
│   │ │   │           │ │ totalCount │ 5 │ │ │
│   │ │   │           │ ╰────────────┴───╯ │ │
│   │ ╰───┴───────────┴────────────────────╯ │
╰───┴────────────────────────────────────────╯

We care about the total count. We get that by accessing users.totalCount.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
    | get users.totalCount
}
| get thumbsUp
| first 5

╭───┬────────────────╮
│ 0 │ [list 0 items] │
│ 1 │ ╭───┬───╮      │
│   │ │ 0 │ 1 │      │
│   │ ╰───┴───╯      │
│ 2 │ [list 0 items] │
│ 3 │ [list 0 items] │
│ 4 │ ╭───┬───╮      │
│   │ │ 0 │ 5 │      │
│   │ ╰───┴───╯      │
╰───┴────────────────╯

Some rows now have empty lists, and some have lists containing a single entry: the number of 👍 reactions. With get 0 we get the first element of a list. By adding --optional, this command doesn’t fail on empty lists but returns null instead. We replace null with 0, by running default 0.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
    | get users.totalCount
    | get 0 --optional
    | default 0
}
| get thumbsUp
| first 5

╭───┬───╮
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 0 │
│ 3 │ 0 │
│ 4 │ 5 │
╰───┴───╯

Get the Five Issues With the Most 👍 Reactions

The three columns we truly care about are thumbsUp, title and url, so let’s select those. We also sort the table, so that the issues with the most 👍 reactions come first.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
    | get users.totalCount
    | get 0 --optional
    | default 0
}
| select thumbsUp title url
| sort-by --reverse thumbsUp
| first 5

╭───┬──────────┬─────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────╮
│ # │ thumbsUp │                                        title                                        │                      url                       │
├───┼──────────┼─────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────┤
│ 0 │        5 │ Proposal to allow the use of Pixi workspaces through a named registry of workspaces │ https://github.com/prefix-dev/pixi/issues/4461 │
│ 1 │        1 │ pixi-build: load variants from packages or files                                    │ https://github.com/prefix-dev/pixi/issues/4429 │
│ 2 │        1 │ `pixi run echo '{{ hello }}'` fails                                                 │ https://github.com/prefix-dev/pixi/issues/4432 │
│ 3 │        1 │ Environment variable of tasks are broken when defined inside task                   │ https://github.com/prefix-dev/pixi/issues/4451 │
│ 4 │        1 │ Documentation: Add switchable pyproject.toml / pixi.toml code snippets              │ https://github.com/prefix-dev/pixi/issues/4452 │
╰───┴──────────┴─────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────╯

Rename `thumbsUp` Column

Unicode can be a bit annoying to type in the terminal, but now it’s time to rename our thumbsUp column to 👍.

gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
    | get users.totalCount
    | get 0 --optional
    | default 0
}
| select thumbsUp title url
| sort-by --reverse thumbsUp
| rename --column { thumbsUp: 👍 }
| first 5

╭───┬────┬─────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────╮
│ # │ 👍 │                                        title                                        │                      url                       │
├───┼────┼─────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────┤
│ 0 │  5 │ Proposal to allow the use of Pixi workspaces through a named registry of workspaces │ https://github.com/prefix-dev/pixi/issues/4461 │
│ 1 │  1 │ pixi-build: load variants from packages or files                                    │ https://github.com/prefix-dev/pixi/issues/4429 │
│ 2 │  1 │ `pixi run echo '{{ hello }}'` fails                                                 │ https://github.com/prefix-dev/pixi/issues/4432 │
│ 3 │  1 │ Environment variable of tasks are broken when defined inside task                   │ https://github.com/prefix-dev/pixi/issues/4451 │
│ 4 │  1 │ Documentation: Add switchable pyproject.toml / pixi.toml code snippets              │ https://github.com/prefix-dev/pixi/issues/4452 │
╰───┴────┴─────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────╯

Format Table in Markdown Format

In the end, we want to add this table to the body of a GitHub issue. Luckily, Nu has integrated support to convert its values to Markdown.

let top_issues_week = gh issue list --repo $repo --json createdAt,reactionGroups,title,url
| from json
| where ($it.createdAt | into datetime) >= (date now) - 1wk
| insert thumbsUp {
    $in.reactionGroups
    | where content == THUMBS_UP
    | get users.totalCount
    | get 0 --optional
    | default 0
}
| select thumbsUp title url
| sort-by --reverse thumbsUp
| rename --column { thumbsUp: 👍 }
| first 5
| to md

What you can see here is the Markdown table directly embedded in this post, which is also written in Markdown.

👍	title	url
5	Proposal to allow the use of Pixi workspaces through a named registry of workspaces	https://github.com/prefix-dev/pixi/issues/4461
1	pixi-build: load variants from packages or files	https://github.com/prefix-dev/pixi/issues/4429
1	`pixi run echo '{{ hello }}'` fails	https://github.com/prefix-dev/pixi/issues/4432
1	Environment variable of tasks are broken when defined inside task	https://github.com/prefix-dev/pixi/issues/4451
1	Documentation: Add switchable pyproject.toml / pixi.toml code snippets	https://github.com/prefix-dev/pixi/issues/4452

Create the Issue

Now we can create an issue with the table we just generated.

gh issue create --title "Top issues last week" --body $top_issues_week

How to update an existing issue is left as an exercise to the reader.

Conclusion

I hope I convinced you that scripting with Nushell can be a lot of fun. It’s quick to type like bash, and has proper data types like Python.

With Nu, it’s easy to interact with your data: you extend your pipeline until you are happy with what it does.

Many thanks to Sabrina and Lucas for their comments and suggestions on this article

You can find the discussion at this Mastodon post.

Git Forges Made Simple: gh & glab

Mon, 04 Aug 2025 00:00:00 GMT

When I set the goal for myself to contribute to open source back in 2018, I mostly struggled with two technical challenges:

Python virtual environments, and
Git together with GitHub.

Solving the former is nowadays my job, so let me write up my current workflow for the latter.

Most people use Git in combination with modern Git forges like GitHub and GitLab. Git doesn’t know anything about these forges, which is why CLI tools exist to close that gap. It’s still good to know how to handle things without them, so I will also explain how to do things with only Git. For GitHub there’s gh and for GitLab there’s glab. Both of them are Go binaries without any dependencies that work on Linux, macOS and Windows. If you don’t like any of the provided installation methods, you can simply download the binary, make it executable and put it in your PATH.

Luckily, they also have mostly the same command line interface. First, you have to login with the command that corresponds to your git forge:

GitHub
GitLab

gh auth login

glab auth login

In the case of gh this even authenticates Git with GitHub. With GitLab, you still have to set up authentication via SSH.

Working Solo

The simplest way to use Git is to use it like a backup system. First, you create a new repository on either Github or GitLab. Then you clone the repository:

git clone <REPO>

From that point on, all you have to do is:

do some work
commit
push
repeat

On its own there aren’t a lot of reasons to choose this approach over a file syncing service like Nextcloud. No, the main reason you do this, is because you are either already familiar with the git workflow, or want to get used to it.

Contributing

Git truly shines as soon as you start collaborating with others. On a high level this works like this:

You modify some files in a Git repository,
you propose your changes via the Git forge,
maintainers of the repository review your changes, and
as soon as they are happy with your changes, they will integrate your changes into the main branch of the repository.

Starting Out With a Fresh Branch

Let’s go over the exact commands.

You will want to start out with the latest upstream changes in the default branch. You can find out its name by running the following command:
```
git ls-remote --symref origin HEAD
```
Chances are it displays either ref/heads/main or refs/heads/master. The last component is the branch, so the default branch will be called either main or master. Before you start a new branch, you will run the following two commands to make sure you start with the latest state of the repository:
```
git switch <DEFAULT-BRANCH>
git pull
```
You switch and create a new branch with:
```
git switch --create <BRANCH>
```
That way you can work on multiple features at the same time and easily keep your default branch synchronized with the remote repository.

Open a Pull Request

The next step is to open a pull request on GitHub or merge request on GitLab. Even though they are named differently, they are exactly the same thing. Therefore, I will call both of them pull requests from now on. The idea of a pull request is to integrate the changes from one branch into another branch (typically the default branch). However, you don’t necessarily want to give every potential contributor the power to create new branches on your repository. That is why the concept of forks exists. Forks are copies of a repository that are hosted on the same Git forge. Contributors can now create branches on their own forks and open pull requests based on these branches.

If you don’t have push access to the repository, now it’s time to create your own fork.
- With Forge Tools
- Without Forge Tools
With the Git forge tools, you only need a single command to both fork the repository and set up the git remotes.
GitHub
GitLab
gh repo fork --remote
I don’t know why gh repo fork doesn’t set that for you, but now we need to tell gh which repository is the default. That way it knows against which repository you want to extend when opening a pull request. We want to extend the original repository, so let’s select that with the interactive picker.
gh repo set-default
glab repo fork --remote
Without the forge CLI tools, you first fork the repository in the web interface.
Then, you run the following commands:
git remote rename origin upstream git remote add origin <FORK>
When you cloned your repository, Git set the default branch of the original repo as the upstream branch for your local default branch. This is preserved by the remote rename, which is why the default branch can still be updated from upstream with git pull and no additional arguments.
Then, you open the Pull Request
- With Forge Tools
- Without Forge Tools
pr create directly pushes and sets up your branch, and then opens the pull request for you. If you have a fork available, it will ask whether you want to push your branch there:
GitHub
GitLab
gh pr create
glab mr create
With Git, you first have to tell it that it should create the corresponding branch on the remote and set it as upstream branch.
git push --set-upstream origin <BRANCH>
Next, you open the repository in the web interface, where it will suggest opening a pull request. The upstream branch of your local branch is now configured, which means you can update your remote by running git push without any additional arguments.

Checking out Pull Requests

Often, you want to check out a pull request on your own machine to verify that it works as expected.

With Forge Tools
Without Forge Tools

First you check out which pull requests are available

GitHub
GitLab

gh pr list

glab mr list

You remember the ID and use it to check out the pull request.

GitHub
GitLab

gh pr checkout <PR_ID>

glab mr checkout <MR_ID>

This works no matter if the pull request is coming from the repo itself or a fork, and it doesn’t set up any additional remotes.

You can check out the status of your pull request with pr view. By adding --web, it will directly open the web browser for you:

GitHub
GitLab

gh pr view --web

glab mr view --web

Checking out a pull request is surprisingly involved with Git alone. First, navigate to the pull request in your web browser.

Fork
Same Repository

In this example, can see that the pull request proposes changes from the repository by Hofer-Julian to a repository by prefix-dev. If the both branches are on the same repository, click on the tab “Same Repository” above.

If the pull request comes from a fork, you execute the following commands:

# Add a remote for the user who opened the pull request
git remote add <USER> <FORK_OF_USER>
# Fetch their repo
git fetch <USER>
# Check out their branch
git switch <BRANCH>

In this example, can see that the pull request proposes changes from the repository by Hofer-Julian to a repository by prefix-dev. If the branches are on the different repositories, click on the tab “Fork” above.

If it’s the same repository, you run checkout the pull request like this:

git fetch origin
git switch <BRANCH>

Conclusion

When I first heard of gh’s predecessor hub, I thought this is merely a tool for people who insist on doing everything in the terminal. I only realized relatively recently that Git forge tools are in fact the missing piece to an efficient Git workflow. Hopefully, you now have a better idea of the appeal of these tools!

Many thanks to Sabrina and Lucas for their comments and suggestions on this article

You can find the discussion at this Mastodon post.

How to send Emails via Python

Wed, 28 Dec 2022 00:00:00 GMT

I’ve assumed that sending emails via a CLI would be easy. That might even be the case, but sending them in a way that they actually show up in the receiver’s mailbox is quite a different story.

After following multiple tutorials and using tools from sendmail to mailx, not a single email arrived. Since I wanted to send the mail from within a Python script anyway, I moved on to a Real Python tutorial. This is the snippet they use to send an email.

import smtplib, ssl

port = 465  # For SSL
smtp_server = "smtp.domain.com"
sender_email = "my@domain.com"      # Enter your address
receiver_email = "your@domain.com"  # Enter receiver address
password = "MY_PASSWORD"            # Enter password
message = """\
Subject: Hi there

This message is sent from Python."""

context = ssl.create_default_context()
with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, message)

And again, nothing arrived at my preferred receiver protonmail. However, if you try to email to a gmail address, you get a helpful error back.

Our system has detected that this message is not RFC 550-5.7.1 5322
compliant: 'From' header is missing. To reduce the amount of spam sent
to Gmail, this message has been blocked.

This is how the snippet looks after adding the ‘From’ header:

import smtplib, ssl

port = 465  # For SSL
smtp_server = "smtp.domain.com"
sender_email = "my@domain.com"      # Enter your address
receiver_email = "your@domain.com"  # Enter receiver address
password = "MY_PASSWORD"            # Enter password
# 👇 The string is now a f-string and the 'From' header has been added
message = f"""\
From: <{sender_email}>
Subject: Hi there

This message is sent from Python."""

context = ssl.create_default_context()
with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, message)

And voilà, the email arrives at gmail. Again nothing at protonmail, but now it wasn’t too hard to guess that it might want a ‘To’ header.

import smtplib, ssl

port = 465  # For SSL
smtp_server = "smtp.domain.com"
sender_email = "my@domain.com"      # Enter your address
receiver_email = "your@domain.com"  # Enter receiver address
password = "MY_PASSWORD"            # Enter password
# 👇 The 'To' header has been added
message = f"""\
From: <{sender_email}>
To: <{receiver_email}>
Subject: Hi there

This message is sent from Python."""

context = ssl.create_default_context()
with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
    server.login(sender_email, password)
    server.sendmail(sender_email, receiver_email, message)

The Real Python tutorial is from 2018, so chances are that there are better ways to send emails nowadays. After looking through the standard library docs, I think the following snippet is a more idiomatic way to achieve the same thing in 2022. The main difference is that it removes duplication with the help of the EmailMessage class.

import smtplib, ssl
from email.message import EmailMessage

port = 465  # For SSL
smtp_server = "smtp.domain.net"
sender_email = "my@domain.at"       # Enter your address
receiver_email = "your@domain.com"  # Enter receiver address
password = "MY_PASSWORD"            # Enter password

subject = "Hi there"
content = "This message is sent from Python."

msg = EmailMessage()
msg['Subject'] = subject
msg['From'] = sender_email
msg['To'] = receiver_email
msg.set_content(content)

context = ssl.create_default_context()
with smtplib.SMTP_SSL(smtp_server, port, context=context) as server:
    server.login(sender_email, password)
    server.send_message(msg)

You can find the discussion at this Mastodon post.

How to install Nix on Fedora Silverblue

Fri, 25 Nov 2022 00:00:00 GMT

There is a lot to like about Fedora Silverblue. Updates are atomic and if there is something wrong with the newest version, you can always roll back. You always move between immutable images of your operating system, but that also means that installing packages with dnf doesn’t work anymore. For GUI applications, the answers to this are flatpak and its app store flathub. For everything else you can enter a mutable Fedora container with the help of toolbx. There, the dnf command is readily available and can be used as usual. This is convenient for development, but not necessarily outside it. Whenever you want to use an installed CLI tool, you now have to enter the toolbx beforehand. Also, there are a couple of system directories that are inaccessible from within the container.

Nix

Nix is a cross-platform package manager with the largest repository at the time of this writing. Like with Silverblue, upgrades in Nix are atomic and can be rolled back. In order to install it, we run the Determinate Nix installer:

curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install

To get started using Nix, open a new shell or run source nix-daemon.sh as shown below:

. /nix/var/nix/profiles/default/etc/profile.d/nix-daemon.sh

Now you can install tools on your machine with nix-env. If that’s all you want, then you can skip over to the last section.

Home Manager

Home Manager is a tool that allows declarative configuration of user specific packages and dotfiles. This not only helps you to keep track which changes you made to your user environment, but also greatly reduces the amount of work necessary to migrate to a new machine. Convinced? Then let’s get started!

First, we add the nixpkgs-unstable and home-manager channels.

nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --add https://github.com/nix-community/home-manager/archive/master.tar.gz home-manager

Then we update our nix-channels.

nix-channel --update

Now we can install home-manager with nix-shell.

nix-shell '<home-manager>' -A install

You can edit its config file by executing:

home-manager edit

This should open your editor with a couple of values already set. In the following snippet you see:

how to set your git data with useful extra config, and
how to ensure that a set of nix packages is installed.

{ config, pkgs, ... }:

{
  # Leave `home.username`, `home.homeDirectory`, `home.stateVersion`
  # and `programs.home-manager.enable` as they are

  # Set git config
  programs.git = {
    enable = true;
    userName  = "Julian Hofer";
    userEmail = "julianhofer@gnome.org";
    extraConfig = {
      init = {
        defaultBranch = "main";
      };
      pull = {
        rebase = true;
      };
      rebase = {
        autostash = true;
      };
    };
  };

  # Ensure that the following packages are installed
  home.packages = with pkgs; [
    bat
    fd
    gh
    glab
    ripgrep
  ];
}

Now we activate our config file by executing

home-manager switch

This also means that if you remove a setting or package in the config file, it will be removed on your system as well.

In order to update your environment run:

nix-channel --update
...
unpacking channels...

home-manager switch

Distrobox

Distrobox is a tool that creates container that are tightly integrated with the host. This makes it perfect for development tasks.

First install distrobox.

rpm-ostree install --apply-live distrobox

Enter your distrobox with:

distrobox enter

Distrobox mounts /nix inside of your container. This way you can continue using Nix and the apps you’ve installed with it. To see if everything is working as expected, you can try to view your git config with the cat-replacement bat:

bat ~/.config/git/config

You can find the discussion at this Mastodon post.

Home | Blog

Scripting is More Fun With Nushell

Extract the Top Issues From a Repository

Only take Issues From Last Week

Extract the 👍 Reactions

Get the Five Issues With the Most 👍 Reactions

Rename thumbsUp Column

Format Table in Markdown Format

Create the Issue

Conclusion

Git Forges Made Simple: gh & glab

Working Solo

Contributing

Starting Out With a Fresh Branch

Open a Pull Request

Checking out Pull Requests

Conclusion

How to send Emails via Python

How to install Nix on Fedora Silverblue

Nix

Home Manager

Distrobox

References

Rename `thumbsUp` Column