Skip to main content

The AI-Native Linux Desktop: Hyprland, Kitty, Fish, and Claude Code

Most "Linux rice" posts focus on aesthetics. This one focuses on productivity.

The goal: a desktop where the terminal is the primary interface, the keyboard drives everything, and an AI agent can modify any part of the setup through natural language. Not a desktop that looks good in screenshots — a desktop that makes you faster.

Here's the stack, why each piece matters, and how Claude Code ties it all together.

The Stack

flowchart TD
    subgraph OS["Operating System"]
        AR[Arch Linux / EndeavourOS<br/>Rolling Release Base]
    end

    subgraph Desktop["Desktop Environment"]
        HY[Hyprland<br/>Tiling Window Manager]
        NC[Noctalia Shell<br/>Bar, Launcher, Notifications]
    end

    subgraph Terminal["Terminal Layer"]
        KT[Kitty<br/>GPU-Accelerated Terminal]
        FS[Fish Shell<br/>Autosuggestions & Syntax Highlighting]
    end

    subgraph AI["AI Layer"]
        CC[Claude Code<br/>Terminal-Native AI Agent]
    end

    subgraph Config["All Plain Text Configs"]
        C1[hyprland.conf]
        C2[kitty.conf]
        C3[config.fish]
        C4[~/.ssh/config]
    end

    AR --> HY
    AR --> NC
    HY --> KT
    NC --> HY
    KT --> FS
    FS --> CC
    CC -->|reads & modifies| C1
    CC -->|reads & modifies| C2
    CC -->|reads & modifies| C3
    CC -->|reads & modifies| C4

    style AR fill:#d1c4e9
    style HY fill:#e1f5fe
    style NC fill:#f3e5f5
    style KT fill:#fff3e0
    style FS fill:#c8e6c9
    style CC fill:#ffcdd2
    style Config fill:#f5f5f5
Layer Tool Role
OS Arch Linux / EndeavourOS Rolling release base with latest packages
Window Manager Hyprland Tiling compositor with keyboard-driven workflow
Desktop Shell Noctalia All-in-one bar, launcher, notifications, Bluetooth, network, power menu
Terminal Kitty GPU-accelerated terminal with built-in splits
Shell Fish Smart autocompletion and syntax highlighting
AI Agent Claude Code Terminal-native AI that reads and modifies everything

Why Tiling? Why Terminal-First?

Traditional desktop environments are designed around the mouse. You drag windows, click menus, resize things manually. That workflow breaks down when your primary tool is a terminal running an AI agent.

A tiling window manager like Hyprland eliminates window management entirely. Every window gets placed automatically. You switch between them with keyboard shortcuts. Your hands never leave the keyboard, and your screen real estate is always maximized.

When you spend most of your time in a terminal talking to Claude Code, the rest of the desktop needs to stay out of the way. That's exactly what this stack does.

Arch Linux & EndeavourOS: The Base

Every tool in this stack depends on having recent software. Hyprland moves fast — new features, new config syntax, bug fixes — and you don't want to be stuck on a version from six months ago because your distro hasn't packaged it yet. That rules out most fixed-release distributions.

Arch Linux is a rolling release distribution. There are no major version upgrades, no reinstalls, no waiting for the next release cycle. You run pacman -Syu and you have the latest everything — kernel, drivers, Hyprland, Kitty, Fish, all of it. Software hits the Arch repos days after upstream release, not months.

Why Arch Specifically

  • Rolling release — Always on the latest stable versions. Hyprland, Noctalia, Kitty, and Fish all get frequent updates. On Arch, you get them immediately.
  • Upstream-first packaging — Arch ships software as the original developers release it, with minimal patches. What you install is what upstream intended. Fewer surprises, fewer distro-specific bugs.
  • The AUR — The Arch User Repository has packages for nearly everything, including Noctalia. One yay -S noctalia-shell and you have a fully integrated desktop shell with all its dependencies resolved.
  • Minimal base — Arch installs only what you ask for. No pre-installed office suites, no bundled games, no desktop environment you'll immediately replace. You build exactly the system you want.
  • The Arch Wiki — Arguably the best Linux documentation in existence. When something doesn't work, the answer is almost always on the wiki, and it applies directly because you're running unmodified upstream packages.

EndeavourOS: Arch Without the Installation Pain

If you want all of the above but don't want to spend an afternoon manually partitioning disks and configuring bootloaders, EndeavourOS is the answer.

EndeavourOS is Arch Linux with a graphical installer. That's it. No custom repos, no forked packages, no "Arch-based but different" surprises. After installation, you're running pure Arch with the same repos, the same pacman, and the same AUR access. The only difference is you got there through a GUI installer instead of the command line.

flowchart LR
    subgraph Arch["Arch Linux"]
        A1[Manual CLI install]
        A2[Partition, chroot, configure]
        A3[Full control, steep learning curve]
    end

    subgraph Endeavour["EndeavourOS"]
        E1[Graphical Calamares installer]
        E2[Choose desktop or 'No Desktop']
        E3[Same repos, same AUR, same Arch]
    end

    subgraph Result["End Result"]
        R1[Identical Arch system]
        R2[Rolling release]
        R3[Pacman + AUR]
    end

    Arch --> Result
    Endeavour --> Result

    style Arch fill:#fff3e0
    style Endeavour fill:#c8e6c9
    style Result fill:#e1f5fe

For this stack, the recommended path is:

  1. Download EndeavourOS
  2. Choose Online Install and select No Desktop
  3. You get a clean minimal base — no pre-installed DE, no bloat
  4. Install Hyprland, Kitty, Fish, and Noctalia yourself
  5. You're running Arch with exactly the tools you chose

This matters for a terminal-first, AI-driven workflow because you want an OS that stays current and stays out of the way. Arch does both. EndeavourOS just makes the initial setup less painful.

Why Not Ubuntu, Fedora, or Manjaro?

  • Ubuntu/Debian — Fixed release cycles mean older packages. Hyprland may not be in the repos at all, or it's several versions behind. PPAs help but introduce maintenance overhead.
  • Fedora — Better than Ubuntu for freshness, but still on a 6-month release cycle. Hyprland support varies by version.
  • Manjaro — Arch-based but uses its own repos that hold packages back for "stability testing." This delays updates and causes AUR compatibility issues. The Hyprland community specifically discourages Manjaro due to these packaging differences.

Arch and EndeavourOS give you the same packages Hyprland's developers test against, updated at the same pace. Fewer compatibility issues, fewer workarounds.

Hyprland: The Window Manager

Hyprland is a dynamic tiling Wayland compositor. Unlike older X11 window managers, it runs on Wayland — which means better security, native fractional scaling, and proper multi-monitor support.

What makes Hyprland stand out from other tiling WMs:

  • Smooth animations — Windows don't just snap into place. They slide, fade, and pop in with configurable easing curves. This isn't just eye candy; it gives you spatial awareness of where windows are moving.
  • Dynamic tiling — The dwindle layout splits space recursively. Each new window gets half of the current space, creating a natural hierarchy.
  • Hot-reload config — Edit ~/.config/hypr/hyprland.conf and changes apply immediately. No restart needed.

Key Configuration Choices

Here's the layout section from my config:

general {
    gaps_in = 5
    gaps_out = 10
    border_size = 2
    col.active_border = rgba(828891ee) rgba(e8a898ee) 90deg
    col.inactive_border = rgba(595959aa)
    resize_on_border = true
    extend_border_grab_area = 30
    layout = dwindle
}

Small gaps between windows give visual separation without wasting space. The gradient active border makes it immediately obvious which window has focus. Border resize with a 30px grab area means you can resize windows by dragging edges when you need to — but keyboard resize bindings (Super+Ctrl+HJKL) are faster.

The keybindings follow a logical hierarchy:

flowchart LR
    subgraph Focus["Super + Arrow"]
        F1[Move Focus]
    end
    subgraph Move["Super + Shift + Arrow"]
        M1[Move Window]
    end
    subgraph Resize["Super + Ctrl + HJKL"]
        R1[Resize Window]
    end
    subgraph WS["Super + Number"]
        W1[Switch Workspace]
    end
    subgraph MWS["Super + Shift + Number"]
        MW1[Move to Workspace]
    end

    Focus -.->|add Shift| Move
    Move -.->|swap Ctrl| Resize
    WS -.->|add Shift| MWS

    style Focus fill:#e1f5fe
    style Move fill:#fff3e0
    style Resize fill:#c8e6c9
    style WS fill:#f3e5f5
    style MWS fill:#ffcdd2

Every operation is one modifier away from the next related operation. Focus, move, resize — all on the same spatial keys with different modifiers.

Multi-Monitor Setup

Hyprland handles multi-monitor setups natively:

monitor=DP-2,3440x1440@60,0x0,1
monitor=eDP-1,2880x1800@60,856x1440,1.666667

An ultrawide on top, laptop display below with fractional scaling at 1.67x. Workspaces span both monitors, and windows can be moved between them with the same keybindings used for everything else.

Noctalia: The Desktop Shell That Replaces Everything

If you've ever set up a tiling WM from scratch, you know the pain. You need Waybar for a status bar. Wofi or Rofi for an app launcher. Dunst or Mako for notifications. wlogout for a power menu. A separate Bluetooth manager. A network applet. A clipboard manager. Each tool has its own config format, its own theming system, and its own quirks. Getting them to look and behave consistently is a project in itself.

Noctalia replaces all of them.

flowchart TD
    subgraph Traditional["Traditional Tiling WM Setup"]
        direction TB
        T1[Waybar<br/>Status Bar]
        T2[Wofi / Rofi<br/>App Launcher]
        T3[Dunst / Mako<br/>Notifications]
        T4[wlogout<br/>Power Menu]
        T5[blueman<br/>Bluetooth]
        T6[nm-applet<br/>Network]
        T7[cliphist + wofi<br/>Clipboard]
    end

    subgraph Noctalia["Noctalia Shell"]
        direction TB
        N1[Status Bar]
        N2[App Launcher]
        N3[Notification Center]
        N4[Session / Power Menu]
        N5[Bluetooth Controls]
        N6[Network Controls]
        N7[Clipboard Manager]
        N8[Lock Screen]
        N9[Media Controls]
        N10[Unified Theming]
    end

    Traditional -->|"7 tools, 7 configs<br/>7 theme files"| X[Inconsistent mess]
    Noctalia -->|"1 tool, 1 config<br/>1 theme engine"| Y[Consistent desktop]

    style Traditional fill:#ffcdd2
    style Noctalia fill:#c8e6c9
    style X fill:#ffcdd2
    style Y fill:#c8e6c9

It's a single Wayland-native desktop shell that provides everything you need out of the box:

  • Status bar with workspace indicators, system monitors, clock, and quick-access controls
  • Application launcher with favorites, recent apps, and built-in calculator
  • Notification center with full history panel
  • Clipboard manager with search
  • Power/session menu for logout, sleep, restart, shutdown
  • Lock screen with PAM authentication
  • Bluetooth and network controls built into the side panel
  • Media controls with playback info and volume
  • Power profile switching (balanced, performance, power saver)

All of that from one package, one config, one consistent theme. Install it, add one line to your Hyprland config, and your desktop is complete:

exec-once = qs -c noctalia-shell

Theming Without the Pain

Ricing a tiling WM typically means manually editing color values across a half-dozen config files. Change your color scheme and you're updating Waybar CSS, Rofi theme files, Dunst config, terminal colors — hoping they all look coherent.

Noctalia has a built-in theming system that handles this globally. It ships with popular color schemes — Catppuccin, Dracula, Gruvbox, Nord, Rosepine, Tokyo Night, and its own warm Noctalia palette — and can apply them across your entire desktop from one setting.

Even better, it supports Material You wallpaper color extraction. Point it at a wallpaper and it generates a full color scheme derived from the image, then applies those colors to your GTK apps, Qt apps, and supported terminals like Kitty. Your entire desktop stays visually cohesive without manually matching hex values.

