Login

u/Klutzy_Bird_7802

▲ 36 r/unixporn

[OC] built a fully 3D rubik's cube that runs in your terminal. manual mode, auto screensaver, kociemba solver, the works.

been sitting on this for a while. had a cube on my desk, looked at my terminal, you know how it goes.

it renders isometrically with three visible faces, real ANSI shading, the whole thing. supports standard cube notation so you can type R U R' U' directly into a command prompt inside the app. undo/redo stack, live FPS counter, TOML config, themes.

the solver uses kociemba two-phase so it actually solves it properly instead of doing something naive.

rubui -m auto --speed 0.1

that runs it as a screensaver. looks genuinely good on a dark terminal.

stack is pure Python 3.10+, no dependencies beyond the solver. written in about a dozen modules, nothing crazy. cube_engine.py holds state, renderer.py does the isometric projection, input_handler.py deals with raw keyboard.

repo: https://github.com/programmersd21/rubui
install: pip install -e . after cloning it

happy to answer questions about the renderer if anyone's curious, that part was the most interesting to figure out. would love a star on the repo.

note: used a bit of AI help on the renderer specifically, that part was genuinely painful to work out. everything else is mine. also yes this is Arch, I just configured fastfetch to flex windows for the screenshot.

u/Klutzy_Bird_7802 — 21 hours ago
▲ 171 r/computergraphics+6 crossposts

[OC] I made a small terminal screensaver that renders Perlin noise flow fields with Braille characters

Hi everyone,

I wanted to share a small Python project I have been working on called halo.

It is a terminal screensaver / visualizer that renders a particle flow field using 3D Perlin noise, Braille cells, and 24-bit ANSI color. The main idea was to see how much visual detail I could get out of a normal terminal without opening a GUI window or relying on an external rendering engine.

The renderer uses Braille characters as a kind of sub-cell pixel grid, so each terminal character can represent a 2x4 block of virtual pixels. Particles move through a vectorized noise field, leave trails behind, and the output is diffed frame-to-frame so it only writes changed cells back to the terminal.

It includes a few color presets such as neon, sunset, ocean, forest, and fire, and it should work in modern true-color terminals like Windows Terminal, WezTerm, Alacritty, kitty, Ghostty, and iTerm2.

Install from GitHub:

pip install git+https://github.com/programmersd21/halo.git

Run it with:

halo

Example:

halo -c fire -p 600 -s 2.0

This is not meant to be a serious productivity tool. It is just a small terminal art experiment that I had fun building, and I tried to keep it lightweight and readable.

Repo: https://github.com/programmersd21/halo

I would appreciate any feedback, especially from people who enjoy terminal graphics, creative coding, or small CLI projects. Consider checking out the repo and leaving a star!

u/Klutzy_Bird_7802 — 21 hours ago
▲ 9 r/PythonProjects2+1 crossposts

[RICE] Velvet Noir - minimal glass setup with single-command Matugen theme switching

[Velvet Noir] - glass-forward, dynamically themed Hyprland setup

Been working on this for a few months before uploading to GitHub and finally feel like it's at a point worth sharing. Velvet Noir is my take on a dark-glass Hyprland rice: minimal, fast, and fully automated through Matugen for wallpaper-driven color generation. Chezmoi handles the whole config structure, which makes it surprisingly painless to manage across machines.

System details

  • OS: Arch Linux
  • WM: Hyprland (14px roundings, 4-pass blur, custom whooshZap bezier animations)
  • Bar: Waybar (44px floating pill modules, debossed styles and hover-lift effects)
  • Terminal: Kitty (85% opacity, 64-level blur, JetBrainsMono Nerd Font)
  • Shell prompt: Starship (Tokyo-Night powerline with dynamic Matugen colors)
  • Launcher: Rofi (expanding glass launcher with blurred background)
  • File manager: Yazi (terminal-native, custom colors)
  • Notifications: SwayNC (dark-glass blurred control center)
  • Lock screen: Hyprlock (animated blurred locker)
  • Theme sync: custom theme-switch.sh hooked into Matugen

