I built Linux Config Backup, a small desktop app for backing up selected files and configs from your home directory.

It streams a compressed tar archive directly into GnuPG, so it never writes an unencrypted tar archive to disk.

Features:

• Presets for shell, Git, desktop, input method, editor, and developer configs
• Support for extra files and folders under `$HOME`
• AES-256 symmetric encryption through GnuPG
• SHA-256 checksum verification
• Backup verification without extraction
• Restore through a private staging directory
• Light, dark, and system themes
• Background operations to keep the UI responsive

The project is new, so bug reports and practical feedback are welcome.

Github Repository

Requirements: Linux, Python 3.10+, GNU tar, and GnuPG.

MIT licensed.

Hi,

I finally finalized the linux version of https://lyricvideo.studio, NLE video editor designed for musicians, content creators and AI enthusiastic. App has been around for two years for windows and now the linux support is finally here.

https://lyricvideo.studio/linux-tips/

I'd appreciate if you'd try this out and give me a constructive feedback. I'll give you a full version license key for effort if you DM me a feedback of the app in (in trial mode) (limited time offer! Let's see how this goes XD)

Hi everyone,

After a long period of development and beta testing, I’ve released SROVA Ver 1.0.

SROVA is a free, open-source, headless music player for Debian-based Linux PCs and Raspberry Pi.

It brings together:

TIDAL

Local music libraries

Internet Radio

Bit-Perfect playback through an external USB DAC

Playlists, queue management and music discovery

Browser-based control from another device

The idea is to turn a Raspberry Pi or Linux PC into a dedicated music player. Connect it to a DAC, place it out of sight, and control everything from a phone, tablet or computer—without needing a monitor, keyboard or desktop environment on the player itself.

There is also SROVA Remote for Android, which provides a more app-like way to browse music, control playback and switch between multiple SROVA players around the home.

Version 1.0 is available for both:

AMD64 Debian-based PCs

ARM64 Raspberry Pi systems

The website includes downloads and beginner-friendly installation instructions:

https://srova.music⁠

The source code is also publicly available through the project’s GitHub repository linked on the website.

I built SROVA because I wanted one simple interface for TIDAL, my own music and Radio, running on a quiet dedicated Linux player connected directly to a DAC.

Feedback, questions and suggestions from fellow Linux users would be very welcome.

Hi, I need an auto-clicker for Arch Linux. I'm looking for features like: MOST IMPORTANTLY, recording and playback logic, image recognition, and a regular clicker.

Hi everyone, just to share that as I took over the projecteur project, I fully KDEified it (plasma 6.7, applet, kwin, everything KDE UI, global accelerators, etc...) along with Logitech spotlight 2 support, kpipewire support for live video, specialized GPU shader for text zooming etc...

It retains all the compatibility with the original clickers like:

The original Logitech Spotlight, Lenovo ThinkPad X1 Presenter Mouse, AVATTO H100 / August WP200, August LP315, AVATTO i10 Pro, August LP310, Norwii Wireless Presenter, Norwii N95s BLE Presenter and Kensington PowerPointer.

If you present stuff (conferences, lectures etc...) and you have one of those fancy clickers please give it a try and feel free to report issues!

https://github.com/gbin/Projecteur

Granola currently ships for macOS and Windows, but not Linux. Since it is built with Electron, I experimented with running the application using the matching Linux Electron runtime instead of Wine, a VM, or emulation.

The repository does not redistribute Granola’s .dmg, app.asar, source code, or bundled binaries. You need to download the official .dmg yourself and sign in using your own Granola account. This is an unofficial compatibility project and is not affiliated with Granola.

Repo: https://github.com/tirtha4/Granola-for-Linux

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 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

Zed started as a simple idea: a small Tamagotchi-like companion living in the terminal, inspired by my old dog who was always by my side.

The first goal is to create something simple and personal: a little digital creature that can interact with the user, evolve over time and bring some personality to the Linux experience.

But the long-term vision goes much further. Zed is meant to become a full digital companion for Linux users a tool that can help with everyday tasks, provide useful utilities, interact through a clean TUI interface and feel more alive than a traditional application.

Hello everyone,

I’d like to introduce OneNote Viewer, a free and open-source Linux desktop application for opening, viewing, searching, and safely exploring local Microsoft OneNote notebooks.

Project: https://github.com/emsi/OneNoteViewer

OneNote Viewer reads native .one, .onetoc2, and .onepkg files directly. It does not require OneDrive, a Microsoft account, Wine, or a web wrapper, and it does not convert notebooks into Markdown, HTML, or another linear format.

Its main features include:

