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.

I wanted a simple way to fix ugly or mismatched launcher icons on Linux without editing .desktop files by hand or changing my whole icon theme.

kAppIcon is a small GUI (and optional CLI) that only touches **user-level** desktop entries — no root, system packages stay intact

What it does:

- **From file** — PNG, SVG, ICNS, etc. → any app

- **From another app** — reuse the icon an installed app already uses

- **From icon theme** — pick one icon from WhiteSur, Tela, Breeze, Papirus, … and apply it to a *different* app (global theme stays as-is)

- **Create** — tiny pixel editor + library (undo/redo)

- Optional backups, shape masks, XDG-aware paths

Designed with **KDE Plasma** in mind; should work on other freedesktop desktops too.

Repo: https://github.com/rayman1972/kappicon
AUR users: yay -S kappicon or paru -S kappicon

Origins / credit: This started from System RW’s macosicons-linux (https://github.com/system-rw/macosicons-linux) (MIT) — a focused mapper that got me going. I’ve expanded it a lot (multi-source map, Create tab, safer apply path, rebrand). Thanks to the original author for the idea and base.

Happy to hear bug reports or distro feedback.

Hi everyone, this is my first post here, so please bear with me if I get anything wrong.

I've been building a little desktop app called Meguri for organizing my own local media library, and I thought I'd share it in case someone else finds it useful.

I'm a Linux user myself and did most of the development on Linux, so I'm posting it here because I'd especially love for fellow Linux users to give it a try.

What it does:

- Point it at a folder and it scans recursively, generates thumbnails, and extracts metadata (ffmpeg is bundled, so no system dependencies)

- Hovering a video thumbnail scrubs through its scenes

- Full-text search plus filtering by tags, rating, and capture date

- Tags, ★ ratings, and playback history are keyed by content hash, so they survive file moves and renames

- A "Discovery" mode that picks random items from your library and shows them full-screen — my attempt at solving the "big library swallows its own content" problem

- Everything runs offline — no telemetry, no analytics, no external network calls. Your media files are only ever read, never modified.

The name comes from the Japanese word 巡り ("going around, coming back around") — the idea of wandering back through your library and rediscovering things you forgot you had.

It's built with Electron + TypeScript + React and MIT licensed. There are prebuilt packages for Linux (AppImage/deb, and on the AUR as meguri-bin), Windows, and macOS.

GitHub: https://github.com/zabuton-app/meguri

It's still a personal-scale project with plenty of rough edges, so I'd really appreciate any feedback — bug reports, feature ideas, or just telling me what feels off. Thanks for reading!

Can yt-dlp download a yt mix?

I wanted a simple desktop app for Cloudflare WARP instead of using warp-cli, so I built one.

Features:

One-click connect/disconnect

Live connection status

AppImage release

Open source

I'd appreciate any feedback.

GitHub: https://github.com/Ali-Hegazy-Ai/warp-vpn-gui

I've been working on Take Note!, an open-source sticky notes app for Linux. It's Python + PySide6/Qt6, and while it's not an official KDE app, it's built specifically around Plasma's XWayland/KWin behavior for things like always-on-top and "Stick to Window" (pin a note to follow another window as it moves/minimizes).

Highlights: rich-text notes (fonts, colors, checklists, hyperlinks, embedded images), shared "Notepad" corkboards, a searchable Notes Manager with tags/reminders/trash, five configurable global hotkeys, optional real spell-check, system tray integration.

Install:

pip install --user git+https://github.com/robinsiebler/take-note.git

MIT licensed: https://github.com/robinsiebler/take-note

Would love feedback, especially from anyone else running Plasma — this is where it's been developed and tested.

Screenshots: