Linux Neofetch: The Complete Guide to a Terminal Icon (And What Comes Next)

Open any Linux screenshot thread on Reddit or a distro forum and you will find it within the first few posts: a terminal window with a colorful ASCII logo on the left and a neat column of system specs on the right. That output almost certainly came from neofetch. For nearly a decade, neofetch was the first tool many people installed on a fresh Linux setup and the last thing visible in a flex screenshot. It became shorthand for "I use Linux and I care about how my terminal looks."

Then, on April 26, 2024, developer Dylan Araps archived every one of his 70 GitHub repositories simultaneously, leaving behind a single line in a README: "Have taken up farming." The neofetch project was officially dead, though it had functionally been on life support since its last commit in December 2021. Understanding what neofetch is, why it resonated so widely, and where to go from here is worth more than a passing mention in a changelog.

What Neofetch Actually Does

Neofetch is a command-line system information tool written in Bash 3.2. Its job is simple: collect details about the host machine and display them in the terminal alongside the ASCII art logo of the detected operating system. The output is designed to be human-readable and visually appealing rather than machine-parseable.

According to the archived GitHub repository, github.com/dylanaraps/neofetch, neofetch supports nearly 150 different operating systems. That breadth is part of what made it so popular: the same script worked on Ubuntu, Arch, macOS, BSD variants, and even exotic platforms like Haiku and Minix. By default, the output includes:

• Operating system name and version
• Host machine model
• Kernel version
• System uptime
• Package count across installed package managers
• Shell name and version
• Display resolution
• Desktop environment and window manager
• WM theme, GTK theme, and icon set
• Terminal emulator
• CPU model and speed
• GPU model
• RAM usage
• A row of color palette blocks at the bottom

Every item in that list is optional and configurable. That configurability is what turned neofetch from a utility into a hobby. Entire communities formed around sharing config files and custom ASCII logos.

What the Output Actually Looks Like

The layout is two columns, side by side in the terminal: the ASCII logo on the left, the info column on the right. The width of the logo determines how far right the info column sits. Here is a representative example of what a default neofetch invocation produces on an Arch Linux system:

                  -`                    user@hostname
                 .o+`                   -------------
                `ooo/                   OS: Arch Linux x86_64
               `+oooo:                  Host: ThinkPad X1 Carbon
              `+oooooo:                 Kernel: 6.8.1-arch1-1
              -+oooooo+:               Uptime: 3 hours, 42 mins
            `/:-:++oooo+:              Packages: 847 (pacman)
           `/++++/+++++++:             Shell: zsh 5.9
          `/++++++++++++++:            Resolution: 2560x1440
         `/+++ooooooooooooo/`          DE: Hyprland
        ./ooosssso++osssssso+`         WM Theme: Dracula
       .oossssso-````/ossssss+`        Terminal: kitty
      -osssssso.      :ssssssso.       CPU: Intel i7-1185G7 (8) @ 4.800GHz
     :osssssss/        osssso+++.      GPU: Intel Iris Xe Graphics
    /ossssssss/        +ssssooo/-      Memory: 3891MiB / 15822MiB
  `/ossssso+/:-        -:/+osssso+-
 `+sso+:-`                 `-/+ossso-
`++:.                           `-/+/  [][][][][][][][][][][][]

The colored stripe at the bottom is neofetch's palette block: eight normal colors followed by eight bright colors from the terminal's current color scheme. It is a quick visual check of how your terminal theme looks. The entire output is designed to be screenshot-ready in a single terminal window with no extra formatting required.

Why Bash?

Neofetch being a Bash script was not a limitation — it was a deliberate portability decision. Bash 3.2 ships on virtually every Unix-like system, including macOS (where it remained the default shell through macOS Catalina) and every mainstream Linux distribution. A compiled binary would require distribution-specific packages or architecture-specific builds. A Bash script requires nothing beyond what is already present on the system.

That choice had real consequences. It made neofetch trivially installable — a single script file, no build step, no dependency chain beyond the standard POSIX utilities it calls. It also meant anyone comfortable reading shell code could inspect, fork, or modify it with no toolchain. The tradeoff was performance: spawning subprocesses for every piece of system information is inherently slower than a compiled program making direct syscalls, which is precisely why Fastfetch can claim such a significant speed advantage by doing the same work in C.