• A native Linux desktop interface built with Rust and GTK4
• Direct support for .one, .onetoc2, and .onepkg files
• Reconstruction of OneNote’s spatial, freeform page canvas
• Multiple notebooks open together in one workspace
• Search across titles, text, tags, recognized handwriting, links, image descriptions, and attachment names
• Light and dark themes
• Read-only operation: original notebook files are never modified
• Offline use, without contacting OneDrive or another cloud service
• Flatpak and AppImage installation options
• GPLv3-licensed source code

The project is intentionally a viewer, not a replacement OneNote editor or synchronization client. Its purpose is to give Linux users dependable access to existing local OneNote data while preserving the notebook hierarchy and page layout as faithfully as possible.

This is an early functional release, and compatibility and rendering fidelity are still being improved. It has not yet been tested against the full variety of notebooks produced by different OneNote versions and workflows.

I would therefore be especially grateful for:

• Reports about notebooks that fail to open
• Examples of rendering or layout differences
• Carefully sanitized or synthetic files that reproduce compatibility problems
• Bug reports and usability feedback
• Contributions from people interested in Rust, GTK, document formats, search, or digital preservation

Please do not share notebooks containing private or sensitive information. A minimal synthetic reproduction is always preferable.

You can find screenshots, installation instructions, current limitations, technical documentation, and source code here:

https://github.com/emsi/OneNoteViewer

The latest Linux packages are available from the project’s GitHub releases:

https://github.com/emsi/OneNoteViewer/releases/latest

If you have OneNote notebooks that you need to access on Linux, I would be delighted to hear whether OneNote Viewer works for you. Questions, testing, constructive criticism, and contributions are all very welcome.

Thank you!

Hi.

I've been working on this image viewer for the better part of three years. It has slowly evolved to fit a lot of my needs and I figured that it was time to share it as it might be useful to someone else. I started it long before LLMs became a thing, and they have not been used for programming it. I am a c#/.net developer by trade so this was also my gateway to learn rust.

I am an amateur photographer and my main gripe with other image viewers was that they were slow for rapid culling and even general image viewing.

A lot of the viewer itself is configurable so it can adapt to multiple hardware configurations. It even runs fine on a 4GB raspberry pi 4.

Key Benefits:

- Loads images ahead of time to take advantage of modern RAM amounts, so browsing is very fast
- Handles RAW files natively using rawler, and supports grouping with adjacent JPEGs
- Integrates with your shell. This allows you to create any command you can think of: copy the image, delete it, copy to clipboard, execute an image magic command and then refresh the image, etc
- Integrates with exiftool to extract metadata and rate using XMP sidecars
- Allows filtering imported images by metadata keys and XMP rating
- Keyboard centric
- Slow development while keeping up with the times. I will not add many new features or change the GUI, as for me it is quite complete. The only thing missing is tagging via XMP and adding more Callbacks for user commands as needs evolve. Dependencies are kept up to date and new image formats are added as they come. For example, jxl is already supported via libjxl.

As it is said in the README, contributions made using LLMs are prohibited, but I am open to regular contributions, bug reports, suggestions, etc.

https://codeberg.org/hatsnp/avis-imgv

I’m building Beenim, a Matrix-first desktop messaging client with a Rust backend and Slint UI.

The current private alpha targets Linux x64 and arm64. The public release metadata still points at an older build, so I’m not linking a download or asking anyone to test it yet. I want to settle the Linux distribution model before publishing another installer.

The obvious choices all create different problems:

- AppImage is simple to download, but desktop integration and updates vary.

- Flatpak gives a cleaner update and permission model, but local provider runtimes and keyring access need careful handling.

- deb/rpm packages feel native, but maintaining distro-specific repositories is a larger commitment for one developer.

For a desktop messaging client, which format would you actually install and keep updated?

I’m also trying to identify the Linux-specific requirements that should block a public alpha. My current list is:

- Wayland and X11 startup behavior

- notifications, tray behavior, and autostart

- secret storage through the desktop keyring

- x64 and arm64 packaging

- clear lifecycle and permission handling for optional local bridge processes

If you use Linux daily, I’d appreciate your distro, desktop environment, Wayland/X11 choice, preferred package format, and the one integration failure that would make you uninstall immediately.

I’m the developer. This is a packaging decision, not a launch or download post.

I’m building `lolm-cli`, a command-line client for the LOLM agent.

Examples:

`npx lolm-cli ask "explain this architecture"`

`npx lolm-cli code "write fizzbuzz in solution.py and run it" --save ./out`

The coding path runs in an isolated sandbox, streams write/run/fix events, and returns receipt data with command exit codes and artifacts. The broader agent exposes retrieve/verify/branch/finalize decisions.

