If you just set up a fresh Ubuntu 26.04 LTS machine and you want a quick, reliable way to display your system specs right inside the terminal, Fastfetch is the tool you need. It replaced the old Neofetch as the go-to system information utility because Neofetch was officially archived and abandoned in early 2024, leaving millions of Linux users without an actively maintained alternative.
This guide walks you through exactly how to install Fastfetch on Ubuntu 26.04 LTS, from updating your package index all the way through generating a custom config file, launching it automatically on every new terminal session, and solving the most common errors users run into. By the end, you will have a fully working Fastfetch setup that shows your OS, CPU, memory, disk, and GPU info in a clean, colorful terminal display every time you open a shell.
Before jumping in, it is worth understanding why this process is actually easier on Ubuntu 26.04 than on any earlier Ubuntu release. Ubuntu 25.10 and 26.04 (codenamed Resolute Raccoon, released April 23, 2026) both ship Fastfetch in their official apt repository for the first time. That means no third-party PPA, no manual .deb download from GitHub, and no version drift risk. You pull it straight from the same trusted Ubuntu package mirrors that deliver every other tool on your system.
One more thing worth saying upfront: this tutorial was written and tested against Ubuntu 26.04 LTS specifically. If you are running Ubuntu 24.04 or 22.04, some steps differ, and the native apt install fastfetch command will not work without first adding the ppa:zhangsongcui3371/fastfetch PPA manually. This guide focuses on 26.04, so let us get into it.
Prerequisites
Before running a single command, make sure your environment meets these requirements:
- OS: Ubuntu 26.04 LTS (Resolute Raccoon), either desktop or server edition
- User Permissions: A non-root user account with
sudoprivileges - Internet Access: Active connection to reach Ubuntu’s package mirrors
- Terminal Emulator: Any terminal works (GNOME Terminal, Kitty, Alacritty, Konsole). Kitty or Alacritty are recommended if you plan to display PNG logos later
- Architecture: amd64, arm64, or riscv64. The apt repository serves the correct binary automatically
Why does the sudo requirement matter? Running apt install without sudo throws a Permission denied error that silently leaves your system unchanged. Confirming these basics before you start saves you from debugging a problem that was never a Fastfetch issue to begin with.
What Is Fastfetch and Why Should You Install It?
Fastfetch is a system information tool written in C that prints a structured summary of your hardware and software configuration directly in the terminal. It shows details including your OS version, kernel, uptime, installed package count, shell, terminal emulator, desktop environment, CPU model, GPU, RAM usage, disk usage, and local IP address.
The reason experienced sysadmins prefer Fastfetch over alternatives comes down to three things: speed, accuracy, and active development.
Neofetch was written in Bash. Every time it ran, it spawned multiple subprocesses to gather data, which caused a noticeable delay even on decent hardware. Fastfetch is compiled C code. It runs near-instantly, even on ARM single-board computers or resource-constrained virtual machines.
The accuracy difference is also real. Fastfetch reports memory as 22.97 GiB while Neofetch would round that to 23 G. For sysadmins documenting server specs or troubleshooting resource issues, that precision matters.
Finally, and most critically: Neofetch is abandoned. Its GitHub repository was archived in April 2024. It receives no security patches, no Wayland support, and no compatibility updates. Ubuntu 26.04 uses Wayland by default for its desktop session. Running Neofetch on Ubuntu 26.04 means running unmaintained software that cannot read your display resolution correctly because it has no Wayland protocol support. Fastfetch has had full native Wayland support since its early releases.
Fastfetch vs. Neofetch at a Glance
| Feature | Fastfetch | Neofetch |
|---|---|---|
| Actively maintained | Yes | No (archived 2024) |
| Written in | C | Bash |
| Wayland support | Full native | None |
| Config format | JSONC | Bash config |
| Execution speed | Near-instant | Noticeably slow |
| Ubuntu 26.04 apt repo | Yes (native) | No |
| Value precision | High (e.g., 22.97 GiB) |
Low (e.g., 23 G) |
Step 1: Update Your Package Index
The very first thing you do before any apt installation is refresh your local package metadata.
sudo apt updateWhat this command does: It reads /etc/apt/sources.list and all files inside /etc/apt/sources.list.d/, contacts each configured repository server, and downloads the latest package index. No software gets installed or modified. The package index is essentially a catalog that tells apt which packages exist, what version is current, and where to download them from.
Why this step is not optional: If you skip this and your local cache is even a few days old, apt may report that Fastfetch is unavailable or offer an outdated version. This is one of the most common reasons new Linux users report installation failures for any package, not just Fastfetch.
Expected output:
Hit:1 http://archive.ubuntu.com/ubuntu resolute InRelease
Hit:2 http://archive.ubuntu.com/ubuntu resolute-updates InRelease
Reading package lists... Done
Building dependency tree... Done
Reading state information... DoneIf you see any Err: lines, check your internet connection and DNS resolution before proceeding.
Step 2: Install Fastfetch via APT
With a refreshed package index, install Fastfetch using the standard apt command.
sudo apt install fastfetchWhat this command does: It instructs apt to locate the fastfetch package in the Ubuntu 26.04 repository, calculate its dependencies, download all required files, and install them to your system.
Why this is the correct method for Ubuntu 26.04: The native apt repository on Ubuntu 26.04 includes Fastfetch, which was not the case on Ubuntu 24.04 or earlier. Using apt instead of manually downloading a .deb from GitHub gives you three things that matter in a production environment:
- Automatic security updates via
sudo apt upgrade - Clean uninstallation through
sudo apt remove fastfetch - Dependency tracking managed entirely by the package manager
When apt prompts you for confirmation, type Y and press Enter.
Expected output:
The following NEW packages will be installed:
fastfetch
0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Need to get 1,234 kB of archives.
After this operation, 3,456 kB of additional disk space will be used.
Do you want to continue? [Y/n]You may also see libvulkan1 listed as a new dependency. That is expected and legitimate. Fastfetch uses the Vulkan library to query GPU information. Installing it does not modify your graphics stack in any harmful way.
Step 3: Verify the Installation
Never assume an install succeeded. Always confirm it.
Check the Installed Version
fastfetch --versionWhat this does: Prints the installed version string of Fastfetch.
Expected output:
fastfetch 2.x.xIf this command throws command not found, the installation failed. Re-run sudo apt install fastfetch and watch for any error messages during the install process.
Run Fastfetch for the First Time
fastfetchWhat this does: Triggers the full system information output using Fastfetch’s default built-in configuration. You will see your distro’s ASCII logo on the left and a column of system modules on the right.
Why verify with the full run: The --version flag only confirms the binary exists. Running fastfetch without arguments confirms that it can actually read your system’s hardware and software data without errors. A broken dependency (rare but possible) will show as a missing or empty module here rather than a clean exit.
A healthy first run on Ubuntu 26.04 typically looks like this:
_
/ \ root@idroot.us
/ _ \ -----------
/ / \ \ OS: Ubuntu 26.04 LTS x86_64
/ / \ \ Host: Your Machine Model
/_/ Ub \_\ Kernel: 6.x.x-generic
Uptime: 5 mins
Packages: 1523 (dpkg), 12 (snap)
Shell: bash 5.2.x
Resolution: 1920x1080
DE: GNOME 48
WM: Mutter (Wayland)
Terminal: gnome-terminal
CPU: Intel Core i7 (8) @ 4.50 GHz
GPU: NVIDIA GeForce RTX ...
Memory: 4.22 GiB / 15.44 GiB (27%)
Disk (/): 32.5 GiB / 100.0 GiB (32%)Step 4: Generate Your Configuration File
Fastfetch does not create a configuration file automatically after installation. You generate it manually, and that is intentional. The manual generation means you explicitly control when your config is created and where it lives.
fastfetch --gen-configWhat this command does: It creates a minimal config.jsonc file at ~/.config/fastfetch/config.jsonc based on the current default output. This file lists all the modules Fastfetch currently displays and gives you a starting point for customization.
Why JSONC and not a plain text config? JSONC stands for JSON with Comments. It is standard JSON format, but you can add // comments on any line to annotate your settings. For anyone managing multiple machines or maintaining a dotfiles repository, self-documented configs are critical. Reading a JSONC file six months after writing it is far easier than parsing a flat Bash config with no context.
If you want every possible configuration option exposed in the file at once, use this variant instead:
fastfetch --gen-config-fullWhy use --gen-config-full: The standard --gen-config gives you a minimal file covering the active modules. The --gen-config-full variant includes every available option, commented out by default, so you can uncomment and edit exactly what you want without looking up the documentation for each parameter. This is the version experienced sysadmins use when setting up a new machine.
Confirm the file was created:
ls -la ~/.config/fastfetch/You should see config.jsonc listed.
Step 5: Customize Your Fastfetch Output
With your config file generated, you can now control exactly what Fastfetch shows and how it looks. Open the file in your preferred text editor.
nano ~/.config/fastfetch/config.jsoncControl Which Modules Display
The modules array in config.jsonc is the core of your configuration. Each entry in the array represents one line of output.
Example: Remove the GPU module on a headless server
If you are running Fastfetch on a headless Ubuntu 26.04 server with no GPU, the GPU module will show empty output or error text. Remove it by deleting or commenting out the GPU entry in the modules array:
// "GPU", // removed: headless server, no GPU presentWhy order in the array matters: Fastfetch prints modules in the exact sequence they appear in the modules array. Put the information most relevant to your workflow at the top. A developer might prioritize CPU and Memory. A network administrator would put IP and Disk at the top. There is no universally correct order.
List All Available Modules
Before editing your config, check what modules are available:
fastfetch --list-modulesThis prints every module Fastfetch supports on your system. Common ones include: OS, Kernel, Uptime, CPU, GPU, Memory, Disk, LocalIP, Shell, Terminal, DE, WM, Packages, Battery, and Colors.
Add the JSON Schema Line for Editor Support
If you edit your config in VS Code or any JSON-schema-aware editor, add this line at the top of config.jsonc:
{
"$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json"
}Why this matters: With the schema reference in place, your editor provides real-time autocomplete and validation for every Fastfetch configuration key. You will never mistype a module name or use an invalid option value again without your editor flagging it immediately.
Preview All Modules at Once
Before committing changes to your config, see what every module looks like:
fastfetch -c allWhat this does: Runs Fastfetch with all available modules enabled, regardless of what your config.jsonc currently specifies. It is the fastest way to see which modules produce useful output on your specific hardware before deciding what to include in your permanent config.
Step 6: Auto-Run Fastfetch on Every Terminal Launch
Many sysadmins configure Fastfetch to run automatically every time a new terminal session opens. It turns every terminal launch into an instant system health snapshot.
For Bash (Ubuntu’s Default Shell)
Add Fastfetch as the last line of your ~/.bashrc file:
echo "fastfetch" >> ~/.bashrcThen reload the Bash config in your current session without logging out:
source ~/.bashrcWhy source ~/.bashrc instead of opening a new terminal: The source command executes the file in your current shell process, applying the changes immediately. Opening a new terminal would also work, but source is faster and confirms the edit took effect in the same session.
For Zsh Users
echo "fastfetch" >> ~/.zshrc
source ~/.zshrcFor Fish Shell Users
echo "fastfetch" >> ~/.config/fish/config.fishImportant warning: Place the fastfetch call at the very end of your shell config file, after all environment variable exports and path modifications. If Fastfetch runs before your $PATH is fully configured, some module detections (like package managers or terminal identification) may return incomplete data. Putting it last guarantees it reads a fully initialized environment.
Troubleshooting Common Fastfetch Issues on Ubuntu 26.04
Error: “Package fastfetch not found”
Symptom:
E: Unable to locate package fastfetchCause: Your package index is stale, or you are not actually running Ubuntu 26.04.
Fix:
lsb_release -a
sudo apt update
sudo apt install fastfetchRun lsb_release -a first to confirm your Ubuntu version. If you see 24.04 or earlier, the native apt install method will not work. You need to add the PPA manually:
sudo add-apt-repository ppa:zhangsongcui3371/fastfetch
sudo apt update
sudo apt install fastfetchError: GPU Module Shows “No GPU Detected”
Symptom: The GPU line in Fastfetch output shows blank or reports an error string.
Cause 1: The libvulkan1 library is missing.
Fix:
sudo apt install libvulkan1Cause 2: You are running a headless server or virtual machine (VirtualBox, KVM) without a physical GPU passed through.
Fix: Remove the GPU module from your config.jsonc entirely. On a server, GPU data is irrelevant and the module only produces noise in your output.
Error: ASCII Logo Displays as Garbled Characters
Symptom: The Ubuntu logo renders as a mess of boxes, question marks, or strange symbols instead of clean ASCII art.
Cause: Your terminal is not configured for UTF-8 encoding, or your font does not include the required Unicode glyphs.
Fix:
- Check your terminal’s encoding settings and confirm UTF-8 is selected
- Install a Nerd Font, which includes the Unicode icon set Fastfetch uses for module labels:
sudo apt install fonts-notoThen set a Nerd Font as your terminal’s monospace font in its preferences.
Error: Fastfetch Runs on Every Shell Instance, Including Scripts
Symptom: Automated scripts using Bash start displaying Fastfetch output unexpectedly.
Cause: You added fastfetch to ~/.bashrc without wrapping it in an interactive shell check.
Fix: Replace the bare fastfetch call in your ~/.bashrc with:
[[ $- == *i* ]] && fastfetchWhat this does: The [[ $- == *i* ]] condition checks whether the current shell is interactive before running Fastfetch. Non-interactive shells (like those invoked by cron jobs or scripts) skip it entirely.
Error: Config File Not Found After Running –gen-config
Symptom: Fastfetch still uses default settings even after you generated and edited your config file.
Cause: The config directory ~/.config/fastfetch/ was not created before running --gen-config, or the .jsonc extension is missing.
Fix:
mkdir -p ~/.config/fastfetch/
fastfetch --gen-config
ls ~/.config/fastfetch/Confirm the output shows config.jsonc. If the file is named config.json (without the c), Fastfetch will not recognize it. Rename it:
mv ~/.config/fastfetch/config.json ~/.config/fastfetch/config.jsoncConfigure Fastfetch on Ubuntu 26.04 for a Production Server
When you manage Ubuntu 26.04 LTS servers, a customized Fastfetch setup can serve as a quick operational check every time you SSH in. Here is a practical minimal config for a headless server environment.
After generating your config with fastfetch --gen-config-full, edit ~/.config/fastfetch/config.jsonc and set your modules array to this:
{
"$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
"modules": [
"OS",
"Kernel",
"Uptime",
"Packages",
"Shell",
"CPU",
"Memory",
"Disk",
"LocalIP"
]
}Why this specific set for servers: It drops the GPU, DE, WM, Terminal, and Resolution modules, which are irrelevant on a headless machine and produce empty or error output. It keeps the data a sysadmin actually needs on login: uptime (is the server running cleanly?), memory (is there pressure?), disk (is storage nearly full?), and local IP (am I on the right machine?).
Add it to your ~/.bashrc for SSH sessions with the interactive check:
[[ $- == *i* ]] && fastfetchNow every SSH login gives you an instant operational summary without running free -h, df -h, uptime, and ip a separately.
Congratulations! You have successfully installed Fastfetch. Thanks for using this tutorial for installing the Fastfetch system information on the Ubuntu 26.04 LTS (Resolute Raccoon) system. For additional help or useful information, we recommend you check the official Fastfetch website.
