---
title: "What Is Yeet?"
description: "yeet is a platform for easy, just-in-time observability of Linux systems."
date: 2025-04-16
authors: Julian Goldstein
canonical: https://yeet.cx/blog/what-is-yeet
---
It’s what you reach for when the dashboards say everything is fine, but the system clearly isn’t.

It’s built for SREs and sysadmins. People who live in `htop`, write clever one-liners with `awk`, and sometimes stare into the abyss at dashboards wondering where their day went.

## ***Ok, that’s cool, but like… what is it?***

yeet is a way to ask questions about your systems — and actually getting answers. It does this by providing a good abstraction on top of the Linux kernel’s BPF subsystem so that *normal people* can use it without sacrificing their sanity to its black magic.

When something’s broken, slow, or just being weird, you don’t want to dig through five dashboards or write a custom exporter. You just want to ask:

- *“What’s hogging all the CPU?”*
- *“What services is this service talking to.”*
- *“Which process opened this file?”*

![Point Click Drag And Drop](/blog/what-is-yeet/point-click-dnd.png)

**yeet gives you the power to explore live data** **coming from your system** — from kernel events to process info — by deploying tiny observability programs and streaming the results straight to your browser.

yeet is **not about collecting everything forever.** It’s about **getting the right data, right now.**

Because let’s be honest, when pagers start going off at 3am, your systems are melting, you don’t need dashboards. **You need answers.**

## ***Nice, but after browsing around a bit I can’t really tell. Is it like a website? A package manager? A server? A CLI?***

**All of the above.**

yeet isn’t just one thing — it’s a **comprehensive solution to live systems exploration** — built for when dashboards fall short and you need real answers, in real-time.

### *Mask off: Let’s see what’s really underneath.*

![Em & Dre](/blog/what-is-yeet/eminem.gif)

### **I. 🧱 yeet the system daemon (yeetd)**

This is the part that lives on each host — quietly waiting for your instructions, ready to download and launch observability tools when you need them. It’s what you are installing when you type that good old `curl -fsSL https://yeet.cx | sh` into your terminal.

Here’s what it does:

- **Downloads and remotely deploys yeet packages** from the *yeet package manager (YPM).*
- **Manages the lifecycle of BPF objects**, including pinned maps, programs and links, from creation to cleanup, as well as permissions
- **Streams data** from kernel space into structured, real-time performance insights.

All communication with `yeetd` happens over a custom RPC protocol called **yeetRPC** — designed specifically for fast, low-friction control, and data streaming.

*tl;dr `yeetd` is your local agent that makes live observability possible. You tell it what you want to look at, and it handles the nitty-gritty kernel details — so you can get a real-time stream of exactly what you asked for, without writing a single line of glue code.*

### **II. 📦 yeet the package manager (YPM)**

One-off tools are cool — until you need to run them somewhere else, version them, or share them with your team. That’s where the ***yeet package manager*** comes in.

Every observability tool in yeet is a **package**. Each one includes:

- A compiled eBPF object
- Metadata describing what it does and what kind of data it emits
- Optional config (like user-defined arguments or filters)
- READMEs providing hints for how the output should be visualized in the dashboard.

Packages can be simple — like “show me all TCP connections” — or complex multi-program bundles that track high-level system behavior across layers.

**You don’t have to write everything from scratch.**

**You don’t even have to know how eBPF works (unless you want to).**

**You just grab the tool you need, yeet it into action, and get answers.**

*tl;dr YPM makes observability feel like a 4 am all-you-can-eat buffet you and your friends somehow haven’t managed to get yourselves kicked out of yet — just search, download, run, and see what’s going on.*

### **III. 🎨 yeet the website (https://yeet.cx)**

***AKA Where the magic happens.***

You remotely-deploy a probe and click a big green play button to start it — and yeet starts streaming structured output, about whatever you chose to probe instantly.

yeet isn’t just about streaming data —  **it’s about turning that data into answers your dashboards aren’t giving you, as quickly as possible.**

Once the stream begins, the browser doesn’t just show it — it **collects** it into a local DuckDB instance running in WebAssembly. That gives you a full-blown, in-browser analytical database, backed by live system data — **that you can shape with SQL queries and feed directly into visualizations.**

With zero-config, zero additional deployments you can:

- Pause, filter, and inspect the data on the fly
- Run SQL directly in the browser (no backend needed)
- Build custom tables and charts in real time
- Ask GPT natural-language questions and get real answers back
    - *“Which processes are touching sensitive files?”*
    - *“Which hostnames are resolving the slowest?”*
    - *“How much bandwidth is being hogged by this network interface?”*

And here’s the best part:

- Those visualizations you build? **They become the dashboard you need right now.**
- No setup, no config files, no team Slack thread at 3 am asking, *“hey do we have a panel for this?”*
- You didn’t open tickets.
- You didn’t escalate.
- You didn’t wait for someone to wire up metrics.
- You just dropped in, asked the right questions, and got out — with answers.

*tl;dr yeet enables you to be a one-person incident response team. Like being John McClane, but for distributed-systems spewing alerts. Yippee-ki-yay, on-call escalations.*

![Die Hard](/blog/what-is-yeet/die-hard.jpg)

## *Now that’s pretty neat — **you’ve got a whole observability pipeline reduced to a button press and a browser tab.***

yeet isn’t just a tool — it’s a new paradigm to work with your systems.

It’s built for the moments when:

- The dashboards aren’t helping
- The alerts are too vague
- And you just need to figure out what’s actually happening — ***right now, so you can get back to sleep when the 3 am pager goes off and the dashboards aren’t telling you what the hell is going on.***

With yeet, you can:

- Deploy observability probes with a single click.
- Stream real-time data directly to your browser.
- Query it like a database.
- Visualize it instantly.
- And get answers — without tickets, escalations, or duct tape.

It’s fast, focused, and built for SREs who don’t have time to wait for observability to catch up — **they need answers now, so they can go back to sleep.**

**Because when things go sideways, dashboards are static. Yet, incidents aren’t — and having yeet in your tool-belt gives you the power to explore, investigate, and get real-time answers when it matters most.**

# ***Click. Stream. Query. Chart. Sleep.***

Try yeet today!