Bootstrapping Your Future: A Guide to Installing NixOS

Context for the Curious Book Reader

This journal entry marks a pivotal transition from philosophy to practice. After exploring the ‘why’ behind adopting a Linux-based, future-proof toolkit, this entry dives headfirst into the ‘how.’ It’s a raw, hands-on account of the very first practical step: creating a bootable NixOS installer and breathing new life into a machine that proprietary systems have left behind. This is the bootstrapping moment, the creation of the ‘outside force’ needed to begin the journey.

When I advocate Linux, Python, vim & git as the bedrock of tech, it supposes an awful lot and I know people aren’t going to switch off of their proprietary desktop OSes of macOS and Windows anytime soon. But I also know that because of designed obsolescence, there is actually quite a lot of windows of opportunities to consider doing just that, and plenty of recently so-called obsolete hardware with which to experiment with the switch, if only there wasn’t such a mountain of intimidation between here and there.

The Philosophy of a Lifelong Toolkit

So the initial strategy is to lower the friction with experimenting with that ostensibly obsolete Linux in such a way as to avoid the nullifying void of just playing with one Linux distro after the next after the next and get stuck in that “for its own sake” rabbithole trap of Linux. Linux Desktop will never replace Mac or Windows based purely on the merit of some toe-to-toe comparison of features or product/game-compatibility. You switch to Linux because you’re developing some skill-set and even particular assemblage of apps and a way it will carry its data along with you for the rest of your life.

This is the journey you’re beginning when you’re switching to Linux. You’re internalizing a toolbox and skill-set into your body the way early lifeforms incorporated calcium to become bones and fingers and eventually the tools of hands and fingers with opposable thumbs and stilts to walk on. Calcium started as a chemical to help transmit messages inside your cells as part of your nervous system but over time the body figured it out could protect that spinal-cord making us vertebrates and that same foamy calcium extrusions became our bones and skeleton. With insects it’s the chitin exoskeleton. Different shape, same story. This what we’re doing with Linux.

There’s no time to be a purist about it either, holding out for the perfect distribution of Linux. If the best technology won we’d be on LISP or Plan 9, the better systems that became both before and after Unix. The 80/20-rule is in effect here and good enough is good enough, especially when Metcalfe’s Law kicks in and enough people are on a thing such that network effects take over and the snowball effect starts to occur and more people doing a thing leads to more people doing a thing. Basically all embedded systems, super-computer and cloud computer is Unix/Linux — even phones. Oddly enough it’s only the desktop that’s a hold-out and not even Macs (which are Unix). Only Windows.

So why not stick on Windows and it’s network effect on the desktop? Because it’s proprietary and you need the network effect of the whole rest of the world leaking into the desktop world. Microsoft knows this and every version of Windows is one wsl --install (or a Windows Store Ubuntu click) away from also being a Linux system. Windows would not be a viable platform for developers anymore if not and you have to hold onto the hearts and minds of the developers if you want to hold onto the desktop platform. So even if you’re sticking with Windows, sooner or later you’re on Linux too. That is if you want to do anything beyond MS Office and games.

All roads lead to Linux. Is Linux Unix? Well no not technically, but for all intents and purposes, yes. We’re talking about what we call API-compatibility. When you learn to use the command-line interface (CLI) in Linux you’re effectively learning the Unix Terminal and that’s what makes your skills timeless. A system’s got to boot. It’s low-level stuff before everything else happens, even the activation of a desktop. However even after the desktop is running, that command-line environment that got it there is so powerful they leave you with access to it. I can just imagine the conversations with Steve Jobs as to whether Macs should include the Unix terminal program or not by default.

And the thing that comes up on Window so easily that looks like this Unix terminal environment really isn’t that. It’s still a CLI (command-line interface) but the details of the underlying API’s are all different. Back in the day it was DOS (disk operating system) which has now become split into a myriad of things from Powershell to COM — none of them really the Unix-like terminal that future-proof’s you until you type wsl --install into one of them or grab Ubuntu from the Windows Store. After that you can type wsl into a Powershell or COM CLI and turn it into a Unix-like terminal (Ubuntu Linux) or select Ubuntu from the Start Menu if you prefer. Start sliding down that slippery slope. Microsoft co-founder Steve Ballmer was right; Linux is a virus. Let the infection begin, but forget desktop.

The Real Goal: A Normalized Terminal

The desktop you’re using is just whatever window dressing you use to pull up a Unix/Linux terminal. That outer-most thing can still remain the consumer-oriented proprietary macOS or Windows. Or it can be whatever kooky Linux distribution is your favorite. The idea is to not take up whatever most difficult holy war there is to fight here but rather get a Linux terminal at your command so you can start working on a normalized terminal where things will run exactly the same way when you type in a command from now through the rest of your life.

