Skip to content
Kula

K U L A

Lightweight, self-contained Linux® server monitoring tool.

Linux Go JS Bash License: GPL v3

💾 Installation | 🌏 Website | 👀 Demo | 🐋 Docker Hub

Zero dependencies. No external databases. Single binary. Just deploy and go.

Kula Kula

📦 What It Does

Kula reads system metrics every second directly from /proc and /sys, stores them in a built-in tiered ring-buffer storage engine, and serves them through a real-time web dashboard, a terminal UI and a Prometheus endpoint.

Metric What's Collected
CPU Total usage (user, system, iowait, irq, softirq, steal) + core count
GPU Load, Power consumption, VRAM
Load 1 / 5 / 15 min averages, running & total tasks
Memory Total, free, available, used, buffers, cached, shmem
Swap Total, free, used
Network Per-interface throughput (Mbps), packets/s, errors, drops; TCP errors/s, resets/s, retrans, established; sockets
Disks Per-device I/O (read/write bytes/s, reads/s, writes/s IOPS); filesystem usage
System Uptime, entropy, clock sync, hostname, logged-in user count
Processes Running, sleeping, blocked, zombie counts
Self Kula's own CPU%, RSS memory, open file descriptors
Thermal CPU, GPU and Disk temperatures
Battery /sys/class/power_supply - power supply / battery status
Containers Docker, podman, raw cgroups
Applications PostgreSQL, MySQL/MariaDB, nginx, apache2
Custom Monitor anything with custom metrics

Monitoring NVIDIA GPUs might require additional setup — see GPU troubleshooting.

  • Web dashboard — live charts, pan and zoom through history, Min–Max bands, Focus and TV modes, rearrangeable cards, a System Info hardware page, and 26 languages.
  • Terminal UI — a fast live read over SSH, including charts of stored history.
  • Tiered storage — fixed-size ring-buffer files keep raw 1-second samples, then 1-minute and 5-minute rollups. No database to run.
  • Application monitoring — nginx, Apache2, PostgreSQL, MySQL/MariaDB and containers, plus your own custom metrics.
  • Prometheus exporter — scrape Kula into an existing observability stack.
  • AI assistant — optional chat about your metrics, powered by a local Ollama model.
  • Authentication — optional Argon2id login, with multiple users.
  • Backups — scheduled snapshots of the storage tiers.
  • Secure by default — strict headers, CSRF protection, rate limits, DNS rebinding protection, and a Landlock sandbox that confines file and network access. See the security model.

⚙️ How It Works

    ╭──────────────────────────────────────────────╮
    │                  Linux Kernel                │
    │      /proc/stat  /proc/meminfo  /sys/...     │
    ╰───────────────────────┬──────────────────────╯
                            │ Read every 1s
                            ▼
    ╭──────────────────────────────────────────────╮
    │                   Collectors                 │
    │        (CPU, Mem, Net, Disk, System)         │
    ╰───────────────────────┬──────────────────────╯
                            │ Live Data
         ╭──────────────────┼─────────────────────╮
         ▼                  ▼                     ▼
╭─────────────────╮  ╭────────────────╮  ╭─────────────────╮
│ Storage Engine  │  │   Web Server   │  │   TUI Terminal  │
╰───┬─────────┬───╯  ╰──────┬─────────╯  ╰─────────────────╯
    │         │             │
    │         ╰──(History)──┤              ╭───────────────╮
    │                       ╰──(HTTP/WS)─► |   Dashboard   |
    ▼                                      ╰───────────────╯
╭──────────┬──────────┬──────────╮
│  Tier 0  │  Tier 1  │  Tier 2  │
│    1s    │    1m    │    5m    │
│  250 MB  │  150 MB  │  50 MB   │
╰──────────┴──────────┴──────────╯
 Ring-buffer binary files
 with circular overwrites

Storage Engine

Kula is powered by a custom-built, high-performance ring-buffer storage system that writes metrics directly into fixed-size binary files. Because the files have a strict maximum capacity, new data seamlessly wraps around to overwrite the oldest entries.

To maximize efficiency, Kula employs a multi-tiered architecture that intelligently downsamples older data:

  • Tier 0 — Raw 1-second samples (default 250 MB)
  • Tier 1 — 1-minute metric rollups (default 150 MB)
  • Tier 2 — 5-minute metric rollups (default 50 MB)

💾 Installation

Kula is a single binary with no dependencies: upload it to a server and run it. Release packages cover amd64, arm64 and riscv64 — see Releases.

Note: Never thoughtlessly paste commands into the terminal. Even checking the checksum is no substitute for reviewing the code.

Guided

bash -c "$(curl -fsSL https://raw.githubusercontent.com/c0m4r/kula/refs/heads/main/addons/install_v3.sh)"

Guided (verify installer)

