blaeckfetch

A fast, minimalist system fetch for your terminal. Written in Rust.

Powered by blaeck for rendering.

Features

• Customizable - Configure logos, fields, colors, and labels to your preference
• Splash mode - Retro console-inspired splash screens with starfield and image backgrounds
• Neofetch compatibility mode - Familiar layout for neofetch users
• Blazingly fast - ~7ms execution time (vs ~400ms for neofetch)
• Boot-cycle cache - Intelligent caching for even faster subsequent runs
• Minimal - Clean, distraction-free output with essential system info
• Wide terminal support - Truecolor (24-bit) with automatic 256-color fallback for older terminals

Getting Started

Ready to try blaeckfetch? Head over to the Installation page to get started.

Installation

macOS (Homebrew)

brew tap gustafeden/tap
brew install blaeckfetch

Arch Linux

yay -S blaeckfetch-bin

Linux/macOS (Install Script)

curl -fsSL https://gustafeden.github.io/blaeckfetch/install.sh | bash

The installer script:

• Supports Linux (x86_64, aarch64) and macOS (Intel, Apple Silicon)
• Detects your platform automatically
• Installs to ~/.local/bin/blaeckfetch
• You can specify a version with BLAECKFETCH_VERSION environment variable:

BLAECKFETCH_VERSION=0.2.0 curl -fsSL https://gustafeden.github.io/blaeckfetch/install.sh | bash

From Source

Clone the repository and build with Cargo:

git clone https://github.com/gustafeden/blaeckfetch
cd blaeckfetch
cargo build --release

The binary will be available at target/release/blaeckfetch.

Alternatively, install directly from Git:

cargo install --git https://github.com/gustafeden/blaeckfetch blaeckfetch

Quick Start

First Run

After installing blaeckfetch, simply run:

blaeckfetch

You'll see the default moon logo with your system information.

Basic CLI Examples

Color Themes

Change the color scheme:

blaeckfetch -c cyan
blaeckfetch -c magenta

Logos

Use different built-in logos:

blaeckfetch --logo arch
blaeckfetch --logo ubuntu
blaeckfetch --no-logo

Use a custom ASCII logo from a file:

blaeckfetch --logo-file ~/my-logo.txt

JSON Output

Get machine-readable JSON output:

blaeckfetch --json

Modes

Try splash mode:

blaeckfetch --splash

Or neofetch compatibility mode:

blaeckfetch --neofetch

Configuration File

blaeckfetch looks for a config file at:

~/.config/blaeckfetch/config.toml

Generate Default Config

Create a config file with default settings:

blaeckfetch --print-config > ~/.config/blaeckfetch/config.toml

Quick Config Example

Here's a minimal config to get you started:

color = "cyan"
logo = "moon"

fields = [
    "OS",
    "Kernel",
    "Shell",
    "Terminal",
    "CPU",
    "Memory",
    "Uptime"
]

labels = { OS = "os", Kernel = "kernel", Shell = "shell" }

For more configuration options, see the Configuration page.

Configuration

Config File Location

blaeckfetch reads configuration from:

~/.config/blaeckfetch/config.toml

Generating Default Config

To see all available options with their defaults:

blaeckfetch --print-config

To create a config file:

blaeckfetch --print-config > ~/.config/blaeckfetch/config.toml

Configuration Options

Color Values

Colors can be specified as:

Named Colors

green (default), cyan, red, magenta, yellow, blue, mono

RGB Arrays

color = [255, 165, 0]  # Orange

Terminal Compatibility

Truecolor terminals (iTerm2, WezTerm, Kitty, Ghostty, Alacritty) render RGB values at full 24-bit precision. Terminals without truecolor support (e.g. macOS Terminal.app) automatically receive 256-color approximations. No configuration needed — detection is automatic.

Full Example Config

color = "cyan"
logo = "arch"
palette = false
separator = "="

# Show only these fields, in this order
fields = [
    "OS",
    "CPU",
    "Memory",
    "Disk (/)",
]

# Rename fields
[labels]
"Disk (/)" = "Disk"
"Local IP" = "IP"

# Custom colors (named or RGB)
[colors]
title = [255, 165, 0]
label = "cyan"
separator = "dark_gray"
logo = "magenta"

Fields Reference

CLI Flags Override Config

Command-line flags always take precedence over config file settings. For example:

blaeckfetch -c magenta --logo arch

This will use magenta color and arch logo, even if your config specifies different values.

Modes

blaeckfetch supports three display modes, each with a different visual style and purpose.

Default Mode

