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?”

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.

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.

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!