How To Install Fastfetch on Fedora 43

Your terminal is more than just a command-line interface. It’s your gateway to understanding your system’s hardware, software, and capabilities. If you’ve been using your Fedora 43 system for a while, you’ve probably wondered about those beautifully crafted system information displays that showcase OS details, CPU specifications, GPU information, and more—all rendered in your terminal with elegant ASCII art.

Fastfetch is a cutting-edge command-line tool designed to display comprehensive system information with remarkable speed and extensive customization options. As a modern, actively maintained alternative to the aging Neofetch utility, Fastfetch represents the evolution of system information retrieval for Linux users who demand both performance and aesthetics.

This guide provides everything you need to know about installing, configuring, and mastering Fastfetch on your Fedora 43 installation. Whether you’re a seasoned Linux administrator, a casual desktop user, or a terminal enthusiast looking to elevate your system administration experience, this comprehensive tutorial will walk you through every step of the process. You’ll learn installation methods, understand configuration options, troubleshoot common issues, and discover advanced customization techniques that will transform how you interact with your system information.

By the end of this guide, you’ll have a fully functional Fastfetch installation tailored to your specific preferences and workflow requirements.

Understanding Fastfetch

Fastfetch represents a significant advancement in the landscape of Linux system information tools. Built from the ground up using C programming language, this utility delivers system information at exceptional speeds—approximately 78.53% faster than its predecessor, Neofetch.

What Exactly Is Fastfetch?

Fastfetch is a command-line system information tool that retrieves and displays detailed information about your Linux system in an organized, visually appealing format. This information includes your operating system, Linux kernel version, hardware specifications, installed packages, running shell, environment variables, GPU details, display protocols, and much more. The tool renders this information alongside an ASCII art representation of your distribution’s logo, creating an aesthetically pleasing display that showcases your system’s capabilities.

Historical Context

Neofetch, released in 2016, became the de facto standard for displaying system information in Linux terminals. However, as the maintainer of Neofetch stepped back from active development, the open-source community recognized the need for a modern, actively maintained alternative. Fastfetch emerged to fill this gap, providing not just a replacement but a significant improvement in performance and functionality.

Core Functionality and Information Display

When you execute Fastfetch, the tool performs a series of system queries to gather information. It detects your Linux distribution, retrieves kernel details, identifies CPU and GPU specifications, reads installed package counts, detects your default shell, displays environmental information, and much more. This comprehensive data gathering happens in milliseconds, making Fastfetch nearly instantaneous compared to other system information utilities.

Performance Statistics That Matter

The performance advantages of Fastfetch aren’t merely theoretical. Real-world benchmarks demonstrate that Fastfetch executes significantly faster than Neofetch due to its C-based implementation rather than the shell-based scripting approach used by Neofetch. For users who want their terminal to feel snappy and responsive, this matters considerably.

Cross-Platform Support and Versatility

While this guide focuses on Fedora 43, it’s worth noting that Fastfetch’s development includes support for Linux, macOS, Windows, FreeBSD, and even Android. This cross-platform availability makes it an excellent choice if you work across multiple operating systems.

Key Advantages of Using Fastfetch on Fedora 43

Performance Benefits That You’ll Feel

Fastfetch’s C-based architecture delivers noticeable performance improvements. On systems with slower storage or older hardware, this acceleration becomes particularly apparent. The tool loads nearly instantaneously, eliminating the lag that sometimes accompanies other system information utilities.

Customizability Through JSON Configuration

Unlike many system utilities that rely on difficult-to-parse configuration formats, Fastfetch uses JSON (JavaScript Object Notation) for its configuration files. This standardized format is widely supported by code editors, provides automatic syntax highlighting, and enables IDE-based validation. You can easily customize which modules display, modify formatting, adjust colors, and even integrate custom scripts.

Active Development and Regular Updates

The Fastfetch project maintains active development, with regular updates introducing new features, performance improvements, and bug fixes. This ongoing support ensures compatibility with the latest Linux technologies and distributions, including Fedora 43.

Modern Technology Support

Fastfetch includes built-in support for modern display technologies including Wayland sessions, Wayland protocols, and advanced terminal graphics protocols. As desktop environments and terminals evolve, Fastfetch evolves alongside them.

Comprehensive Information Retrieval

The tool provides an extensive array of information modules, including font detection, cursor information, locale settings, audio device identification, and more. This comprehensive approach means you get a complete picture of your system in a single command.

Lightweight Resource Consumption

