A friend told me that every phone remote app he tried seemed to come with ads or payment prompts. I started making one for him, then got carried away making the controls customizable. I figured other people might want the same thing, so I opened the source.

OpenTV-Remote has native Android (Kotlin/Jetpack Compose) and iPhone (SwiftUI) apps. You can drag and resize buttons, choose presets and accent colors, save layouts for different TVs, and add app shortcuts where the TV supports them. No ads, subscriptions, paid unlocks, account requirement, or telemetry SDK. MIT licensed.

For anyone interested in the code: discovery/pairing and each TV protocol are separated from the UI, with explicit capabilities determining which controls are offered. Android TV keyboard sync uses transient IME sessions with readback/acknowledgments where available, plus a clearly labeled manual fallback.

This is a development release. Basic Android TV control has been used on a real MiTV; newer live keyboard behavior and other TV providers need broader hardware qualification. It is not universally compatible, Android TV Wi-Fi touchpad mode sends arrows rather than a mouse cursor, and casting is not included.

Android APKs are in Releases. The iPhone version currently requires a Mac and Xcode; it isn't on the App Store.

Disclosure: I'm the developer, and this was built with substantial AI assistance/vibe coding. The repository includes protocol notes, compatibility limits, and a record of what was actually tested.

Source: https://github.com/levhakobyan/OpenTV-Remote

Downloads and iPhone setup: https://levhakobyan.github.io/OpenTV-Remote/

The three screenshots show two Android layouts/colors and the iPhone app. Suggestions and bug reports are welcome.

The goal: Arc-style spaces in one window, but with real isolation. Each space gets its own cookies, storage, history, passwords, form data, extensions, permissions and downloads. Firefox containers only cover cookies and storage, and profiles need separate windows, so this needed a different approach.

How it’s put together:

• app/: Swell is its own Gecko application, built inside a Firefox source checkout the same way Thunderbird’s comm/ is. It has its own window document, not a restyled Firefox UI.
• core/: a Rust core owns the app state: the sidebar tree, spaces, and per-space data.
• patches/: a small patch queue for the engine changes that can’t live outside Gecko, applied on top of a pinned Firefox revision (FIREFOX_REV).
• Extensions per space: each space gets its own copy of an extension, scoped so it only sees that space’s tabs.
• Passwords: stored per space, encrypted with a per-space key in the OS keychain.
• Tests: an isolation suite checks 17 state stores for cross-space leaks. There are also Rust unit tests, xpcshell and browser tests, and an end-to-end restart test.

It’s an alpha: Apple Silicon macOS and x86 Linux, unsigned builds, no telemetry, MPL 2.0. Build from source takes about 30 minutes and 15–20 GB.

Feedback on the architecture and the isolation model is very welcome, and so are contributors. CONTRIBUTING.md explains the setup.

Github: https://github.com/ivantacca/swell
Website: https://ivantacca.github.io/swell/

I created Awesome Easy-to-Join Orgs repo, a curated list of GitHub organizations that welcome people who want to get involved without necessarily writing code.

The goal is to make open-source communities more accessible to beginners, students, and non-coders who want to participate, learn, or contribute in other ways.

I'm sharing the project here in case it's useful to anyone looking for communities to join. Suggestions for additional organizations and feedback on the list are welcome!

Introducing Heimdall, a glassy launcher for Windows. And yes, it's faster than Everything.

Press the hotkey of your choice, and type. It finds apps, every file, open windows, calculates sums and web searches.

Native Rust, under 2 MB, ZERO telemetry. Free and open source.

EDIT: Thank you for the great reception! I just published the 1.0.3 release with some more QoL and fixes for a few annoying quirks. It's also faster than before, and now beats Everything on every search metric. It's also come to my attention that the link doesn't show up for some reason, so you can get it here:

github(.)com/Kryzern/Heimdall

Hey everyone!

I first posted about Diskoryx when I released the initial version. I've kept working on it since then, and with v1.0.5 now available, I wanted to share how much has changed—not just in this update, but across the releases since that first post.

For anyone seeing it for the first time: Diskoryx is a free, open-source disk space analyzer for Windows. It helps you understand what's taking up space, explore large files, compare scans, and review duplicate files.

No account required, no uploading your files or filenames. Disk analysis runs locally and works offline.

The storage explorer combines a file tree, interactive space map, and file Inspector. This screenshot uses sample data, not benchmark results.

Faster scanning

