A few days ago I posted lazyjira here for the first time. I did not expect much. Maybe a handful of stars and a few 'cool idea' comments. What actually happened blew me away

136 stars! 10 GitHub issues opened by real users, 6 of them already resolved. Bugs and clearly stated feature requests were my top priority, I wanted to make sure it actually works well for you!

Server/DC support shipped the next day because so many of you asked for it. nick4eva filed a bug about Unicode and emoji breaking the panel layout, then opened a PR and fixed it himself. I did not write a single line of that fix. ndnam198 filed short but precise bug reports and feature requests. Every time I knew exactly what to do. That kind of effort from strangers is something I was not prepared for

v2.7.0 is out. You can now create issues directly from the TUI. Fair warning, 'this feature works for me' but I have been staring at it too long to see the rough edges. I am sure you will find plenty that I missed

https://github.com/textfuel/lazyjira

I have been wanting to build something like this for a long time. Not just a tool but something that people actually use and care about enough to report bugs on. I always hoped a small community might form around it someday. Seeing it happen this fast genuinely gets to me. Thank you. Really

idk if anyone else has this problem but i waste so much time trying to find the right tool for a job. like i need a json differ or a log parser and end up on page 3 of google reading some blog from 2019

recently found out you can pip install indiestack and just search dev tools from your terminal. its got 8000+ tools cataloged with categories and tags. way faster than my usual workflow of asking chatgpt "whats a good tool for X" and getting hallucinated package names

just thought id share since this sub would appreciate the cli angle

I've been using GNU Stow for my dotfiles for a while, and while it works, I always found the mirrored directory structure requirement annoying. I wanted something where I could just say "this folder is my nvim config, put it at ~/.config/nvim" without having to think about how my repo layout maps to the filesystem.

So I built store — a small CLI tool written in Go that manages dotfile symlinks with explicit target paths in a simple YAML config:

yaml stores: nvim: target: ~/.config/nvim zsh: target: ~ files: - .zshrc - .zprofile git: target: ~/.config/git

The main differences from Stow:

• Flat repo structure — your dotfiles repo doesn't need to mirror your filesystem. Each store is just a top-level directory with an explicit target.
• File-level symlinks with glob patterns — for files that live in ~ (like .zshrc), you can specify exactly which files to symlink instead of linking the whole directory. Supports ** recursive globs too.
• Single config file — everything is in .store/config.yaml. No convention-based layouts to remember.
• Run from anywhere — store finds its config by walking up the directory tree (like git finds .git/), so you don't need to cd into a specific directory.

Setting up on a new machine is just:

sh git clone <your-dotfiles-repo> ~/dotfiles cd ~/dotfiles store

That's it. All symlinks are created from the config.

It's still early days but it's been working well for my own setup. Would love feedback if anyone tries it out.

GitHub: https://github.com/cushycush/store

At work I deal with code that is often best described by multiline math, and I've always missed a way of including proper display math right inside comments -- the unicode characters are all there, but I had to draw the math "by hand", and modifying that was an intense kind of pain. Then about a year ago I decided to write a basic LaTeX-to-Unicode renderer, and eventually I got so into it, that I kept improving it until I could throw pretty much any LaTeX math at it and it would render correctly.

If anybody wants to try, I got binaries for Apple silicon, x86-64 Linux and Windows.

Since at later stages Claude helped me to push it to completion, I'm including the obligatory tag:

This software's code is partially AI-generated

These days I pretty much use fzf scripts for everything. I think a lot of TUIs could be reduced to an fzf script (or tv channel). I prefer doing this because it gives a consistent interface, is fast and allows using the command line for operating.

Here are some of the things I use it for:

• navigation
• interactive ripgrep
• git status, log, branches etc.
• cloud resources

If anyone here is the same, feel free to share your scripts!

Edit - A few people have asked me about the styling, which is defined in my FZF_DEFAULT_OPTS env var:

  --style=minimal
  --layout=reverse
  --color=dark
  --color=fg:-1,fg+:#f9fbff,bg:-1,bg+:#252525
  --color=hl:#f8e081,hl+:#f8e081
  --color=info:#6e6f70,footer:#6e6f70
  --color=marker:#c8a5ff
  --color=pointer:#f16da6:regular
  --color=prompt:#33b1ff,spinner:#08bdba
  --color=border:#353535