What makes it tick

The main thing I wanted to get right was single-command theme switching - run the script, Matugen picks up the wallpaper, and everything from terminal colors to Waybar styling to GTK assets updates automatically. No manual hex editing.

The blur setup is 4-pass on the Hyprland side with transparent floating layouts throughout. The whooshZap animations are custom bezier curves I tuned for workspace switching and window open/close — snappy but not jarring.

Dotfiles

Everything's open-source and managed with chezmoi: https://github.com/programmersd21/velvet

git clone https://github.com/programmersd21/velvet.git
cd velvet && chmod +x dot_config/install.sh && ./dot_config/install.sh

A note on AI use - I used AI assistance in a few places: debugging Hyprland config errors, tuning keybinds, writing code comments, and as a general reference when I didn't want to dig through docs. The rice, design decisions, and overall config structure are my own.

Happy to answer questions about any part of the config. Would love contributions and other forms of feedback!

u/Klutzy_Bird_7802 — 1 day ago
▲ 18 r/unixporn

[Hyprland] Velvet Noir - minimal glass setup with single-command Matugen theme switching

[Velvet Noir] - glass-forward, dynamically themed Hyprland setup

Been working on this for a few months before uploading to GitHub and finally feel like it's at a point worth sharing. Velvet Noir is my take on a dark-glass Hyprland rice: minimal, fast, and fully automated through Matugen for wallpaper-driven color generation. Chezmoi handles the whole config structure, which makes it surprisingly painless to manage across machines.

System details

  • OS: Arch Linux
  • WM: Hyprland (14px roundings, 4-pass blur, custom whooshZap bezier animations)
  • Bar: Waybar (44px floating pill modules, debossed styles and hover-lift effects)
  • Terminal: Kitty (85% opacity, 64-level blur, JetBrainsMono Nerd Font)
  • Shell prompt: Starship (Tokyo-Night powerline with dynamic Matugen colors)
  • Launcher: Rofi (expanding glass launcher with blurred background)
  • File manager: Yazi (terminal-native, custom colors)
  • Notifications: SwayNC (dark-glass blurred control center)
  • Lock screen: Hyprlock (animated blurred locker)
  • Theme sync: custom theme-switch.sh hooked into Matugen

What makes it tick

The main thing I wanted to get right was single-command theme switching - run the script, Matugen picks up the wallpaper, and everything from terminal colors to Waybar styling to GTK assets updates automatically. No manual hex editing.

The blur setup is 4-pass on the Hyprland side with transparent floating layouts throughout. The whooshZap animations are custom bezier curves I tuned for workspace switching and window open/close — snappy but not jarring.

Dotfiles

Everything's open-source and managed with chezmoi: https://github.com/programmersd21/velvet

git clone https://github.com/programmersd21/velvet.git
cd velvet && chmod +x dot_config/install.sh && ./dot_config/install.sh

A note on AI use - I used AI assistance in a few places: debugging Hyprland config errors, tuning keybinds, writing code comments, and as a general reference when I didn't want to dig through docs. The rice, design decisions, and overall config structure are my own.

Happy to answer questions about any part of the config. Would love contributions and other forms of feedback!

u/Klutzy_Bird_7802 — 5 days ago
▲ 11 r/LinuxUsersIndia+1 crossposts

[Hyprland] Velvet Noir - minimal glass setup with single-command Matugen theme switching

[Velvet Noir] - glass-forward, dynamically themed Hyprland setup

Been working on this for a few months before uploading to GitHub and finally feel like it's at a point worth sharing. Velvet Noir is my take on a dark-glass Hyprland rice: minimal, fast, and fully automated through Matugen for wallpaper-driven color generation. Chezmoi handles the whole config structure, which makes it surprisingly painless to manage across machines.

