How To Install Fastfetch on Ubuntu 24.04 LTS

Modern Linux users demand efficient system information tools that deliver performance without sacrificing functionality. Fastfetch emerges as the definitive successor to the now-deprecated Neofetch, offering blazing-fast system data retrieval with extensive customization options. This comprehensive guide walks you through three proven installation methods on Ubuntu 24.04 LTS, complete with configuration strategies and troubleshooting solutions.

Ubuntu 24.04 LTS (Noble Numbat) users seeking to display system specifications in terminal sessions will find Fastfetch indispensable. Whether managing servers remotely, documenting system configurations, or personalizing terminal aesthetics, this tool provides precisely the information needed. The following tutorial covers everything from basic installation to advanced customization techniques.

What is Fastfetch?

Fastfetch represents a command-line utility designed to fetch and display system information in an aesthetically pleasing format. Built entirely in C programming language, this tool prioritizes performance while maintaining feature completeness. The application queries hardware specifications, operating system details, kernel information, and resource usage statistics with remarkable speed.

The tool supports cross-platform deployment across Linux distributions, BSD variants, macOS systems, and Windows environments. Its modular architecture enables users to display over 100 different information modules, from basic OS data to complex GPU configurations. The multi-threaded design ensures rapid data collection, typically completing execution in milliseconds rather than seconds.

Fastfetch distinguishes itself through an extensive ASCII logo library featuring distribution logos, hardware manufacturer branding, and custom artwork. The JSON-based configuration system provides granular control over display formatting, color schemes, and information modules. Active development from the open-source community ensures regular updates, bug fixes, and new feature implementations.

The tool maintains a minimal resource footprint, consuming negligible memory and CPU cycles during execution. Built-in caching mechanisms prevent redundant system queries, further optimizing performance for repeated invocations. This efficiency makes Fastfetch ideal for inclusion in shell startup scripts without impacting terminal launch times.

Why Choose Fastfetch Over Neofetch?

Performance differences between Fastfetch and Neofetch become immediately apparent during execution. Neofetch’s bash scripting foundation introduces inherent overhead, while Fastfetch’s compiled C codebase executes system calls with minimal latency. Benchmark testing reveals execution time reductions exceeding 50% in typical scenarios, with even greater improvements on resource-constrained systems.

The Neofetch project entered archival status in 2024, marking its transition to unmaintained software. No further updates, security patches, or compatibility fixes will emerge from the original developers. Fastfetch actively receives development attention, ensuring compatibility with emerging hardware standards, new display protocols, and evolving Ubuntu releases. This active maintenance proves critical for Ubuntu 24.04 LTS users seeking long-term reliability.

Customization capabilities extend far beyond Neofetch’s offerings. Fastfetch provides access to over 100 information modules compared to Neofetch’s limited selection. The JSONC configuration format supports comments and conditional logic, enabling sophisticated display configurations. Command-line arguments allow dynamic module selection without editing configuration files, facilitating flexible usage patterns.

System administrators benefit from Fastfetch’s speed when incorporating system information into remote management workflows. Server documentation becomes streamlined when system specifications can be captured instantly. Terminal startup customization no longer introduces noticeable delays. Inventory management scripts execute more efficiently when gathering hardware details across multiple machines.

Prerequisites for Installing Fastfetch

Ubuntu 24.04 LTS (Noble Numbat) serves as the target operating system for this tutorial, though these instructions remain compatible with Ubuntu 22.04 LTS and Ubuntu 23.10 releases. Administrative privileges through sudo access enable package installation and system modifications. Verify sudo permissions by executing sudo -v in the terminal before proceeding.

A stable internet connection facilitates package downloads from Ubuntu repositories, Personal Package Archives (PPAs), and GitHub infrastructure. Terminal access through GNOME Terminal, Konsole, Terminator, or SSH connections provides the necessary command-line interface. Remote server installations proceed identically to local desktop environments.

System updates should precede any new software installation. Execute the following commands to refresh package lists and upgrade existing software:

sudo apt update && sudo apt upgrade -y

This process synchronizes local package indices with Ubuntu repository servers and installs available security patches. The upgrade operation may require several minutes depending on the number of outdated packages. System reboot becomes necessary only if kernel updates were applied.

Disk space requirements remain minimal, with Fastfetch consuming approximately 5-10 MB including dependencies. The /usr/local/bin directory requires write permissions for manual installations. Verify available disk space using df -h to ensure adequate capacity.

Method 1: Installing Fastfetch from PPA (Recommended)

Personal Package Archives provide curated software repositories that integrate seamlessly with Ubuntu’s package management system. PPA installation offers automatic updates through the standard apt upgrade workflow, ensuring Fastfetch remains current without manual intervention. Dependency resolution occurs automatically, preventing library conflicts and missing prerequisite packages.

This method suits users prioritizing convenience and system integration. Software removal becomes straightforward through apt commands. Package managers track installed files, simplifying maintenance operations and system cleanup. PPA repositories undergo testing before publication, providing reasonable stability assurances.

Add the Fastfetch PPA Repository

Official and community-maintained PPAs distribute Fastfetch packages for Ubuntu systems. The following command registers the repository with your system:

sudo add-apt-repository ppa:zhangsongcui3371/fastfetch

The system prompts for confirmation before adding the repository. Press Enter to accept and proceed with PPA addition. This operation downloads the repository’s GPG key for package verification and appends repository information to your system’s source list.

Alternative PPAs may offer different Fastfetch versions or update schedules. Research community forums and the official Fastfetch GitHub repository for recommended PPA sources if the above repository becomes unavailable.

Update Package Lists

Package index synchronization informs apt about newly available software from the added PPA:

sudo apt update

This command contacts all configured repositories, including the newly added Fastfetch PPA, and downloads current package manifests. Output displays the number of packages that can be upgraded, though Fastfetch installation doesn’t require upgrading existing software.

Install Fastfetch

Package installation proceeds through the standard apt command:

sudo apt install fastfetch -y

The -y flag automatically confirms installation prompts, streamlining the process. Apt downloads the Fastfetch package and any required dependencies, then extracts files to appropriate system directories. Installation typically completes within 30-60 seconds depending on internet connection speed.

Verify Installation

Confirm successful installation by checking the installed version:

fastfetch --version

This command outputs the Fastfetch version number, build date, and compiler information. Execute the tool without arguments to display your system information:

fastfetch

The default output includes the Ubuntu logo alongside system specifications including OS version, kernel details, uptime, package count, shell information, display resolution, CPU model, GPU details, memory usage, and disk capacity.

Method 2: Installing Fastfetch from GitHub (Latest Version)

Source compilation provides access to development versions containing cutting-edge features before official package releases. This method enables custom compilation flags for optimized binary generation. Advanced users seeking specific feature branches or experimental functionality benefit from direct GitHub access.

Compilation introduces additional complexity compared to package installation but offers maximum flexibility. Understanding build systems becomes beneficial when troubleshooting compilation errors. The process demonstrates how open-source software transitions from source code to executable binaries.

Install Build Dependencies

Compiling C programs requires development tools and library headers. Install the complete build environment:

sudo apt install git cmake build-essential libpci-dev libvulkan-dev libwayland-dev libxrandr-dev libxcb-randr0-dev libdconf-dev libdbus-1-dev libmagickcore-dev libxfconf-0-dev libsqlite3-dev librpm-dev -y

These packages provide essential functionality:

• git: Version control system for repository cloning
• cmake: Cross-platform build system generator
• build-essential: GCC compiler and make utilities
• Library packages (lib*-dev): Development headers for hardware detection and display protocols

Installation downloads approximately 200-300 MB of build tools and libraries. The process requires several minutes depending on network speed and system performance.

Clone the Fastfetch Repository

Download the complete source code from GitHub:

git clone https://github.com/fastfetch-cli/fastfetch.git
cd fastfetch