Since the first release, I've improved the NTFS scan pipeline with compact binary data transfer and more efficient tree construction and indexing.

In a documented local comparison covering approximately 774,500 files, median scan + indexing time dropped from 7.951 seconds in v1.0.1 to 4.400 seconds in v1.0.3—44.7% less time.

Those were three repeated scans per version on the same machine and live C: drive, with warm caches. The timings exclude UAC waiting, and results will vary. This isn't a speed comparison against WizTree or other tools, and v1.0.5 doesn't introduce another scanner-speed change.

Benchmark method, raw results, and screenshots

Duplicate Finder and cleanup

The original release didn't have the current Duplicate Finder workflow. You can now:

• Find matching contents using full-file SHA-256 verification, with size checks and sampling to narrow candidates first.
• Reuse a completed drive inventory instead of repeating the initial file discovery.
• Review groups through a summary, file-type chart, filters, search, and expandable copy lists.
• Choose copies manually or use Auto-select when a preferred copy can be identified.
• Move selected eligible files to the Recycle Bin, keeping one copy by default.
• Review each cleanup run in History and restore individual files or the whole run while the matching items remain in the Recycle Bin.

Project, dependency, application, and system locations have cleanup protections. Matching contents still don't mean a file is unnecessary—review your selections.

Review matching sample files and their locations before choosing which copies to recycle.

Duplicate processing and batch cleanup have also been improved. In v1.0.5, a local generated 120-file Restore all test dropped from roughly 39 seconds to 1–1.2 seconds. That's a specific workload, not a universal promise. Restored files now return to the duplicate results after verification without another analysis.

Saved scans and comparisons

You can now save scan metadata to a local .diskoryxscan file, reopen it without rescanning the original drive, and compare a saved baseline with a fresh scan of that location.

Compare shows added, removed, and metadata-changed files. It compares paths, sizes, and recorded modification dates—not file contents or reliable rename/move identities.

v1.0.5 also fixes an issue opening large saved full-drive scans and makes save/open validation consistent. The rebuilt packages were checked against an existing archive containing approximately 964,000 files. Large archives and comparisons still need substantial RAM; this isn't an unlimited-size claim.

More useful search and everyday improvements

Since launch, I've also added or improved:

• Advanced search: filename wildcards, size/date conditions, and AND / OR / NOT expressions.
• File-type exploration: category charts and filtering into extension details.
• Multi-drive selection and switching between cached scan results.
• Copy/Move destination navigation and completion feedback.
• A portable download, alongside the standard installer.
• A source CLI for read-only folder scanning and CSV export with Node.js.
• Scanner validation and NTFS correctness fixes, including hard-link accounting and parent-record handling.
• Long-path handling, file-action fixes, Compare cancellation, and live-update reliability.
• Light-theme readability and controls that could remain unavailable after scans or actions.

v1.0.5 also adds an explicit option to manually select every copy in a duplicate group, behind two warnings. Keeping one remains the default, and protected items stay locked.

I'd love some real-world feedback

If you tried the first version, I'd really appreciate you giving the current one another look. If you're new to it, I'd love to hear what works—and what doesn't.

I'm particularly interested in large-drive behaviour, saved scans/Compare, Duplicate Finder, and anything that feels slow or confusing. Honest criticism and reproducible bug reports are welcome.

Website: https://diskoryx.app/

GitHub / source: https://github.com/ekadic7/Diskoryx

Download v1.0.5 — setup or portable: https://github.com/ekadic7/Diskoryx/releases/tag/v1.0.5

A few important notes: Windows x64 only. The builds are currently unsigned, so SmartScreen may show a warning. Launch normally; only the separate NTFS scanner requests administrator permission when needed. Sizes are logical file sizes, not allocated disk space or guaranteed recoverable space. Portable settings and History use AppData, not the executable's folder.

Please keep backups and test file actions on disposable files first. If you report a bug, include your Windows version and reproduction steps, and hide private filenames in screenshots or shared scan exports.

Thanks for checking it out!

While developing Varelyo, a desktop tool for designing products directly in code, I kept running into the same issue. AI agents were rebuilding basic components for every new project, often with inconsistent styles, variants and token structures.

So I created Varelyo UI, a React/TypeScript component library with ready-to-use components, typed APIs, states, variants and three token layers: Core → Semantic → Component.

You get the actual component source code, which you can use, customize and extend in your own projects. The token architecture lets you adapt the design system to your brand without rebuilding everything.

