How To Install Fastfetch on openSUSE

Fastfetch is a powerful system information tool written in C that offers a faster and more feature-rich alternative to Neofetch. If you’re looking to enhance your openSUSE system with a customizable system information display tool, Fastfetch is an excellent choice. This comprehensive guide will walk you through the installation process, configuration options, and advanced customization techniques specifically for openSUSE users.

Understanding Fastfetch

Fastfetch is a modern system information display tool that shows your operating system details, hardware specifications, and software configurations in an aesthetically pleasing way. Unlike Neofetch, which is written in Bash, Fastfetch is developed in C, making it significantly faster and more efficient. This performance advantage is particularly noticeable on systems with limited resources.

The tool provides comprehensive information about your system, including operating system details, kernel version, uptime, package count, CPU, GPU, memory usage, disk space, and much more. What sets Fastfetch apart is its extensive customization capabilities through structured configuration files, allowing you to tailor the output precisely to your preferences.

Fastfetch supports numerous operating systems, including Linux distributions like openSUSE, as well as FreeBSD, macOS, and even Windows 7 or newer. For openSUSE users, Fastfetch integrates seamlessly with the system, providing accurate and detailed information specific to the distribution.

Prerequisites for Installation

Before installing Fastfetch on your openSUSE system, ensure you have the following:

• An updated openSUSE system (Leap or Tumbleweed)
• Administrative (sudo) privileges
• Basic familiarity with terminal commands
• Internet connection for downloading packages

It’s also recommended to update your system repositories before installation to ensure you get the latest version of Fastfetch:

sudo zypper refresh

This command synchronizes your local package database with the remote repositories, ensuring that you have access to the most recent packages available.

Installation Methods for openSUSE

There are several ways to install Fastfetch on openSUSE, with the package manager method being the simplest and most straightforward.

Using Zypper Package Manager

Installing Fastfetch through openSUSE’s native package manager, Zypper, is the recommended approach:

sudo zypper install fastfetch

This command will automatically handle all dependencies and install the latest version of Fastfetch available in the openSUSE repositories. The installation process is typically quick and straightforward, requiring minimal user intervention.

Using openSUSE Build Service

If you prefer to install Fastfetch from the openSUSE Build Service, you can add the utilities repository and install it manually:

sudo zypper addrepo https://download.opensuse.org/repositories/utilities/openSUSE_Tumbleweed/utilities.repo
sudo zypper refresh
sudo zypper install fastfetch

Replace openSUSE_Tumbleweed with your specific openSUSE version if you’re using Leap.

Building from Source

For users who prefer to build from source or need the latest development version, follow these steps:

1. Install necessary build dependencies:

   sudo zypper install git cmake gcc make

2. Clone the Fastfetch repository:

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

3. Navigate to the source directory:

   cd fastfetch

4. Create a build directory and compile:

   mkdir -p build
   cd build
   cmake ..
   make

5. Install the compiled program:

   sudo make install

This method gives you access to the most recent features and improvements, but may require more manual maintenance for updates.

Verifying the Installation

After installation, verify that Fastfetch is correctly installed by running:

fastfetch --version

This should display the installed version of Fastfetch. If the command is not found, ensure that the installation directory is in your PATH variable.

First Run and Basic Usage

Once Fastfetch is successfully installed, you can run it with the simple command:

fastfetch

This will display the default output, showing your system information alongside the default logo for your distribution. On openSUSE, you’ll see the characteristic green chameleon logo alongside details about your system.

Some basic command-line options include:

• fastfetch -l [logo]: Use a specific logo instead of the default
• fastfetch -s [modules]: Specify which modules to display
• fastfetch -c [preset]: Use a predefined preset configuration

For example, to run Fastfetch with just the hardware information using the openSUSE logo:

fastfetch -c hardware -l opensuse

This command loads the hardware preset, which focuses on displaying hardware-related information while using the openSUSE logo.

Configuration Basics

Fastfetch uses JSONC (JSON with Comments) for its configuration files, making it highly customizable yet straightforward to configure.

Generating Your First Configuration File