Even if you’re on the non-standard macOS Unix terminal you can convert it into a normalized Linux terminal and get it compatible with the rest of the world by installing a Linux subsystem called Nix. Nix is a software repository system a lot like Homebrew but instead of just installing this piece of software or that from the free and open source software (FOSS) world, it installs a complete Linux OS on Mac — or Windows with WSL or other Linux distros — which normalizes a Linux environment between them for perfect infrastructure builds. It’s called Infrastructure as Code (IaC) and uses single files (flake.nix) to make the exact same thing run the exact same way on any machine no matter the host OS.

So even if you don’t have that ostensibly now obsolete piece of hardware to do a test Linux installation on, you can still get your hands dirty with the Linux command-line interface (CLI) to learn the Unix Terminal which is the first baby-step of future-proofing yourself to resist obsolescence for the rest of your life. There’s no amount of technology churn in our lifetimes that will obsolete this particular set of skills because everything including the entire AI industry is based on it. Unix-terminal methodology through a Linux implementation is the bedrock of tech. We’ll sooner have Armageddon than that changing — and if we have Armageddon that will still be one of the most valuable skill-sets.

If you do have that extra piece of hardware lying around, that laptop that won’t run Windows 11 or whatever, you’re in luck! The first thing you do is get a USB keychain set up to do the NixOS install. Nix is not only a version of Linux that will run in a normalized way in a Mac or Windows WSL subfolder, but it is also (but only optionally) the entire version of the desktop OS as well. Nix is many things which I’ll talk about plenty in this Future-proofing Your Tech Skills In the Age of AI book, but it’s not the only way to do this. There’s also the Nix-alternative Guix (pronounced geeks) from the same GNU Project that brings you Linux itself. It’s just that right now and for the foreseeable future, Nix is more mature and better supported on Mac. Over time I expect this will change and everything you learn about Nix will translate to Guix and the single-source dependency for a forever-Linux will go away. It is in fact already gone, but we have to focus on one thing at a time, so Nix first.

Getting that USB installer set up is the first magic step for breathing new life into old hardware and have a machine to play around on the side with a full Linux desktop. Some people will advocate that you use virtual machines or docker on your Mac or Windows destkop to do this. But if you’re on a Mac or Windows desktop, you use Nix. The whole point of your next phase of future-proofing growth is to get your hands dirty with a system that doesn’t have Windows or macOS on it at all. If you’re not ready for that step yet, keep working on whatever familiar desktop is your preference with Nix installed too. If you are ready for the next step, get ready to bootstrap.

Bootstrapping is such an interesting concept in tech. It refers to being able to pick yourself up by your own boot-straps. I guess once upon a time work-boots had straps on them, maybe to help you pull them on. And you can use these straps, the mental model metaphor goes, to keep pulling and pulling and lift yourself straight up off the ground and into the air — bootstrapping. This is of course a violation of Newton’s Third Law of Motion in which every action has an equal and opposite reaction. There needs to be a force applied from an outside system to actually provide the lift. You and your boots and any forces you apply between them are internal forces to the system that is you. That is why you can’t lift yourself up off the ground (any more than temporarily by jumping). A USB keychain with the NixOS installer is that outside force.

You don’t need to know this to just plug in a NixOS USB installer and use it, but it’s worth knowing the history here. Unix is like a virus (and by extension, Linux) because it’s easy to bootstrap. If you have a piece of hardware that isn’t running Unix, pretty soon it can be. This is because of decisions made by Ken Thompson the creator of Unix and his partner in crime Dennis Ritchie who made the C operating system. This combo solved the bootstrapping problem in that you wrote a C-compiler for a special piece of hardware and then compiled Unix for it, and then you had the whole Unix OS on that piece of hardware as well. This is the tradition Linus Torvalds continued when he made Linux.

Linux is like an API-compatible version of Unix that took the viral bootstrapping principle of Unix to heart even more by basing it on the innovative GNU General Public License (GNU GPL) which insists that Linux not only can spread like a virus but must. If you base a money-making product off of it, you are in fact legally obliged to share it back to the community. That’s where we got something called OpenWRT when a company called Linksys (later bought by Cisco) did just that and tried to not share back and were forced to. Linux spreads by design. There are loopholes now with the TiVo GPL3 license, but Linus refuses to change the formal Linux licence from the much more altruistic GPL2. People who say if the product is free then you are the product are flat out wrong and GNU/Linux is proof.

