It all began with "I just want to look up Pokémon without having to leave my terminal," but it sort of got away from me after that. Presenting pokeductor, a Pokédex in your terminal, made with Rust and ratatui.

Features

• 1,351 entries: species and alternate forms, with filtering by type (type:ghost), generation (gen:1), ability (ability:levitate), or simply the species number (25 for Pikachu).
• Evolution families: connected sprite cards showing branching evolution lines. Big ones like Eevee's can go fullscreen with F.
• Team builder: add up to 6 Pokémon to find overlapping weaknesses, missing resistances, and gaps in super-effective coverage.
• Shiny mode: hit X to recolor every sprite in sight right away.
• Terminal-friendly: Unicode half-block rendering with truecolor, a 256-color fallback, and a classic 4-shade Game Boy mode (--theme dmg).
• Vim controls: full Vim navigation, help with ?, and disk caching.

Installation

cargo install pokeductor
yay -S pokeductor          # Arch (AUR)

Also available pre-built for Linux, macOS, and Windows via GitHub Releases.

GitHub repository: github.com/Huseynteymurzade28/pokeductor

Open source (MIT). Any comments (strange key bindings, cursed terminal rendering, feature suggestions) are welcome!

You asked for it, and now it's available : https://github.com/splaching-boop/Lumitype

The first version of Lumitype, a free alternative to Photoshop on Linux is now available.

The goal : to do a fast, modern, and free app open sources (yes you can use the code for an side project, fork it, do what ever you want with it !). So now Enjoy ! You can find the app some Google font i have pre-download, and some project i did with the software to debug it.

There a risk of some known glitches, and no place to report it for the moment, so you can use this reddit post.

WhatsApp voice and video calls work

Hi all! I'm a student from the Netherlands and I got tired of running WhatsApp, Discord and Teams as three separate Electron apps, each eating its own chunk of RAM. So I built Tabchat: one window with tabs and one shared browser engine.