The clone operation transfers the entire project history and current codebase to your local system. Navigate into the newly created fastfetch directory to proceed with compilation. Examine available branches using git branch -a if specific versions are required.

Build Fastfetch with CMake

Create a dedicated build directory to isolate compilation artifacts:

mkdir -p build && cd build

Configure the build system by running CMake:

cmake ..

CMake analyzes your system configuration, locates required libraries, and generates platform-specific makefiles. Output displays detected dependencies and enabled features. Warning messages indicate missing optional libraries that don’t prevent compilation but may limit functionality.

Compile the application using all available CPU cores:

cmake --build . --target fastfetch --target flashfetch -j$(nproc)

The -j$(nproc) flag parallelizes compilation across all processor cores, significantly reducing build time. Compilation duration ranges from 1-5 minutes depending on hardware capabilities. The flashfetch target creates a minimal version with reduced features.

Install the Compiled Binary

System-wide installation places executables in standard directories:

sudo cmake --install .

This command copies binaries to /usr/local/bin, manual pages to /usr/local/share/man, and configuration templates to /usr/local/share/fastfetch. The installation preserves file permissions and creates necessary directory structures.

Verify the Build

Confirm the installation with version and functionality checks:

fastfetch --version
fastfetch

The version output should reflect the latest Git commit if compiled from the main branch. System information display confirms successful compilation and installation.

Method 3: Manual Installation via Tarball (Direct Download)

Precompiled binary archives offer installation without package manager dependencies or compilation requirements. This approach minimizes system modifications and works in environments with restricted repository access. Portable installations enable Fastfetch deployment without administrative privileges when extracting to user-writable directories.

The tarball method suits containerized environments, minimal installations, and situations requiring specific Fastfetch versions. Manual installations bypass automatic update mechanisms, granting precise version control.

Download the Latest Release

Navigate to the GitHub releases page or use wget for direct downloads:

wget https://github.com/fastfetch-cli/fastfetch/releases/latest/download/fastfetch-linux-amd64.tar.gz

This command retrieves the most recent stable release for 64-bit x86 processors. Alternative architectures require different archive files (amd64, arm64, armv7). Verify the download completed successfully by checking file size with ls -lh fastfetch-linux-amd64.tar.gz.

Extract and Install the Binary

Extract the binary directly to the system binary directory:

sudo tar xf fastfetch-linux-amd64.tar.gz --strip-components=3 -C /usr/local/bin fastfetch-linux-amd64/usr/bin/fastfetch

The --strip-components=3 argument removes nested directory structures, placing the executable directly in /usr/local/bin. This location resides in the default PATH, ensuring command availability from any terminal session.

For Debian package installation, if available:

sudo dpkg -i fastfetch-linux-amd64.deb

Resolve any dependency issues automatically:

sudo apt --fix-broken install -y

Set Executable Permissions

Ensure the binary has execute permissions:

sudo chmod +x /usr/local/bin/fastfetch

This step typically isn’t necessary but guarantees proper file attributes. Verify permissions with ls -l /usr/local/bin/fastfetch, which should display -rwxr-xr-x.

Clean Up Downloaded Files

Remove the archive after successful installation:

rm -f fastfetch-linux-amd64.tar.gz

This reclaims disk space while preserving the installed executable. Verification proceeds identically to previous methods using fastfetch --version and fastfetch.

Basic Usage and First Run

Executing Fastfetch without arguments triggers default behavior:

fastfetch

The output presents an ASCII representation of the Ubuntu logo alongside comprehensive system information. The default configuration displays approximately 15-20 information modules in a two-column layout, with the logo occupying the left column and data filling the right.

Information categories typically include:

• Operating system name and version (Ubuntu 24.04 LTS Noble Numbat)
• Host and board manufacturer details
• Kernel version (6.8.x or newer for Ubuntu 24.04)
• System uptime since last boot
• Package count across all package managers
• Shell environment (Bash, Zsh, Fish)
• Display server protocol (Wayland, X11) and resolution
• Desktop environment and window manager
• Terminal emulator name
• CPU model, core count, and current frequency
• GPU vendor and model
• Memory usage and total capacity
• Swap space allocation and usage
• Disk usage per mounted filesystem
• Local IP address