So anyway if you’re on Mac or Windows go research how to make an USB thumbdrive installer for NixOS. It’s plenty documented out there. For myself, well I’m on NixOS already and want to document the sort of budding off of new NixOS systems from the first one. This is something you’re going to want to do after you’ve turned some experimental piece of hardware on the side into a NixOS machine and are ready to set up a server-like device so you can run things 24x7x365 in your house to do your bidding in some way or another. This is wise because if you’re on a big fat machine with an awesome GPU for everyday work, you probably don’t want to keep that running all the time in high performance mode or it will show up on your electric bill as expensive as cloud hosting and the point is to bring down expenses. So a logical step not too far into your future-proofing experience is to find something nice and low-power efficient to keep on all the time as a server. And by that time you may have lost your USB installer or want to update it to the latest and are no longer on Mac or Windows anymore so the well-documented process with rufus is no longer the golden path.

So Gemini, how do you make a thumbdrive NixOS installer from NixOS? Walk me through the whole thing of making sure you have your USB drive installed with a before-and-after lsblk and lsusb command. We want to get rid of the obfuscation and mystery of this process if you’re already on Linux and you encounter that flakiness of stubborn mountpoints and connecting and disconnecting external drives. Don’t worry about incorporating it into configuration.nix or a flake.nix file yet. We can work out of a folder doing temporary installs for simplicity’s sake.

Be real precise like in helping me continue this article. The thing people face is that they pop a USB drive in of unknown status and they don’t see anything change on their Linux machine the way Macs and Windows are usually so good at picking that up. Linux isn’t so hot. And to solve that we can do before-and-after’s with lsblk and lsusb to get extreme transparency and explicitness of what’s going on with your system as you walk us through the process, please and thank you!

Forging the Key: Creating the Bootable USB

Gemini: Of course. You’ve set the stage perfectly. We’ve established the “why,” and now it’s time for the “how.” This process is the first practical step in turning philosophy into a working system, creating that “outside force” to bootstrap a new machine.

Here’s how to create a bootable NixOS USB installer from an existing NixOS system, demystifying the process by being explicit about every step.

Crafting the Bootstrapping Tool

You’re already running NixOS, and you have an old laptop ready for a new life. Your goal is to create a bootable USB drive that will act as the installer. This USB drive is the key—it’s the external system that will apply the force needed to lift that “obsolete” hardware into a state of modern, future-proof utility.

The most common point of confusion on Linux is figuring out what the system just did (or didn’t do) when you plugged something in. Unlike Windows or macOS, many Linux setups won’t immediately pop up a window. This is not a weakness; it’s an opportunity for precision. We’ll use two powerful commands, lsblk and lsusb, to see exactly what’s happening.

Step 1: System Reconnaissance (Before)

First, before you plug in your USB drive, open your terminal and get a baseline reading of your system. This is our “before” snapshot.

Run lsblk (list block devices) to see the storage devices currently connected:

$ lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
nvme0n1     259:0    0 931.5G  0 disk
├─nvme0n1p1 259:1    0   512M  0 part /boot
└─nvme0n1p2 259:2    0   931G  0 part /

This output shows one device, nvme0n1, which is the main internal SSD, split into two partitions.

Next, run lsusb (list USB devices) to see what’s connected to your USB ports:

$ lsusb
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 003: ID 8087:0029 Intel Corp. AX200 Bluetooth
Bus 001 Device 002: ID 04f2:b6d0 Chicony Electronics Co., Ltd Integrated Camera
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Here, you can see the internal devices that use the USB bus, like the Bluetooth adapter and webcam. Notice there’s no generic mass storage device.

Step 2: Connecting and Identifying the Target (After)

Now, plug in your USB thumb drive. Wait a few seconds, and run the same two commands again. This is our “after” snapshot.

First, lsblk:

$ lsblk
NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda           8:0    1  57.7G  0 disk
└─sda1        8:1    1  57.7G  0 part /run/media/youruser/USBDrive
nvme0n1     259:0    0 931.5G  0 disk
├─nvme0n1p1 259:1    0   512M  0 part /boot
└─nvme0n1p2 259:2    0   931G  0 part /

Aha! 💡 A new device, sda, has appeared. The system sees it as a 57.7GB disk. Your system might name it sdb or sdc, but it will be the new entry that wasn’t there before. Note that the system even helpfully auto-mounted its partition (sda1) for you.

Now, lsusb:

$ lsusb
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 004: ID 0781:5583 SanDisk Corp. Ultra Fit
Bus 001 Device 003: ID 8087:0029 Intel Corp. AX200 Bluetooth
Bus 001 Device 002: ID 04f2:b6d0 Chicony Electronics Co., Ltd Integrated Camera
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

The new line, Bus 001 Device 004: ID 0781:5583 SanDisk Corp. Ultra Fit, confirms the system has recognized a SanDisk USB drive.

The critical piece of information is the device name from lsblk: /dev/sda. This is your target.