Fastfetch operates with minimal resource overhead. The tool requires only minimal disk space, minimal RAM during execution, and negligible CPU usage. This makes it suitable for resource-constrained environments or systems where efficiency matters.

Versatility for Different Use Cases

Whether you want Fastfetch to display hardware specifications for documentation purposes, showcase your system configuration for screenshots, or simply enjoy an aesthetically pleasing terminal greeting, Fastfetch adapts to your specific needs.

Prerequisites and System Requirements for Installation

Before beginning the installation process, ensure your Fedora 43 system meets the necessary prerequisites.

Fedora 43 System Requirements

Your Fedora 43 installation should be functional and up-to-date. You don’t need high-end hardware; Fastfetch runs efficiently on systems ranging from older laptops to powerful workstations. The tool requires minimal disk space—typically less than 5 MB for the binary and configuration files.

Internet Connectivity

A working internet connection is necessary to download Fastfetch packages or source code. Verify your network connectivity before proceeding with installation.

Terminal Access and Command-Line Familiarity

You’ll need comfortable access to a terminal or console session. Basic familiarity with Linux command-line operations will prove helpful, though this guide explains each command in detail.

Administrative Privileges

Most installation methods require superuser (sudo) access. Ensure your user account has sudo privileges configured. If you’re unsure, attempt typing sudo -l in your terminal; if it doesn’t return a command list, you may need administrative assistance.

Current System Update Status

It’s best practice to ensure your Fedora 43 installation is fully updated before adding new software. This minimizes the risk of dependency conflicts or missing libraries.

Optional Dependencies for Enhanced Functionality

While Fastfetch functions without optional dependencies, certain features require additional packages. These include:

• chafa: For better image rendering support
• imagemagick: For image processing capabilities
• libpulse: For audio device detection
• libxrandr: For X11 display information
• wayland: For Wayland session support

These optional packages aren’t strictly necessary but enhance Fastfetch’s functionality on capable systems.

Pre-Installation Preparation: Updating Your System

Before installing Fastfetch, properly preparing your Fedora 43 system ensures smooth installation and optimal performance.

Why System Updates Matter

System updates provide security patches, dependency updates, and package manager improvements. Installing software on an outdated system increases the risk of compatibility issues or missing library dependencies.

Performing a System Update

Open your terminal and execute the following command:

sudo dnf upgrade --refresh -y

This command performs several important operations. The dnf upgrade portion handles the actual package updates. The --refresh flag updates your package manager’s cache to ensure you have the latest package information. The -y flag automatically answers yes to any prompts, streamlining the update process.

Understanding DNF: Fedora’s Package Manager

DNF (Dandified Yum) is Fedora’s modern package management system. It replaced the older Yum package manager and provides significant improvements in dependency resolution, performance, and user experience. When you install Fastfetch via DNF, the system automatically resolves dependencies, ensuring all required libraries are installed alongside the main package.

What to Expect During Updates

The update process may take anywhere from a few minutes to several minutes, depending on your internet connection speed and the number of available updates. During this time, DNF will download packages, verify checksums, and install updates. You may see output scrolling across your terminal; this is normal and indicates progress.

Handling Update Errors

If you encounter errors during the update process, they’re typically related to repository configuration or network connectivity. Retry the command after confirming your internet connection. If persistent errors occur, the error message will provide specific troubleshooting guidance.

Verification of Successful Updates

After the update completes, verify success by checking your system version:

cat /etc/os-release | grep VERSION

This command displays your Fedora version information, confirming the update’s success.

Installation Method 1: Using DNF Package Manager (Recommended)

Installing Fastfetch through DNF represents the recommended approach for most users. This method offers the optimal balance of simplicity, safety, and maintainability.

Why DNF Installation Is Recommended

The DNF package manager handles all complexity associated with dependency management. Rather than manually researching and installing prerequisite packages, DNF automatically determines what’s needed and installs everything in the correct order. Additionally, DNF integration means future system updates will automatically update Fastfetch alongside other system packages.

Advantages of Package Manager Installation

Several compelling reasons support choosing DNF over alternative installation methods. First, automatic dependency resolution eliminates manual troubleshooting. Second, system integration ensures Fastfetch behaves like a native Fedora package. Third, future updates are handled seamlessly during regular system maintenance. Fourth, uninstallation is straightforward and complete, leaving no orphaned files or configuration remnants.

Step 1: Refresh Your Repository Cache

Begin by refreshing DNF’s package cache to ensure you have the latest package information:

sudo dnf clean all && sudo dnf makecache

This two-part command clears the cached package information and rebuilds it fresh from your configured repositories. This ensures DNF has access to the most current Fastfetch version available.

Step 2: Install Fastfetch via DNF

Now install Fastfetch with a simple command:

sudo dnf install fastfetch -y

The system will display output indicating package retrieval, dependency checking, and installation progress. The -y flag automatically confirms the installation without requiring manual approval.

Understanding the Installation Process

As DNF executes, it performs several operations. First, it checks available packages in your configured repositories for “fastfetch.” Second, it identifies all dependencies required by Fastfetch. Third, it verifies that these dependencies aren’t already installed. Finally, it downloads all necessary packages and installs them in the correct sequence.

Step 3: Verification of Successful Installation

After installation completes, verify that Fastfetch installed correctly:

fastfetch --version

This command displays the installed Fastfetch version number. A successful installation shows output similar to:

fastfetch 0.18.2

If the command returns “command not found,” the installation encountered an issue. In this case, return to Step 1 and attempt the installation again.

Alternative Verification Commands

You can verify installation through additional methods. The which command locates the Fastfetch executable:

which fastfetch

Expected output resembles /usr/bin/fastfetch, indicating the installation location.

The rpm command confirms package installation:

rpm -q fastfetch

Successful output shows the package name and version number.

Additional DNF Installation Options

The -y flag is optional; omitting it requires manual confirmation of the installation. The --no-docs flag skips documentation installation, saving minor disk space. The --best flag ensures DNF selects the best compatible package version if multiple versions exist.

Installation Method 2: Building from Source Code

Advanced users preferring the latest development features or those requiring custom compilation options may prefer building Fastfetch from source code. This method offers flexibility but requires more technical knowledge.

When Source Installation Makes Sense

Source compilation becomes necessary in specific scenarios. If you want access to bleeding-edge features not yet packaged for Fedora, source installation provides the answer. If you need custom compilation flags or specific feature configuration, source building is your option. If you’re developing Fastfetch itself or testing unreleased versions, source code access is essential.

Understanding Build Dependencies

Before compiling Fastfetch, your system must have development tools installed. These include compilers, build utilities, and development headers for various libraries.

Step 1: Install Build Dependencies

Install all necessary build tools with this command:

sudo dnf install git cmake gcc gcc-c++ make ninja-build pkg-config -y

Additionally, install development headers for optional libraries:

sudo dnf install libxrandr-devel wayland-devel wayland-protocols-devel pulseaudio-libs-devel -y

This comprehensive approach ensures your system has everything needed to compile Fastfetch successfully. The installation may take a few minutes as development packages typically include extensive documentation and header files.

Step 2: Clone the GitHub Repository

Navigate to a suitable directory for source code:

cd ~/src

If the src directory doesn’t exist, create it:

mkdir -p ~/src && cd ~/src

Clone the official Fastfetch repository:

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

This command downloads the complete repository, including all source code, build configurations, and documentation.

Exploring the Downloaded Repository

After cloning completes, navigate into the directory:

cd fastfetch

Examine the repository structure. The src/ directory contains source code files. The CMakeLists.txt file contains build configuration. The README.md provides project information.

Step 3: Create Build Directory and Configure

Create a separate build directory:

mkdir build && cd build

This keeps source and build artifacts separate, following standard practice. Now configure the build:

cmake .. -DCMAKE_BUILD_TYPE=Release

The CMake command reads configuration from the parent directory (..) and sets the build type to Release, which optimizes the compiled binary for performance.

Understanding CMake Configuration Output

CMake performs extensive checks during configuration. It verifies compiler availability, checks for required libraries, and determines feature support. The output displays which features CMake detected and will include in the compilation. If important features show as disabled, missing dependencies may be the cause.

Step 4: Compile Fastfetch

Begin compilation with:

make -j$(nproc)

The -j$(nproc) parameter enables parallel compilation using all available CPU cores, significantly accelerating the build process. On multi-core systems, this typically completes in under a minute.

Monitoring Compilation Progress

The make command displays compilation progress, showing which source files are being compiled. This helps you understand that the process is working, particularly on systems with many CPU cores where progress is harder to track.

Handling Compilation Errors

If compilation errors occur, they typically relate to missing dependencies. The error message will indicate which library or header file is missing. Use DNF to install the necessary development package and retry compilation.

Step 5: Install the Compiled Binary

After successful compilation, install Fastfetch:

sudo make install

This command copies the compiled binary to system directories (typically /usr/local/bin/fastfetch) and installs configuration files and documentation.

Verification of Source Installation

Verify the source installation similarly to DNF installation:

fastfetch --version

The output confirms installation success. Additionally, check the installation location:

which fastfetch

Source installations typically install to /usr/local/bin/fastfetch, distinguishing them from package manager installations.

Post-Installation Verification and Testing

Regardless of your installation method, thorough testing ensures everything works correctly.

Running Fastfetch for the First Time

Execute Fastfetch with the simple command:

fastfetch

Your terminal displays comprehensive system information alongside your Linux distribution’s ASCII art logo. This default output showcases the tool’s capabilities immediately.

Examining the Default Output

The default display includes multiple sections. At the top, you see the ASCII logo representing your Fedora distribution. To the right of the logo, organized information appears in key-value pairs. This includes your username, hostname, OS name and version, kernel version, uptime, CPU model and specifications, GPU information, memory usage, and installed package count.

Testing Output Display Quality

Examine the ASCII art rendering. It should appear properly aligned without distortion or misalignment. Colors should render appropriately for your terminal’s color scheme. If the output appears corrupted or misaligned, terminal compatibility issues may exist; we’ll address these in the troubleshooting section.

Color Output Verification

Fastfetch automatically detects your terminal’s color capabilities. Modern terminals support 256 colors or true color (16 million colors). Fastfetch leverages this capability to render colored output. Verify that colors appear properly and match your terminal’s theme.

Accuracy Validation

Cross-reference the displayed information with system facts you already know. Verify CPU information matches your processor. Confirm memory amount matches your system specifications. This validation ensures Fastfetch correctly detects and reports system information.

Exploring Available Features

Discover Fastfetch’s available components with these commands:

fastfetch --list-modules

This displays all available information modules that Fastfetch can display. Modules include OS, kernel, uptime, CPU, GPU, memory, and dozens more.

fastfetch --list-logos

This displays ASCII art logos available for various Linux distributions. You can customize which logo displays with your system information.

fastfetch --list-presets

This reveals pre-configured display presets optimized for different use cases. Some presets emphasize hardware information, others prioritize system software details.

Testing Different Display Options

Try displaying information using different logos:

fastfetch --logo Fedora

fastfetch --logo Debian

Experiment with different presets:

fastfetch --config neofetch

This testing explores Fastfetch’s capabilities and helps you understand available customization options.

Basic Usage: Running Fastfetch

Understanding basic operation prepares you for more advanced customization.

Default Execution

The simplest usage is executing Fastfetch without parameters:

fastfetch

This invokes Fastfetch with default settings, loading configuration from ~/.config/fastfetch/config.jsonc if it exists. If no configuration file exists, Fastfetch uses built-in defaults.

Understanding Command-Line Options

Fastfetch provides numerous command-line options for one-time customization without permanently changing configuration files.

The help option displays all available parameters:

fastfetch --help

The version option shows your installed version:

fastfetch --version

The logo option specifies which logo to display:

fastfetch --logo Fedora

Replace “Fedora” with any available logo name from the --list-logos output.

Selecting Specific Modules

Display only specific information modules with the -s flag:

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

This displays only the OS, kernel, CPU, GPU, and memory information, omitting all other modules.

Practical Command Examples

Create a Fedora-branded system information display:

fastfetch --logo Fedora --logo-size 16 --image-width 32

Display minimal information for quick reference:

fastfetch -s OS:Kernel:Uptime:CPU:Memory

Use a preset configuration:

fastfetch --config neofetch.jsonc

Generate a brand-new configuration file:

fastfetch --gen-config

Generate a comprehensive configuration file with all available options:

fastfetch --gen-config-full

Understanding Output Behavior

Fastfetch respects terminal width and automatically adjusts output formatting to fit your terminal dimensions. If your terminal is particularly narrow or wide, output adjusts accordingly.

Configuration Fundamentals: Customizing Fastfetch

Customization transforms Fastfetch from a useful tool into a perfectly tailored system information display reflecting your preferences.

Configuration File Location and Format

Fastfetch reads configuration from ~/.config/fastfetch/config.jsonc by default. The .jsonc extension indicates JSON with Comments support, meaning you can include comments in your configuration for clarity.

The full configuration path is:

~/.config/fastfetch/config.jsonc

The tilde (~) represents your home directory. If the directory structure doesn’t exist, you’ll create it during configuration file generation.

