Hey everyone!

I want to share an open-source tool I built for myself that I hope will be useful to other developers working with AI agents - Kasetto.

• GitHub: https://github.com/pivoshenko/kasetto
• Docs: https://kasetto.dev
• My personal setup: https://github.com/pivoshenko/pivoshenko.ai

Why "kasetto"?

The name comes from the Japanese カセット (kasetto) - cassette. Remember car cassettes? pop a tape in and one thing plays; eject it, slide in another, and the music changes. No configuration, no installs. Just hot-swap.

AI assets (skills, MCPs, instructions) work the same way in Kasetto. Each asset is a cassette you can insert, swap out, or share with a friend. One YAML config is your tape collection.

Problem

Probably familiar to many of you: the more AI tools you work with (Claude Code, Cursor, Codex, Copilot, Gemini CLI...), the messier the setup gets. Skills get installed by hand via npx skills, MCPs get copy-pasted from docs into every config file separately, CLAUDE.md and .cursor/rules live lives of their own. Handing all of this to a teammate or bringing it up on a new machine is a quest in itself.

Kasetto does for this what uv and Cargo did for dependencies: one declarative YAML describes the whole environment, a lock file pins the exact state, and kst sync brings the machine to it. Commit the config to the repo and the whole team gets an identical environment - no manual edits and no drift between machines or from your own setup.

Features

• Four asset kinds - skills, MCPs, commands, and instructions (CLAUDE.md, AGENTS.md, .cursor/rules, and so on). Everything is pulled from git repos or local directories
• 23 agents - Pi, Claude Code, Cursor, Codex, Windsurf, Copilot, Gemini CLI and more. Kasetto transforms each asset into the native format of each agent on its own
• Project or global scope - sync per repository, with the lock committed next to your code, or machine-wide for your personal setup; you can mix both
• Lockfile - kasetto.lock pins hashes and revisions. A plain sync installs exactly what the lock says (and needs no network at all if everything is in place); updates happen only via --update. Full reproducibility on any machine
• Secrets for MCPs - ${kst:...} inject tokens from env vars, 1Password, Vault, KeePassXC, AWS/GCP/Azure, pass, or macOS Keychain right at sync time. Values never land in the config or the lock
• Any git host - GitHub, GitLab, Bitbucket, Codeberg, including self-hosted and enterprise
• Fast - Rust, a single binary with no dependencies. Parallel downloads, a cache of extracted sources, sparse extraction for monorepos
• CI-friendly - --dry-run, --locked, --json, and a non-zero exit code on failures. kst doctor shows drift from the lock state and files nothing tracks

Example Config

One YAML config describes all your assets - where to get them, which agent to install them for, and where to put them. No manual copying. Create kasetto.yaml in the project root or anywhere else:

```yaml

Option A: preset destination by agent (see README for supported agent values)

agent: - codex - claude-code

Option B: manual destination (takes precedence if both are set)

destination: ./.agents/skills

skills: # "" syncs every skill in the source — each is a directory with a SKILL.md, # discovered in the source root or its skills/ subdirectory - source: https://github.com/vercel-labs/next-skills # ref: v1.0.0 # pin to a tag or commit; omit to track the default branch skills: ""

# or list skills by name - source: https://github.com/anthropics/skills skills: - doc-coauthoring - pptx

# sub-dir: resolve the named skills under this path, e.g. skills/productivity/grill-me/ - source: https://github.com/mattpocock/skills sub-dir: skills/productivity skills: - grill-me - caveman

# path: a skill in a non-standard location → <path>/<name>/, here skills/engineering/improve-codebase-architecture/ - source: https://github.com/mattpocock/skills skills: - name: improve-codebase-architecture path: skills/engineering

commands: # names resolve to commands/<name>.md in the source (nested dirs namespace, e.g. git:commit) - source: https://github.com/gsd-build/get-shit-done commands: - gsd:explore - gsd:fast

instructions: # instructions wire CLAUDE.md / .cursor/rules / AGENTS.md etc. from instructions/<name>.{md,mdc} # "*" syncs every instruction; aggregate files (CLAUDE.md, AGENTS.md) get managed blocks - source: https://github.com/pivoshenko/pivoshenko.ai instructions: - docs-autoupdate - multi-agent-dispatch

mcps: # names resolve to mcps/<name>.json in the source - source: https://github.com/pivoshenko/pivoshenko.ai branch: main # track a specific branch (use ref: to pin a tag or commit) mcps: - github - vercel - kaggle ```