Step 3: Preparing the Drive for Writing

Before we can write the NixOS installer image to the drive, we need to ensure no part of it is in use. From the lsblk output, we saw that /dev/sda1 was mounted at /run/media/youruser/USBDrive. We must unmount it.

$ umount /dev/sda1

If your drive had multiple partitions that were auto-mounted, you would unmount each one. Now the device is idle and ready to be overwritten.

Step 4: The Magic - Writing the Image with dd

This is the most critical step. We will use the dd command, a powerful tool that copies data bit-for-bit. It’s sometimes jokingly called “disk destroyer” because if you specify the wrong output device, it will silently wipe it without asking for confirmation. This is why our reconnaissance in steps 1 and 2 was so important.

⚠️ Triple-check your device name! In our example, it’s /dev/sda. Make sure you use the correct one for your system. Writing to your main drive (/dev/nvme0n1 in our example) would erase your operating system.

First, make sure you have downloaded the NixOS installer image. You can get the latest from the NixOS download page. Let’s assume you downloaded the graphical installer to your ~/Downloads folder.

Now, run the dd command:

$ sudo dd if=~/Downloads/nixos-graphical-24.05.xxxx-x86_64-linux.iso of=/dev/sda bs=4M conv=fsync status=progress

Let’s break that down:

• sudo: This command requires root privileges because it’s writing directly to a hardware device.
• dd: The command itself.
• if=...: The input file. This is the path to your downloaded .iso file.
• of=/dev/sda: The output file. This is your target USB drive. This is the dangerous part; be certain it’s correct. Note you are writing to the whole device (sda), not a partition (sda1).
• bs=4M: The block size. This tells dd to read and write in 4 Megabyte chunks, which is much more efficient than the tiny default.
• conv=fsync: This ensures that dd flushes the data completely to the USB drive’s physical storage before it finishes, rather than leaving it in a write cache.
• status=progress: This provides a helpful, real-time progress bar so you know it’s working and how long you have to wait.

The command will run for a few minutes. Once it’s complete, you’re almost done.

Step 5: Finalizing the Process

As a final measure of safety, you can run the sync command. This flushes any remaining file system caches to disk, ensuring all data is written.

$ sync

Once sync returns you to the prompt, the process is complete. You can now safely unplug your USB drive.

You have successfully created the “outside force.” This thumb drive now contains a fully operational, bootable NixOS environment, ready to breathe new life into that old hardware and continue your journey.

Me: Excellent, thank you! You should also cover that conceptually we are downloading an .iso-image and that this is the same thing as if we were “imaging” a hard drive, CD/DVD-ROM or any other sort of bootable device and that what we’re doing conceptually is just a bit-by-bit exact write of this bootable image onto a bootable device. There’s a certain magic here of just putting the right kind of binary image, thus it must be made for your particular architecture (64-bit Intel/AMD vs. 64-bit ARM) and put in the right place on a system set to actually allow booting from that device. Thus we sometimes have to go into the BIOS or UEFI of the machine and set it to be able to boot from USB. And finally you should also touch on the concept of a live CD which just brings you far enough to run an installer in turn.

Gemini: You’re absolutely right. Understanding the “what” and “why” behind these commands removes the mystery and turns a mechanical process into a foundational skill. Let’s add that conceptual layer.

What We’re Really Doing: From Digital Blueprint to Bootable System

When you download a file like nixos-graphical-24.05.iso, you’re not just getting a collection of files; you’re getting an ISO image. Think of it as a perfect, bit-for-bit digital blueprint of an entire storage disk, frozen in time. This concept originates from the days of CDs and DVDs, where an .iso was a complete snapshot of an optical disc, including not just the files but also the filesystem structure and, most importantly, the boot sector.

The Magic of Imaging 🪄

The dd command we used is conceptually very simple: it performs a direct, low-level copy. It takes the blueprint (the .iso file) and pours it onto the target device (your USB drive), overwriting everything in its path. This process, often called imaging or flashing, transforms your generic USB stick into an exact clone of the original disk the .iso was created from.

This is why the process works for creating installers. The .iso image contains a special chunk of data at the very beginning that a computer’s firmware (the low-level software that starts up before your OS) knows how to read. When the computer starts, this firmware—either the older BIOS or the modern UEFI—scans the drives for this bootable signature.

This leads to two key requirements:

1. Matching Architecture: The blueprint must be for the right kind of machine. Most desktops and laptops use the x86_64 architecture (Intel/AMD). However, devices like a Raspberry Pi, some servers, or modern Macs use the ARM architecture. You can’t boot an x86_64 image on an ARM machine any more than you can use a car key to open a house door. You have to download the correct .iso for your hardware.
2. Boot Order: You often need to tell your computer to check the USB ports first. By default, it looks at the internal hard drive. To change this, you typically press a key like F2, F12, or Delete during startup to enter the BIOS/UEFI setup and change the “Boot Order” to prioritize USB devices.

The “Live” Environment: A Test Drive for Your OS

Finally, when you successfully boot from the USB drive you just created, you’re not running the final, installed version of NixOS. Instead, you’re running it in a live environment.

Think of it as a “Live CD” or “Live USB.” The entire operating system is running directly from the USB drive and loading into your computer’s RAM. Your internal hard drive remains untouched. This is incredibly useful because it lets you:

• Test hardware compatibility to ensure things like Wi-Fi, graphics, and sound work correctly.
• Use the OS as if it were installed, allowing you to open a browser or fix a broken system.
• Run the installer. Somewhere on the desktop of this live environment, you’ll find an installer application. Running this program is what begins the actual process of partitioning your internal hard drive and copying the OS files onto it, creating a permanent installation.

Me: Alright, this is all very remarkable. I do want to point out their latest instructions on their site to give you a chance to make any modifications. I do believe we want to proceed with the dd procedure, but I do want to point out their official instructions for completeness and for you to put it all in perspective.

[Pastes instructions from official page]

Do your instructions still stand or do you want to make modifications?

Gemini: Excellent point, and thank you for providing the official documentation. This is a crucial step in responsible technical learning: comparing trusted sources to build a complete picture. Let’s analyze their instructions and put them in perspective with the process we’ve outlined.

The verdict is that my instructions are fundamentally correct and fully compatible. The official manual simply adds one extra flag to the dd command that can be beneficial for performance and provides an extra layer of safety against caching issues.

Let’s put them side-by-side.

Comparative Analysis: dd vs. dd

The core procedure recommended in the NixOS Manual is identical to what we walked through. The steps are:

1. Identify the device: Use lsblk.
2. Unmount the partitions: Use umount.
3. Write the image: Use dd.

The only substantive difference is in the exact flags passed to the dd command.

Our Recommended Command:

$ sudo dd if=... of=/dev/sdX bs=4M conv=fsync status=progress

NixOS Manual’s Command:

$ sudo dd bs=4M conv=fsync oflag=direct status=progress if=<path-to-image> of=/dev/sdX

(Note: The order of arguments like if= and of= doesn’t matter for dd.)

The Key Difference: oflag=direct

The manual includes one additional flag: oflag=direct.

Conceptually, when your computer writes data to a disk, it often uses a “page cache” in RAM as a temporary holding area to speed things up. The conv=fsync flag we used ensures that this cache is fully flushed to the physical disk before the dd command reports that it’s finished. This is critical for data integrity.

The oflag=direct flag goes a step further by telling dd to bypass the page cache entirely for the output file. It attempts to write directly to the storage device.

So, why add it?

1. Performance: On some systems, especially those with a lot of RAM, bypassing the cache can prevent the system from filling up memory with data that’s only going to be written once and never read back from the cache. This can make the operation faster and reduce the memory pressure on the host system.
2. Immediacy: It provides an even stronger guarantee that data isn’t being buffered in a way you don’t expect. It’s a “belt and suspenders” approach alongside conv=fsync.

It is a good practice and a worthwhile refinement.

Redundancy of the sync Command

I also recommended running sync after the dd command completes. The manual does not. This is because the conv=fsync flag already handles the crucial task of ensuring the data is physically written before dd exits. Running a separate sync command is a classic (and harmless) Unix habit that flushes all filesystem caches system-wide, but in this specific case, it’s largely redundant. The manual’s approach is more streamlined.

The Verdict and Refined Instructions

My instructions absolutely still stand. They are safe and effective. However, incorporating the oflag=direct from the official manual is a good refinement that aligns with best practices.

Your final, battle-tested command should be:

$ sudo dd if=~/path/to/nixos.iso of=/dev/sdX bs=4M conv=fsync oflag=direct status=progress

This combines the clarity of our step-by-step process with the technical robustness of the official documentation. You are proceeding on the correct path.

Unlocking the Door: Navigating BIOS/UEFI on a Windows Machine

Me: Excellent, thank you! I should also point out how to get into the BIOS of UEFI interface of a semi-modern Windows laptop. One of the best times to do this process of testing NixOS is during a frustrating Windows re-install or attempted recovery after the bluescreen of death. There’s so many hurdles to get over from finding that infernally long Windows boot key and actually restarting the machine in such a way that you can type it in, and then the Microsoft account login and then the Windows login after than and the focus face recognition and setting up a pin, yadda yadda. There’s so many places where this may fail that in frustration you can just hold the magic key combination on a Windows restart and get to the interface where you can set the USB boot permission and boot order. Can you cover a bit of that on semi-modern laptops? I imagine the situation many people are in are being on hardware that doesn’t “qualify” for Windows 11.