KULA_INSTALL=$(mktemp)
curl -o "${KULA_INSTALL}" -fsSL https://raw.githubusercontent.com/c0m4r/kula/refs/heads/main/addons/install_v3.sh
echo "1f90556010a7e427525b2c919f9bcedc406a7de1a81a78bcd6baeefb5852494e ${KULA_INSTALL}" | sha256sum -c && bash "${KULA_INSTALL}"
rm -f "${KULA_INSTALL}"

Standalone

wget https://github.com/c0m4r/kula/releases/download/0.22.0/kula-0.22.0-amd64.tar.gz
echo "5faada3a6a187b7f850c0556cd4e3dc0b6df56ddfb9c9a460b3cccd12e35405d kula-0.22.0-amd64.tar.gz" | sha256sum -c && tar -xvf kula-0.22.0-amd64.tar.gz
cd kula
./kula

Docker

Kula needs the host's PID and network namespaces and a read-only /proc, and no capabilities.

Temporary, no persistent storage:

docker run --rm -it --name kula --pid host --network host \
  --cap-drop ALL --security-opt no-new-privileges:true \
  -v /proc:/proc:ro c0m4r/kula:latest

With persistent storage:

docker run -d --name kula --pid host --network host \
  --read-only --cap-drop ALL --security-opt no-new-privileges:true \
  -v /proc:/proc:ro -v kula_data:/app/data c0m4r/kula:latest
docker logs -f kula

To count logged-in users, also mount the host's utmp or systemd-logind sessions, whichever it has, read-only. --mount refuses a source the host does not have (-v would create it as a directory); drop that line instead:

docker run -d --name kula --pid host --network host \
  --read-only --cap-drop ALL --security-opt no-new-privileges:true \
  -v /proc:/proc:ro -v kula_data:/app/data \
  --mount type=bind,source=/run/utmp,target=/run/utmp,readonly \
  --mount type=bind,source=/run/systemd/sessions,target=/run/systemd/sessions,readonly \
  c0m4r/kula:latest

More in Installation → Docker.

Debian / Ubuntu (.deb)

wget https://github.com/c0m4r/kula/releases/download/0.22.0/kula-0.22.0-amd64.deb
echo "d5e06e1f6e58d35fa245163e70571d61c2b601ba79038955dc9d980425372b8e kula-0.22.0-amd64.deb" | sha256sum -c && sudo dpkg -i kula-0.22.0-amd64.deb
journalctl -f -t kula

RHEL / Fedora / CentOS / Rocky / Alma (.rpm)

wget https://github.com/c0m4r/kula/releases/download/0.22.0/kula-0.22.0-x86_64.rpm
echo "81c98938afc722e446cd07832f3f5cd0629e65337f0df0801d3a896c56de8792 kula-0.22.0-x86_64.rpm" | sha256sum -c && sudo rpm -i kula-0.22.0-x86_64.rpm
journalctl -f -t kula

Arch Linux / Manjaro (AUR)

https://aur.archlinux.org/packages/kula

git clone https://aur.archlinux.org/kula.git
cd kula
makepkg -si

Snap

sudo snap install kula

The snap uses strict sandbox so by default Kula features will be limited to the basics, which can be extended with snap connect. Its daemon runs as root, bounded by that sandbox rather than an unprivileged user.

See Snap Wiki for the full guide.

Build from Source

Requires Go.

git clone https://github.com/c0m4r/kula.git
cd kula
./addons/build.sh

💻 Usage

Quick Start

Starting Kula is as simple as running:

./kula

Dashboard will be available at: http://localhost:27960

You can change default port and listen address in config.yaml or using environment variables:

export KULA_LISTEN="127.0.0.1"
export KULA_PORT="27960"
./kula

The default command is serve (./kula serve). Global flags are -config <path> to select another configuration file and -version (or -v) to print the version.

Every command and flag: CLI reference.

TUI

./kula tui

Prometheus metrics

See: Prometheus metrics for more info.

Authentication (Optional)

# Generate password hash
./kula hash-password

# Add the output to config.yaml under web.auth

⚙️ Configuration

All settings live in config.yaml. config.example.yaml lists every option with its default, and the configuration reference explains each one along with the environment variables that override them.

📚 Documentation

The documentation has a user guide and a developer guide:

More operational guides are on the wiki.

🧰 Development

./addons/check.sh         # full gate: govulncheck, gofmt, vet, race tests, golangci-lint
./addons/build.sh         # build for the current architecture
./addons/build.sh cross   # cross-compile amd64, arm64, riscv64

Building & toolchain covers dependency updates and running the CI workflows locally; Packaging & release covers the .deb, .rpm, AUR, Snap and Docker builds.

🔒 Privacy

Privacy is a core pillar, not an afterthought.

Kula is built for privacy-conscious infrastructure. It is a completely self-contained binary that requires no cloud connection and no third-party APIs. Designed to function perfectly in air-gapped networks, Kula never sends metadata to external servers, never serves advertisements, and requires no user registration. Your monitoring starts and ends on your infrastructure, exactly where it should be.

📖 License

GNU Affero General Public License v3.0

🫶 Attributions