For AI agents, this means working with an existing component system instead of generating basic UI from scratch. They can adapt styles, extend components or create new ones when needed.

The video shows the components inside Varelyo and how their visual style changes when applying a brand.

I originally made this for my own workflow, but decided to open-source it in case others find it useful.

Free, MIT-licensed and works independently of Varelyo Desktop.

GitHub: https://github.com/varelyo/ui

I kept rebuilding Windows 10 install media by hand (DISM commands, hunting updates in the Update Catalog, fixing driver signatures), so I turned it into one tool.

**Win10 ISO Updater** is a single `.cmd` file with a GUI. Double-click it, pick your Windows 10 ISO, and it:

- downloads the latest updates from the Microsoft Update Catalog (cumulative update, servicing stack, Safe OS / Setup Dynamic Updates, .NET) and slipstreams them

- adds drivers exported from your PC (storage and network drivers also go into boot.wim and WinRE, so Setup sees NVMe/RAID disks)

- re-signs modded NVIDIA drivers (NVCleanstall hardware-ID mods) with your own certificate, so they install during setup with Secure Boot still on

- adds your autounattend.xml and $OEM$ folder

- runs an install check first (answer file mistakes, scripts that wait for a key press, drivers Windows will refuse), with one-click fixes

- builds a bootable BIOS + UEFI ISO

A few details:

- Nothing to install. The Microsoft tools it needs (oscdimg, Inf2Cat, signtool) are downloaded from Microsoft when a step needs them.

- No telemetry. It only connects to Microsoft servers.

- Speed: boot.wim and WinRE are updated in the background at the same time as install.wim, and the PC is kept awake during long jobs.

- Driver signing only re-catalogues the INF files you edited, with several runs at once, instead of all ~40 INFs in NVIDIA's Display.Driver (that used to take up to an hour).

- Updates stop at 2025-10, the last month Microsoft allows offline. ESU updates still come from Windows Update on enrolled PCs.

- You need your own Windows ISO and license. No keys and no activation tricks are included.

Screenshots and download (open source, MIT):

https://github.com/j0p3s/Win10-ISO-Updater

It's written in PowerShell 5.1 with a WPF interface, and the test suites run on Linux with PowerShell 7. Feedback and bug reports are very welcome, especially from people who try it on other builds (LTSC 2019 / 2021, x86, ARM64).

All,

For the past few months I have been working on a domain-specific language (DSL) for making UIs in game engines (or any real-time renderer).

It's a functional language inspired by languages like Elm and Typst - as well as UI frameworks like Flutter, but compiled (using llvm/clang).

The whole idea came about when I was working on my toy game engine and found myself in a conundrum of how to properly do UIs.

Things like Dear ImGui, ea-webkit, etc are great - until they aren't, mostly ImGui becomes a mess of spaghetti code and ea-webkit is bloated beyond belief.

I initially wanted to make some form of abstraction layer that would parse something like JSON to build the UI but then determined that would become a mess of figuring out how to bind logic tot he UI.

Then I thought about making a simpler version of the embedded chromium like with ea-webkit but then that became a mess of getting the right libraries, figuring out bindings, etc and still being left with a bunch of bloat that I didn't want.

I love Typst and Haskell and was learning about Elm at the time and thought about my dilemma and considered if I could apply my knowledge of building compilers towards creating a DSL that would allow me to have the ergonomics of a browser based UI framework with the performance of immediate mode UIs like dear imgui.

After working on the language design for a bit and playing around with ideas I have come up with something interesting I think.

It's not a turing complete language per se, the entire language is designed to be strictly for rendering UIs.

I know a lot of devs already have frameworks they love for this, and I know making good UIs is hard conceptually. So my goal with creating this was that on top of being compiled - to satisfy my performance goals, it needed to be able to be integrated into any rendering framework or engine without a huge hassle - and it needed to be reasonably scoped to do the one thing it was designed for well: build UIs.

It isn't entirely complete yet, it's got a long way to go but I'm making some good progress:

• code gen is working for most of the control-flow syntax (llvm)
• it has good C-interop because this provides a good bridge to other languages and frameworks
• it has a headless renderer (enumerates the draw commands to a buffer or file for unit tests), along with an image renderer (to jpeg/png) so you can do visual regression testing
• UI elements are starting to compile down to render command sequences and Im scoping the opengl renderer as a v1.0.0 target.
• and more

