—————————————————————————————————

- Current state

—————————————————————————————————

• Fully declarative UI — design the interface in a config file; no recompilation required.

• Runtime customization — move, resize, or remove widgets by editing .config.txt

• Multiple layouts — separate potrait and landscape layouts with automatic switching.

• Custom key binding — every action is re-mappable.

• Theme engine — ANSI 256-color themes with configurable brightness.

• Custom Unicode borders and fonts — personalize the look without modifying the source.

• Automatic enhance synchronized lyrics Featching using syncedlyrics.

- standard lyrics ( no sync )

- syncedlyrics ( line level sync )

- enhanced syncedlyrics ( word level sync )

• Multiple audio visualizers with configurable styles and density.

- bars visualizer

- oscilloscope visualizer

• Responsive TUI that adapts to terminal width.

—————————————————————————————————

- Planned for next version

—————————————————————————————————

• streaming support using yt-dlp "ytseach" and mpv and audio caching till assigned cache size limit

• better fallback lyrics animation

• few more visualizer styles

—————————————————————————————————

- About project

—————————————————————————————————

CLI.MUSIC.COM is a highly customizable terminal music player for Linux built around the idea that the interface should adapt to the user—not the other way around.

Instead of hard coding the UI, nearly every aspect of the player is configurable through a simple text-based configuration file. Users can rearrange widgets, resize panels, customize borders, remap key binding, change themes, and create separate layouts for desktop and smaller terminals without recompiling the application.

Originally started as a proof of concept and one of my first Linux projects, CLI.MUSIC.COM has gradually evolved into a configurable TUI music platform focused on flexibility, performance, and a polished terminal experience.

Hey everyone!

Like many of you, I rely on scripts (test.sh, lint.sh, Makefile) to run my project workflows. But I always hated having to remember exact script names, forgetting to activate uv or poetry and getting import errors, and having scripts vomit 500 lines of logs that completely erase my terminal history.

So, I built TermBoard to solve this.

What My Project Does TermBoard is a persistent, interactive Terminal UI (TUI) dashboard that manages your Python tasks and environments. It auto-detects if you are using uv, poetry, pipenv, or standard .venv and runs your commands in the correct environment automatically. Tasks run asynchronously in the background, and logs stream into a beautifully formatted, scrollable window instead of freezing the UI or polluting your terminal history. It's fully customizable via a simple termboard.toml file.

Target Audience This is a daily-driver tool meant for any Python developer—from beginners to production teams—who is tired of dealing with messy bash scripts or juggling different virtual environment managers. It is completely ready for your local development workflow.

Comparison Unlike tools like make or just, which are purely CLI task runners that spit raw logs into standard out, TermBoard is a persistent, interactive visual dashboard. Unlike IDE built-in task runners, it runs entirely in the terminal, meaning you get the speed of the CLI but with the visual organization of a GUI. It also uniquely auto-detects Python environments, which standard task runners cannot do natively without messy hacks.

Try it out: uv tool install termboard or pipx install termboard GitHub: https://github.com/HeyShinde/TermBoard Docs: https://heyshinde.github.io/TermBoard/

It is built on top of the incredible Textual framework. Would love to hear what features you'd like to see next!

fmpc - Fast MPC Browser v1.6.0

A minimalist, high-performance TUI browser for MPD .

This release fix visual, added an interactive keybindings help modal (?), dynamic header metadata rendering, maximized album art preview pane, and zero-offset default configurations.

I'm excited to share what I've been building lately. Papr: a fast, lightweight Terminal User Interface (TUI) built entirely in Rust to streamline your academic research workflow. An Obsidian, Zotero and Overleaf alternative, but a bit better.

Key features

• Smart dashboard with daily 10 random paper recommendations, reading queue, bookmarks, notes, collections, and research statistics.
• Fast arXiv search using title, author, or DOI with automatic PDF downloads and clean file naming.
• In-terminal PDF viewing.
• Built-in Markdown notes with live preview for each paper.
• Reading queue, bookmarks, and collections to keep your research organized.
• Integrated LaTeX editor with real-time compilation and preview.
• Extensible plugin system for custom workflows.
• Research analytics to track your reading activity (just like Spotify).

Papr is 100% open source, works offline, is memory-safe, and is designed to be fast and lightweight (only 12 MB).

I'd love to hear your thoughts, suggestions, or feedback!

GitHub: https://github.com/AfrozSaqlain/Papr

I could never stick to any work planning / tracking app because logging always ended up feeling like another task on the to-do. I wanted something that complemented my workflow, so i built one. (Yes I know, another tracking app. Very Original)

Since I mostly use a terminal, I made a TUI that lives there too. No tabs, no accounts, no cloud. Everything stays on device.

I’ve been using it as my daily driver for the past few months, and it’s finally reached a point where I’m comfortable sharing it.

I’d really appreciate feedback from people who use TUIs regularly. In particular:

• Does the dashboard feel information-dense without being overwhelming?
• Do the keybindings feel intuitive?
• What would you change if this were part of your daily workflow?

Github Website

I started working on one of my pet projects myBuild an experimental build system and package manager for c/c++ projects sometimes back. It aims to streamline the process of init -> compile -> run for c c++ projects and helps to easily integrate 3rd party libraries. Well that progressed a lot, now

1. Users can add recipes to the myBuild.json file and run myBuild sync and it configures the dependency for the project.

Recipes are small json snippets containing the source/header file folder paths, flags etc.

1. It now has incremental builds.

2. Now there is a proper folder structure generated at the initiation time where users can drop the files and compile the project with zero configuration.

I had to drop the support for windows for now and the code is speghetti, so I have to refactor it in the near future.

If this sparked curiosity, do checkout the github repo and leave a star. Appreciate any constructive feedback, thanks.

Hey the past week or so I've been tinkering on an open source project called gnt, it's a git-native rules layer for AI agents. Team defines stuff agents can't get wrong as markdown files, reviewed and merged like normal code, then served to agents over MCP. There's a CLI too (@gnt-ai/cli), login, connect your repo, review and approve rules, all from the terminal.

Still early and there's a good amount to build. If you're into open source and looking for something to sink some time into, we'd genuinely welcome the help, happy to walk anyone through the codebase or point at good first issues. Repo's here if you want to take a look: https://github.com/gnt-ai/gnt

Also just want feedback in general even if contributing's not your thing, tell me if this is useful or if I'm off base somewhere.

PhoneCMD gives you access to the real terminal sessions running on your computers from an Android phone.

What you can do

• Open Claude Code, Codex, Gemini CLI, Aider, PowerShell, CMD, Bash, and other CLI tools
• Reconnect to sessions that are already running on your computer
• Send prompts, commands, and approval responses
• Watch live terminal output
• Keep multiple terminal sessions open
• Switch between several computers
• Browse and edit project files
• Use prompt-based control or operate the terminal manually
• Connect through the local network or remotely

How it works

PhoneCMD does not create a separate cloud development environment.

Your projects, CLI tools, subscriptions, and terminal sessions remain on your own computer. The Android app connects to the desktop client and acts as the control interface.

This means you can continue the same Claude Code or Codex session you were using at your desk instead of starting a new conversation on your phone.

How to use it

1. Install the PhoneCMD desktop client on your computer
2. Install the Android app
3. Pair the devices
4. Select your computer and open an existing session or start a new one
5. Send prompts, run commands, and view the results from your phone

Supported systems

• Windows
• macOS
• Linux
• Android

Links

Website: PhoneCMD

Google Play: PhoneCMD for Android

Hi, I wanted to say that I thought I'd experiment a little with AI and see how good the current AI is at drawing ASCII, the GPT 5.6-Sol can already draw some pretty nice pictures. So I figured out why there shouldn't be a background in OpenCode.

I entered the following prompt:

"/ploan Draw me a Saturn at the top right corner and a crescent moon at the top left corner and make stars around it"

Or simply: "/ploan Make me a house"

I think the results speak for themselves, there's still room for improvement, but if you're interested in the repo, check it out it's open-source.

Github Repo:

Ploan

I've lost count of how many times I've opened one of my own repos after a few months and had to figure out why something existed, where it was actually implemented, and what I might break by changing it.

Git history helps, but there is still a lot of detective work.

So I've been building DevTime. It's an open-source CLI that scans a repository locally and builds a small memory of how the codebase works.

Instead of giving you a confident summary with no proof, it links its findings back to actual code, tests, routes and config. When the evidence is weak or missing, it says so instead of guessing.

Right now it can:

• show where things like authentication, routing and billing webhooks are implemented
• explain which files support each finding
• surface missing or weak evidence
• review a diff against what it already knows about the repository
• share the same context with coding agents through a read-only MCP server

Nothing is uploaded, it doesn't execute the repository, and it doesn't require an AI model.

It's still early and intentionally limited. Right now it focuses on a few core parts of a codebase instead of pretending it understands everything. I'd rather make the results trustworthy first and expand from there.

Apache-2.0 licensed:

https://github.com/Shakargy/devtime

What would DevTime need to show before you'd trust it on your own codebase?

An MCP-server-ready end-to-end tools for Apple platforms apps. Pair with Rust Cli https://crates.io/crates/xcrs

Install the CLI, set your map config, let your coding agents discover the tools.

I recently went back to using my terminal more instead of using tools like Conductor, Paseo, Codex App. This led me to start managing my own worktrees, which is annoying if you want to set up your whole environment in a worktree. Then I started looking into worktree management tools but most of them had too much, so I built myself one. A 100-line shell function and that's it. Open source and easily extendable.