The clean, minimal mode featuring the moon logo with essential system information. This is the evolved minimal identity of blaeckfetch.

blaeckfetch
# or explicitly
blaeckfetch --mode default

In your config:

mode = "default"

Neofetch Mode

A familiar layout for users coming from neofetch. This mode provides a classic fetch-style display.

blaeckfetch --neofetch
# or
blaeckfetch --mode neofetch

In your config:

mode = "neofetch"

Splash Mode

A retro console-inspired animated splash screen with starfield backgrounds and optional custom images. Perfect for terminal startup sequences.

blaeckfetch --splash
# or
blaeckfetch --mode splash

In your config:

mode = "splash"

For detailed splash mode configuration options, see the dedicated Splash Mode page.

Switching Modes

You can switch modes using:

CLI Flags

• --mode default - Default moon logo mode
• --mode neofetch - Neofetch compatibility mode
• --mode splash - Splash screen mode
• --neofetch - Shorthand for neofetch mode
• --splash - Shorthand for splash mode

Config File

mode = "default"  # or "neofetch" or "splash"

CLI flags always override the config file setting.

Splash Mode

Splash mode transforms blaeckfetch into a retro console-inspired splash screen with animated starfield backgrounds and optional custom images. Press any key to dismiss, or it auto-closes after the configured timeout. Perfect for shell startup animations.

Launching Splash Mode

blaeckfetch --splash
blaeckfetch --splash --center

Add it to your shell RC file (.zshrc, .bashrc) for a startup splash.

Background Images

Add a background image in your config:

[splash]
image = "~/.config/blaeckfetch/space.png"
stretch = "fill"        # fill, fit, or crop

Supported formats: PNG and JPEG.

Images are converted to half-block characters (▄▀█) — every cell packs two vertical pixels using foreground and background colors. The conversion is pure Rust with no external tools.

On truecolor terminals (iTerm2, WezTerm, Kitty, Ghostty, Alacritty), images render with full 24-bit RGB. Terminals without truecolor (e.g. macOS Terminal.app) automatically fall back to 256-color approximation.

Stretch Modes

• fill — stretch to fit the canvas (default)
• fit — letterbox to preserve aspect ratio
• crop — fill and trim the edges

Full-Resolution Inline Images

Terminals that support inline images (iTerm2, WezTerm, Ghostty, kitty) can render the background at full pixel resolution instead of half-block ASCII. blaeckfetch auto-detects this — no config needed.

To force a specific mode:

[splash]
render_mode = "image"   # force inline image (iTerm2 protocol)
render_mode = "ascii"   # force half-block characters
render_mode = "auto"    # auto-detect (default)

Limitations

• Inline image mode uses the iTerm2 image protocol. Terminals that don't support it will show nothing — use render_mode = "ascii" as a fallback.
• Image resizes on terminal resize may briefly flicker.
• VHS and screen recorders capture the half-block fallback, not the inline image.

Alignment

Control horizontal alignment via CLI flags or config:

blaeckfetch --splash --left
blaeckfetch --splash --center
blaeckfetch --splash --right

[splash]
align = "left"  # left (default), center, or right

Full Splash Configuration Reference

Backward Compatibility

The config section name [boot] still works as an alias for [splash].

Performance

Comparison

~57x faster than neofetch. Uses a boot-cycle cache for static fields — first run after reboot is ~40ms, every run after that is ~7ms.

How It's Fast

• Compiled Rust binary — no interpreter startup
• Direct syscalls for host model, disk stats, display resolution (no subprocess spawning)
• Boot-cycle cache (~/.cache/blaeckfetch/cache) for fields that don't change between reboots
• Only two subprocess calls on macOS (defaults read for theme), and those are cached
• sysinfo crate for memory/CPU instead of parsing command output

Benchmarking

You can benchmark blaeckfetch on your system:

# Using hyperfine (recommended)
hyperfine 'blaeckfetch' 'neofetch'

# Using time
time blaeckfetch

Development

Dependencies

• blaeck — inline terminal UI framework
• sysinfo — cross-platform system information
• clap — CLI argument parsing
• image — image loading and processing (splash mode backgrounds)

Building from Source

git clone https://github.com/gustafeden/blaeckfetch
cd blaeckfetch
cargo build --release

The binary will be at target/release/blaeckfetch.

Releasing

1. Bump version in Cargo.toml and installer/Cargo.toml
2. Commit: git commit -am "v0.X.0"
3. Tag and push: git tag v0.X.0 && git push && git push origin v0.X.0

GitHub Actions builds binaries for macOS/Linux (Intel + ARM) and creates the release.