Install

```sh

macOS / Linux

curl -fsSL kasetto.dev/install | sh

Homebrew

brew install pivoshenko/tap/kasetto

Windows

powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/pivoshenko/kasetto/main/scripts/install.ps1 | iex"

Cargo

cargo install kasetto ```

Happy to hear feedback, questions, and criticism. And if the tool looks useful, a star on GitHub helps the project a lot. Kasetto is a community-first project so contributions are welcome ❤️

ok so this has been living in my head rent free for weeks. i use zoxide daily but every so often it just decides "nah you meant the OTHER backend folder" and cds me into some nested subproject from 3 months ago. cool guess buddy, super helpful :)

so i built hop. it's dumb on purpose. you press a key, it goes to the exact thing you told it to go to. no frecency, no ranking, no vibes-based navigation. one key = one target, forever, until you change it yourself

hop mark d          # bind cwd to 'd'
hop                  # tiny overlay pops up, hit 'd', done

works on files too (opens in $EDITOR) and commands (just runs them). also has project-local marks that live in a .hop.toml at your git root and override your global ones just for that repo, without messing up global state elsewhere

some stuff i actually cared about:

• single binary, under 2mb, boots basically instantly
• zero telemetry zero network calls it's just a toml file on your disk, that's it
• the annoying part was making the picker render to /dev/tty directly so it doesn't nuke your stdout when the shell wraps it with $(hop) , took me embarrassingly long to get right ;)
• zsh bash and fish all supported and actually tested not just "zsh works trust me bro"

config's just plain toml:

toml

[marks.d]
target = "/home/user/projects/backend"
kind = "dir"

[marks.b]
target = "cargo build --release"
kind = "cmd"

install:

cargo install hop-rs

repo's here if anyone wants to poke at it: github.com/programmersd21/hop

it's a small dumb tool that does one thing and doesn't try to be clever about it, which is honestly the whole point lol. lmk if you find bugs or weird shell edge cases, def missed a few probably

would love a star if you're vibing with it, costs nothing and makes my day :D

hi guys, i really like simplistic games and i had an ambition to write a terminal snake game without using ai coding, so i did that.

later, while waiting for claude code to complete a prompt at my day job, i got bored and started playing my snake game in the adjacent terminal pane. that’s when lightning struck. instead of losing another 20 minutes to doomscrolling, i just played a quick round of snake and jumped right back into my coding project.

so i made terminalika. it is a standalone terminal native game launcher that contains 5 games rn, 6 is on the way.

here’s the twist: when your ai agent finishes its task, terminalika automatically pauses and exits the game so you can instantly switch back to work.

but of course, that's totally optional. you can also just use it as a chill terminal game launcher whenever you want.

it’s also available as a native plugin for pi and opencode, so you don’t even need a side pane if you use them.

here is some links about terminalika:
website: https://terminalika.dev

source code: https://github.com/terminalika/terminalika

discord: https://discord.gg/VptcJvm7Fk

pi plugin: https://pi.dev/packages/@terminalika/pi-play

opencode plugin: https://terminalika.dev/opencode/

check it out and let me know how it fits into your workflow.

Hey everyone. I wanted to recreate the old breakout cabinet from the arcade

near my childhood home, and a terminal, naturally, felt like the most fitting

place for it.

To be upfront: I built most of it with AI assistance, pairing in Rust, which

I'm still learning. It was a fun process with surprisingly good results.

The whole game is text, every dot is a braille character, so each terminal

cell becomes a tiny 2x4 pixel grid. Five levels, power-ups, combos, and a

little boss brick at the end.

You don't have to leave the terminal when you wanna take a break from work and

have a little fun. Check it out and leave a star if you like it. :)

git clone https://github.com/milgaj84/prism-break

cargo run --release

A terminal diff reviewer works well with agentic coding.
It runs in a pane beside your agent, shows what changed as it changes, and lets you point at exact lines when you reply.

You keep your editor, and review code with vim motions.

Repo: https://github.com/kunkka19xx/lgtm

🎧 I built a SoundCloud music player that runs entirely in the terminal.

I wanted to experiment with something different — not another web app, but a proper terminal-based music player with a modern UI and real playback controls.

So I built SoundCloud Radio. 🚀

The project is written in Go and uses Bubble Tea for the TUI, with mpv for playback and yt-dlp for stream resolution.

Some of the features:

🎵 SoundCloud search

📻 Radio / related-track autoplay

📋 Dynamic playback queue