Installing Neofetch

Because the project is archived rather than deleted, neofetch remains in the package repositories of many major distributions. You can still install it through your package manager, though you should be aware that the version you receive may differ from the last upstream release depending on when your distribution last synced its packages.

# Debian / Ubuntu / Linux Mint
$ sudo apt install neofetch

# Arch Linux
$ sudo pacman -S neofetch

# Fedora / RHEL / CentOS
$ sudo dnf install neofetch

# Alpine Linux
$ sudo apk add neofetch

# openSUSE
$ sudo zypper install neofetch

# FreeBSD
$ sudo pkg install neofetch

Once installed, running neofetch with no arguments produces the default output. You can suppress the logo entirely with neofetch --off, show only the logo with neofetch -L, or point the tool at a custom ASCII art file with neofetch --source /path/to/art.txt.

Installing Neofetch on macOS and BSD

Neofetch was never Linux-only. On macOS, the straightforward route is Homebrew:

# macOS via Homebrew
$ brew install neofetch

# macOS via MacPorts
$ sudo port install neofetch

# NetBSD via pkgsrc
$ pkgin install neofetch

# OpenBSD via ports
$ doas pkg_add neofetch

On macOS, neofetch detects the macOS version and uses the Apple logo as its ASCII art. The output includes the same fields as the Linux version, though some entries behave differently: the package count reflects Homebrew or MacPorts instead of a Linux package manager, and the GPU field reports the Apple Silicon or Intel GPU as reported by system_profiler. Wayland is irrelevant on macOS, but display resolution and desktop environment detection work correctly.

One caveat worth knowing: macOS ships with Bash 3.2 rather than a modern Bash release, for licensing reasons. Neofetch targets Bash 3.2 specifically, so this is intentional compatibility rather than an oversight — it works correctly on the system Bash without requiring an upgraded shell.

The Config File: Where the Real Work Happens

The first time neofetch runs, it generates a config file at ~/.config/neofetch/config.conf. This file is a Bash script, not a structured data format like TOML or JSON. That choice reflects neofetch's design philosophy: if the config is a Bash script, you can put any valid Bash in it, including conditionals, variable substitutions, and shell commands. As the official wiki at github.com/dylanaraps/neofetch/wiki/Customizing-Info explains, because the config file is a Bash script and print_info() is a function within it, any valid Bash syntax is fair game inside the configuration.

A system-wide config also exists at /etc/neofetch/config.conf, which serves as the template from which the per-user file is copied. If you want to apply changes for every user on a system, edit the system-wide file. If you want personal settings that survive a distro update touching the system-wide config, keep your changes in the user-level file.

The print_info() Function

The heart of neofetch configuration is the print_info() function at the top of the config file. This function controls exactly which lines appear in the output column and in what order. The default looks like this:

print_info() {
    info title
    info underline

    info "OS"        distro
    info "Host"      model
    info "Kernel"    kernel
    info "Uptime"    uptime
    info "Packages"  packages
    info "Shell"     shell
    info "Resolution" resolution
    info "DE"        de
    info "WM"        wm
    info "WM Theme"  wm_theme
    info "Theme"     theme
    info "Icons"     icons
    info "Terminal"  term
    info "CPU"       cpu
    info "GPU"       gpu
    info "Memory"    memory

    # Commented-out extras — uncomment to enable:
    # info "Disk"       disk
    # info "Battery"    battery
    # info "Local IP"   local_ip
    # info "Public IP"  public_ip
    # info "Locale"     locale

    info cols
}

To remove a line from the output, prepend a # to comment it out. To add a line, uncomment it. To reorder, cut and paste the lines. The label in the first string argument (like "OS" or "Kernel") is arbitrary — you can rename any label to whatever you want. The second argument is the internal function name neofetch calls to collect that data.

You can also inject completely custom content using the prin function, which behaves like echo inside the output column. For example, adding prin "My Label" "My Value" anywhere in print_info() will print a static line with that label and value every time neofetch runs. This is useful for showing information neofetch does not natively collect, such as the output of a shell command.

ASCII Art and Logo Options

By default, neofetch detects your operating system and selects the matching ASCII logo automatically. You can override this in the config with the ascii_distro variable:

# Force a specific distro logo regardless of the running OS
ascii_distro="arch"