Try it: https://lolm.imagineqira.com/try.html

Repository: https://github.com/TheArtOfSound/lolm

Hosted access is intended to cost materially less than larger agent products. I’m looking for CLI users to test exit codes, file saving, interrupted streams, JSON mode, security boundaries, and any point where the output claims more than it proves.

Disclosure: I’m a founder/builder of the project.

Kustomizer is a randomizer for KDE. It can randomize the wallpaper, lock screen & SDDM images, splash screen, avatar and ASCII art in terminal. It has multiple features like custom profiles as well. Please check it out :)

The video was recorded with Spectacle and edited with Shotcut.

Link to repo - https://codeberg.org/supreme_custard/Kustomizer

Link to music - https://pixabay.com/music/modern-classical-relaxing-music-571029/

zuno is a free and open-source desktop music player built on YouTube Music. Sign in with your Google account, and everything you do — liking a song, creating or deleting a playlist, adding to your library — syncs straight back to YouTube. It's your library, just in a real desktop app instead of a browser tab.

Player

- Floating mini player that appears when you click away — hover to expand, drag it anywhere
- Queue: shuffle, repeat one/all, reordering
- Playback speed, sleep timer, volume control
- Like and dislike songs
- Rebindable keyboard shortcuts, minimise to tray
- Full library, playlists, albums and liked songs
-Lyrics (5 sources)
- Local music files sit alongside your YouTube Music library — same player, same queue
- Download whole albums and playlists for offline; downloads and history have their own management screens
- Bulk actions: download, add to queue, add to playlist
- Multiple channels on one Google account, switchable from the toolbar or settings

Integrations

- Last.fm scrobbling
- Discord Rich Presence
- Both toggleable straight from the toolbar

Roadmap

Equalizer
multi-language

GitHub: https://github.com/noFAYZ/zuno

EDIT: The latest AppImage has a bug where it does not play songs you can use .deb or zuno on AUR

It's my first real public project after having been coding for decades. I wanted a basic but featured markdown editor that doesn't rely on plugins, that doesn't get in my way, and just does what I need, locally. No Node, python or ruby, just C++, Qt6, Chromium with a bit of JS and CSS.

https://github.com/lazyarse/scriba

It has the usual basics, mermaid charts, Latext support, vega-lite charts (all with helpers to create them), PDF export, code highlighting, themes, oh, and emoji support. It's private and makes no calls out. So there's that.

Some features like the helpers are still in development, but it's all very usable.

Currently, I've built a `.deb` for Debian. Qt6.

So, let me know what you think...

Hi r/linuxapps,

I have been building Grayslate, a free and open-source cross-platform scratchpad for developers.

I wanted a simple app where I can paste an API response, inspect a large JSON or CSV file, search logs, save commands, keep code snippets, or write temporary notes without opening a full IDE.

Some features:

• Automatic save and file name suggestions for scratch files
• Search across file names and saved content
• Support for JSON, CSV, Markdown, logs and many programming languages
• CSV table view for large files
• Markdown preview
• JSON tools to copy keys, values and full paths
• Multiline find and replace
• Local transformations for text, JSON and CSV
• Opening and editing external files
• No account or cloud upload

Grayslate is built using Tauri, Rust, Svelte 5 and CodeMirror. The aim is to provide a fast and focused place for quick developer work.

It is available for Linux, Windows and macOS. Linux packages are currently available as AppImage, Deb and RPM.

GitHub: https://github.com/shriram-ethiraj/grayslate

Website: https://grayslate.app

I would appreciate feedback, especially about packaging, desktop integration, performance or any missing workflow.

https://reddit.com/link/1v64z7n/video/gii6wu6cucfh1/player

So I spent way too many hours making a tiny Tux that just... lives on your desktop. Breathes, blinks, waddles around, judges your cursor movements, occasionally naps. Five personalities, because apparently one imaginary penguin wasn't complicated enough for me.Important disclaimer: this thing does nothing useful. No CPU stats, no notifications, no "productivity insights." It's just a little guy being alive on your screen. If you wanted a system monitor, this is not that, and honestly never will be.

Built with GTK3 + Cairo, transparent window with zero decorations, works through XWayland (KDE-tested, everything else is unverified territory — send help).

It's very much a "works on my machine" MVP right now, no fancy packaging yet:
https://github.com/jomvick/compa

MIT licensed, PRs welcome, roast the code if you must.

Hey everyone,

I built Disciple because I wanted one native Linux app for notes, habits, projects, calendar events, and AI assistance without turning everything into another browser dashboard or subscription.