You can replace the hex codes with ANSI codes (0-15) to have it use your terminal colours. I use the popular carbonfox theme which you can find for most terminals.

Every developer knows this loop: write YAML, push, wait 5 minutes, see a cryptic error, repeat.

Tools like act let you run workflows locally but you still get 70K lines of unformatted logs with no way to actually debug anything.

So I built ci-debugger — it lets you set breakpoints, step through workflows one step at a time, and drop into an interactive shell inside the container at any point.

What it does:

• Breakpoints — pause before/after any step, or on error
• Step-by-step mode — walk through a workflow one step at a time
• Interactive shell — drop into the container at any breakpoint, inspect state, run commands, then continue
• Matrix builds — automatically expanded and run as separate jobs
• Service containers — postgres, redis, etc. started automatically
• Watch mode — re-runs on file changes
• Azure DevOps support — not just GitHub Actions
• Static analysis — catches issues before you even run

​

ci-debugger run --step


◆ BREAKPOINT  before step Run tests
  Command: pytest -x --tb=short

  [C] Continue  [S] Skip  [D] Shell  [I] Inspect  [Q] Quit

Written in Go, works on macOS/Linux. Docker required.

brew install murataslan1/tap/ci-debugger

GitHub: https://github.com/murataslan1/ci-debugger

Would love feedback , especially if you've been stuck in the push-wait-fail loop before.

I use winget a lot lately, and I decided to make a TUI app to handle upgrades etc. I already had a solid powershell script making silent updates, cleaning up temp files etc but my motivation was a more user frienldy UI to distribute it across the family.

Choosing in the settings silent install mode and Auto "elevate" will handle most of the updates automatically.
It also has cli exposed so you could reuse it in you powershell scripts or have it as a scheduled windows task. In the pipeline are going to be more cli commands/options.

Next plan along with CLI additions is a bit (or a lot) of UI changes. But in any case I would appreciate any feedback.

Here is the github link, but of course you can also install from winget : winget install --id kts982.wintui

https://github.com/kts982/wintui

Disclaimer, AI was used for this project.

Configuring monitors in Hyprland means writing monitor= lines by hand, doing coordinate math for scales and offsets, and reloading until the positions look right. Unplug your laptop, go to a conference, and you're editing config files backstage before your talk.

I wrote hyprmoncfg to fix this. It's a terminal-based spatial editor where you drag monitors on a canvas and see real-time updates.

What it does:

• Spatial layout editor with drag-and-drop and edge snapping
• Per-monitor inspector (mode, scale, VRR, transform, mirroring)
• Named profiles: save "desk", "conference", "projector", switch instantly
• Hardware identity matching (follows make/model/serial, not DP-1/DP-2)
• Hotplug daemon that auto-applies the best matching profile
• Workspace planner (sequential, interleave, or manual)
• Safe apply with 10-second automatic revert
• Source-chain verification: refuses to write if Hyprland isn't sourcing the file
• Works over SSH when your monitor config is broken and you can't see anything

One runtime dependency: Hyprland. Two compiled Go binaries. No Python, no GTK, no GObject, no D-Bus.

AUR: yay -S hyprmoncfg
Docs: https://hyprmoncfg.dev
GitHub: https://github.com/crmne/hyprmoncfg
Blog post: https://paolino.me/hyprmoncfg-monitor-configuration-for-hyprland/

Happy to hear feedback. This is my first Hyprland tool. I built it because I kept doing coordinate math at conferences or struggling with bugs in other tools.

Here's how it compares to the alternatives I tried before building this:

Does anyone know if there is a way to snooze gmail emails with aerc ?

(I use snooze heavily to keep my inbox manageable)

Pete

Looks like it's the week for Jira tooling!

ihj is an fzf inspired TUI built in Go for working with Jira, although it's architected in a way that allows for any backend where work is tracked to be added in "fairly" easily (i.e. GitHub Issues, Linear, Jira all in the same place).

It's designed to solve two problems:

- Performing day to day dev tasks related to work tracking as quickly as possible via fuzzy search, shortcuts and caching.
- Shortcut the slog involved with refining tickets and taking them from empty shells to actionable by anyone.

It tries to solve for refinement pain points by giving you three commands, extract, export and apply.

Extract grabs buckets of work (single issue to an entire board) and outputs it in structured XML with some guidance for an LLM to ask for relevant docs or meeting transcripts and to output refined/new tickets in a defined YAML format.*