Color schemes automatically adapt to terminal capabilities, utilizing 256-color support when available. The ASCII logo renders in distribution-appropriate colors—Ubuntu’s distinctive orange and white palette in this case.

Configuring Fastfetch

Configuration files enable persistent customization without repeatedly specifying command-line arguments. Fastfetch searches for configurations in the following order:

1. ~/.config/fastfetch/config.jsonc (user-specific)
2. ~/.config/fastfetch/config.json (user-specific, alternate format)
3. /etc/fastfetch/config.jsonc (system-wide)

The JSONC format permits comments using // and /* */ syntax, facilitating documentation within configuration files.

Generate a Default Configuration

Create a template configuration file:

fastfetch --gen-config

This command generates ~/.config/fastfetch/config.jsonc populated with default settings. Open the file in your preferred text editor:

nano ~/.config/fastfetch/config.jsonc

The configuration structure consists of JSON objects defining logo settings, module selection, and display formatting.

Basic Configuration Examples

Change the displayed logo:

{
  "logo": {
    "source": "debian",
    "padding": {
      "top": 1
    }
  }
}

This configuration replaces the Ubuntu logo with Debian’s spiral emblem. The source field accepts distribution names, file paths to ASCII art, or image file references.

Customize displayed modules:

{
  "modules": [
    "os",
    "kernel",
    "uptime",
    "packages",
    "shell",
    "cpu",
    "gpu",
    "memory",
    "disk"
  ]
}

This array defines which information modules appear in the output and their display order. Module names correspond to specific system attributes.

Adjust color schemes:

{
  "logo": {
    "color": {
      "1": "red",
      "2": "blue"
    }
  }
}

Color values accept standard color names or hexadecimal values for precise control.

Explore Available Modules

List all available information modules:

fastfetch --list-modules

This command outputs over 100 module names covering everything from basic OS information to specialized hardware details like Bluetooth adapters, battery status, and filesystem types.

Advanced Usage and Customization

Command-line arguments provide dynamic control without configuration file modifications. This flexibility enables context-specific output formats and quick experimentation with display options.

Display Comprehensive Help

Access detailed usage information:

fastfetch --help

The help output documents every command-line argument, configuration option, and module parameter. Scroll through extensive documentation covering logo options, color controls, formatting flags, and module-specific settings.

Use Built-in Presets

Fastfetch includes predefined configurations for common scenarios:

fastfetch --list-presets

Common presets include:

• minimal: Essential system information only
• all: Every available module
• hardware: Focus on physical components
• software: Emphasize installed software

Apply a preset:

fastfetch -c all.jsonc

The -c or --config flag specifies which preset or custom configuration file to use.

Display Specific Modules

Select modules dynamically:

fastfetch -s OS:Host:Kernel:CPU:GPU:Memory

The -s or --structure argument accepts colon-separated module names, displaying only specified information. This proves useful for scripting when you need particular data points without full system profiles.

Customize Logo Display

List available logos:

fastfetch --list-logos

Use a different logo:

fastfetch -l arch

The -l or --logo flag accepts distribution names, brands, or custom ASCII art file paths. Disable logo display entirely:

fastfetch --logo none

This produces a compact, text-only output suitable for narrow terminals or scripting contexts.

Shell Integration

Automatic Fastfetch execution during terminal startup provides instant system information visibility. This integration works particularly well on workstations where system status awareness proves valuable.

Bash Integration

Edit your Bash configuration file:

nano ~/.bashrc

Append the following line at the end:

fastfetch

Save and exit, then reload the configuration:

source ~/.bashrc

New terminal sessions automatically display system information upon launch.

Zsh Integration

For Zsh users, edit the appropriate configuration:

nano ~/.zshrc

Add Fastfetch invocation:

fastfetch

Reload with source ~/.zshrc to activate immediately.