This matters for a terminal-first workflow because it means you spend zero time fiddling with appearance. Pick a theme or a wallpaper, and everything matches. Get back to work.

Everything Through Keybindings

In the Hyprland config, Noctalia's features are bound to keyboard shortcuts:

$menu = qs -c noctalia-shell ipc call launcher toggle

bind = $mainMod, D, exec, $menu
bind = $mainMod, V, exec, qs -c noctalia-shell ipc call launcher clipboard
bind = $mainMod, N, exec, qs -c noctalia-shell ipc call notifications toggleHistory
bind = $mainMod, X, exec, qs -c noctalia-shell ipc call sessionMenu toggle
bind = $mainMod, slash, exec, qs -c noctalia-shell ipc call plugin:keybind-cheatsheet toggle

Super + D to launch apps. Super + V for clipboard history. Super + N for notifications. Super + X for power menu. Super + / for a keybind cheatsheet that reads your Hyprland config and displays all bindings in a searchable overlay — genuinely useful when you're still learning your own keybinds.

No right-click menus, no system tray hunting, no settings panels. Just keyboard shortcuts to focused utilities that appear when needed and disappear when they're not.

Kitty: The Terminal

If the terminal is your primary workspace, it needs to be fast. Kitty is a GPU-accelerated terminal emulator that offloads rendering to the GPU, giving you smooth scrolling and zero lag even with heavy output.

But speed isn't why Kitty is the right choice for this stack. It's the built-in splits.

Built-In Terminal Splits

enabled_layouts splits,tall,stack,grid
map ctrl+shift+enter launch --location=split --cwd=current
map ctrl+shift+\ launch --location=vsplit --cwd=current
map ctrl+shift+h neighboring_window left
map ctrl+shift+l neighboring_window right
map ctrl+shift+k neighboring_window up
map ctrl+shift+j neighboring_window down

You can split your terminal vertically or horizontally without tmux. Navigate between panes with Ctrl+Shift+HJKL. Each pane inherits the current working directory. This means you can have Claude Code running in one pane, a dev server in another, and git operations in a third — all within a single Kitty window managed by Hyprland.

Terminal Configuration for AI Work

font_family      JetBrainsMono Nerd Font
font_size        12.0
background_opacity 0.5
cursor_shape beam
cursor_blink_interval 0
scrollback_lines 50000
copy_on_select clipboard

Key choices:

  • JetBrains Mono Nerd Font — Ligatures for code readability, plus Nerd Font icons for the Fish prompt
  • 50% opacity — See your other windows through the terminal. When Claude Code is running a long operation, you can monitor what's happening underneath without switching windows.
  • No cursor blink — Reduces visual noise during long coding sessions
  • 50K scrollback — Claude Code can produce verbose output. You want to scroll back through it.
  • Copy on select — Highlight text and it's in your clipboard. No extra keystrokes.

The Color Scheme