Generating Initial Configuration Files

Fastfetch provides simple commands to generate configuration files automatically. For a minimal configuration with common settings:

fastfetch --gen-config

This creates ~/.config/fastfetch/config.jsonc with essential configuration options. The process creates the ~/.config/fastfetch/ directory if it doesn’t already exist.

For a comprehensive configuration including all available options:

fastfetch --gen-config-full

This generates a detailed configuration file useful for reference when building custom configurations.

Understanding Configuration File Structure

A typical Fastfetch configuration file contains several main sections. The schema section references the JSON schema for IDE validation. The logo section configures ASCII art display settings. The display section controls general presentation options. The modules array defines which information displays and in what order.

Logo Configuration Options

Within the logo section, you configure how your distribution’s ASCII art displays. The type setting determines logo source (auto-detection, built-in, or file-based). The size setting controls logo dimensions in characters. The padding setting adjusts spacing around the logo.

Example logo configuration:

{
  "logo": {
    "type": "builtin",
    "source": "Fedora",
    "width": 30,
    "height": 16,
    "padding": {
      "top": 0,
      "right": 1,
      "bottom": 0,
      "left": 1
    }
  }
}

Display Configuration Options

The display section controls overall presentation. The separator option customizes the key-value separator (commonly a colon). The keyColor and valueColor options set text colors. The barsCharacter option defines bar chart characters for visual elements like memory usage.

Example display configuration:

{
  "display": {
    "separator": " : ",
    "keyColor": "white",
    "valueColor": "blue",
    "barsCharacter": "●",
    "keyWidth": 10
  }
}

Module Configuration and Ordering

The modules array defines which system information displays and the display order. Each module can include format specifications and module-specific options.

Example modules configuration:

{
  "modules": [
    { "type": "OS" },
    { "type": "Kernel" },
    { "type": "Uptime" },
    { "type": "CPU" },
    { "type": "GPU" },
    { "type": "Memory" },
    { "type": "Disk" }
  ]
}

Editing Configuration Files

Several options exist for editing your configuration. The nano editor offers simplicity:

nano ~/.config/fastfetch/config.jsonc

The vim or vi editor serves experienced users:

vim ~/.config/fastfetch/config.jsonc

Graphical text editors like GNOME Text Editor or KDE Kate provide familiar GUI-based editing:

gedit ~/.config/fastfetch/config.jsonc

After editing, save your changes. In nano, press Ctrl+O to save and Ctrl+X to exit. In vim, press Escape, type :wq, and press Enter.

Syntax Validation After Editing

After modifying your configuration file, validate syntax before running Fastfetch:

fastfetch

If syntax errors exist, Fastfetch displays error messages indicating the problem location. Common issues include missing commas between JSON elements, unclosed brackets, or invalid option names.

Advanced Customization and Presets

Beyond basic configuration, Fastfetch offers sophisticated customization possibilities.

Creating Custom Presets

Save multiple configurations for different purposes. Create separate configuration files for different scenarios:

cp ~/.config/fastfetch/config.jsonc ~/.config/fastfetch/gaming.jsonc
cp ~/.config/fastfetch/config.jsonc ~/.config/fastfetch/workstation.jsonc

Edit each configuration for its specific purpose. Load them with the --config option:

fastfetch --config ~/.config/fastfetch/gaming.jsonc

Leveraging JSON Schema Support

Add a schema reference line at your configuration file’s beginning:

{
  "$schema": "https://json.schemastore.org/fastfetch.json",
  ...
}

Modern editors like VS Code and Helix recognize this schema, providing autocomplete suggestions, syntax validation, and hover documentation for all configuration options.

Understanding Format Strings

Format strings allow custom module output. Each module supports specific format variables. For example, the CPU module might use:

{name} ({cores-physical}C/{cores-logical}T) @ {freq-max}

This displays your CPU name, physical and logical core counts, and maximum frequency.

Discover available format options:

fastfetch --help | grep -i format

Review module-specific format documentation:

fastfetch --help CPU

Color Configuration and Theming

Configure module-specific colors based on thresholds. Memory usage might display green when usage is low, yellow for medium usage, and red for high usage:

{
  "modules": [
    {
      "type": "Memory",
      "format": "{used} / {total}",
      "colors": {
        "0-25": "green",
        "25-75": "yellow",
        "75-100": "red"
      }
    }
  ]
}

Using Custom Images and Logos

Display custom images instead of ASCII logos. Fastfetch supports multiple image protocols:

{
  "logo": {
    "type": "file",
    "source": "~/.config/fastfetch/my-logo.png",
    "width": 32,
    "height": 16
  }
}

Supported image protocols include Sixel (xterm), Kitty graphics protocol, and iTerm2 inline images. Your terminal must support the protocol for image display to work.

Terminal Integration Strategies

Integrate Fastfetch into your shell initialization. Add to your ~/.bashrc:

# Display system information on shell startup
fastfetch

For zsh, add to ~/.zshrc:

# Display system information on shell startup
fastfetch

For Fish shell, add to ~/.config/fish/config.fish:

# Display system information on shell startup
fastfetch

Conditional execution prevents Fastfetch from running in non-interactive shells:

# Bash/Zsh
if [[ $- == *i* ]]; then
  fastfetch
fi

Troubleshooting Common Installation Issues

Despite careful planning, installation issues occasionally occur. These solutions address the most common problems.

Package Not Found Errors

If DNF reports that the fastfetch package doesn’t exist, your system’s repositories may lack this package. First, ensure your repositories are properly configured:

sudo dnf config-manager --set-enabled fedora
sudo dnf config-manager --set-enabled fedora-updates
sudo dnf clean all
sudo dnf makecache

Retry installation. If the package still doesn’t appear, check your Fedora version:

cat /etc/os-release | grep VERSION_ID

Ensure your Fedora version is current. Fastfetch may not be available for older Fedora versions in standard repositories. In this case, source installation becomes necessary.

Dependency Resolution Errors

If DNF reports unresolvable dependencies, conflicting packages may exist. Attempt a clean installation:

sudo dnf remove fastfetch -y
sudo dnf clean all
sudo dnf makecache
sudo dnf install fastfetch -y

This approach removes any partial installation and reinstalls cleanly.

Display and Rendering Issues

If Fastfetch displays incorrectly or doesn’t render properly, terminal compatibility issues may exist. Test with minimal modules:

fastfetch -s OS:Kernel

If minimal output displays correctly, certain modules may be problematic on your terminal. Disable problematic modules in your configuration.

Terminal encoding issues cause character corruption. Ensure your terminal uses UTF-8 encoding:

echo $LANG

Output should include UTF-8. If not, set it:

export LANG=en_US.UTF-8

Configuration File Syntax Errors

If Fastfetch reports configuration errors, validate JSON syntax using online validators or local tools:

python3 -m json.tool ~/.config/fastfetch/config.jsonc

Common syntax errors include missing commas after JSON elements, unclosed quotes, or mismatched brackets. Carefully review your configuration, checking for these issues.

Performance or Responsiveness Issues

If Fastfetch seems slow, certain modules might be problematic. Disable modules one by one to identify the culprit:

fastfetch -s OS:Kernel:CPU

If performance improves with fewer modules, a specific module may be slow on your system. Remove that module from your configuration.

Feature Availability Problems

If expected features don’t work, optional dependencies may be missing. Install optional packages:

sudo dnf install chafa imagemagick libpulse -y

Reinstall Fastfetch after installing optional dependencies:

sudo dnf reinstall fastfetch -y

This may enable previously unavailable features.

Keeping Fastfetch Updated on Fedora 43

Maintaining current software ensures security, compatibility, and access to new features.

Updating via DNF

Regular updates keep your Fastfetch installation current:

sudo dnf update fastfetch

Include this in your regular system update routine:

sudo dnf upgrade

This command updates all installed packages, including Fastfetch if updates are available.

Checking for New Versions

Determine your current version:

fastfetch --version

Check available versions:

sudo dnf info fastfetch | grep Version

Compare versions to determine if updates are available. The official GitHub repository also shows the latest development version at https://github.com/fastfetch-cli/fastfetch/releases

Updating Source Installations

For users who compiled from source, update by pulling the latest code:

cd ~/src/fastfetch
git pull origin main
cd build
cmake ..
make -j$(nproc)
sudo make install

This sequence updates your local repository, rebuilds, and reinstalls the latest version.

Reviewing Changes and Features

Examine release notes to understand new features:

fastfetch --help

This displays help information for the current version. GitHub release pages provide detailed changelogs explaining improvements and additions.

Best Practices for Timely Updates

Enable automatic system updates for convenience:

sudo dnf install dnf-automatic
sudo systemctl enable --now dnf-automatic.timer

Alternatively, regularly run:

sudo dnf check-update

This command shows available updates without installing them, allowing informed decisions about update timing.

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