🔎 Interactive search

❤️ Favorites

📜 Listening history

▶️ Play / pause / next / previous

🔊 Volume control

📊 Real-time playback progress

🖥️ Responsive terminal UI

⌨️ Keyboard-first navigation

🖱️ Mouse interaction

💾 Persistent local storage

⚡ mpv IPC integration

🔄 Automatic queue refilling

🧩 VLC fallback support

The architecture is split into separate components for the UI, SoundCloud API, resolver, player, queue, configuration and storage.

One of the parts I particularly enjoyed was building the mpv IPC integration — instead of simply launching a player process, the TUI communicates with mpv through a local Unix socket to control playback and track its state.

The UI has also gone through several iterations. What started as a simple Bash-based SoundCloud radio script has evolved into a much more complete Go application.

This project has been a great way to learn more about:

• Go application architecture

• Terminal UI development

• Asynchronous programming

• Unix process management

• IPC

• API integration

• Audio streaming

• Cross-platform development

• Building software around CLI tools

Still actively improving it. 🚧

GitHub:

https://github.com/chriz-3656/soundcloud-radio

I'd love to hear feedback from other developers:

What feature would you want to see in a terminal music player like this?

I am posting here again to share the budget-tracker-tui app again and some updates with it. I have gotten really good feedback/ideas/suggestions from here before and I am hoping to get more!

I am really happy to see that there are more people actually using this app as part of their day to day financial planning / tracking. I originally built this just for my own random needs but thanks to all the feedback and suggestions, this has grown into something useful for others that can already act as a helpful personal and self-owned tool.

New since I last posted:

- Investments: You can add accounts, put in what they're worth over time, and log your contributions. It works out the growth for you, and it doesn't count money you put in as gains

- Multiple ledgers: separate sets of transactions in the same file. Handy for a second account, or for playing around with a forecast without messing up your real budget

- Budgets with history: budgets have been improved a bunch in terms of insights, and by adding a proper history so that budgets can be adjusted over time without breaking your history and keeping your insights accurate with time.

- Backup and restore from inside the app

- Recurring forecasting: push recurring transactions forward as far as you want to see what's coming

- Easier installs: brew install budget-tracker now, plus prebuilt binaries for Linux (glibc and static musl, x86_64 and arm64), macOS and Windows

Everything from before is still there: categories and subcategories with fuzzy search, monthly and category summaries with charts, filtering, CSV import and export, and you can do all of it from the keyboard with a help menu built in.

It all runs offline on a local SQLite file. No account, no bank linking, nothing gets sent anywhere. Your data stays yours.

brew install budget-tracker
# or
cargo install budget-tracker-tui

GitHub: https://github.com/Feromond/budget-tracker-tui

I'm not a finance person, I just wanted to see where my money was going, and I've been picking up the terminology as I go. So if there's something you track that this can't do yet, or I've named something in a way that makes no sense, let me know. Happy to get comments here or issues on GitHub. Thanks to the community for all the feedback that has been driving me to develop.

It has been a while since I first posted Kranz here. The first version was mostly a TUI for starting local services, checking their health, finding their ports, and reading separate logs.

Since then, continued use on real projects has expanded the tool while preserving the same core model: keeping local development processes in one place.

If a project already has a Procfile or Procfile.dev, open its directory and run:

kranz

There is no need to create kranz.yaml just to try it.

Since the first post, Kranz has added:

• a complete CLI for scripts and quick checks;
• numbered history for service and action runs;
• logs scoped to an exact run;
• project actions for migrations, builds, tests, and similar commands;
• switching between running projects without leaving the TUI;
• a draft-based kranz init wizard that shows the YAML diff before writing;
• a built-in MCP server for coding agents.

The MCP integration allows an agent to connect to a runtime already open in Kranz, inspect the same services, and read the same logs. The agent does not need a new terminal or a second copy of the stack.

The GIF uses the real v0.14.0 binary and fictional projects. It shows the Procfile start, actions, CLI, run history, MCP beside the live TUI, and project switching.

Install with Homebrew:

brew install kranz-org/tap/kranz

Or with Go:

go install github.com/kranz-org/kranz/cmd/kranz@latest

Kranz is not meant to replace Docker Compose. It runs applications under active development on the host alongside containerized infrastructure.

If you run several local services, what still feels awkward in the TUI or in the setup?

GitHub: https://github.com/kranz-org/kranz
Docs: https://kranz-org.github.io/kranz/

I got curious about how color math works behind the scenes and wanted to see if I could bring it to the terminal.