# Use a small variant of the logo (where available)
ascii_distro="ubuntu_small"

# Use a custom ASCII art file from disk
image_source="/home/user/my_ascii.txt"
image_backend="ascii"

# Override the logo colors (six values for the six color slots)
ascii_colors=(4 6 1 8 8 6)

# Control whether the logo is bold
ascii_bold="on"

The color numbering follows the standard 256-color terminal palette. The value distro in ascii_colors is a special keyword that tells neofetch to use the official colors for the detected distribution, which is the default behavior.

Running Neofetch on Terminal Startup

The canonical use case for neofetch is displaying your system info every time you open a new terminal session. To achieve this, add a call to neofetch at the end of your shell's startup file. For Bash, that file is ~/.bashrc. For Zsh, it is ~/.zshrc. For Fish, it is ~/.config/fish/config.fish.

# Add at the end of your shell config to run on every new terminal
neofetch

# Or use a specific config file
neofetch --config ~/.config/neofetch/minimal.conf

# Run only in interactive shells (not scripts)
[[ $- == *i* ]] && neofetch

The guard [[ $- == *i* ]] is worth including. It checks whether the current shell is interactive before running neofetch, preventing it from printing output when a script sources your shell config non-interactively. Without that guard, you may see unexpected neofetch output in places like SSH automation scripts or certain login processes.

What About Windows and WSL?

Neofetch was never Linux-exclusive. The archived repository explicitly lists Windows as a supported platform, and for years it was one of the first things people installed inside a Windows Subsystem for Linux environment. If you were on WSL and ran sudo apt install neofetch, it worked — mostly.

The qualifier matters. Neofetch running inside WSL reads its system information from the Linux layer, not the Windows host directly. The OS field correctly shows your WSL distribution (Ubuntu, Debian, and so on), and hardware fields like CPU and memory report accurately because WSL 2 exposes those through a real Linux kernel. The notable failure was Windows version detection: a known bug caused neofetch to report "Windows 10" even on Windows 11 hosts, a consequence of the project being frozen before Microsoft's build number conventions were updated in neofetch's detection logic. That bug was never fixed.

Fastfetch on Windows and WSL

Fastfetch handles the Windows ecosystem significantly better. According to the project's GitHub repository, Fastfetch natively supports Windows 8.1 and newer without requiring WSL at all — it compiles as a native Windows binary. That means you can install it directly in Windows Terminal using a package manager like Scoop or by downloading the prebuilt binary from the Fastfetch releases page, and it will report accurate Windows version information, GPU data via DirectX queries, and display resolution without any of the translation layer issues that plagued neofetch under WSL.

For users who want to stay inside WSL, Fastfetch works correctly there too — and since it is packaged in Ubuntu's repositories (directly for 25.04 and later, via PPA for earlier releases), the installation path inside WSL is identical to the one on a native Linux machine.

Winfetch: The Native Windows Alternative

If you are on Windows and prefer something built specifically for the platform, Winfetch is the most direct replacement. Written in PowerShell, it runs natively in Windows Terminal without WSL and produces output that mirrors the neofetch aesthetic. It supports custom ASCII art, can use your desktop wallpaper as the background image source, and detects Windows-specific information like Windows edition, BitLocker status, and battery state that a Linux-derived tool running in WSL cannot easily access. You can install it through PowerShell's package gallery with Install-Script -Name winfetch, or via Scoop with scoop install winfetch.

Neofetch and the Linux Screenshot Culture

It would be incomplete to discuss neofetch purely as a technical tool. It became a social artifact within Linux communities. The subreddit r/unixporn, dedicated to desktop customization screenshots, effectively standardized neofetch output as a required element in any submission. Posting a riced desktop without neofetch in the corner became the exception rather than the rule.

As OMG! Ubuntu noted in April 2024, neofetch had become a fixture in Linux desktop screenshots and had earned a place on lists of the best Linux command-line tools precisely because it transcended utility — visually distinctive and deeply embedded in community culture, to the point that many people had encountered it in screenshots long before ever running it themselves. It was a signal: the person at that terminal cared about their environment.