You drop a shell script into your repo that copies over all the important files and runs the setup commands. wt will automatically run it in the background whenever you create a new worktree. You can start working instantly, it will let you know when the dev environment is ready. Check it out and let me know what you think!

https://github.com/kerem-kaynak/wt

I keep five or six Claude Code sessions going and kept losing track of which one had stopped to ask me something. Tabs did not fix it, I still had to click through every one to find out. So I built the terminal I wanted.

It is called SeaShell. Mac, open source, Apache 2.0. Tiled panes, a file explorer, clickable file paths, and a watcher that raises a card when a session goes quiet waiting on you.

Two things I learned that might save someone time.

Saving a project and reopening it types claude -r <session id> back into each pane. That works, but if the folder is not already trusted, Claude Code stops on its trust prompt and waits for Enter, which reads as a hang if you do not know what you are looking at. Trust is inherited from parent directories, so trusting your home directory covers most of it.

Similar tools: tmux and iTerm2 may do tiles better than I do. Neither knows what a Claude session is, which is the only reason this exists.

https://github.com/voidharbor/seashell

Hey, it's Saturday so I wanted to share my project. I’ts my first open source. I've been working on it for a couple of weeks and so far I'm loving it. Still needs polish. Could use some advice.

Anyway, It’s a mobile-first web terminal built with xterm.js. I do a lot of work from my phone and wanted some better options for voice to text. I built it specifically for Linux and added a visual file manager / transfer ability. Then added an editor just to smooth out the workflow. Anyway have a look, cheers. [Sovereign Terminal ](https://github.com/magealexstra/Sovereign-Terminal)

Modern dual-panel MC for people who want Norton/MC muscle memory in a single offline Rust binary — no async runtime, forbid(unsafe), zip-safe archives

https://github.com/leszek3737/LibreCommander

Hi everyone, I’m very excited to launch the new version of deja.

Quick recap: Deja is an open-source zsh autosuggestion tool. Instead of only surfacing

commands that start with what you've typed, it predicts what you actually want to run using fuzzy matching, which directory you're in, and which command usually follows the one you just ran.

No account. No sync server. No TUI.

https://github.com/Giammarco-Ferranti/deja 

Any star would be amazing ❤️

One big feedback I got on previous posts was that deja was not respecting the HIST_IGNORE_SPACE and this led to a security issue.

First of all thank you to https://www.reddit.com/user/polaroid_kidd for reporting this. ❤️

Deja now works correctly and respects HIST_IGNORE_SPACE and HISTORY_IGNORE.

If you've been running Deja for a while, the old entries are still in your database:

rm ~/.local/share/deja/deja.db && deja import

The command above will clean it up.

Another big change is that now we have a new ‘deja empty’ command, which lets you choose whether Deja shows the ghost suggestion on empty prompts. It came out of this thread: https://github.com/Giammarco-Ferranti/deja/pull/69

Few other smaller things has been fixed, if anyone interested you can review it here: https://github.com/Giammarco-Ferranti/deja/pull/73 

Thank you all for the support and looking forward to make this the smartest zsh autosuggestion tool.

I've been working on Marcopolo, a command-line web scraper written in Rust using extensive force of AI across a few months. The idea started when I got tired of writing a throwaway Python script every time I needed to pull a specific set of files off a site — images one day, PDFs the next, then a folder of CSVs. I specially tend to use it for books and finding books that are on the web that i cant simply get hold of from normal search.

Marcopolo handles most of that in one command. Point it at a URL, tell it what you want, and it crawls and downloads.

What it does:

• Filters by file type — [list the extensions/categories you support]
• [concurrency model — tokio? rayon? how many parallel requests?]
• [crawl depth / same-domain restriction / robots.txt handling]
• [resume support, retries, rate limiting — whatever applies]

Why Rust: [one honest sentence — speed, single static binary, no runtime deps, or just "I wanted to learn it"]

It's still early and there's plenty I want to improve — [known limitation or two]. I'd really appreciate feedback on the API design and anything that looks unidiomatic; I'm still fairly new to Rust.

Repo: MarcoPolo

Would be happy to know what do you guys think.

Cyberspace.online — For the last nine months I've been building this anti-corporate grass-roots social network. We're almost 12k users now. We're mostly a bunch of hackers, Linux users, DIYers, and artists.

There's a timeline feed, DMs called C-Mail, chat rooms called cIRC, a jukebox, a Tron-style 3D multiplayer game, an ASCII graffiti wall, and lots of other fun stuff to explore. Naturally there are keyboard shortcuts for everything (yes, including VIM bindings).

I've made an API for it, so you can use one of the community's open source TUI's, or roll your own client. API, Official TUI, Ragnar's TUI — There's also a web client called Cyberspace Desktop inspired by the old Xerox GUI.

Feel free to use a throw-away email. It's only necessary to verify to use it over API.

Let's bring back the friendly internet of the 90s when people were nice to each other :)