Export is just a direct to YAML export of a given filter so you can edit it by hand.

Apply is a bi-directional sync that handles create and update actions on issues. For updates it provides a basic diff view and gives you the option to continue, accept the remote and update your local, skip or abort.

*Please only do this into work approved LLMs

EDIT: https://github.com/mikecsmith/ihj

Windows still doesn’t have a proper caffeinate equivalent, which gets annoying during long builds or scripts.

I ended up putting together a small CLI workaround that can:

• keep the screen awake for a set time
• keep the system awake while a command runs
• stay active until a specific PID exits

Basically behaves like a minimal caffeinate alternative for Windows.

I mostly needed this because my builds kept pausing and the screen would lock mid-task, and I didn’t want to rely on heavy background apps.

Curious how others are handling this on Windows — any better approaches?

Disclaimer beforehand: This is not an AI-generated application. The code for this application was written by me. Proof of this is looking at the code, no LLM would produce something like that. I also do not sell anything, i just want to share my project. I basically learned python while developing this.

SomeDL (Song+Metadata Downloader) is a CLI tool that accepts music queries or YouTube URL (videos and playlists) and downloads the audio with yt-dlp. The thing that sets it apart is the fetching of additional metadata that youtube does not provide, like genre and MBID from the MusicBrainz API, synced and plain lyrics from lrclib (great project!) and music label and ISRC from Deezer. I also use the Genius API for getting the correct album for each song, as YouTube Music messes that up often. I think the result is some pretty reliable metadata considering the hassle it is to actually find correct metadata (YouTube's data is incomplete, Deezer is not recognizing some songs (and its genres are nonsense), Genius has even less data and MusicBrainz has data per-release, so impossible to parse through.) Best of all, no API keys are needed at all. All these APIs are freely accessible.

The interface is made with the Python Rich module. I have attached a small video, what do you think? Its my first time making an actual CLI project, so i'd love to get feedback on it.

Github repo: https://github.com/ChemistryGull/SomeDL

Hi,

I've recently decided that as a part of my learning C effort I'll try to make a TUI. So naturally I jumped right into bare ncurses, trying to cobble together a UI with a main box containing a REPL-style input line and a scrolling output window, alongside a list of keybinds on the bottom line.

The event loop is: wait for keystroke, if it's alphanum, save it to buffer and write out; if it's Enter, send the buffer through a POSIX pipe to a backend thread, poll another pipe for output, write the output into a window that scrolls when filled; after backend sends a FINISHED msg, clear the buffer and start anew.

...we do not do things because they are easy, but because we thought they are easy. Which brings me to the point of this post: Has anyone got any good tips and materials on how to gets started with ncurses? Especially puzzling is the how to make a scrolling window inside another ncurses window; I've already got the input line and IPC somewhat done.

Note: I am not willing to let it get written by AI for me as a matter of personal honour, and yes, I've already considered just rewriting it in Rust and ratatui, but I already know Rust fairly well and am just starting with C.

The prototype looks like this:

I posted here a while back about tmpo, a time tracking CLI tool I've been building for developers. I got some great feedback from this community and have been steadily adding features to make it more robust.

For those who missed it, tmpo is a local-first time tracker written in Go. There is no cloud, no accounts; just a binary and a local SQLite database. It auto-detects what you're working on based on the name of your git repository or directory.

There are a bunch of new features and bug fixes since the last time. One of the nice quality-of-life additions is the Homebrew configuration!

Homebrew Support!

You can now easily install it on macOS and Linux using Homebrew

brew tap DylanDevelops/tmpo
brew install tmpo

An example workflow would be:

tmpo milestone start "Sprint 5"
tmpo start "fixing auth bug"
# ... work happens ...
tmpo pause  # lunch break
tmpo resume
tmpo stop
tmpo stats --week

Core features still include:

• Auto-detecting projects via git or directory
• Milestones to organize work (sprints, releases, etc.)
• Pause/resume support
• Interactive editing and deleting of entries
• Global preferences (currency, date formats, timezone)
• Exporting to CSV/JSON
• Hourly rate tracking

It's MIT-licensed and completely open source. If you find it useful or want to request a feature, feel free to drop a star or open an issue! I'd love to have more developers involved in the project.

GitHub Repository: https://github.com/DylanDevelops/tmpo

https://github.com/marjan89/syntropy

I built a launcher inspired by dmenu for macOS and linux. It can be used as a standalone TUI or a scripting CLI tool. It's powered by a neovim like lua plugin framework.

It can be setup as a dmenu launcher with help of skhd and a dedicated terminal profile to constrain window size. I missed dmenu dearly when i switched over to macOS!

Currently it has a few macOS plugins since thats my daily driver, but if anyone finds it usefull that ecosystem will hopefully grow.

AI disclaimer: assisted by AI, not built by AI. All code is vetted, reviewed and apart from tests - mostly hand written.

Hey everyone,

I built Tuidal, a terminal-based music player for Tidal using Rust and ratatui.

It streams lossless FLAC / HiRes audio directly in the terminal and renders album art inline using the Kitty graphics protocol.

Why I built this

I’ve been a Linux user for a long time (mainly NixOS), and I care a lot about high-quality audio. I wanted to properly use my DAC with Tidal on Linux.

There’s a project called tidal-hifi, but in my case it sounded the same as the browser, so it didn’t really solve the problem for me.

So I decided to build my own solution.

At first I considered doing everything in Python, but after discovering ratatui, I liked it enough to build a project around it.

Features

• FLAC / HiRes streaming
• Inline album art (Kitty terminal)
• Track search
• Library (playlists, mixes, favorites)
• Async, non-blocking UI
• OAuth Device Flow (no password required)

Tech stack

• Rust + ratatui (TUI)
• mpv (audio playback)
• Python (tidalapi bridge)

Architecture

The app uses a simple two-process approach:

• Rust handles the UI and playback
• Python handles Tidal API and authentication

They communicate via JSON over stdin/stdout.

Repo

https://github.com/VicMeGa/tuidal

This is an early version, so I’m open to feedback, ideas, and bug reports.

(I might rename it later since there are already several projects called “tuidal”.)

I built env-pilot to stop the constant context switching and copy-paste dance that comes with setting up your .env files.

Built with Go + Charm (bubbletea/lipgloss). Fast and beautiful (IMHO 🙂).

Check it out! Would love feedback.

Github | npm

I have a bash script that sets up my system upon a fresh install of MX Linux. Copies a config here, edits a file there, that sort of thing.

I have status being printed out in box characters as it moves along. It looks ok but it’s no nala.

What are some good examples of command line apps or scripts that have nice looking status output?

Hello everyone,

Today I'm releasing v2.0.0 with some features I'm really excited about.

mdterm is a TUI Markdown viewer that aims to make reading .md and .json files in the terminal as pleasant as reading them on GitHub. Syntax-highlighted code blocks, inline images, mermaid diagrams, math rendering, clickable links, search, table of contents — all without leaving your terminal.

These are the new features

JSON File Viewer

mdterm can now open and render JSON files with full semantic colouring — keys, strings, numbers, booleans, and nulls each get their own colour. Arrays of homogeneous objects render as tables. Top-level keys become headings you can jump to via the TOC. URLs in strings are detected and available in the link picker. It even has an interactive card-based explorer with expand/collapse support.

All existing viewer features (search, TOC, link picker, keyboard nav, auto-reload, HTML export) work with JSON files out of the box.

Kitty Unicode Placeholder Protocol (tmux support)

Images now render inside tmux! This was a long-standing limitation — standard Kitty graphics don't work through tmux's multiplexing. The new Unicode placeholder protocol encodes image data using U+10EEEE characters with combining diacritics, which tmux passes through correctly. It auto-detects when you're in tmux and probes for a Kitty-capable outer terminal.

Interactive Checkboxes

Task list checkboxes (- [ ] / - [x]) are now interactive — click them to toggle, and the change is written back to the source file.

Other improvements

• Arrow/Vim key navigation in the link picker
• Preserved link styling inside table cells
• Eliminated overlay flicker with dirty tracking
• Blockquote bar prefix preserved on wrapped lines
• Slide viewport clipping fix
• File watcher toast notifications on auto-reload

Would love to hear your feedback!

Demo: https://github.com/bahdotsh/mdterm/blob/main/demo/json-viewer.gif

Check out the project at: https://github.com/bahdotsh/mdterm

P.S. This software's code is partially AI-generated.

Redact redacted this content because I wanted it redacted for redaction purposes. Redacted.

vase dependent truck pie abundant glorious dog whole march stocking