The GitHub repository for neofetch sat at 23,400 stars at the time of archiving, a significant number for a pure Bash utility with no graphical interface. The community that grew up around it produced repositories dedicated entirely to neofetch themes and config variations, such as the neofetch-themes repository on GitHub, which collected dozens of contributed configurations ranging from minimal single-line outputs to elaborate multi-column displays using Nerd Fonts.

The Archiving: What Happened

Understanding the end of neofetch requires acknowledging the warning signs that accumulated over years. The last update to the neofetch codebase was version 7.1.0, released in August 2020. The last commit of any kind was made in December 2021. In the roughly two and a half years between that final commit and the April 2024 archiving, the repository accumulated over 100 unmerged pull requests and a growing list of issues that the maintainer was not addressing.

As development on Neofetch stalled, new hardware and software continued to emerge. Newer CPUs began returning incorrect or missing information. Some newer GPU models were not recognized. Wayland session detection was never properly implemented. The project was, in effect, frozen while the Linux ecosystem moved around it.

Dylan Araps did not give a detailed explanation at the time. On April 26, 2024, all 70 of his GitHub repositories were archived simultaneously, and his personal profile README was updated to read: "Have taken up farming." A community member at adamsdesk.com sent Araps a set of questions by email in April 2024 asking about his motivations, but received no response as of the date of that post. The departure was total and deliberate.

In early 2026, Araps broke his silence publicly for the first time, publishing a first-person account on his personal site, dylan.gr, and announcing a natural farming venture called WILD. The account revealed what had been hidden behind the four-word README: years of developer burnout, physical deterioration from sedentary 16-hour workdays, and a deliberate, years-long personal transformation.

Araps's account on dylan.gr described the physical cost of years of sedentary 16-hour screen days and the deliberate transformation that followed — a period he characterized as spending the majority of his waking hours staring at a screen.

Araps, who had moved with his family from Australia to Greece in 2018, described going completely offline in 2021 without telling anyone, beginning a process of quitting what he described as every vice and overhauling his diet and daily routine. In 2024, the family acquired an abandoned estate in the village of Amphithea on the Greek island of Euboea. They named the venture WILD — a small, family-run natural farming operation producing olive oil and wine using methods that leave the soil untilled and avoid synthetic inputs. His archived repositories were not the result of impulsive burnout; they were the deliberate closing of one chapter before beginning another.

This context matters for anyone who wondered whether the archiving was a temporary disappearance similar to earlier periods when Araps had gone quiet on other projects like KISS Linux. It was not. The archiving was the official confirmation of a transition that had been underway since 2021, and Araps has since made clear he has no plans to return to software development.

For those unfamiliar with it: KISS Linux was a minimalist Linux distribution Araps maintained alongside neofetch, built around a philosophy of extreme simplicity and minimal dependencies. It attracted a small but committed following, and its archiving alongside neofetch meant the Linux community lost two of his projects simultaneously. Both had the same solo-maintainer structure and the same abrupt end.

The Wikipedia article on Neofetch notes that the project was the work of a solo maintainer throughout its entire life. That structure, combined with the scale of community expectations built up over nearly a decade, is a textbook example of open-source sustainability pressure. Araps had received no organizational support, no co-maintainers, and no transition plan for the project. The result was an abrupt end rather than a handoff.

Can Someone Fork Neofetch and Continue It?

Yes, and several people have. The MIT License under which neofetch was released explicitly permits forking, redistribution, and modification with no restrictions beyond preserving the license notice. Araps archiving the repository did not revoke those rights. Anyone can clone the repository, take the codebase, and publish a maintained fork under a new name.

HyFetch, described in the alternatives section below, is the most prominent example of exactly this. It takes the neofetch codebase, applies ongoing patches for modern hardware and distribution detection, and adds the interactive color scheme selector. The original neofetch configuration files remain compatible because the underlying Bash functions are structurally unchanged.

What a fork cannot do is merge changes back into the original repository, file issues there, or update the package that distributions ship as neofetch. The original package in Ubuntu's repositories, for example, still points to Araps's archived code. Distribution maintainers would need to redirect their packages to a maintained fork before users installing sudo apt install neofetch would automatically receive the updated codebase. That transition has not happened at scale, which is part of why Fastfetch — a clean independent rewrite rather than a fork — has become the more commonly recommended path.

Where to Go From Here: Active Alternatives