What it adds on top of the web versions:
- Unread counters on tabs, the tray icon and the dock
- Keeps running in the tray, click a notification to jump to the chat
- WhatsApp voice and video calls work
- Multiple accounts of the same service side by side
- One Microsoft sign-in for Teams, Outlook and OneDrive (school/work accounts too) that stays signed in
- Tab sleep to free memory, Do not disturb (follows GNOME's DND)
- Ctrl+K quick search and browser-style shortcuts
- Screen sharing on Wayland, light/dark theme

It's free, open source (MIT) and collects no data.

Install: snap install tabchat, or .deb / AppImage from GitHub.
Try the interactive demo: https://mmv2408.github.io/tabchat/
Source: https://github.com/MMV2408/tabchat

Hi r/linuxapps,

I'm sharing OpenBox Game Launcher, an open-source game library and launcher for Linux that also runs on Windows. It gathers games from the launchers you already use into one searchable catalog. Steam, Heroic and Lutris games still start through those launchers. ROMs and standalone games start through an emulator or program that OpenBox can install and configure for you. No OpenBox account is required, and your library is a JSON file on your own disk.

OpenBox's original development used AI assistance (Claude). The repository includes the instruction files the AI tools worked from (CLAUDE.md and AGENTS.md). I'm saying this up front so you know it before you read the code or open an issue.

It isn't affiliated with LaunchBox, and it has no connection to the Openbox window manager.

Where your games come from

• Steam. Steam Bridge can preview, apply and remove non-Steam shortcuts in Steam's shortcuts.vdf.
• Heroic (Epic, GOG, Amazon), Lutris and Faugus Launcher.
• Gameyfin libraries, and ES-DE gamelist.xml files, which you can review before they change your library.
• ROM folders, MAME and FinalBurn full sets, and standalone executables.

For Steam, Heroic and Lutris games, OpenBox sends the launch through steam://rungameid, heroic://launch or lutris:rungameid, so the game starts as it would from that launcher.

Emulators and launch checks

OpenBox ships 42 emulator definitions as YAML files: 23 RetroArch definitions and 19 standalone emulators. The RetroArch definitions cover systems such as the NES, SNES, N64, Game Boy through GBA, Genesis, Saturn, Atari, Amiga and C64. The standalone list includes Dolphin, PCSX2, RPCS3, DuckStation, PPSSPP, Cemu, Eden (Switch), Azahar (3DS) and ScummVM.

Emulators install and update through Flatpak on Linux, and as native builds on Windows. Definition packs can also update through a channel signed with the release key. OpenBox verifies each pack, and it never overwrites a definition you edited yourself.

The Launch Doctor checks whether each game can launch without starting it, and it groups problems by cause. When a Flatpak emulator can't see your game folder, one Grant access button covers every game in that group. The grant is read-only, and OpenBox won't grant access to your entire home folder. Each game can also use its own RetroArch core, and the rest keep the definition's default.

Your library

• Game DNA search runs on your machine. It combines a local BM25 index with a concept lexicon, so it needs no model download and no cloud service.
• "What should I play?" filters by time, mood, familiarity and player count, and it has a Surprise me button.
• Backlog Radio weighs the genres and platforms you've spent time on, your usual session length, and what you tend to finish. Saved searches can become smart collections that update as your library changes.
• Each game has a status (Unplayed, Playing, Paused, Beaten, Completed, Mastered or Abandoned), a 0 to 5 star rating, dated notes, and manual playtime.
• The Mastery view breaks progress down by platform, with a decade filter.
• The library health score runs from 0 to 100. Every point lost is explained with the games involved. The score only measures, and each fix shows a preview first and can be undone.
• Time Machine shows the library as it was at an earlier point, and it can compare two points.
• "Your Year in Games" is a yearly recap with playtime, sessions, streaks, top game, platform and genre, plus a print option.
• Constellation draws a graph of links between games: series, developer, publisher, genre, platform family, and games you played together.

Sessions, saves and backups

• Sessions are tracked automatically. OpenBox follows each game's process on Linux and Windows, and it records playtime and history.
• Save backups are per game. Restore Preview shows what a restore would remove, bring back or overwrite before anything changes.
• An opt-in weekly backup keeps a bounded archive history of your library.
• Quick Resume relaunches a game from the emulator state OpenBox stored, when the emulator supports it.
• Moments attach a short note, and a screenshot when one can be taken, to a game's timeline.

Big Box, Game Night and handhelds

• Big Box is a fullscreen layout you drive with a controller. It has a D-pad on-screen keyboard and shows the battery level.
• Game Night is a party queue in Big Box, with a spinner that picks the next game.
• Arcade Room and Museum mode present the library for a controller. Their optional PIN is a convenience lock, not a security system.
• On a Steam Deck or in a gamescope kiosk, start OpenBox with --game-mode, for example openbox --web --game-mode.

Recording and media

• Record That saves replay clips from OBS Studio's replay buffer over OBS's WebSocket interface, and keeps a gallery for each game. Highlight reels render with ffmpeg when it's installed.
• Metadata and artwork come from the LaunchBox Games Database, ScreenScraper (matched by ROM hash), SteamGridDB, IGDB, EmuMovies and Steam's store data. RetroAchievements adds achievement progress.
• ScreenScraper, SteamGridDB and IGDB read their keys and logins from a local .env file, such as ~/.env, not from the settings file. Auto-scrape after import is opt-in for each provider.

Plugins, webhooks and the REST API

• The plugin API (v1) is frozen. Plugins can add hooks and palette commands, read the library in a bounded way, and post notifications. The reference is in docs/plugin-api.md.
• On Linux, plugins run inside bubblewrap when it's installed. Without it, a plugin is skipped unless you trust that exact package, and a trusted plugin then runs without a sandbox. Windows has no bubblewrap, so the same rule applies there.
• The bundled community plugin catalog ships with the app. The remote copy is pinned to one commit on GitHub.
• Webhooks you configure receive signed, bounded deliveries for automation.
• The web UI exposes a local REST API. Requests carry an X-OpenBox-Token header, and the README has examples for listing the library and launching a game by ID.

Privacy and network use

• No OpenBox account is required, and the repository has no analytics or telemetry code.
• The app makes outbound requests only for features that use a service:
  • The in-app update check runs when you ask for it in Settings. Installs are checked against the release's SHA-256 checksum and Ed25519 signature first.
  • Emulator definition packs come from GitHub release assets, when you update them.
  • Metadata, artwork, RetroAchievements and Steam store lookups run when you start them, or after import for providers you've turned on.
  • The plugin catalog reads a file pinned to one GitHub commit, and webhooks go only to URLs you configure.
• Statistics sync (beta) writes to a folder you mount, such as a cloud drive folder. OpenBox doesn't talk to a cloud service itself.
• Crash reports stay on your machine. OpenBox builds a redacted report, and you decide whether to paste it into a GitHub issue.

Install

• Linux: the AppImage is on the latest release page for x86_64 and aarch64. The versioned installer script checks the SHA-256 checksum and the Ed25519 signature before it installs. You can also run the AppImage directly.
• Windows 10 and 11 (x86_64): a signed portable zip with an install script that checks the same signature before it extracts anything.
• Flatpak: the manifest is in the repository and builds for x86_64. OpenBox isn't on Flathub yet.
• From source: python3 web_app.py with Python 3.10 or newer.

The native window uses WebKitGTK 4.1 on Linux or WebView2 on Windows. Without either one, OpenBox opens in your browser. python3 web_app.py runs without them.

Latest release (v1.16.1): https://github.com/vindeckyy/OpenBoxGL/releases/latest Source: https://github.com/vindeckyy/OpenBoxGL

What's rough

• The interface is available in English, Spanish, German, French and Portuguese. Each locale file holds 55 strings, so the translations are partial.
• Some features need other software: OBS Studio for clips, ffmpeg for reels, bubblewrap for plugin sandboxing, and Flatpak for emulator installs on Linux.
• The Flathub submission hasn't been made yet.

Feedback

Bug reports are welcome on GitHub. The crash report builds a redacted diagnostic you can paste into an issue. Results from a Steam Deck, an aarch64 handheld, or a Fedora or Arch install would help most, since those have the least coverage so far. Include the model, distro and desktop session. Import problems with any supported launcher are useful too.

Screenshots are attached. They use a sample library of 12 games, not a real collection. I'll answer questions in the comments.

I've seen another desktop photoshop clone floating around that was Javascript/Electron, but I wanted to do full native Rust for full performance. I also wanted to do all of Adobe's software suite. I've been bitten by their unsubscribe bill several times and it's the shittiest thing a software company has ever done to me.

No more. These are clean room, rust-only implementations that are fully open source. You can clone them, fork them, own them.

There's still work to do, so please join our Discord and give us feedback.

Links in comments.

Files is a popular open-source file manager for Windows (WinUI 3), and "when is the Linux version coming?" gets asked a lot. The team's answer is that they're focused on Windows, so I tried it myself.

LinuxFiles is an unofficial, community fork that runs Files natively on Linux (X11/XWayland). It isn't affiliated with or endorsed by the Files team. The upstream MIT license and credits are kept, and the Windows app isn't being replaced.

What it does today (0.1.0-alpha1)

• Tabs, grid/list/details views, search, tags, previews, archives (browse inside zip/tar/7z/rar)
• Linux integration: freedesktop trash, XDG thumbnails and icon themes, UDisks2 drives, GVfs network/MTP, D-Bus, desktop file portals
• KDE service menus, drag and drop and clipboard with other Linux apps
• Root actions through a polkit helper, plus a root mode
• A grouped-view virtualization fix: a 10,000-file folder went from 90 s to 1.7 s

How it was built

• The UI runs on Uno Platform (Skia) instead of WinUI 3, so most of the original UI, view models and logic carry over.
• The Win32/COM layer is replaced by a Linux platform abstraction layer. The Windows-only code paths are kept in the tree but aren't built or tested.
• Most of the code was written by AI agents, mainly Claude Code, with Codex and Gemini as cross-reviewers. I directed and reviewed the work. Every change went through PR and cross-model review and CI, and I tested it by hand several times on a real Linux desktop. The risky areas (file operations, root elevation, archive extraction) have written threat models in the repo.

Caveats: it's an alpha, so expect rough edges and keep backups. Wayland runs through XWayland for now.

Install: AUR (`linuxfiles-bin`), Flatpak, AppImage, tarball - these are in the releases section on github

Repo / release: https://github.com/MemerGamer/LinuxFiles

I'd especially like feedback on bugs, on distros I haven't tested, and on whether the AI-assisted process makes you trust it more or less. Happy to answer questions about the port.

Hey everyone,

I've had this problem for years: icons in my Downloads folder, logos lost in old project directories, SVGs dumped on the desktop "just for now". Every time I needed a specific file, I ended up digging through folders or downloading it again.

There are apps made exactly for this on Windows and Mac, but I've never found one on Linux, at least not one that's native, local and open source. So I made Pigoune.

>Platform for Icons and Graphics Organized, Unified, Native and Elegant

It's a pretty simple idea. You drop your images in (SVG, PNG, JPEG, WebP, GIF, ICO, single files or whole folders), and Pigoune keeps a copy in its library. Your original files are left alone. From there you can sort things into collections, add tags and favorites, and note where an asset comes from, who made it and under which license. That last part has saved me a few times when I needed to credit something.

When you need a file, you search for it and drag it straight into whatever app you're using. You can also copy it to the clipboard or export it.

A few other things:

• No account, no cloud, no telemetry. Everything stays on your machine.
• The library is just a regular folder, so it's easy to back up or move to another computer.
• Duplicates are detected on import.
• There's a trash and Ctrl+Z, because I delete things by mistake.
• It follows GNOME's design: dark mode, keyboard navigation, screen reader support, works in small windows.

And as a little bonus: it works perfectly for organizing an entire wallpaper collection too! In fact, I'll be adding some cool related features soon.

It's written in Rust with GTK4 and libadwaita, and licensed GPLv3.

I want to be honest about one thing: I'm a sysadmin, not an app developer, and I wrote this with a lot of help from AI tools. I know some people won't like that, and I get it. I've done my best to keep it clean and documented, and I use it every day, but if anyone who knows Rust or GTK well feels like looking at the code, I'd really appreciate it.

I chose to ship it as a Flatpak mainly for the sandbox. Being a sysadmin, I like knowing exactly what an app can and can't touch, and I wanted the same for Pigoune. Its Flatpak has zero permissions: no access to your files, no network, nothing. You can check it yourself in Flatseal.

It's not on Flathub yet, so for now you can grab the .flatpak from the releases page and install it with:

flatpak install --user pigoune-*.flatpak

(It won't update by itself, you'll need to install new releases manually.)

https://github.com/Gor3pig/Pigoune

Any feedback is welcome, bugs, ideas, translations. And if there's already an app that does this and I completely missed it, please tell me!

Hi everyone! 👋

I’ve been building OwnDash, an open-source visual dashboard editor for Linux, and 0.14.0 Beta 5 is now available.

The idea is simple: build your own hardware-monitoring dashboard, connect it to live system sensors, and put it on a dedicated display—without writing code or manually editing configuration files.

Your display. Your design.

Create a dashboard that fits your setup

OwnDash combines a drag-and-drop editor with live previews and customizable widgets:

• Live system information: CPU, GPU, RAM, storage, network, temperatures, and power readings where your hardware exposes them.
• Your own look: gauges, charts, sparklines, text, images, clocks, backgrounds, and animated elements.
• Multiple dashboard pages: organize different views and cycle between them.
• Sensor-driven behaviour: rules, animations, and alert states that respond to live values.
• English and German UI, with Light, Dark, and System appearance modes.

Which displays work?

OwnDash supports two output paths:

Standard Linux monitors
Use a display Linux already recognizes, including HDMI, DisplayPort, and USB-C display outputs.

Compatible direct USB displays
Supported ArtInChip / VSDISPLAY panels receive dashboard output directly over USB without appearing as a normal monitor.

My own setup runs Bazzite and KDE Plasma with a 480×1920 VSDISPLAY, using USB device ID 33C3:0E02. That’s the confirmed direct-USB hardware baseline. Other proprietary USB panels may need a separate backend; they aren’t automatically compatible.

What’s new in Beta 5?

This release focuses on making everyday use more reliable:

• Responsive system-state screens for tall, portrait, square, and landscape formats.
• Safer USB detection: multiple compatible devices are reported as ambiguous instead of silently choosing one.
• Manual update checks, even with automatic checks disabled. OwnDash doesn’t download or install updates itself.
• No frozen clocks on static screens: standby, shutdown, restart, and disconnected screens don’t show a time that can no longer update.
• AppImage packaging fixes, including issues caught during real Bazzite testing.

Try it out

🐧 Download OwnDash 0.14.0 Beta 5

The release is a self-contained x86-64 AppImage, requiring GLIBC 2.36 or newer. No separate Python installation is needed.

🛠️ Source code, documentation, and roadmap

OwnDash is MIT licensed.

It’s still beta software, and feedback from other distributions, desktop environments, GPUs, and display setups would be especially helpful. Sensor availability depends on your hardware and drivers; missing optional readings shouldn’t stop the rest of the dashboard from working.

Bug reports, code review, and contributions are very welcome!

If you try it, let me know your setup and what worked—or what didn’t.

What would you want on your own dedicated Linux dashboard?

Hey! I’m the developer of Screenix, a screen recorder for Linux, this video shows what you can make with its Studio mode.

It adds automatic zooms and smooth cursor movement, then you can adjust the zooms, trim the recording and change the background in the built-in editor. I’ve been building it for people recording tutorials and product demos on Linux.

It’s paid, closed-source software with a 7-day free trial: https://screenix.studio

Happy to answer questions about how it works!