Conditional Execution

Prevent Fastfetch from running in SSH sessions:

if [[ -z "$SSH_CONNECTION" ]]; then
    fastfetch
fi

This conditional checks for SSH environment variables, executing Fastfetch only on local terminal launches. Such logic prevents redundant output when connecting to remote systems that also run Fastfetch.

Troubleshooting Common Issues

Installation and display problems occasionally arise due to system configuration variations, missing dependencies, or terminal limitations.

PPA Addition Fails

If adding the PPA produces GPG key errors:

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys <KEY_ID>

Replace <KEY_ID> with the key identifier from the error message. Alternatively, try adding the repository manually by creating a source list file in /etc/apt/sources.list.d/.

Internet connectivity issues prevent PPA addition. Verify network access with ping -c 3 ubuntu.com before troubleshooting further.

Dependency Resolution Errors

Broken packages interfere with installation:

sudo apt --fix-broken install
sudo apt autoremove

These commands resolve dependency conflicts and remove orphaned packages. If problems persist, update package lists with sudo apt update and retry installation.

Compilation Failures

Missing build dependencies cause compilation errors. Review CMake configuration output for unmet requirements. Install any indicated missing packages before rerunning the build process.

Compiler errors may indicate outdated GCC versions. Ubuntu 24.04 includes GCC 13 by default, which satisfies Fastfetch requirements. Verify compiler version with gcc --version.

Logo Display Problems

Terminal Unicode support affects ASCII art rendering. Ensure your terminal emulator supports UTF-8 encoding. GNOME Terminal and Konsole provide full Unicode compatibility.

Install Nerd Fonts for enhanced glyph support:

sudo apt install fonts-powerline fonts-firacode

Switch to a smaller logo if rendering appears corrupted:

fastfetch --logo ubuntu_small

Color Rendering Issues

256-color terminal support enables full color schemes. Verify terminal capabilities:

echo $TERM

The output should contain 256color, such as xterm-256color. If not, configure your terminal emulator settings or export the appropriate TERM value:

export TERM=xterm-256color

Add this export to shell configuration files for persistence.

Missing Information Modules

Hardware detection relies on system utilities and kernel modules. Install common hardware detection tools:

sudo apt install pciutils usbutils lshw

These packages provide lspci, lsusb, and hardware listing functionality that Fastfetch queries for detailed component information.

Updating and Maintaining Fastfetch

Regular updates ensure access to bug fixes, new features, and improved hardware detection.

Update PPA Installation

Standard system updates handle PPA-installed packages:

sudo apt update
sudo apt upgrade

Fastfetch updates automatically alongside other system software. Check the current version periodically:

fastfetch --version

Update Source Installation

Navigate to the cloned repository:

cd ~/fastfetch
git pull origin main

This downloads the latest code changes. Rebuild and reinstall:

cd build
cmake ..
cmake --build . --target fastfetch -j$(nproc)
sudo cmake --install .

The process mirrors initial compilation but updates the existing installation rather than creating a new one.

Uninstalling Fastfetch

Complete removal procedures vary by installation method.

Remove PPA Installation

Uninstall the package:

sudo apt remove fastfetch

Purge configuration files:

sudo apt purge fastfetch

Remove the PPA:

sudo add-apt-repository --remove ppa:zhangsongcui3371/fastfetch

Clean up residual dependencies:

sudo apt autoremove

Remove Source Installation

Delete the binary:

sudo rm /usr/local/bin/fastfetch

Remove the cloned repository:

rm -rf ~/fastfetch

Delete user configuration:

rm -rf ~/.config/fastfetch

Remove Manual Installation

Identical to source installation removal, delete the binary from /usr/local/bin and remove user configuration directories. If installed to a custom location, adjust paths accordingly.

Congratulations! You have successfully installed Fastfetch. Thanks for using this tutorial for installing the Fastfetch fetching system information on the Ubuntu 24.04 LTS system. For additional help or useful information, we recommend you check the official Fastfetch website.