The neofetch ecosystem did not collapse when Araps walked away. Several alternatives were already being developed, and the news of the archiving accelerated community adoption of them. The two most serious replacements to know about are Fastfetch and HyFetch.

Fastfetch: The Clear Successor

Fastfetch is not forked from neofetch; it is an independent project written primarily in C rather than Bash. That architectural difference matters: independent benchmarks showed Fastfetch completing in roughly 78% less time than neofetch, as documented at Tech Providence. The speed difference is most noticeable on systems that count packages across multiple package managers, an operation that requires spawning subshell processes in a Bash tool but can be handled more efficiently in a compiled binary.

Beyond performance, Fastfetch has several advantages over the tool it is replacing. The Fastfetch GitHub repository at github.com/fastfetch-cli/fastfetch documents concrete accuracy differences: where neofetch would display memory as "555 MiB" and disk sizes with inconsistent units, Fastfetch outputs precise decimal values and correctly uses GiB throughout. That accuracy improvement extends to Wayland support, which neofetch technically never implemented correctly, and to GPU detection using driver-specific queries for newer hardware.

Fastfetch uses JSONC (JSON with comments) for its configuration rather than a Bash script. That is a trade-off: you lose the ability to embed arbitrary Bash logic directly in the config, but you gain a structured format that is easier to validate and share. The project ships with over 20 preset configuration files, including one that replicates neofetch's default output exactly. To install and run it in neofetch compatibility mode:

# Arch Linux
$ sudo pacman -S fastfetch

# Fedora
$ sudo dnf install fastfetch

# Alpine
$ sudo apk add fastfetch

# Ubuntu (via official PPA)
$ sudo add-apt-repository ppa:zhangsongcui3371/fastfetch
$ sudo apt update && sudo apt install fastfetch

# Load the neofetch-compatible preset
$ fastfetch --load-config neofetch

# Generate a personal config file to edit
$ fastfetch --gen-config

# List all available logos (400+ entries)
$ fastfetch --list-logos

Fastfetch is packaged in the official repositories of Ubuntu 25.04 and later, meaning a plain sudo apt install fastfetch works without any additional steps on those releases. Ubuntu 24.04 LTS and 22.04 LTS users should use the PPA above to get a current build — Ubuntu 24.10 ships with version 2.15.x, which lags well behind the project's current release cadence. The tool also supports the --pipe flag to disable colors when outputting to non-interactive contexts, and a Command module that can run arbitrary shell commands and include their output, which partially compensates for the loss of embedded Bash in the config.

HyFetch: The Direct Fork

HyFetch is a direct fork of neofetch that takes the original codebase and extends it with active maintenance patches and a Pride-themed color system. Unlike Fastfetch, HyFetch is still a Bash script and is compatible with existing neofetch config files. The alternative invocation command neowofetch uses the same HyFetch codebase but defaults to distro-based colors instead of the Pride flag scheme.

HyFetch is packaged in the Ubuntu 24.04 LTS repositories, which makes it an easy choice for Ubuntu users who want a maintained drop-in replacement without changing their config file or workflow. On first run, HyFetch prompts you to select a color scheme interactively, displaying a preview of each option before you confirm.

screenFetch: The Predecessor That Outlasted Neofetch

screenFetch predates neofetch and was the tool neofetch was originally written to replace. Despite being older and less visually sophisticated, it has the notable distinction of remaining actively maintained. It is available in the default repositories of Arch Linux, Fedora, Ubuntu, Debian, and most other major distributions without the need for a PPA or third-party source. For system administrators who want zero configuration and zero setup overhead, screenFetch is a practical choice precisely because it asks nothing of you: install it, run it, and it works.

The meaningful limitation compared to Fastfetch is customization depth. screenFetch does not expose a config file for rearranging output fields. What you see is what you get. For users who were deeply invested in a tuned neofetch layout, that rigidity is a regression. For users who just want the hostname, kernel, and hardware on screen, it is irrelevant. screenFetch is also written in Bash, so the same performance ceiling that applied to neofetch applies here — startup time grows proportionally on systems with multiple package managers.

macchina: The Rust Rewrite for Low-Resource Systems