System details

  • OS: Arch Linux
  • WM: Hyprland (14px roundings, 4-pass blur, custom whooshZap bezier animations)
  • Bar: Waybar (44px floating pill modules, debossed styles and hover-lift effects)
  • Terminal: Kitty (85% opacity, 64-level blur, JetBrainsMono Nerd Font)
  • Shell prompt: Starship (Tokyo-Night powerline with dynamic Matugen colors)
  • Launcher: Rofi (expanding glass launcher with blurred background)
  • File manager: Yazi (terminal-native, custom colors)
  • Notifications: SwayNC (dark-glass blurred control center)
  • Lock screen: Hyprlock (animated blurred locker)
  • Theme sync: custom theme-switch.sh hooked into Matugen

What makes it tick

The main thing I wanted to get right was single-command theme switching - run the script, Matugen picks up the wallpaper, and everything from terminal colors to Waybar styling to GTK assets updates automatically. No manual hex editing.

The blur setup is 4-pass on the Hyprland side with transparent floating layouts throughout. The whooshZap animations are custom bezier curves I tuned for workspace switching and window open/close — snappy but not jarring.

Dotfiles

Everything's open-source and managed with chezmoi: https://github.com/programmersd21/velvet

git clone https://github.com/programmersd21/velvet.git
cd velvet && chmod +x dot_config/install.sh && ./dot_config/install.sh

A note on AI use - I used AI assistance in a few places: debugging Hyprland config errors, tuning keybinds, writing code comments, and as a general reference when I didn't want to dig through docs. The rice, design decisions, and overall config structure are my own.

Happy to answer questions about any part of the config. Would love contributions and other forms of feedback!

u/Klutzy_Bird_7802 — 5 days ago
▲ 85 r/LinuxUsersIndia+7 crossposts

[OC] i built curv — a terminal bezier curve workstation with a 120fps render loop

Hey r/unixporn,

Been working on curv, a TUI bezier curve editor for the terminal. The idea was to have a proper workstation for designing and tweaking easing curves without ever leaving the keyboard.

Repo: https://github.com/programmersd21/curv

What it does

You get a full multi-panel workspace in your terminal:

  • Visualizer — braille-rasterized curve with live crosshairs
  • Velocity graph — dy/dx momentum analysis for punchiness tuning
  • Spectrum — momentum distribution across animation segments
  • Physics panel — derived tension & friction values from the curve shape
  • DNA intensity — real-time multiplier that exaggerates control points outward from center
  • History — breadcrumb trail of previous coordinate states
  • Animation preview — toggle a live preview with a

All of this runs on a non-blocking 120fps render loop, so every keypress feels instant.

Controls

Key Action
/ Open searchable preset explorer
Tab / Shift+Tab Cycle selection (p0 → p1 → p2 → p3)
Arrow keys Move selected point (0.05 units)
Shift + Arrows Fine movement (0.005 units)
[ / ] Adjust DNA intensity multiplier (0.1x – 3.0x)
a Toggle animation preview
c Copy CSS to clipboard
h Toggle technical help
q Quit

Export formats

Once you've dialed in your curve, c copies it to clipboard. Supports:

CSS

cubic-bezier(0.420, 0.000, 0.580, 1.000)

Hyprland

0.420, 0.000, 0.580, 1.000

SwiftUI

animation.timingCurve(0.420, 0.000, 0.580, 1.000)

Install

pip install git+https://github.com/programmersd21/curv.git

Then just:

curv

Built with Python. The layout degrades gracefully on smaller terminals while keeping zero-gap panel coverage. Preset explorer is fully searchable so you can browse common easing curves without touching the mouse.

Would love feedback — especially if you use Hyprland or do a lot of SwiftUI animation work. Consider leaving a star on the repo you found it interesting!

MIT licensed. Source on GitHub.

u/Klutzy_Bird_7802 — 13 days ago
▲ 20 r/unixporn+1 crossposts

