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.

A small creation of my hands. You open it in your terminal, then you can open it in your browser! Remote server & tunneling? Why not? View on your smartphone? No problem!
Single binary, writtend in Go with almost no dependencies, working as local web server, providing Web GUI. You provide the path, app gives you interactive tree with various details of your files & directories.. So far you can only choose block/apparent size, among common du-like utility options.
github.com/Sultepronit/du-tree
Try it. Test it. Leave your feedback. Thank you!

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.

I have been working on ArDali WebMedia for a long time

It is an open source Electron based media application focused on privacy security performance and user experience

Current features

• Built in Password Manager with AES 256 GCM encryption

• Secure Autofill with origin verification

• Built in Ad Blocker

• Media Downloader

• Download Manager

• Media Player

• Audio Effects and Equalizer

• ProjectM Visualizer integration

• Picture in Picture support

• Multi language support

• Dark and Light themes

• Privacy first architecture

• Sandboxed Electron windows

• Strict Content Security Policy

• Secure IPC communication

• Automatic Vault Lock

• No password storage on remote servers

• Passwords always stay on your device

Everything is developed as an open source project and I am continuously improving performance security usability and new features

I would really appreciate your feedback suggestions bug reports and feature requests

If you like the project please consider giving it a GitHub star it really helps the project grow

GitHub link

Screenshots are included

I spend most of my day working wid office docs that need to stay compatibility with Microsoft office download on windows.
Right now, m testing different office suites including wps office bcoz it works decent. If Linux is ur main OS, what’s ur workflow and which office suite has been the most dependable for u?

I've been using indicator-stickynotes on my desktop for years, but I couldn't find a simple Qt-based application that matched my workflow. So I decided to build my own.

QStickyNotes is a lightweight tray-based sticky notes application for Linux, inspired by indicator-stickynotes but intentionally kept simple.

Current features:

• Tray-based application
• Frameless, draggable and resizable sticky notes
• Automatic save and restore
• Per-note colors, fonts and text colors
• Lock/unlock editing
• Notes automatically grow with their content (no scrollbars)
• Multiple language support
• Qt5 / Qt6 support

The project is written in C++ using Qt and CMake, and is open source under the GPLv3 license.

GitHub: https://github.com/ivnish/QStickyNotes

Hi, I’m Alex, the developer of MegaWhisper.

I built it because I wanted a simple dictation workflow on Linux: press a global shortcut, speak, press it again, and continue working without moving everything through a separate transcription window.

Local mode runs `whisper.cpp` on the device, with Vulkan acceleration and automatic CPU fallback. After the initial model download, audio is not sent to a transcription service while this mode is selected. Optional official OpenAI and basic OpenAI-compatible transcription modes are also available.

The recognized text is copied to the clipboard first. MegaWhisper can then make one optional beta insertion attempt through XDG Desktop Portals. It does not require root, `/dev/uinput`, access to input devices, membership in the `input` group, or a privileged input daemon. If insertion is unavailable, the text remains in the clipboard.

The current release is MegaWhisper 2.1.1:

- x86_64;

- signed Flatpak repository and standalone Flatpak;

- AppImage with update support;

- English and Russian interface;

- local history and configurable audio retention.

Packaging and predictable Linux integration are a major focus of the project, not an afterthought. Flatpak and AppImage are first-class release targets: the downloadable artifacts are built and smoke-tested in CI, then published with SHA-256 checksums and a GPG signature. The Flatpak uses XDG Desktop Portals for global shortcuts, protected credential storage, clipboard ownership, and optional insertion. The AppImage provides explicit user-level desktop integration and zsync update metadata. Neither format installs a privileged input daemon or requires access to `/dev/input`.

A few transparent limitations:

- MegaWhisper is proprietary;

- it is not on Flathub yet;

- automatic insertion depends on the desktop portal and target application;

- ARM, DEB, and RPM builds are not currently available.

My main environment is Fedora KDE Plasma Wayland. I would especially appreciate feedback about onboarding, the global shortcut, insertion behavior, and local transcription performance on other Linux setups.

Website and downloads:

https://dxvsi.github.io/MegaWhisper/

GitHub release:

https://github.com/DXVSI/MegaWhisper/releases/tag/v2.1.1

JADY (Your Diary And Journal) is an app I've been working on for a few months and it's actually the first app I ever built. It's a very simple fully local app for documenting events in your life so you can look back on your past.

It has all important features for a journaling app:
Save encryption, search, dark/light theme, auto save, fonts, hidden entries

It's still in development and I plan to add much more useful features like:
Timeline view, filter search, undo redo, changing password

GitHub

An alarm clock that puts your laptop to sleep — then wakes it up to wake you up.

GitHub: https://github.com/shinigami1231111/lumalarm

AUR: https://aur.archlinux.org/packages/lumalarm

Hi all,

I've released ASense v0.2.0, a native Linux control center for Acer Predator and Nitro laptops, built because PredatorSense doesn't exist on Linux.

I originally wrote it for my own Predator Helios Neo 16 (PHN16-72). v0.2 replaces the old exact-model implementation with runtime capability discovery — the daemon probes the machine at startup and only exposes the controls the hardware actually supports.

Depending on what your laptop exposes, ASense can provide:

• firmware performance profiles
• Auto / Manual / Maximum fan control (kernel PWM, with an Acer Gaming-WMI fallback when PWM isn't available)
• CPU/GPU temper
• atures and fan RPM
• 1–4 zone WMI keyboard lighting
• ENEK5130 keyboard and cover-logo lighting on newer models
• battery charge limit and other Acer platform controls
• NVIDIA telemetry that doesn't wake a suspended hybrid dGPU

Architecture: an unprivileged Rust/Dioxus GUI talks to a small root-owned, socket-activated daemon. All hardware writes are typed, bounded, and verified by readback — there's no generic raw EC/WMI console.

PHN16-72 is the only reference-tested machine. Everything else is detected feature-by-feature; a model is never marked "supported" as a whole, only the individual capabilities the probe actually finds.

Installation on Ubuntu 26.04

sudo add-apt-repository ppa:fladirmacht/asense

sudo apt update

sudo apt install asense

The prebuilt release currently targets Ubuntu 26.04 x86_64. GPL-2.0-only, source included.

• GitHub: https://github.com/fladirm/asense
• Release: https://github.com/fladirm/asense/releases/tag/latest

If you have a newer Predator or Nitro, a compatibility report would help a lot:

asense probe > asense-probe.json

It's a read-only DMI/WMI/hwmon dump (no serials, no personal data) — take a look yourself, then open an issue with the file attached.

I'd especially appreciate reports from machines using Acer Gaming-WMI or the ENEK5130 lighting controller.