Gemini: You’ve perfectly captured the moment. The “window of opportunity” is often a window shattered by the Blue Screen of Death. When a user is staring down the barrel of a frustrating Windows reinstall, they are at their most receptive to an alternative. The path of least resistance is no longer Windows.

Here is how you can guide them to seize that moment and pivot to booting from their newly created NixOS USB drive on a semi-modern laptop.

The Challenge of Modern Laptops: Defeating “Fast Startup”

You’re right to mention a “magic key combination” on restart. Classically, this was pressing a key like F2, F12, Delete, or Escape the split second after powering on the machine to enter the BIOS/UEFI settings.

However, on most semi-modern Windows laptops (especially those from the Windows 10 era and beyond), this often fails. The reason is a feature called Fast Startup. It’s a hybrid shutdown that’s more like hibernation; it saves parts of the system state to disk so Windows can “boot” much faster. The side effect is that it often bypasses the brief window where you can press a key to interrupt the startup process.

The key to success isn’t just restarting; it’s getting to the Advanced startup menu, which is the modern, reliable gateway to the machine’s firmware.

The Reliable Path to UEFI/BIOS: Windows Advanced Startup ⚙️

This is the canonical method and should be the first thing you try. It forces the computer to do a full reboot directly into a special maintenance environment.

Method 1: From a Working Windows Desktop

If you can still get into Windows, this is the easiest way.

1. Click the Start Menu.
2. Go to Settings (the gear icon).
3. Select Update & Security.
4. Go to the Recovery tab.
5. Under the “Advanced startup” section, click Restart now.

Method 2: From the Login Screen (The Pro Tip)

This is perfect for when you can’t log in but the machine still boots to the login screen.

1. Click the Power icon on the bottom-right of the login screen.
2. Hold down the Shift key on your keyboard.
3. While still holding Shift, click Restart.

Both methods will reboot the computer into a blue “Choose an option” screen. From here, the path is the same:

1. Select Troubleshoot.
2. Select Advanced options.
3. Select UEFI Firmware Settings.
4. Click Restart.

The machine will now reboot one last time, directly into its UEFI/BIOS setup utility, with no frantic key-mashing required.

Inside the UEFI/BIOS: The Two Critical Settings

Once you’re in the firmware interface (which will look different for every manufacturer), you generally need to change two things.

1. Disable Secure Boot: Find the “Security” or “Boot” tab. Secure Boot is a feature that prevents operating systems that aren’t cryptographically signed (like most Linux installers) from loading. You almost always need to disable this to boot from a USB stick.

2. Change the Boot Order: Find the “Boot” or “Boot Priority” tab. You need to move the USB Drive (it might be called “USB HDD,” “Removable Device,” etc.) to the top of the list, so it’s checked before the internal “Windows Boot Manager.”

Finally, find the option to Save and Exit (very often the F10 key). The laptop will restart, and if your NixOS USB drive is plugged in, it will boot from it instead of Windows, opening the door to the next stage of the journey.

The Final Steps: Installation and First Boot

Me: Okay, so if you follow all these instructions perfectly the way the NixOS live CD installer is set up is that it’s going to try to auto-install and show you a big red warning that it can’t do the install because you don’t have an Internet connection. Just go to the upper-right where there is the sound and battery icons, click it for the fly-out configuration panel, click the little chevron accordion expander to the right of WiFi to show all the network choices and select your network, provide password and click the “Connect” button, and it will automatically return to the installer and remove the red warning.

You can mostly do the Next, Next, Next thing but you will need to give a username and password. If you like you can set the admin password to be the same as your main username. Provide that stuff, and next, next again.

And I always check “Allow unfree software”

There’s a bunch of Linux destkop manager options you can choose. I use the default GNOME which I think is a really good modern replacement for macOS and Windows. The way it handles virtual desktop workspaces rocks! But the whole list at the time of this writing is:

• GNOME
• Plasma
• Xfce
• Pantheon
• Cinnamon
• MATE
• Enlightenment
• LXQt
• Budgie
• Deepin
• No desktop

Next yo get up to the hard drive choices.

You have to be really careful about because this will wipe out all the data on that system. Presumably you’re doing this on a system where that’s okay. If you have important data on that system, STOP NOW!

This is the point of no going back.

I chose “Erase disk”

One of the key things you have to decide is whether and how big of a Swap portion you’re going to use by choosing between:

• No swap
• Swap (no Hibernation)
• Swap (with Hibernation)

Hey Gemini, what’s the difference?