[OC] Kairo v1.6 — shipped a native Pomodoro focus engine, undo/redo, and a Command Center dashboard to my terminal task manager (Go/Bubble Tea)

Hey, posted Kairo (https://github.com/programmersd21/kairo) here a few days back and got some great feedback. Wanted to share what's changed since — it's been a pretty significant few releases.

Quick recap for newcomers: Kairo is a local-first, keyboard-driven TUI task manager. SQLite backend, 32 themes, Lua plugin system, optional Gemini AI panel, MCP server. Lives entirely in your terminal.

What's new since the last post (v1.5.0 → v1.6.0):

Focus Engine (f) — the biggest addition. Hit f on any task and you drop into a dedicated Pomodoro timer with a minimalist "liquid glass" UI. While a session is running, a DEEP WORK pulse sits in the footer. Sessions are logged to SQLite and linked to the task, so the stats dashboard can actually show you real focus trends over time — not just completion counts.

Command Center Dashboard (s) — a full stats screen with:

  • Productivity DNA heatmap (peak hours breakdown)
  • Real-time momentum score from the last 3 days
  • Activity timeline with adaptive label cleanup
  • Tag cluster intelligence

Undo/Redo (ctrl+z / ctrl+y) — tracks creation, deletion, bulk deletion, edits, status toggles, priority changes, deadline updates. All synced live to the DB. No restart.

Project Switcher (ctrl+e) — jump between project namespaces instantly. Tasks scoped per project, with an <All Projects> view when you need the full picture.

Multi-select + bulk actions — Space to select, then z/d for bulk complete or delete.

Safe deletion — t deletes in current context, a does a database-wide wipe with confirmation. No more accidental nukes.

Also: keybinding for "Filter by Tag" moved from f to ctrl+f to make room for the Focus Engine. If you were a prior user, heads up on that one.

Repo and install instructions in comments. Still MIT, still fully offline, still no account required. Leave a star if it was helpful!

u/Klutzy_Bird_7802 — 14 days ago
▲ 24 r/unixporn

Small patch but a meaningful one. Been grinding on stability and a couple of new fields that make recurring task management actually usable.

The worst offender was a silent date corruption bug: if you set a due date, the MM-dd was being parsed as HH:mm and quietly overwriting your time. It was one of those bugs that's hard to notice until your tasks start showing up at the wrong time. Gone now.

On the new side, wait_until is my favorite addition in a while: you can now hide a task and all its recurrences until a future date. Stuff like "deal with this invoice on the 15th" just disappears from your list until it's actually relevant. Pairs nicely with until, which stops a recurring task from generating new instances after a given date. No more manually deleting the ghost of a habit you dropped three months ago.

Plugin hooks and tag cleanup are now fully live: no restart required after changes, orphaned tags disappear instantly when you delete or prune, and app_start hooks fire correctly after plugins load.

Edit mode also got a visual pass labels are properly highlighted, active fields have a noticeably brighter background, and the right-side field order is now tags → due → priority by default. Configurable via config.toml if you want it your way.

Full changelog and install instructions on GitHub: https://github.com/programmersd21/kairo

Consider leaving a star on github as it inspires me to build more awesome updates for kairo!

Would appreciate feedback on this patch update. Suggestions, PRs, or issues are welcome!

u/Klutzy_Bird_7802 — 17 days ago
▲ 8 r/unixporn

One day I was bored and stumbled onto a YouTube video about pyfiglet. Spent way too long just scrolling through the fonts going "okay but what if these were moving."

That was the idea. Bring the fonts to life: motion, color, effects. So I built Bangen.

It's an ASCII banner renderer with a live split-screen TUI, a composable effect pipeline, and export to TXT, PNG, and GIF.

What it does:

  • Live TUI with split-screen preview as you type/tweak
  • Multi-stop gradients with horizontal and vertical interpolation
  • Transparent PNG and animated transparent GIF export
  • Plain TXT export with exact ASCII output
  • Auto-sizing based on terminal dimensions
  • JSON presets so you can save and replay your exact setup
  • CLI with progress bar, elapsed time, ETA, and status text on export

Stack: pyfiglet · rich · Pillow · Typer

The goal was ASCII art that actually survives being exported, not just looks good in the terminal and turns to mush the second you screenshot it. That took more work than expected.

The GIF export with transparency was the real villain. Pillow's GIF quantization will genuinely humble you.

Repo: github.com/programmersd21/bangen

Dots and feedback welcome... still ironing out font sizing edge cases on ultra-wide terminals.

u/Klutzy_Bird_7802 — 17 days ago
▲ 22 r/LinuxUsersIndia+3 crossposts

Hey everyone! Just shipped v1.5.0 of Kairo, my keyboard-first terminal task manager written in Go, and this one's a big one.

The headline: a full analytics dashboard, press s to open it.

Here's what's inside:

  • Productivity DNA — visualizes when during the day you actually get things done, mapped to your theme colors
  • Momentum Engine — a real-time score based on your task completions and focus sessions over the last 3 days. It moves. Watch it.
  • Behavioral Insights — dynamic, data-driven blurbs that adapt to your actual patterns. Not static tips.
  • Activity Timeline — adaptive graph of your completion trends. Cleans up labels automatically when data is sparse so it never looks broken.
  • Tag Intelligence — heatmap of your tag clusters so you can see where your energy is actually going

Under the hood, I also expanded the data model to support all of this: completed_at timestamps on tasks for velocity tracking, plus new sessions and events tables for granular focus logging.

To update:

kairo update

or via Homebrew:

brew upgrade programmersd21/kairo_tap/kairo

GitHub: https://github.com/programmersd21

Would love feedback — especially on the Momentum scoring, still tuning the formula. Let me know what you think!

u/Klutzy_Bird_7802 — 18 days ago
▲ 85 r/unixporn

Yeah, I know. Another task manager. Bear with me.

I'm a developer who lives in the terminal. Neovim, tmux, the whole setup. Every time I needed to check my tasks I'd either crack open a browser tab (focus: destroyed) or squint at some plain-text todo file with zero structure. Neither felt right.

So I built Kairo — a TUI task manager in Go, using Bubble Tea and Lip Gloss. Keyboard-only. Local SQLite with WAL mode. No cloud. No account. No mouse. Just your tasks, right there in the terminal where your brain already is.

What's actually in it:

  • Vim bindings (j/k/gg/G) and sub-millisecond fuzzy search
  • Nested tasks with collapse/expand (Space)
  • Recurring tasks — weekly (mon,wed,fri) or monthly (15), next instance generates automatically on complete
  • Natural language deadlines: tomorrow 10am, next friday — it just works
  • 32 built-in themes, live-switchable with t (yes, including catppuccin)
  • Bento-style layout with real-time Markdown preview
  • Git-backed sync with zero backend — your data stays yours
  • Lua plugin system that hooks into task events
  • A full headless CLI API (kairo api create/list/update) for scripting and CI
  • An MCP server if you want to wire it up to AI agents
  • Optional Gemini AI panel — toggled with ctrl+a, completely invisible otherwise
  • Cinematic create/complete/delete animations (or kill them in config.toml if you're a purist)

Install is one line:

curl -fsSL https://raw.githubusercontent.com/programmersd21/kairo/main/scripts/install.sh | bash

Or go install, or Homebrew on macOS.

Then kairo, press n, make a task. That's literally it.

Works best on Alacritty. Some terminals have rendering quirks — tracking them in #16.

Repo: https://github.com/programmersd21/kairo

MIT licensed. Free forever. PRs welcome — especially themes and plugins. If something annoys you, fix it and open a PR.

Huge shoutout to @Tornado300 on gh for some critical bug fixes early on.

If this saves you even 10 context-switches a day, a ⭐ on the repo helps other terminal people find it.

u/Klutzy_Bird_7802 — 18 days ago
▲ 30 r/LinuxUsersIndia+5 crossposts

100 stars. I know that's nothing by internet standards, but I genuinely didn't expect anyone outside my own GitHub profile to care about this.

Kairo started as a frustration project. I was deep in a coding session, had to context-switch to my task manager, and just... snapped a little. Opened a new Go module that same night. That was a few months ago.

For those who haven't seen it — Kairo is a fully local, keyboard-first terminal task manager. SQLite storage, 32 themes, fuzzy search, natural language deadlines, a Lua plugin system, a CLI API for scripting, and an optional MCP server if you want to point AI agents at your task list. No cloud. No account. No subscription. Just a binary you run in your terminal.

Things I didn't expect when building it:

  • That people would actually use the Lua hooks (shoutout to the person who built a webhook notifier with them — genuinely wild)
  • That the "32 themes" feature would be the thing people mentioned most
  • That u/Tornado300 would show up and fix bugs I'd been avoiding for weeks

What's coming: encrypted multi-workspace support, a sandboxed plugin environment, and smarter task suggestions. I'm building this in the open and taking feedback seriously — if something annoys you, open an issue or just tell me here.

If you've been looking for a task manager that lives where you actually work — give it a shot.

→ github.com/programmersd21/kairo

Thanks for the stars. They matter more than they probably should.

u/Klutzy_Bird_7802 — 20 days ago
▲ 6 r/CSEducation+2 crossposts

Hey everyone,

I've been working on a Chrome extension called Scratch Copilot AI, and I wanted to share it with this community since I think it could be genuinely useful — especially for people who work with or teach using Scratch.

The basic idea: you chat with an AI assistant (Google's Gemini) directly inside the Scratch editor, and it does the heavy lifting for you. You can describe what you want in plain English, and it will generate block scripts, create sprites, manage assets, set variables, and even trigger the green flag — all without manually dragging blocks around.

Here's a rough overview of what it can do:

• Generate Scratch block scripts from natural language prompts • Automatically create and add sprites, costumes, sounds, and backdrops • Control the Scratch VM in real-time (start/stop, set variables, manipulate sprites) • Summarize your current project state on demand

The extension is open source and built with a modular architecture — there's a dedicated module for VM control, asset management, block building, and more. It hooks directly into the Scratch editor's execution context, so everything happens live inside your project.

To get started, you just load the extension in Chrome's developer mode, open any Scratch project, and enter your own Gemini API key (free tier works fine for most use cases).

The repo is on GitHub — happy to answer any questions, take feedback, or hear if anyone runs into issues. I'd also love to know if this would be useful for classrooms or coding workshops.

https://github.com/programmersd21/scratch-copilot

Thanks for reading!

u/Klutzy_Bird_7802 — 21 days ago
▲ 12 r/VibeCodeDevs

I built a terminal task manager in Go that never phones home — it just hit 100 ⭐ on GitHub and I'm genuinely emotional about it

A few months ago I was fed up. Every task manager I tried was either:

  • A GUI app that yanked me out of flow
  • A cloud thing that wanted my email, my credit card, and probably my soul
  • A plain text file that had zero structure
  • A legacy TUI that looked like it was designed in 1994

So I built Kairo — a keyboard-driven, local-first, fully offline task manager that lives in your terminal.

Today it crossed 100 stars and I wanted to share it here because this community is a big reason I kept going.

What makes it different (I think):

  • 🔒 Your data never leaves your machine — SQLite, WAL-enabled, zero cloud
  • ⚡ Sub-millisecond fuzzy search, full vim keybindings (j/k/gg/G)
  • 🧩 Lua plugin system — hook into task_create, task_update, app_start and automate anything
  • 🤖 Optional AI panel (Gemini) — fully disabled unless you turn it on
  • 🎨 32 built-in themes with live switching, bento-style layout
  • 📡 Full MCP server — so AI agents can actually read and manage your tasks
  • 🔄 Git-backed sync — no backend, just files
  • Natural language deadlines: tomorrow 10am, next friday, in 2 hours

The whole thing is free, MIT licensed, and built in Go.

A quick taste:

kairo api create --title "Finish the thing" --priority 1
kairo api list --tag work
kairo export --format markdown
kairo mcp       # stdio mode for local AI agents
kairo mcp 8080  # SSE mode for remote

I never expected anyone outside my own dotfiles to care about this. 100 people did. That means a lot more than the number suggests.

If you live in a terminal and you've been duct-taping together todo.txt + cron jobs + shell aliases — give Kairo a shot. I'd genuinely love the feedback.

👉 https://github.com/programmersd21/kairo

(install in one line on macOS, Linux, or Windows — see the README)

Also shoutout to @Tornado300 who caught bugs I was too close to the code to see. Open source is cool, man.

u/Klutzy_Bird_7802 — 25 days ago
▲ 117 r/LinuxUsersIndia+6 crossposts

I built a terminal task manager in Go that never phones home — it just hit 100 ⭐ on GitHub and I'm genuinely emotional about it

A few months ago I was fed up. Every task manager I tried was either:

  • A GUI app that yanked me out of flow
  • A cloud thing that wanted my email, my credit card, and probably my soul
  • A plain text file that had zero structure
  • A legacy TUI that looked like it was designed in 1994

So I built Kairo — a keyboard-driven, local-first, fully offline task manager that lives in your terminal.

Today it crossed 100 stars and I wanted to share it here because this community is a big reason I kept going.

What makes it different (I think):

  • 🔒 Your data never leaves your machine — SQLite, WAL-enabled, zero cloud
  • ⚡ Sub-millisecond fuzzy search, full vim keybindings (j/k/gg/G)
  • 🧩 Lua plugin system — hook into task_create, task_update, app_start and automate anything
  • 🤖 Optional AI panel (Gemini) — fully disabled unless you turn it on
  • 🎨 32 built-in themes with live switching, bento-style layout
  • 📡 Full MCP server — so AI agents can actually read and manage your tasks
  • 🔄 Git-backed sync — no backend, just files
  • Natural language deadlines: tomorrow 10am, next friday, in 2 hours

The whole thing is free, MIT licensed, and built in Go.

A quick taste:

kairo api create --title "Finish the thing" --priority 1
kairo api list --tag work
kairo export --format markdown
kairo mcp       # stdio mode for local AI agents
kairo mcp 8080  # SSE mode for remote

I never expected anyone outside my own dotfiles to care about this. 100 people did. That means a lot more than the number suggests.

If you live in a terminal and you've been duct-taping together todo.txt + cron jobs + shell aliases — give Kairo a shot. I'd genuinely love the feedback.

👉 https://github.com/programmersd21/kairo

(install in one line on macOS, Linux, or Windows — see the README)

Also shoutout to @Tornado300 who caught bugs I was too close to the code to see. Open source is cool, man.

u/Klutzy_Bird_7802 — 13 days ago
▲ 0 r/PythonProjects2

Hey everyone 👋

Just shipped Kairo v1.3.0, and this release pushes it way beyond a typical TUI task manager.

This isn’t “AI bolted on.” The assistant can actually control the app.

🧠 What Kairo Is

Kairo is a fast, keyboard-first task manager built in Go.

  • Offline-first
  • Fluid Bubble Tea UI ("liquid glass" feel)
  • Designed for zero-mouse workflows

⚡ What Makes This Release Different

🤖 AI That Can Take Actions (Not Just Chat)

  • Full tool-calling inside the TUI
  • Create/edit/delete tasks
  • Modify themes
  • Generate & edit Lua plugins
  • Instant UI updates (async, no blocking)

👉 This feels closer to a programmable interface than a chatbot.

🔗 Built-in MCP Server

  • Native Model Context Protocol (MCP) server

  • External agents (Claude Desktop, etc.) can:

    • Access your task DB
    • Control themes
    • Manage plugins

👉 Turns Kairo into an AI-controllable system, not just an app.

🎨 Lua Theme Engine (Now Serious)

  • Full theme definition via .lua
  • Plugin system promoted to first-class
  • Event hooks for automation
  • CLI-based plugin management (headless)

👉 You can script behavior, not just appearance.

📂 Real Data Portability

  • CSV + Plain Text support
  • Import/export menu (x)
  • Format-aware feedback

🧩 Small but Important Upgrades

  • Reset settings (r)
  • Live AI + MCP status indicators
  • Model switching inside TUI

📦 Install

macOS (Homebrew)

brew tap programmersd21/kairo_tap
brew install --cask kairo

Linux / macOS

curl -fsSL https://raw.githubusercontent.com/programmersd21/kairo/main/scripts/install.sh | bash

Windows

iwr -useb https://raw.githubusercontent.com/programmersd21/kairo/main/scripts/install.ps1 | iex

🔗 Links

💬 Looking for Feedback

  • Does “AI controlling a TUI” feel useful or overkill?
  • What workflows would you automate with this?
  • Any ideas for plugins or integrations?

If you build something cool (themes/plugins), I’d love to see it 👀

⭐ If this project looks interesting, consider starring the repo — it helps more than you think.

u/Klutzy_Bird_7802 — 27 days ago
▲ 1 r/VibeCodersNest

Hey everyone 👋

Just shipped Kairo v1.3.0, and this release pushes it way beyond a typical TUI task manager.

This isn’t “AI bolted on.” The assistant can actually control the app.

🧠 What Kairo Is

Kairo is a fast, keyboard-first task manager built in Go.

  • Offline-first
  • Fluid Bubble Tea UI ("liquid glass" feel)
  • Designed for zero-mouse workflows

⚡ What Makes This Release Different

🤖 AI That Can Take Actions (Not Just Chat)

  • Full tool-calling inside the TUI
  • Create/edit/delete tasks
  • Modify themes
  • Generate & edit Lua plugins
  • Instant UI updates (async, no blocking)

👉 This feels closer to a programmable interface than a chatbot.

🔗 Built-in MCP Server

  • Native Model Context Protocol (MCP) server

  • External agents (Claude Desktop, etc.) can:

    • Access your task DB
    • Control themes
    • Manage plugins

👉 Turns Kairo into an AI-controllable system, not just an app.

🎨 Lua Theme Engine (Now Serious)

  • Full theme definition via .lua
  • Plugin system promoted to first-class
  • Event hooks for automation
  • CLI-based plugin management (headless)

👉 You can script behavior, not just appearance.

📂 Real Data Portability

  • CSV + Plain Text support
  • Import/export menu (x)
  • Format-aware feedback

🧩 Small but Important Upgrades

  • Reset settings (r)
  • Live AI + MCP status indicators
  • Model switching inside TUI

📦 Install

macOS (Homebrew)

brew tap programmersd21/kairo_tap
brew install --cask kairo

Linux / macOS

curl -fsSL https://raw.githubusercontent.com/programmersd21/kairo/main/scripts/install.sh | bash

Windows

iwr -useb https://raw.githubusercontent.com/programmersd21/kairo/main/scripts/install.ps1 | iex

🔗 Links

💬 Looking for Feedback

  • Does “AI controlling a TUI” feel useful or overkill?
  • What workflows would you automate with this?
  • Any ideas for plugins or integrations?

If you build something cool (themes/plugins), I’d love to see it 👀

⭐ If this project looks interesting, consider starring the repo — it helps more than you think.

u/Klutzy_Bird_7802 — 27 days ago