The Vesper color scheme provides a dark background (#101010) with warm accent colors. The muted palette reduces eye strain during long sessions while maintaining enough contrast to distinguish syntax highlighting:

foreground #ffffff
background #101010
cursor #FFC799
color1 #f5a191    # soft red
color2 #90b99f    # muted green
color4 #aca1cf    # lavender
color11 #FFC799   # warm amber

Fish: The Shell

Fish (Friendly Interactive Shell) is the layer between you and the operating system. It's also the shell that Claude Code runs inside.

Fish's headline feature is autosuggestions — as you type, it suggests completions from your command history in gray text. Press the right arrow to accept. No configuration needed, no plugins to install.

Why Fish Over Zsh or Bash

Feature Bash Zsh + Oh My Zsh Fish
Syntax highlighting No Plugin required Built-in
Autosuggestions No Plugin required Built-in
Tab completions Basic Good with plugins Excellent out of the box
Setup time None 30+ min configuring None
POSIX compatible Yes Yes No
Script readability Low Medium High

Fish trades POSIX compatibility for a better interactive experience. Since Claude Code handles most complex scripting anyway, the tradeoff is worth it.

My Fish Config

if status is-interactive
    fish_add_path ~/.local/bin

    if test -d ~/.local/share/fnm
        fish_add_path ~/.local/share/fnm
        fnm env --use-on-cd --shell fish | source
    end

    alias ll='ls -lah'
    alias gs='git status'
    alias gd='git diff'
    alias gp='git push'
end

Minimal. The config sets up fnm for Node.js version management (which auto-switches Node versions when you cd into a project with an .nvmrc file) and defines a few git aliases. Everything else — the prompt, syntax highlighting, completions — is handled by Fish defaults and the Tide prompt theme.

Tide Prompt

Tide is an async Fish prompt framework that shows contextual information: current directory, git branch and status, Node.js version, command duration, and more. It never slows down your prompt rendering.

The prompt adapts to your environment. In a git repo, it shows branch and dirty/clean status. In a Node project, it shows the Node version. In a Python project, it shows the virtual environment. All without any configuration.

Claude Code: The AI Layer

This is where it gets interesting.

Claude Code is a terminal-native AI agent. It runs in your terminal, reads your codebase, executes commands, edits files, and manages git workflows — all through natural language. It's not an autocomplete tool. It's an autonomous agent that can plan and execute multi-step operations.

Why This Stack Matters for Claude Code

Claude Code operates through your terminal. Every tool in this stack was chosen to make that interaction better:

  1. Hyprland's tiling keeps Claude Code's terminal visible alongside your browser, documentation, or other terminals. No window management overhead.
  2. Kitty's splits let you run Claude Code in one pane while watching build output, test results, or server logs in adjacent panes — all in the same window.
  3. Fish's autosuggestions speed up the commands you type around Claude Code sessions. Quick git status, npm run build, server restarts — all with minimal keystrokes.
  4. Noctalia stays quiet while you work, providing system info in the bar without demanding attention.

Claude Code Can Configure the Desktop Itself

Here's the part that makes this setup uniquely powerful: Claude Code can read and modify every config file in this stack.

Need to change your Hyprland keybindings?

"Add a keybinding to move the focused window to the next monitor"

Claude Code reads ~/.config/hypr/hyprland.conf, understands the existing binding structure, and adds the new binding in the right section. Hyprland hot-reloads it immediately.

Want to adjust your terminal opacity?

"Set Kitty background opacity to 0.7"

Claude Code edits ~/.config/kitty/kitty.conf and the change takes effect on new terminal windows.

Need a new Fish alias?

"Add a Fish alias 'dc' for docker compose"

Claude Code edits ~/.config/fish/config.fish with the new alias.

This is the real power of a text-config-driven desktop: every component is a plain text file that an AI agent can read, understand, and modify. No GUI settings panels, no binary config databases, no registry hives. Just text files and an AI that understands them.

SSH Keys: Making Your Whole Infrastructure AI-Ready

A terminal-first desktop isn't just about your local machine. If you deploy to servers, manage cloud infrastructure, or work across multiple machines, SSH keys are the bridge that extends Claude Code's reach beyond your laptop.

flowchart LR
    CC[Claude Code] -->|SSH| PROD[Production Server]
    CC -->|SSH| STAGE[Staging Server]
    CC -->|SSH| DB[Database Server]
    CC -->|SCP/Rsync| S3[File Transfers]
    CC -->|Git+SSH| GH[GitHub / GitLab]

    PROD --> P1[Deploy code]
    PROD --> P2[Restart services]
    PROD --> P3[Tail logs]
    STAGE --> S1[Run migrations]
    STAGE --> S2[Test deployments]
    DB --> D1[Backups]
    DB --> D2[Query data]

    style CC fill:#ffcdd2
    style PROD fill:#c8e6c9
    style STAGE fill:#fff3e0
    style DB fill:#e1f5fe
    style GH fill:#f3e5f5

With SSH key authentication configured, Claude Code can:

  • Deploy code to production — ssh server "cd /opt/app && git pull && docker compose up -d" becomes a natural language request: "Deploy the latest changes to production."
  • Copy files to remote servers — scp and rsync work without password prompts, so Claude Code can move build artifacts, config files, or backups with a single command.
  • Tail remote logs — "Show me the last 50 lines of the API logs on the production server" just works when SSH is configured.
  • Run remote commands — Database migrations, service restarts, health checks — all executable through Claude Code without manual SSH sessions.
  • Manage multiple servers — With an SSH config file (~/.ssh/config), you can alias servers by name. Claude Code references production, staging, or database instead of IP addresses.

Setting It Up

Generate a key pair and copy it to your servers:

ssh-keygen -t ed25519 -C "[email protected]"
ssh-copy-id user@your-server

Add host aliases in ~/.ssh/config:

Host production
    HostName 143.198.xx.xx
    User deploy
    IdentityFile ~/.ssh/id_ed25519

Host staging
    HostName 167.172.xx.xx
    User deploy
    IdentityFile ~/.ssh/id_ed25519

Now Claude Code can run ssh production "pm2 restart all" without any authentication friction. Your entire infrastructure becomes accessible through natural language.

This is what makes the terminal-first approach compound in value. It's not just local file editing — it's a unified interface to your local machine, your servers, your git repositories, and your deployment pipeline. All keyboard-driven, all AI-accessible.

The Workflow in Practice

A typical development session looks like this:

flowchart TD
    A["Super + Return<br/>Open Kitty"] --> B["Ctrl+Shift+\<br/>Split Terminal"]
    B --> C["Left Pane: claude<br/>Start Claude Code"]
    B --> D["Right Pane<br/>Dev server / logs"]
    C --> E["Natural language<br/>Code, test, debug"]
    E --> F{"Ready to deploy?"}
    F -->|Yes| G["'Deploy to staging'<br/>Claude uses SSH"]
    F -->|No| E
    G --> H["Super + W<br/>Browser to verify"]
    H --> I{"Working?"}
    I -->|Yes| J["'Deploy to production<br/>and commit'"]
    I -->|No| E

    style C fill:#ffcdd2
    style G fill:#c8e6c9
    style J fill:#c8e6c9
  1. Super + Return — Open Kitty
  2. Ctrl+Shift+\ — Split the terminal vertically
  3. Left pane: claude — Start Claude Code
  4. Right pane: dev server, tests, or logs
  5. Talk to Claude Code in natural language — it reads your code, makes changes, runs tests, deploys to staging, commits when you're ready
  6. Super + W — Open browser to verify changes
  7. Super + 2 — Switch to workspace 2 for documentation or research
  8. Super + 1 — Back to your terminal workspace

The keyboard drives everything. The AI handles the code. The desktop stays out of the way.

Getting Started

Install the Base

Download EndeavourOS and run the online installer. Select No Desktop for a clean minimal base. Or if you prefer the manual route, install Arch Linux directly.

Then install the stack:

sudo pacman -S hyprland kitty fish

Install Noctalia from the AUR:

yay -S noctalia-shell

Install Claude Code:

npm install -g @anthropic-ai/claude-code

Bootstrap with Claude Code

Here's the best part — once you have the basics installed, you can use Claude Code to set up the rest:

"Read my Hyprland config and add vim-style HJKL bindings for window focus"

"Configure Kitty with JetBrains Mono font, the Vesper color scheme, and split layouts"

"Set up Fish with fnm for Node version management and basic git aliases"

"Set my Kitty background opacity to 50%"

Each request reads the current config, understands its structure, and makes targeted changes. You're configuring your desktop through conversation.

The Philosophy

This isn't about having the prettiest desktop. It's about having a desktop that disappears.

Every pixel of screen real estate goes to the work. Every interaction happens through the keyboard. Every configuration is a text file an AI can read and modify. The terminal is the center of everything, and Claude Code makes the terminal dramatically more capable.

The mouse is there when you need it. You just won't need it very often.

Tools referenced in this post:

Next Article: Ditch Miro: Create AI-Editable Diagrams with Markdown and Mermaid

Need help with your project or have questions?

We specialize in AI automation, custom integrations, and intelligent workflows tailored to your business needs.

Whether you need help deploying, building, implementing, or creating a solution - or just want expert guidance on your project - we're here to help.

Contact us today to discuss your project.