macchina takes a different approach than both neofetch and Fastfetch. Written in Rust, it prioritizes minimal resource usage and startup time, with benchmarks in the project's documentation showing lower memory overhead than Fastfetch on some configurations. The configuration system uses TOML rather than JSONC, which some users will find more readable. Critically, macchina separates the theming configuration into its own file, meaning you can swap visual themes without touching your data collection settings — a cleaner separation of concerns than neofetch ever achieved.

The practical limitation is distribution availability. macchina is not packaged in the default repositories of Ubuntu, Fedora, or most mainstream distributions. You either install it via Cargo (cargo install macchina), download a prebuilt binary from the GitHub releases page, or find it in the AUR on Arch. For users comfortable with Cargo that is a non-issue, but it adds a step that Fastfetch's PPA and official repository availability avoids. macchina is a strong choice for embedded Linux, low-RAM VMs, or anyone who already has a Rust toolchain and wants something with a smaller binary footprint.

NerdFetch: When You Have Nerd Fonts Installed

NerdFetch is worth understanding as a philosophy as much as a tool. Instead of ASCII art logos, it uses Nerd Font glyphs — the icon font that ships with most modern terminal setups like Oh My Zsh, Powerlevel10k, and similar configurations. The result is a more compact output: the system information takes fewer lines and the icons read as actual symbols rather than character art. On a high-DPI monitor with a configured Nerd Font, it looks noticeably cleaner than a traditional ASCII logo.

The dependency caveat is the entire qualifier here. NerdFetch produces meaningless placeholder characters on any terminal without a Nerd Font installed, which means it is not portable in the way neofetch was. You cannot paste your config on a bare server, a container, or a colleague's machine and expect it to render. It is also a POSIX shell script rather than a compiled binary, so it carries the same class of performance constraints as neofetch and screenFetch. Think of NerdFetch as the right tool for a carefully configured personal workstation where Nerd Fonts are already a prerequisite for your prompt anyway.

cpufetch: A Specialist Tool, Not a Replacement

cpufetch occupies a completely different category from the tools above. It does not attempt to display general system information. Its sole function is CPU identification, and it does that job with a level of technical granularity that no general-purpose fetch tool matches. The output includes the CPU vendor logo rendered in color, the microarchitecture name, process node, die size where known, supported instruction set extensions (SSE, AVX, AVX-512, and so on), peak theoretical performance in GFLOPS, and the physical and logical core topology.

For sysadmins profiling hardware, benchmarking, or verifying that a cloud VM is exposing the CPU features you are paying for, cpufetch surfaces information that would otherwise require reading from /proc/cpuinfo, running lscpu, and cross-referencing a microarchitecture database manually. It is not a neofetch replacement and is not intended to be. The correct pattern is to use it alongside a general-purpose tool like Fastfetch: neofetch gives you the overview, cpufetch gives you the CPU detail when that detail matters.

Choosing the Right Tool for Your Situation

The choice among these tools depends on your actual constraints. If you are migrating a personal machine and want the least friction, Fastfetch with the neofetch preset is the default answer: your existing workflow changes by one command name, the output is identical, and you pick up Wayland support and better hardware detection as a free improvement. If you are deploying on multiple machines and want something available in the default repositories without a PPA, screenFetch or HyFetch (on Ubuntu 24.04+) cover that case. If you maintain a carefully configured workstation setup with Nerd Fonts and want a more refined visual result, NerdFetch rewards that investment. If you work in environments where compiled binaries are undesirable and you want a drop-in Bash script that stays current with new hardware, HyFetch is the most defensible choice precisely because it is a maintained continuation of the original codebase rather than an architectural departure from it.

How to Migrate from Neofetch to Fastfetch

Step 1: Install Fastfetch using your distribution package manager

On Arch Linux run sudo pacman -S fastfetch. On Fedora run sudo dnf install fastfetch. On Ubuntu 25.04 or later run sudo apt install fastfetch. On Ubuntu 22.04 or 24.04 LTS, first add the official PPA with sudo add-apt-repository ppa:zhangsongcui3371/fastfetch, then run sudo apt update followed by sudo apt install fastfetch. On Alpine use sudo apk add fastfetch.

Step 2: Customize which fields appear by editing the config file

