Hi, we are a group of students building Sonora. While it was initially intended as an extremely lightweight Spotify replacement, it has since grown far beyond that.

Current features include:

• Spotify, YouTube (optional login) support
• Local music library import, virtual playlists, favorites
• Synced/karaoke lyrics, including local music!
• Romanization
• Library management within supported providers
• Gapless playback
• Audio normalization
• Cross-platform support
• Custom themes

Inspired by Zed, which has proven excellent performance using their native cross-platform rendering stack, we have decided to use GPUI. Its awesome text rendering on every platform, ease of use in view composition, and, admittedly, TailwindCSS-like naming conventions all made a significant impact. We have found GPUI to perform extremely well when used and optimized with care. Quite a few patches were introduced to our fork of it to meet our needs in the effects and profiling departments. Thanks to that, I am not hesitant to call our lyrics the most beautiful you can currently get on desktop (Apple Music still beats us HARD on mobile). But despite blur and gradient opacity all looking great, my favorite addition has to be visual render highlighting. But this is too much to cover in a Reddit post, I'll have to write a proper blog post at some point...

What may come as a surprise to folks coming from something like Spotify Desktop is that Sonora actually does not need all of your RAM to function. Tested on linux-x86_64, after 5 minutes of playback it averaged around 173 MiB RSS as opposed to Spotify's ~2GiB. Note that 173MiB is still not a small footprint, but at least with Sonora you know it goes towards caching previews and views instead of feeding the Electron monster merely to keep it alive.

Looking forward to hearing your feedback!

Yes, we did use AI.

Hi, I maintain lucidadl, a project I wanted to present u.

That s a cross-platform Python CLI and terminal interface that keeps Lucida(.)to downloads manageable from terminal.

It handles tracks, albums, text batches, and public playlist imports from Apple Music, Spotify, Deezer, YouTube Music, Amazon Music, TIDAL, SoundCloud, and Qobuz. It adds parallel downloads, retry and resume, duplicate detection, ordered M3U8 output, dry-run and match-review modes, and optional local ffmpeg transcoding.

Install with:

pipx install lucidadl

lucida setup

