[Back to all posts](/blog) ![Why Linux Has So Many Kinds of Restart or Reboot](/_next/image?url=https%3A%2F%2Fik.imagekit.io%2Fgrbmndlassts%2Fblogs%2Flinux-restart-hierarchy%2Fcover.jpg&w=3840&q=75) # Why Linux Has So Many Kinds of Restart or Reboot November 7, 2026 · 8 min read linuxsystemdgnomebashsysadmin Reboot, soft-reboot, systemctl restart, logout, Alt+F2 r, source \~/.bashrc: each one restarts a different layer of the Linux stack, and here's which to use when --- # Why Linux Has So Many Kinds of Restart or Reboot Linux has a restart for everything. `sudo reboot`, log out and log in, `Alt + F2` then `r`, `sudo systemctl restart `, `source ~/.bashrc`. Change a font and it's one kind of restart. Add yourself to a group and it's a different one. The thing that ties it together: a program reads its config, environment and permissions when it starts, and mostly never looks again. Every restart on this list just makes some set of processes start over so they re-read what changed. They differ in how big that set is. Linux is a stack of separate programs (kernel, systemd, daemons, login session, desktop shell, terminal), so each layer gets its own restart. ## The ladder From the bottom of the stack to the top: | Level | What restarts | Command | One reason to use it | | ----- | --------------------- | -------------------------------- | ------------------------------------------------ | | 1 | The entire machine | sudo reboot | Installed a new kernel | | 2 | One background daemon | sudo systemctl restart | Wi-Fi is stuck: systemctl restart NetworkManager | | 3 | Your user session | Log out / log in | Ran sudo usermod -aG docker $USER | | 4 | The desktop shell | Alt + F2 \-> r (GNOME on X11) | Installed a GNOME extension | | 5 | One terminal | source \~/.bashrc | Added an alias | The rule is to pick the smallest one that covers the thing that changed. Everything else keeps running. ## Level 1: the whole machine What dies: the kernel, every process, everything in memory, all the driver state.⁠‌‍‌ ‌‍ ‌​ ‍‍‌ ‌ ‌‍‍​‌ ‍‌​‍ ‌‌‍ ​‌‍‍‌‌‍ ‍‌ ‌‌‌ ‍​​‍ ‌‌‍‍​‌‍​‌‌ ​ ​‍ ‌‌ ​ ‌‍ ​‍ ‌‌‍ ‌‌‍​‌‌‍ ‍‌ ‍‌​‍ ‌‌‍‍ ‌‍‍‌‌‍ ‍‌‍‌​‌ ​ ​‍ ‌‌‍ ‌‍‌‍​‍ ‌‌ ​‍‌‍‌‌‌ ​ ‌ ‌​‌‍​‌‌ ​‍‌ ‌​​‍ ‌‌‍ ‌ ​‍​‍ ‌‌ ​‍‌‍‌‌‌‍​‍‌‍ ‌‍ ‌ ‌​​ ‍‍​ ​‌​ ‌ ​ ‍‌​ ‌​​ ​​​ ​ ​ ​ ​ ​​​ ​‍​ ‌‍​ ‍‍​ ‍‌​ ​‌‌‍​‍‌‍‌‍‌‍‌​‌‍​‍​ ‌‍​ ​‍​ ‌‍​ ‌​​ ‌‍​ ​ ​ ‌​​ ​‌​ ​‌​ ‍​⁠ Kernel updates are the main reason this exists. The running kernel is the one that got loaded at boot, and the new one on disk does nothing until it boots. Same for firmware updates, changing low-level system mounts, or when the system freezes hard enough that nothing else responds. There's also a level 1.5\. `systemctl soft-reboot` (systemd 254 and later) tears down all of userspace and boots it again from scratch, but leaves the kernel running. No firmware, no bootloader, no kernel init, so it takes seconds. It's useful after a big package update that touched glibc or systemd itself, where half the running processes are holding old library versions in memory. It does nothing for a kernel update, because the kernel is exactly the part it keeps. ## Level 2: daemons What dies: one background program running as a system service. `systemctl restart NetworkManager` restarts the Wi-Fi and Ethernet logic. `systemctl restart bluetooth`, `systemctl restart docker`, same idea. If Wi-Fi breaks or the firewall rules change, rebooting the whole PC is overkill. systemd kills that one process and spawns a clean one. A few neighbours of this command that look similar and do different things: - `systemctl reload ` asks the daemon to re-read its config without exiting, usually by sending it `SIGHUP`. nginx supports it, so open connections survive. Not every service implements it. - `systemctl daemon-reload` restarts nothing.⁠‌‍‌ ‌‍ ‌​ ‍‍‌ ‌ ‌‍‍​‌ ‍‌​‍ ‌‌‍ ​‌‍‍‌‌‍ ‍‌ ‌‌‌ ‍​​‍ ‌‌‍‍​‌‍​‌‌ ​ ​‍ ‌‌ ​ ‌‍ ​‍ ‌‌‍ ‌‌‍​‌‌‍ ‍‌ ‍‌​‍ ‌‌‍‍ ‌‍‍‌‌‍ ‍‌‍‌​‌ ​ ​‍ ‌‌‍ ‌‍‌‍​‍ ‌‌ ​‍‌‍‌‌‌ ​ ‌ ‌​‌‍​‌‌ ​‍‌ ‌​​‍ ‌‌‍ ‌ ​‍​‍ ‌‌ ​‍‌‍‌‌‌‍​‍‌‍ ‌‍ ‌ ‌​​ ‍‍​ ​‌​ ‌ ​ ‍‌​ ‌​​ ​​​ ​ ​ ​ ​ ​​​ ​‍​ ‌‍​ ‍‍​ ‍‌​ ​‌‌‍​‍‌‍‌‍‌‍‌​‌‍​‍​ ‌‍​ ​‍​ ‌‍​ ‌​​ ‌‍​ ​ ​ ‌​​ ​‌​ ​‌​ ‍​⁠ It makes systemd re-read the unit files themselves, which is needed after editing a `.service` file and before restarting the service. - `systemctl --user restart pipewire` restarts a service that belongs to my user and not the system. Audio on modern desktops runs this way, so fixing broken sound doesn't need `sudo` or a logout. ## Level 3: log out, log in What dies: every program owned by my user account. Browser, terminals, music player, the audio server (PipeWire or PulseAudio), keyrings. The group case is the confusing one. After `sudo usermod -aG docker $USER`, running `docker ps` still says permission denied, even in a brand new terminal. Group membership is stamped onto a process at login and inherited by every child it spawns. The new terminal is a child of the desktop session, and the desktop session started before the group existed, so the terminal inherits the old list. Running `id` shows it: `docker` is in `/etc/group` and still missing from the current process. A fresh login builds a fresh list. One catch: on systemd desktops the terminal is often spawned by the per-user `systemd --user` manager, which survives a logout if another session of the same user is still open. Close everything, or reboot, if `id` still looks stale after logging back in. There's a shortcut for one terminal. `newgrp docker` starts a new shell with the group applied, and only that shell gets it. The same logic covers environment variables set in `~/.profile` or `/etc/environment`. Those get read once, at login, and passed down. Switching between an X11 and a Wayland session also happens here, since that choice is made on the login screen. ## Level 4: the desktop shell What dies: only the UI canvas.⁠‌‍‌ ‌‍ ‌​ ‍‍‌ ‌ ‌‍‍​‌ ‍‌​‍ ‌‌‍ ​‌‍‍‌‌‍ ‍‌ ‌‌‌ ‍​​‍ ‌‌‍‍​‌‍​‌‌ ​ ​‍ ‌‌ ​ ‌‍ ​‍ ‌‌‍ ‌‌‍​‌‌‍ ‍‌ ‍‌​‍ ‌‌‍‍ ‌‍‍‌‌‍ ‍‌‍‌​‌ ​ ​‍ ‌‌‍ ‌‍‌‍​‍ ‌‌ ​‍‌‍‌‌‌ ​ ‌ ‌​‌‍​‌‌ ​‍‌ ‌​​‍ ‌‌‍ ‌ ​‍​‍ ‌‌ ​‍‌‍‌‌‌‍​‍‌‍ ‌‍ ‌ ‌​​ ‍‍​ ​‌​ ‌ ​ ‍‌​ ‌​​ ​​​ ​ ​ ​ ​ ​​​ ​‍​ ‌‍​ ‍‍​ ‍‌​ ​‌‌‍​‍‌‍‌‍‌‍‌​‌‍​‍​ ‌‍​ ​‍​ ‌‍​ ‌​​ ‌‍​ ​ ​ ‌​​ ​‌​ ​‌​ ‍​⁠ Panels, window borders, extensions, the stuff that draws icons. `Alt + F2`, type `r`, Enter. GNOME Shell restarts and every window stays open: unsaved browser tabs, terminal sessions, all of it. Useful after tweaking an icon theme, installing an extension, or when GNOME Shell has a visual glitch or is leaking memory. This only works on X11\. On X11 the display server is Xorg, a separate process, and gnome-shell is just one client of it, so gnome-shell can die and come back while Xorg keeps every other window alive. On Wayland gnome-shell is the compositor, which means it is the display server. Restarting it kills every app connected to it, so on Wayland GNOME refuses with "Restart is not available on Wayland" and the closest thing is a full logout. Newer GNOME releases have dropped the X11 session entirely, so this trick lives only on setups like mine (GNOME 46 on X11) and is gone on current GNOME. Other desktops have their own version. KDE Plasma restarts its shell with `systemctl --user restart plasma-plasmashell`, i3 does it with `i3-msg restart`. The `Ctrl + Alt + F2` thing is something else. It switches to a text console (a TTY) and restarts nothing. `Ctrl + Alt + F1` or `F2` (depends on the distro) gets back to the graphical session. The TTY is where to go when the desktop is frozen but the machine isn't. Log in there and run: Bash ``` sudo systemctl restart gdm ``` That restarts the display manager (the login screen) and with it every graphical session on the machine, without touching the kernel or the system daemons. Fonts need even less than this.⁠‌‍‌ ‌‍ ‌​ ‍‍‌ ‌ ‌‍‍​‌ ‍‌​‍ ‌‌‍ ​‌‍‍‌‌‍ ‍‌ ‌‌‌ ‍​​‍ ‌‌‍‍​‌‍​‌‌ ​ ​‍ ‌‌ ​ ‌‍ ​‍ ‌‌‍ ‌‌‍​‌‌‍ ‍‌ ‍‌​‍ ‌‌‍‍ ‌‍‍‌‌‍ ‍‌‍‌​‌ ​ ​‍ ‌‌‍ ‌‍‌‍​‍ ‌‌ ​‍‌‍‌‌‌ ​ ‌ ‌​‌‍​‌‌ ​‍‌ ‌​​‍ ‌‌‍ ‌ ​‍​‍ ‌‌ ​‍‌‍‌‌‌‍​‍‌‍ ‌‍ ‌ ‌​​ ‍‍​ ​‌​ ‌ ​ ‍‌​ ‌​​ ​​​ ​ ​ ​ ​ ​​​ ​‍​ ‌‍​ ‍‍​ ‍‌​ ​‌‌‍​‍‌‍‌‍‌‍‌​‌‍​‍​ ‌‍​ ​‍​ ‌‍​ ‌​​ ‌‍​ ​ ​ ‌​​ ​‌​ ​‌​ ‍​⁠ Drop a font in `~/.local/share/fonts`, run `fc-cache -f`, and restart the app that should use it. Most apps load the font list at startup, so it's the app that needs restarting and the system can stay up. ## Level 5: a single terminal What dies: nothing. `.bashrc` is just a plain text script that runs when a terminal opens. `source ~/.bashrc` tells the current terminal tab to re-read that file right now and load any new aliases or environment variables. It only affects that tab. Other open terminals, background services and the desktop don't see it. Sourcing only adds. Delete an alias from `.bashrc` and source it again, and the old alias is still defined in that shell, because nothing told the shell to forget it. For a clean slate: Bash ``` exec bash ``` That replaces the current shell process with a fresh one in the same tab, with the same PID and none of the old aliases.