Generate a config file with fastfetch --gen-config, which writes a JSONC file to ~/.config/fastfetch/config.jsonc. Open this file in any text editor. Each module in the modules array corresponds to one output line. Remove an object from the array to hide that line, add one to show it, and reorder the array entries to change the display order. Run fastfetch --list-modules to see all available module names. To load a neofetch-compatible layout immediately without manual editing, run fastfetch --load-config neofetch, then copy that preset as a starting point for your own customizations.

Unlike neofetch's Bash-script config, Fastfetch config.jsonc has a defined structure with three top-level sections. Here is what a minimal hand-edited version looks like:

// JSON with Comments (.jsonc) -- comments are valid here
{
  "$schema": "https://github.com/fastfetch-cli/fastfetch/raw/dev/doc/json_schema.json",

  // Logo: auto-detect the current distro, add a small right margin
  "logo": {
    "type": "auto",
    "padding": { "right": 2 }
  },

  // Display: set the separator between key and value
  "display": {
    "separator": ": ",
    "color": { "keys": "blue" }
  },

  // Modules: each entry is one output line, in order
  "modules": [
    "title",
    "separator",
    "os",
    "host",
    "kernel",
    "uptime",
    "packages",
    "shell",
    "display",
    "de",
    "wm",
    "terminal",
    "cpu",
    "gpu",
    {
      // Inline object lets you override format for a single module
      "type": "memory",
      "format": "{used}/{total} ({used_percent}%)"
    },
    "colors"
  ]
}

Step 3: Update your shell startup file to call fastfetch instead of neofetch

Open ~/.bashrc or ~/.zshrc and replace the neofetch call at the end of the file with fastfetch. If you were passing a custom config path to neofetch, update it to point to your new JSONC config: fastfetch --config ~/.config/fastfetch/config.jsonc. Save the file and open a new terminal session to verify the output looks as expected. If you want to preserve the interactive startup guard, keep the [[ $- == *i* ]] && prefix before the fastfetch call.

Frequently Asked Questions

Is neofetch still safe to use in 2026?

Neofetch still runs fine on most systems since it is a Bash script with no network access. The risk is not security in the traditional sense but accuracy and drift: because the project was archived in April 2024 with no commits since December 2021, it cannot detect newer hardware models, newer distro releases, or Wayland sessions correctly. For personal use on stable hardware it is harmless, but for production systems or shared screenshots you should switch to a maintained tool like Fastfetch.

Why did neofetch get archived and who made it?

Neofetch was created by Dylan Araps and first released in 2015. On April 26, 2024, Araps archived all 70 of his GitHub repositories simultaneously, leaving a single README that read: "Have taken up farming." No further explanation was given. Development had effectively stalled since the last commit in December 2021, with over 100 pull requests left unmerged. The archiving was the official confirmation of what the community had suspected for years.

What is the best neofetch alternative in 2026?

Fastfetch is widely regarded as the leading replacement. Written in C, it is significantly faster than neofetch, supports Wayland natively, includes a neofetch-compatible preset, and is actively maintained with regular releases. It is packaged in the official repositories of Arch Linux, Fedora, Alpine, and is available via PPA on Ubuntu. For users who want a direct fork of neofetch with ongoing patches, HyFetch is another option, available in Ubuntu 24.04 LTS repositories.

Can I still install neofetch on a new machine today?

Yes. The neofetch package remains available in the repositories of many major distributions despite the project being archived, because distribution maintainers have not yet removed it. sudo apt install neofetch works on current Ubuntu and Debian releases. sudo pacman -S neofetch works on Arch. Homebrew still provides it on macOS. What you are installing is frozen at version 7.1.0 — the last release from August 2020 — and that will never change. It runs fine for most purposes; it simply will not improve. If you are setting up a new machine, installing Fastfetch instead takes the same single command and starts you on a maintained codebase.

Does neofetch work on WSL or Windows?

Neofetch runs inside WSL and produces mostly correct output from the Linux layer — CPU, memory, shell, and distribution all report accurately. The main known problem is Windows version detection: neofetch consistently reported "Windows 10" even on Windows 11 hosts because the project was frozen before that distinction was implemented. That bug was never fixed. If you are on WSL and want a maintained tool, Fastfetch works correctly in WSL and also compiles as a native Windows binary for use in Windows Terminal without WSL at all. For a purpose-built Windows tool, Winfetch is written in PowerShell and handles Windows-specific information — edition, BitLocker state, battery — that Linux-derived tools cannot easily reach.