Source: [https://github.com/Jude-A/lucidadl\](https://github.com/Jude-A/lucidadl)

Package: [https://pypi.org/project/lucidadl/\](https://pypi.org/project/lucidadl/)

Feedback on the installation flow and terminal UX is welcome.

Hi,

I’ve released Libre Kambio, an open-source multi-currency converter for Linux.

I built it because I wanted to enter one amount and instantly see many currencies at once, while still being able to verify where the exchange rates came from.

It currently supports 65 currencies and includes:

- Instant simultaneous multi-currency conversion

- Any supported currency can be used as the base

- ECB reference rates as the primary source

- Bank of Russia data for additional currencies and independent cross-checking

- Official USD pegs where applicable

- Optional official Latin American central-bank sources

- Custom currency groups

- Manual ordering and visibility controls

- Source verification and publication dates

- English and Spanish UI

It is distributed as an x86_64 Flatpak and currently tested on Fedora KDE Plasma / Wayland.

I design the functionality, interface and overall direction of the project. Generative AI is used as a development assistant for implementation, testing and documentation. I manually test and maintain it.

GitHub: https://github.com/h2o7Y/Libre-Kambio/

I’m sharing it mainly in case somebody else finds this kind of multi-currency workflow useful. Feedback and testing on other Linux distributions would be very welcome.

Here's a PyQt6-based (Python) GUI wrapper around UGREP. Very handy and powerful way to do desktop search recursively under any folder on Linux.

https://github.com/Clay-Ferguson/sonar

Lumi-o is a Linux-only, open source raster painting app, a radically redesigned GIMP 3.

The GUI has been streamlined and carefully unified stylistically, with the aim of making the whole application feel like a coherent studio rather than a general-purpose image editor.

The goal is a dependable tool: efficient, predictable, focused, and biased toward making pictures. Wacom tablets are supported and have been extensively tested as part of the artist-led development, so stylus input stays smooth and reliable in actual painting use.

A few things that define it:

• Pigment-based colour. Palettes are organised around real pigment profiles and mixed spectrally, so colour behaves more like a painter’s palette than a set of conventional digital colour sliders.
• Saving and recovery. Lazy loading keeps large projects quick to open, with autosave and recovery from earlier versions. Projects use a directory-based .lum format designed to remain readable without proprietary software. XCF and PSD import/export are supported.
• Scheme scripting. If you know Script-Fu, the scripting environment should feel familiar. It uses the same Scheme family, with changes and additions aimed at Lumi-o, including a built-in utility standard library for images, layers, files, paths, GEGL, and more.

Lumi-o is Linux only. I develop on Debian 13 / Cinnamon.

Site, docs, and downloads:

https://lumi-o.org/

Happy to answer questions.

So, after I tried almost every file manager in Linux, I thought why not make one for myself.

With the help of an LLM, I have built what is for me the best file manager in Linux.

It took me hours of thinking what I wanted in a file manager, and after testing for another 60 hours, the application is ready.

If you are interested take a look at my github page : https://github.com/wiedaar

(This post was first shared in [r/commandline](r/commandline).)

I built this because I kept rebuilding my setup from scratch and got tired of manually reinstalling packages and hunting down files every time. It started as a small script and grew into something I figured it was worth of sharing to everyone.

What it does:

Backs up the user´s installed packages, AUR packages, and Flatpak apps, in the right format for whichever package manager the user is using. It lets the user interactively pick which config files/folders to include (via a gum powered TUI) and restores everything in the same place on a fresh install even on a different distro.

Supports Arch, Debian/Ubuntu, Fedora, and openSUSE, with best-effort package name translation between them.

The user´s backup data lives in their own private repository, completely separate from the tool's one, so the tool itself stays fully public/shareable without exposing anything personal.

Some things I cared about while building it:

If you select \`\~/.ssh\` or \`\~/.gnupg\`, it warns you and lets you review exactly which files go in, rather than blindly sweeping the whole directory . Git only tracks the executable permission bit, not full file modes so it explicitly resets SSH/GPG key permissions back to their correct values on restore, and shows you the exact commands before running them. And so on.

Honest caveats:

It's a young project, I'm the only person who's stress-tested it so far (including on some fresh VM installs), and cross-distro package name translation is inherently best-effort. Distros don't agree on package names, so some things need manual installing after a cross-distro restore. I've documented that limitation rather than pretend it's solved.

Anyway here´s the tool link:
[https://github.com/lumertya/Nomad\](https://github.com/lumertya/Nomad)

Would genuinely appreciate feedback, bug reports, or just someone else trying it on a distro I haven't tested yet. Thank you.

Hey everyone,

I wanted to share Tux-Dock (and its companion subreaper daemon, tuxreaperd), an open-source project built to treat Docker containers as persistent, interactive development sandboxes rather than single-process disposable tasks.

• Project Page: https://mentalnet.xyz/forgejo-v2/markmental/tuxdock
• GitHub Mirror: https://github.com/MARKMENTAL/tuxdock

The Problem & Why I Built It

When using Docker containers as persistent local environments (running sleep infinity), standard setups constantly leak zombie processes whenever interactive commands, background jobs, or subshells exit. Furthermore, standard init systems like tini or dumb-init blindly blast SIGTERM down the tree, causing web servers like Apache and PHP-FPM (which rely on non-standard signals like SIGWINCH or SIGQUIT) to drop active in-flight connections on shutdown.

Instead of pulling heavy system container frameworks, I built a two-part solution:

1. tux-dock (C++ TUI): A fast, keyboard-first terminal control center that talks directly to the local Docker UNIX socket to manage retained container lifecycles, stream logs, inspect ports, and dispatch commands.
2. **tuxreaperd (Freestanding PID 1):** A sub-5KB micro-init built with -nostdlib and raw inline assembly syscalls (no glibc/musl). It instantly reaps dead child processes via wait4, scans /proc using Linux syscalls like sys_getdents64, and remaps signals appropriately to ensure zero-downtime draining before exit.

What's New in v0.4.2-beta

• Direct Command Execution with Output: Added an interactive "Run Command in Container (with output)" menu action to fire off one-shot maintenance/init scripts and view terminal output directly in the TUI without attaching a full shell. If you just want to start/restart or check a service, this is often quicker than attaching a shell.
• Background State Poller: Resolved multi-instance state drift with a 5-second background poller and idempotent mutations so Tux-Dock doesn't go out of sync with Docker (and handles 304/404 API states cleanly).
• Port Mapping Fix: Patched duplicate port display entries caused by a lack of filtering Docker's /containers/json API reporting dual IPv4/IPv6 bindings.
• Cross-Arch Verified: Fully tested and running on x86_64 and physical arm64 hardware.

The attached demo video shows Tux-Dock spinning up an Nginx + PHP-FPM Debian docker container sandbox, executing background services via command history, jumping into a live shell to install packages, and verifying zero zombie accumulation with tuxreaperd as PID 1, all running on an old dual-core Intel Haswell laptop.

Would love to hear feedback on the TUI workflow or the tuxreaperd micro init system!

For now there's a nix flake and .deb and .rpm binaries in Releases. The app is still in alpha-release so bugs are expected.

Some features worth mentioning:

- Local Text-to-Speech generation (kokoro-tts).
- Local Captions generation (uses whisper.cpp).

I built sshconfig-lint after repeatedly missing stale key paths and conflicting host blocks in my own ~/.ssh/config.

It checks the full OpenSSH client configuration without making a connection:

• multiple config files in one command
• nested Include resolution and cycle detection
• stale IdentityFile paths
• duplicate or conflicting Host blocks
• JSON, GitHub annotations and SARIF output

Version 0.5 adds an LSP server, a VS Code extension, Pre-Commit hooks and an official GitHub Action. The same Rust engine is used in each workflow.

Install with Cargo:

cargo install sshconfig-lint

Arch Linux:

yay -S sshconfig-lint-bin

Release binaries are available for Linux glibc and musl. Everything runs locally and there is no telemetry.

Repository: github.com/Noah4ever/sshconfig-lint
Playground: sshconfig-lint.apps.thiering.org
VS Code: Marketplace

Feedback about packaging, false positives and real-world Include layouts is welcome.

I maintain Yetty (https://github.com/zokrezyl/yetty), an open-source terminal emulator that can display images, Markdown, plots, and other content in scrlollback.

I’m trying to understand whether Linux users can actually get it installed and use it beyond the demo. If you tried it, where did you stop: installation, first launch, documentation, performance, or missing features?

Negative feedback is useful.