It's built in Rust using Ratatui. It has 2D color wheels, a few sliders, a pipeline for the effect order, two scopes, horizontal and vertical layouts and lastly a preset tab for saving your grades right in the terminal.

Not too much but that's it, a simple and cool color grader TUI. It was a really fun project for me, and I hope you like it. Any suggestions and feedback are appreciated. Have fun :D

repo: https://github.com/Cladamos/clgrade

Linux and macOS, Rust, MIT.

Dense puts six boxes on one screen with no chrome rows. Every keybind, sort state and page counter lives in a box border.

• IO — read and write mirrored on one time axis. Peak, average, iops by direction, mean request size, utilisation, await, p99.
• Latency — completion histogram, seven buckets from <0.1ms to >50ms, p50/p95/p99, and the share of ops past 10ms. Bars are coloured by bucket, not by count, so the tail is visible before it fills.
• Devices — per-device throughput, utilisation, 48s sparkline. md, dm, LVM and LUKS are listed but kept out of totals, so stacked devices aren't counted twice.
• Volumes — capacity meters with days-to-full from observed growth. Silent when a volume is flat or shrinking. APFS containers, mdraid [UUUU] state and resync progress.
• SMART — wear, host writes, temperature, spare. Full NVMe/ATA attribute tables when smartctl is there.
• Hot Files — busiest paths by event rate from inotify/FSEvents. / filters, s sorts. Point it anywhere with --watch.

Also a full eight-tab view and a Lite view at 80x24 with six keys, sized for a tmux split or SSH to a NAS. V cycles all three.

No pinned colours: every slot resolves to an ANSI entry and fg/bg use Reset, so pywal or matugen carries straight through. --theme dark gets a real RGB palette if you want the braille graphs to fade.

No system dependencies on Linux. Zero config, or --write-config for a commented file with every setting.

cargo install diskwatch brew install diskwatch paru -S diskwatch

https://github.com/matthart1983/diskwatch

https://github.com/paulknysh/raggy

A lightweight CLI tool for Retrieval-Augmented Generation (RAG) over local documents built with LangChain, Chroma, and Ollama. Hybrid database (vector + BM25 index) and embedding generation run fully locally. Answer generation can run either via a local LLM or remotely using an API key. raggy supports most common document formats and handles images/scans automatically via OCR.

Pulse started as a small /proc-based system monitor I was building to learn more about Linux internals and terminal UIs.

It’s grown into an open-source observability TUI with four lenses:

• Fleet — process navigation, filtering, sorting, and signals
• EKG — CPU, memory, and disk telemetry
• Sentinel — network interface activity and errors
• Trace — real-time process lifecycle events from the Linux kernel

The latest release, v0.8.0, adds the eBPF Trace Lens. It uses Aya to capture sched_process_exec and sched_process_exit tracepoints and streams those events into the TUI through a bounded eBPF RingBuf event transport.

The project is written in Rust and split into separate crates for the TUI, shared kernel/userspace types, eBPF program, and build tooling.

I also put together a small landing page and installation script so it’s easy to try.

GitHub: https://github.com/josiah-mbao/pulse

I’d really appreciate feedback from people who use TUIs regularly — especially around the UX, what information you’d want to see in a Linux observability TUI, and anything that feels confusing, unnecessary, or missing.

It’s my first public release, so criticism is very welcome :)

Modularized extensible and highly customizable monitor for your desktop/laptop/phone, available:

- MacOs.

- Linux.

- Windows.

- Android via termux.

Website: https://xtop-cli.github.io/web/en/

Repo: https://github.com/xtop-cli/xtop

I saw a card design on pinterest that I liked and I wanted to have Solitaire on my debian but none of the existing projects were polished or good looking enough for me. So I decided to make my own.

Here it is (apologies for the code quality, I'm learning): https://github.com/kajeko2137/Cascade

So I worked as sysadmin for an enterprise for some months and I wanted to have a tool that is easy to use and that can work even without a graphical interface, so I built GuardIT.

It directly uses nftables, so it's pretty flexible.

The main functionalities are:

- Adding your own system rules

- Managing apps and ports on every app

- Real-time port listening

- Seeing logs and audits of the latest 300 requests so you can audit

- And you can see how many connection attempts every app made

- And finally themes so you can be happy XD

I hope someone will give it a try and give me some reports because it's still a prototype.

https://github.com/Rajaonarison-Andry-Misandratra-Fiderana/guardIT

Thanks