Gemini: When installing NixOS, you’re presented with a crucial choice regarding your disk setup: how to handle swap space. The installer offers three options: Erase disk with No Swap, Swap (no Hibernate), and Swap (with Hibernate). Understanding the implications of each will help you make the best decision for your system’s performance and your personal workflow.

Here’s a breakdown to help you decide:

No Swap

This option, as the name suggests, forgoes the creation of a dedicated swap partition or swap file on your hard drive.

• What it is: Your system will rely solely on your physical RAM (Random Access Memory) to manage all running applications and processes.

• Pros:
  • Simplicity: It’s the most straightforward disk layout.
  • Saves Disk Space: You dedicate all your storage to your operating system and personal files.
  • Reduced Disk Wear: On Solid State Drives (SSDs), it can theoretically reduce the number of write cycles, potentially extending the drive’s lifespan.
• Cons:
  • Risk of System Instability: If your RAM becomes full, the system has no overflow space. This can lead to applications crashing or the entire system becoming unresponsive, a situation known as an “Out of Memory” (OOM) error.
  • No Hibernation: You cannot use the hibernation feature, as there is no space to save the contents of your RAM.
• Who should choose this?
  • Users with a large amount of RAM (typically 16GB or more) who are confident their daily usage will not exceed their physical memory.
  • Those who prioritize maximizing disk space and are not concerned with hibernation.

Swap (no Hibernate)

This option creates a swap partition or file, but it is not configured to be large enough for hibernation.

• What it is: A portion of your hard drive is set aside to be used as “virtual memory.” When your physical RAM is close to being full, the operating system can move less-used data from RAM to the swap space, freeing up RAM for active processes.

• Pros:
  • Increased System Stability: It provides a safety net against “Out of Memory” errors. If you experience a spike in memory usage, the system can use the swap space to prevent crashes.
  • Improved Performance for Low-RAM Systems: For systems with less RAM, having swap can allow you to run more applications simultaneously than would otherwise be possible.
• Cons:
  • Slower than RAM: Accessing data from a hard drive (even a fast SSD) is significantly slower than accessing it from RAM. Heavy reliance on swap can lead to a noticeable slowdown, often referred to as “swapping” or “thrashing.”
  • No Hibernation: The created swap space is typically smaller than your total RAM, making it unsuitable for saving the entire state of your system for hibernation.
• Who should choose this?
  • Most users, especially those with 8GB of RAM or less. It’s a good default choice for a stable and reliable system.
  • Users who want the safety net of swap space but have no intention of using the hibernation feature.

Swap (with Hibernate)

This option creates a swap partition or file that is large enough to support hibernation.

• What it is: Similar to the “Swap (no Hibernate)” option, it creates virtual memory. However, the size of this swap space is intentionally made at least as large as your physical RAM. This allows the entire contents of your RAM to be written to the swap space when you hibernate your computer.

• Pros:
  • Enables Hibernation: You can save your current session (all open applications and their states) to the disk and completely power off your computer. When you turn it back on, your session is restored exactly as you left it. This is particularly useful for laptop users who want to save battery life without losing their work.
  • All the benefits of “Swap (no Hibernate)”: You still get the increased system stability and virtual memory capabilities.
• Cons:
  • Uses More Disk Space: The swap partition will be larger, consuming more of your valuable disk space. The general rule is that the swap size should be at least equal to your RAM size for hibernation to work reliably.
• Who should choose this?
  • Laptop users who want to take advantage of hibernation to save their session and battery power.
  • Anyone who desires the ability to completely power down their machine and resume their work later without having to reopen all their applications.

Summary Table

There’s a bit of an eduction here on Hibernate vs. Suspend mode as well. No matter your Swap partition choice, you will still be able to put your computer in Suspend mode instead of a full shut-down but it uses RAM for faster performance and to not complicate your drive partition situation.

So what I’m saying is None is simpler. It controls all the factors, using a simpler start-up routine and guarantees success. But if you’re NixOS on a laptop and you want the battery to be able to go completely dead and still have it spring back to its previous state without a reboot next time you plug it, you’re going to want Swap (with Hibernate).