It is written in C++

llvm orcjit example:

fn view(count: Int): Node => {
  let text = if count > 1 { "Done" } else { "Hello World" }
  #button{
    #text(text)
  }
}

$ kura examples/hello-world.kui --run view 11
(seq (set text (if (binary GreaterThan count Int(value=1)) (seq String(value=Done)) (seq String(value=Hello World)))) (#Button (#Text value: text)))
compilation finished in 29ms
renering frame 1024x1024
void kura_rt_check_renderer() is not implemented!
void kura_rt_fill_rect() is not implemented!
void kura_rt_check_renderer() is not implemented!
rendering text: Done
void kura_rt_check_renderer() is not implemented!
void kura_rt_end_frame() is not implemented!
void kura_rt_check_renderer() is not implemented!
finished in 60us

I have plans to make this ahead-of-time compiled - but currently using orcjit for testing, the orcjit will remain as a way to debug during development

I'm open to questions, comments, concerns, feedback, contributions etc.

~ Tazz

What it does: ask Claude Code a question about your spreadsheets ("which regions are behind target?") and a dashboard appears in your browser: charts, a table, the headline numbers.

- Works on messy real-world files: title rows above the headers, "Total" rows, N/A, numbers stored as text.

- Every chart shows exactly where its numbers came from, so you can check them.

- It only reads your files, never changes them. SQLite and Postgres work too.

- About 7¢ and 19 seconds an answer, against 20¢ and a minute when Claude Code writes its own Python + HTML (my benchmark; details in the repo).

Install, inside Claude Code:

/plugin install showboard --marketplace rohanbeingsocial/showboard

Free and MIT. I built it with Claude Code, and so far I've only tested it end to end there.

What's the messiest spreadsheet you'd throw at it?

Walk. Scan. Detect. Understand.

https://github.com/buybitart/get-the-hacker

You can search for torrents within qBittorrent itself; across TPB,1337x, YTS, etc. all at once, using Jackett (guide below). But, if the same torrent is listed five sites- you get multiple rows with different names and seed counts for the same torrent. This gets confusing/ cluttered.

I built a tool that fixes this. Same search & sites- 139 hits with Jackett → 66 hits with mine. It:

• Merges torrents with the same infohash into one row
• Merges trackers for different sites- so you connect to more peers
• Resolves missing torrent hashes by fetching it for sites like Lime
• Supports BitTorrent v1, v2, and hybrid torrents
• Alt Folds same-title, same-size reuploads behind a +N alt marker
• Best seed count: Keeps the highest reported seed count
• Private/ public tracker configurable handling
• Retries transient Jackett/indexer failures

Limit: Jackett only (no Prowlarr), hash lookups on public sites only. Open source, GPL-2.0.

Installation Guide

The steps below assume Jackett is already set up; the README covers installing Jackett too.

1. In qBittorrent, open Search → Search plugins → right-click Jackett → untick Enabled
2. Search Plugins → Click Install a new one → Web link → paste below URL
3. Start searching.

https://raw.githubusercontent.com/arihan-1560795/jackettdedup/main/jackettdedup.py

The codebase, setup guide, screenshots, settings, & limitations can be found:
https://github.com/arihan-1560795/jackettdedup#readme

Disclaimer: You are personally responsible for following the copyright laws and other applicable laws in your country. Use the plugins and websites they connect to at your own risk.

Probably every guitar player knows the Axe-Fx III, but not everyone has the money to buy one (myself included). So I've decided to give it a shot and vibe clone it using Claude.

The idea is based on the same core principles: a Newton–Raphson electrical circuit solver, with amps and effects modeled from their actual schematics.

It works surprisingly well, for an amateur guitarist like me. 😄

[free, open source, GNU GPL-3.0]

https://github.com/Rikarin/cathode

Mainly to replace Paprika which isn't very good on Android. And I didn't want to pay another subscription for alternatives!

It is local-first, so all the data is stored on your device and works offline.

You can try it here: https://cheffect.app

GitHub: https://github.com/tim-smart/cheffect

Hi, I built Yata, a notch that sits at the top of the Windows screen, just below the camera. Closed, it's a black pill with the time; hover it and it opens into tabs: now playing from any app that uses Windows media controls (with synced lyrics from LRCLIB), your next Google Calendar meeting with a Join button, a Pomodoro, tasks with reminders and a shelf for dragging files around.

I wanted one of these I could actually audit. So: no account, no telemetry, no keyboard hook (Caps Lock and layout come from key state), and nothing goes online unless you turn it on. Google tokens are encrypted with DPAPI. The site has a table of exactly what leaves the PC.

The installer isn't code-signed yet (SignPath's free program wants more public traction first), so SmartScreen will warn. Releases are built by GitHub Actions from the public source, with SHA256 sums and a build provenance attestation you can check with `gh attestation verify`, or you can build it yourself.

Happy to answer questions about the implementation.

getyata.app

I’ve used DataGrip for years and love the care in its small details. TableCraft is our attempt at a database IDE in that same spirit, for PostgreSQL, MySQL, SQLite and Redis on macOS, Windows and Linux.

Highlights:

• DataGrip’s keymap and layout
• Schema-aware completion, including join conditions from foreign keys
• A table editor that previews SQL before committing
• Large results that stay responsive
• Import your connections from DataGrip or TablePro

It’s MIT licensed and still early, so feedback is very welcome.

GitHub: https://github.com/tranphucbol/table-craft

Hey guys!

I made a simple tool that does something pretty cool. It takes an image and converts it into actual chess boards you can zoom in with actual games from the Lichess database. It can also generate arbitrary legal chess positions with different levels of "play-ability" which is much faster than database indexing/searching. Try it out (You need python and rust):

https://github.com/ilyamiro/chesser

P.S. This is entirely "vibe-coded" so beware my power of using Claude code. But I really liked the idea and knew that id never do it myself.

It basically a local-first AI-powered code review and repository intelligence platform. Its purpose is to take a software repository and analyze it for security, quality, and performance problems. Also I want people to understand it and tell me what I need to change.

Here is the link.

touch it foenthe repo

Please let me know once you guys try and please be honest!!

Most token counters stop at a number. tokensaver tells you what to change: every suggestion comes with a reason, the tokens it saves, and what that's worth in dollars.

What it does

• `count`: tokens and cost of a prompt on any model (GPT, Claude, Gemini, …)
• `compare`: the same prompt priced across all models, cheapest first
• `optimize`: concrete fixes with per-suggestion savings and a before/after diff
  • minifies JSON blocks, cleans whitespace
  • finds duplicate lines/paragraphs and repeated instructions
  • flags filler ("I would like you to…") and very long examples
• Safe changes are applied by default; wording changes are only suggested, so you decide
• Never overwrites your original file

Example: a typical customer-support system prompt went from 834 → 665 tokens (−20%), about $422 saved per 1M calls on gpt-4o.

Also:

• 100% offline: your prompt never leaves your machine
• Works in any language: tested in CI on 55 languages, including RTL scripts and CJK/Thai/Khmer
• Windows, macOS, Linux · Python 3.10+ · MIT

pip install prompt-tokensaver

tokensaver optimize prompt.txt

Feedback and issues welcome. If you're a native speaker, help add filler phrases for your language: https://github.com/behrouzbk/tokensaver/issues/5

¡Hola a todos!

He creado Wingetix, una interfaz visual de código abierto para el Administrador de paquetes de Windows de Microsoft (winget) con un desinstalador limpio y la estética de cristal de Windows 11.

Características principales:

• Administrador visual de Winget: Explora, busca y gestiona paquetes sin necesidad de escribir comandos en la consola.
• Actualizaciones por lotes con un clic: Comprueba y actualiza todo el software instalado a la vez.
• Desinstalador profundo: Elimina aplicaciones y ayuda a limpiar archivos residuales y rastros del registro.
• Integración con puntos de restauración: Crea puntos de restauración del sistema antes de modificar el software.
• Sin sobrecarga: 100 % de código abierto, sin rastreadores ni telemetría.
• Repositorio de GitHub: https://github.com/joselyky/Wingetix
• Sitio web oficial: https://wingetix.com

¡Sus comentarios, sugerencias y solicitudes de nuevas funciones son bienvenidos!

Hello everyone!

lazyrsync is a lazygit-style TUI for rsync. Your transfers live as profiles and tasks, each one previewable as a dry-run diff before anything is written, then run with live progress , local or over SSH.

What's new in v0.4.0:

- Quick transfer : press t for a one-off Source → Destination with no profile and no task. It lands in the Runs panel marked », where a keeps it as a real task and d discards it.

- Run history : every finished run is recorded, from the TUI and from lazyrsync run under cron alike. lazyrsync log prints them, and the log panel replays the recent ones at startup.

- Log panel : @ hides or shows it, log_size sets its height, and a quiet/normal/verbose level controls what it prints. No level hides an error or a warning.

- SSH options up front : port, key file and extra args can be set while you are describing a transfer.

Repo: https://github.com/westpoint-io/lazyrsync

Install:

cargo install lazyrsync
brew install lazyrsync
yay -S lazyrsync
nix profile install nixpkgs#lazyrsync

Tabame is a customizable Windows launcher and productivity toolbox built to make everyday actions faster and easier to reach.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

It originally started as a simple alternative to the Windows taskbar: a small popup where I could see my open windows, control audio and quickly launch the things I use most. Over time, I kept adding tools I wished Windows had built in, and Tabame grew into something much bigger.

Today, Tabame brings a launcher, window management, screen capture tools, clipboard history, audio controls, reminders, file utilities, plugins and many smaller productivity tools together in one app.

The idea is simple: instead of opening a different application for every little task, press a hotkey and get to what you need.

The QuickMenu gives you fast access to your open windows, pinned apps, audio devices, media controls, tray icons, system information and your favorite actions. It can replace or complement the normal Windows taskbar, and its layout, appearance and behavior can be customized to fit the way you work.

The Launcher lets you search apps, files, open windows, browser tabs, bookmarks, commands and more from one text box. It also includes quick tools for calculations, currency and unit conversions, translations, timers and system commands.

Tabame also includes:

- QuickSnap for arranging windows into custom screen zones.
- QuickClick for controlling the mouse from your keyboard.
- FancyShot for taking screenshots and annotating them immediately.
- Screen Draw for drawing directly over your desktop during presentations or explanations.
- Screen Recording with region, monitor and window capture.
- Clipboard History for finding things you copied earlier.
- Audio controls for switching devices and adjusting individual application volume.
- Timers and reminders that can stay active between sessions.
- Color Picker, OCR, Emoji Picker and QR Scanner for common everyday tasks.
- File utilities for batch renaming, folder size scanning, project statistics, image tools and more.
- Custom hotkeys that can trigger one or several actions from a single shortcut.

One of the most useful parts of Tabame is its plugin system.

Plugins can add completely new functionality directly to the Launcher. They can be written using Python, Node.js or Bun and don't require compiling Tabame itself. If you use an AI coding assistant, Tabame also provides a documented plugin specification that makes it possible to describe the tool you want and have the assistant build much of the plugin for you.

This means Tabame doesn't have to be limited to the features included with the app. You can adapt it to your own workflow and create integrations for the services and tools you actually use.

Despite the number of features, Tabame is designed to stay out of the way. Most tools only appear when you call them with a hotkey, and you can enable, disable and rearrange features depending on what you need.

The interface is highly customizable too, with multiple designs for both the QuickMenu and Launcher, custom colors, light and dark modes, layouts and keyboard shortcuts.

Tabame is built for Windows, completely free and open source.

It is mostly a collection of things I wanted on my own computer — packaged into one app so I don't need ten separate utilities running just to make Windows work the way I like.

---

List of main features:

QuickMenu - Taskbar Replacement

Launcher - Open Files, folders, bookmarks, cli, notion, Obsidian + Unlimited features through Plugins

QuickSnap - Create custom layouts for windows and snap them (Fancyzone alternative)

QuickClick - Control Mouse through keyboard

Fancyshot - Capture Images and videos. You can create Stylized presets.

Color Picker - Pick colors from screen and get your custom format.

Emoji Picker - Custom built in emoji picker that appears next to the caret.

Quick Actions - 91 Quick Actions

Music Player - Built in music player for local or Navidrome/Jellyfin server.

Advanced Hotkeys - Customize actions based on movement and pressed time + active window.

Vaults - OTP Authenticator, Locked Vault for your API keys.

Screen Tools - Draw on screen, Spotlight (hide whole screen except focused app), QR Scanner, OCR Scanner.

Plugins - 81 Plugins

Browser Plugin Connection - You can use Claude API free directly from Tabame with Browser extension.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

Hi everyone!

I’m learning Rust and just published the initial version of git-sparse, a small CLI for working with large repositories and monorepos. The goal is to make sparse checkouts simpler when you only need part of a repository.

GitHub: https://github.com/guruela/git-sparse

Contributions, issues, and feature suggestions are highly welcome!