To create a default configuration file, run:

fastfetch --gen-config

This command generates a default configuration file at ~/.config/fastfetch/config.jsonc. If you want to force-generate a configuration file (overwriting any existing one), use:

fastfetch --gen-config-force

The configuration file contains various sections for customizing logos, colors, layout, and which modules to display.

Understanding the Configuration Structure

The Fastfetch configuration file follows a JSON structure with the following main sections:

1. Logo: Controls which logo to display and how
2. Display: Controls the overall display formatting
3. Modules: Defines which information modules to show and their order

Here’s a simple example of a basic configuration file:

{
  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",
  "logo": {
    "type": "auto",
    "source": "opensuse"
  },
  "display": {
    "separator": ": ",
    "color": {
      "keys": "green",
      "title": "green"
    }
  },
  "modules": [
    "title",
    "separator",
    "os",
    "kernel",
    "uptime",
    "packages",
    "shell",
    "terminal",
    "cpu",
    "memory",
    "disk"
  ]
}

This configuration uses the openSUSE logo, sets the text color to green (matching the openSUSE brand), and displays a selection of common information modules.

Customizing the Display

Fastfetch offers extensive customization options for tailoring the output to your preferences. Let’s explore some of the most useful customization techniques.

Changing Logos

Fastfetch comes with a variety of built-in logos for different distributions. To list all available logos:

fastfetch --list-logos

To use a specific logo:

fastfetch -l opensuse

You can also use custom ASCII art or image files as logos by specifying the path in your configuration file:

"logo": {
  "type": "file",
  "source": "/path/to/your/logo.txt"
}

For openSUSE users, the default logo is the recognizable green chameleon, but you might want to use alternatives like the openSUSE Leap or Tumbleweed specific logos for better visual identification.

Color Customization

You can customize the colors used for different elements of the output:

"display": {
  "color": {
    "keys": "green",
    "title": "bright_green",
    "separator": "white"
  }
}

This sets the module names to green, the title to bright green, and the separator to white, creating a visually appealing color scheme that matches the openSUSE brand colors.

Formatting and Alignment

Control how information is aligned and formatted:

"display": {
  "separator": " → ",
  "key": {
    "width": 12,
    "alignment": "left"
  },
  "value": {
    "alignment": "left"
  }
}

This configuration uses a custom separator (→) and ensures that all keys have a consistent width of 12 characters, improving readability.

Working with Modules

Modules are the individual components that display different pieces of system information. Fastfetch offers a wide range of modules that can be customized to suit your needs.

Available Modules

To see all available modules:

fastfetch --list-modules

This command displays all modules that Fastfetch can show, along with a brief description of each.

Selecting Specific Modules

You can specify which modules to display either in the configuration file or directly from the command line:

fastfetch -s Title:OS:Kernel:Uptime:Memory:Disk

This command displays only the Title, OS, Kernel, Uptime, Memory, and Disk modules, in that order.

In your configuration file, you can achieve the same result with:

"modules": [
  "title",
  "os",
  "kernel",
  "uptime",
  "memory",
  "disk"
]

Customizing Individual Modules

Each module can be customized with specific formatting options. For example, to customize the Memory module to show used and total memory with percentages:

"modules": [
  {
    "type": "memory",
    "format": "{used}/{total} ({used_percent}%)"
  }
]

This creates a more detailed and informative memory display that shows both absolute values and percentages.

Using Presets

Fastfetch includes several predefined presets that configure the output to mimic other system information tools or focus on specific aspects of your system.

Available Presets

To list all available presets:

fastfetch --list-presets

Common presets include:

• neofetch: Mimics the output style of Neofetch
• hardware: Focuses on hardware information
• software: Focuses on software information
• minimal: Shows only essential information

To use a preset:

fastfetch -c neofetch

This command loads the neofetch preset, which configures Fastfetch to display information in a style similar to Neofetch.

Creating Custom Presets

You can create your own presets by saving configuration files in the presets directory. The default locations for presets are:

1. ~/.local/share/fastfetch/presets/
2. /usr/share/fastfetch/presets/

Create a new JSON configuration file in one of these directories, and you can then load it using the -c option:

fastfetch -c mypreset

This approach allows you to switch between different configurations easily, which is particularly useful if you need different information displayed in different contexts.

Advanced Configuration

For power users, Fastfetch offers advanced configuration options to fine-tune performance and display.

Performance Tuning

Control the performance aspects of Fastfetch:

"general": {
  "multithreading": true,
  "processingTimeout": 1000,
  "detectVersion": false
}

This configuration enables multithreading for faster information gathering, sets a processing timeout of 1000ms, and disables version detection for applications (which can be slow).

Conditional Display

You can set conditions for displaying certain modules:

"modules": [
  {
    "type": "gpu",
    "displayFormat": "{%{vendor}% %{name}%} ({%{temperature}%}°C)",
    "temperatureFormat": true,
    "condition": "%{temperature}% > 60"
  }
]

This displays the GPU information with temperature, but only if the temperature exceeds 60°C, which can be useful for monitoring potential overheating issues.

Using Environment Variables

Fastfetch supports environment variables for dynamic configuration:

export FASTFETCH_LOGO="opensuse"
export FASTFETCH_COLOR_KEYS="green"
fastfetch

This sets the logo to openSUSE and the key color to green for the current session, without modifying the configuration file.

Integration with System

Integrating Fastfetch with your system allows you to automatically display system information in various contexts.

Adding to Shell Startup

To display Fastfetch every time you open a terminal, add the following line to your shell’s configuration file:

For Bash (~/.bashrc):

fastfetch

For Zsh (~/.zshrc):

fastfetch

This ensures that Fastfetch runs automatically whenever you open a new terminal session, providing a quick overview of your system.

Using with Terminal Multiplexers

If you use terminal multiplexers like tmux or screen, you can configure Fastfetch to display in new sessions:

For tmux, add to ~/.tmux.conf:

set-option -g default-command "fastfetch; $SHELL"

This runs Fastfetch at the start of each tmux session, providing system information before returning control to your shell.

Troubleshooting

When using Fastfetch on openSUSE, you might encounter some issues. Here are solutions to common problems:

Missing Dependencies

If you encounter errors about missing libraries, install the required dependencies:

sudo zypper install libpci-dev libvulkan-dev

These packages provide the necessary libraries for hardware detection features in Fastfetch.

Display Issues

If the ASCII art logo appears distorted, try using a different terminal font or adjusting your terminal size. Monospace fonts generally work best for ASCII art displays.

For color issues, check your terminal’s color support:

fastfetch --true-color=off

This disables true color support, which can help if your terminal doesn’t support 24-bit colors.

Performance Optimization

If Fastfetch seems slow to start:

fastfetch --detect-version=off

This disables version detection for applications, which can significantly improve startup time on systems with many installed packages.

Comparison with Other Tools

Fastfetch offers several advantages over similar tools like Neofetch, particularly for openSUSE users.

Fastfetch vs Neofetch on openSUSE

• Performance: Fastfetch is significantly faster than Neofetch due to being written in C rather than Bash
• Customization: Fastfetch offers more granular control through its JSON configuration system
• Features: Fastfetch provides additional modules not available in Neofetch, such as detailed GPU information and temperature monitoring
• Integration: Fastfetch includes specific optimizations for openSUSE, ensuring accurate package counting and distribution detection

For most openSUSE users, Fastfetch provides a more responsive and feature-rich experience, especially on systems where performance is a consideration.

Command Reference

Here’s a quick reference of commonly used Fastfetch commands:

• fastfetch: Run with default configuration
• fastfetch -c [preset]: Use a specific preset
• fastfetch -l [logo]: Use a specific logo
• fastfetch -s [modules]: Display specific modules
• fastfetch --gen-config: Generate a default configuration file
• fastfetch --list-modules: List all available modules
• fastfetch --list-logos: List all available logos
• fastfetch --list-presets: List all available presets
• fastfetch --version: Display version information

These commands provide a solid foundation for exploring and utilizing the full capabilities of Fastfetch on your openSUSE system.

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