On the test I’m doing for this tech journal entry, I’m choosing Swap (with Hibernate. This is also your preview on the coming discussion of managing your electric bill.

Then I hit “Next” and “Install”

Congratulations! If you actually followed along and made it this far, you’re on your way to future-proofing and freedom using the bootstrapping method.

You will see a little checkmark asking whether you want to “Restart now”

WARNING!

Given that you may have messed with the BIOS/UEFI settings to get the USB thumbdrive to boot first, you may be tempted to pull out the thumbdrive before clicking that Restart Now. DONT!

Leave the thumbdrive in, click the checkmark for Restart now and then click Done and wait. It’s the click on “Done” that will start the reboot.

You will be faced with the NixOS boot menu which will have 2 choices at this time:

• NixOS
• The bootloader

Just let the countdown finish and it will boot NixOS native from your drive for the first time. It is now safe to pop out the USB thumbdrive.

Log into the system using the username/password you just set up during the install, and then go ahead and take the extremely short tour they prompt you to take. NixOS is so friggn well thought out, even the way they “reveal” stuff to you in the tour. First, the version.

At the time I made this technical journal entry, it was NixOS 25.5 (Warbler).

Next, they tell you about the single tap on the “Super” key, aka the Windows key for most people. What you want to know about NixOS — and really the Linux GNOME desktop — is that you can tap that key and just start typing the name of whatever program you want to launch. So long Windows Start Menu, you are a thing of the past. This is SO MUCH BETTER.

Next they tell you about the most wonderful and underutilized of all features on desktop operating systems today: virtual desktop workspaces! They dedicate a couple of steps in the tour to show you how to navigate them with the touchpad and start you out with one virtual workspace set up — for a total of 2 including the one you’re on. You can make more.

And as a final note you will have to set up WiFi again. Your settings from during the install does not carry over automatically after the reboot because settings made under the live CD do not automatically carry over to your fresh new install. So after you log in and exit the tour, connect to your WiFi network again.

This is a fresh install, but if you’re far enough into this that you have a configuration.nix file from a previous NixOS system and you want to do the “Noah’s Ark of Tech” trick that Nix is so good at, you copy that file over and do a system rebuild and your system is reconstructed in the exact original image of your old system — minus your user-data files which you have to backup and handle separately, which will be the subject of other entries.

Book Analysis

Ai Editorial Take

This is a cornerstone entry for the book. It successfully bridges the gap between the author’s high-level philosophy and the ground-level reality of implementing it. The narrative flow from abstract concept (future-proofing) to a tangible outcome (a working NixOS installation) is compelling. The collaborative dialogue with the AI not only produces a more robust guide but also serves as a meta-narrative on modern problem-solving. This entry provides immense value by empowering the reader to take their first, and often most intimidating, step away from proprietary ecosystems.

Title Brainstorm

• Title Option: Bootstrapping Your Future: A Guide to Installing NixOS
  • Filename: bootstrapping-nixos-installation-guide
  • Rationale: Directly uses the central metaphor of ‘bootstrapping’ from the text and clearly states the article’s practical purpose. It’s both evocative and descriptive.
• Title Option: The First Step to Freedom: Your Practical NixOS Installation Guide
  • Filename: practical-nixos-installation-guide
  • Rationale: Focuses on the theme of liberation from proprietary systems and highlights the hands-on, practical nature of the content.
• Title Option: From Windows Frustration to NixOS Liberation
  • Filename: windows-frustration-nixos-liberation
  • Rationale: Targets a specific audience: frustrated Windows users. It creates a strong ‘problem/solution’ narrative that is highly relatable.
• Title Option: How to Turn an ‘Obsolete’ Laptop into a Future-Proof Workstation
  • Filename: nixos-obsolete-laptop-future-proof
  • Rationale: Emphasizes the sustainability and cost-saving aspect of the project, which is a major sub-theme of the entry.

Content Potential And Polish

• Core Strengths:
  • Connects a strong philosophical ‘why’ with a practical ‘how,’ making the technical steps feel meaningful.
  • The conversational format with the AI demystifies the process and models how to seek and refine technical information.
  • Excellent use of analogies (bootstrapping, calcium, virus) to make complex ideas accessible and memorable.
  • Addresses common real-world friction points like accessing UEFI on modern laptops and identifying USB drives in Linux.
• Suggestions For Polish:
  • Integrate screenshots or diagrams for the UEFI/BIOS steps and the NixOS installer GUI, as these are highly visual processes.
  • Add a small section clarifying the difference between Nix (the package manager), NixOS (the full OS), and flake.nix earlier in the text to ground the reader.
  • Include a ‘Prerequisites’ box at the top, listing what the user needs (e.g., an 8GB+ USB drive, the target laptop, an internet connection) before they begin.

Next Step Prompts

• Based on the final paragraph of this entry, generate a follow-up technical journal entry titled ‘The Noah’s Ark of Tech: Replicating Your System with configuration.nix’. Explain the concept of declarative configuration, provide a commented example of a basic configuration.nix file, and walk through the process of copying it to a new NixOS install and running nixos-rebuild switch to replicate the original system’s software environment.
• Create a visual aid generation plan for this article. List 6 key moments in the process (e.g., lsblk before/after, UEFI Boot Order screen, NixOS WiFi setup, NixOS partition screen) and write a detailed prompt for each to generate an illustrative, generic screenshot-style image.