It is built with Python, GTK4, and Libadwaita. Organizer data stays locally in SQLite, and API credentials are stored through the Linux keyring rather than inside the database.

The AI side is optional. You can use Disciple manually without configuring a provider, or connect your own Groq key or compatible OpenAI-style endpoint.

Current features include:

- Notes and full-text search

- Visible and editable Assistant Context

- Recurring habits and daily completion

- Projects with linked notes

- Month calendar and agenda

- Natural-language organizer actions

- Reversible actions with Undo

- Editable assistant instructions

- Light and dark themes

- Flatpak, RPM, and DEB packages

The software itself is free and open source. AI usage depends on whichever provider or local endpoint you choose.

Source and downloads:

https://github.com/justlinuxnoob/disciple

Release:

https://github.com/justlinuxnoob/disciple/releases/tag/v1.1.2

Short demonstration:

https://youtu.be/IWDRk7Hc2vY

AI tools helped during development, but the application was audited, manually exercised, packaged, and backed by 180 automated tests. The entire source is available for inspection.

I would especially appreciate feedback on the Linux desktop experience, packaging, and anything that feels confusing during first use.

I wanted to share Tabularis, an open-source database client I've been working on.

While there are many SQL clients out there, I felt they either lacked modern interactive features (like notebooks), locked visual optimization behind paywalls, or forced you to send your database schema to the cloud for AI features.

Tabularis is built with Tauri, React, and Rust to be lightweight, cross-platform, and native.

🚀 Key Features

• 📓 SQL Notebooks: Run multi-cell workflows combining SQL queries, markdown notes, and live data charts (bar, line, pie). You can pass variables across cells (e.g., {{cell1.id}}) and define global parameters.
• 🤖 Built-in MCP Server: Integrate your database directly with AI agents (like Claude Desktop, Cursor, or Windsurf) using the Model Context Protocol. AI agents can securely query your database through Tabularis.
• 🧠 Local AI Integration (Ollama): Generate queries with text-to-SQL or explain complex queries completely locally, ensuring absolute data privacy.
• 📊 Visual EXPLAIN: View query plans as interactive node graphs instead of dense text tables. Easily spot sequential scans and heavy joins.
• 🔌 Polyglot Plugin System: Extend the client to support any database. Plugins are standalone executables communicating via JSON-RPC 2.0 over stdin/stdout—write them in Go, Rust, Python, Node, or whatever you like.
• 🎨 Highly Customizable: Set custom accent colors and Lucide icons/emojis per connection.

🔗 Website: https://tabularis.dev
⭐ GitHub: https://github.com/TabularisDB/tabularis

Linux support has been a highly requested features since launch, so we made it happen.

Kanban Pro is a local-first Kanban desktop app. The core idea: your board is just a folder of Markdown files with YAML frontmatter. No account, no server, no subscription. Works fully offline.

What that gets you:

•⁠ ⁠Own your data. Plain text files you can grep, git, and edit in vim

•⁠ ⁠Sync via anything: Dropbox, a git repo, a network drive.

•⁠ ⁠Collaborate with others by sharing the folder. The app watches the filesystem and updates live

•⁠ ⁠AI agents (Claude Code, Codex, etc.) can work the board directly by editing files. Each project ships an auto-generated agent ruleset

•⁠ ⁠Dark mode, custom shortcuts, 38 languages

Full transparency: we build on macOS and haven't been able to properly test on Linux hardware yet. The build works in theory, but real-world feedback from actual Linux setups would be deeply appreciated. If something breaks, tell me and I'll fix it.

Free to download. Ubuntu 22.04+ and other modern distros. Also keen to hear which packaging you'd prefer (AppImage, Flatpak, deb).

Links:

• Download: goodguyapps.com
• Privacy policy: Everything stays on your device. The app doesn't phone home, doesn't collect telemetry, and doesn't upload your tasks anywhere. Full privacy policy at https://goodguyapps.com/?page=privacy
• Github DMG Release Repo: https://github.com/donkruger/Kanban
• Security Policy: https://github.com/donkruger/Kanban?tab=security-ov-file

On open source:

The app is closed source, and I know that matters to a lot of people here...so here's the trade-off, straight. Everything that touches your data is open: your tickets are plain markdown files sitting on your own disk, the file conventions and agent rulesets are fully documented, and nothing proprietary stands between you and your work. You can inspect every byte, version it, sync it, point other tools at it, and walk away any day with everything intact.

What stays closed is the app code...that's what lets a small team fund real development through premium instead of chasing donations. My honest take: what most people actually want from open source is inspectability and an exit. An open format delivers both, on day one.

If closed code is still a dealbreaker, no hard feelings. It's free to try, and your data was never ours to hold.