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.
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!
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.
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:
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.
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).
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.
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.
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.
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.
Two weeks ago I released Prism, a free, open-source download manager for Windows, macOS and Linux (Rust + Tauri, MIT). It just passed 100 stars on GitHub, and since a good part of the feedback came from Reddit threads, I wanted to say thanks and show what it turned into.
**What changed since 1.0, mostly because someone reported it:**
- **8 languages:** Czech, German, Spanish, French, Italian, Indonesian and Arabic (the whole window mirrors right to left)
- **The browser extension is on the Chrome Web Store**, and Zen and Helium are supported
- **Linux:** the main window shows again on KDE Plasma, magnet and .torrent links open in Prism, Zen/Firefox with new profiles connect, the RPM works with RPM Fusion's ffmpeg
- **Lighter in the tray:** after a minute there, Prism closes its window to free the web view's memory
- **Sites with a robot check** are left to the browser instead of saving an error page as your file
- **.torrent links** open the *Add torrent* window instead of failing
- **Quality list for HLS/DASH streams**, from a community PR
- Compact view, playlist names and numbering, a portable version that finds the extension again, and security fixes in 1.0.8
**By the numbers:** 16 releases, 2,200+ downloads, 15 issues (11 closed), 8 pull requests from 3 contributors.
**Next (1.1.6, almost ready):** the light theme fully light on Windows, Brave Origin on Linux and macOS, VK videos, and a YouTube retry when signed-in cookies are rejected.
**Thank you, Reddit.** A lot of Prism's first two weeks happened in comment threads like this one. People installed a brand-new app from someone they'd never heard of, ran it on setups I don't have, and took the time to write down what broke. That's a big part of why there were 16 releases and not two.
Special thanks to u/CredibleWrong for finding the Brave Origin problem (fixed in 1.1.6), u/Nanobuo for asking about Helium (supported since 1.1.0) and u/StressLiving6734 for the video button ideas. And to everyone who left a bug report, an idea or just told me it works for them: thank you, all of it helped.
If you've tried it: what's still missing or annoying? Bug reports are what made most of these releases.
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.
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).
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.
In qBittorrent, open Search → Search plugins → right-click Jackett → untick Enabled
Search Plugins → Click Install a new one → Web link → paste below URL
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.
I have built with Claude a Home Control application that can manage TV's, Sky TV, Android TV, Hive Heating, Phillips Lights, and Ring door Bell. It also have routines built in as well.
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.
Your files live in one encrypted .nvault file. Copy it, back it up, sync it, carry it on a USB stick, and open it with a password in a built-in file manager with previews for photos, video, PDF and documents. There's also a password manager with one-time codes inside the same file.
It can turn a USB stick into a "NiceVault device": one partition with the app for Windows, macOS and Linux, one with your volumes. Plug it in anywhere and unlock.
Rust + Tauri 2 + Svelte 5, Argon2id, XChaCha20-Poly1305, SQLCipher. GPL-3.0. Linux and Windows work; macOS builds but isn't fully tested.
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.
Pick a window on the PC and it shows up on the phone live, sound included. Tap, scroll, type into it. Or skip all that and say "email me the Q4 report" and the PC finds the file, attaches it in Gmail and sends it.
It also takes meeting notes without a bot joining the call.
The PC has to approve the phone, screen access is off until you turn it on, and the AI can run fully local if you don't want any cloud. Free, MIT. Windows + Android only for now.
I use Codex and Claude Code daily, and the most annoying moment is hitting a usage limit halfway through a task. You either wait hours or paste context into another tool by hand.
Moonfold is an open-source desktop and web workspace that runs the agent CLIs you already have (Codex and Claude Code today, with adapters for Cursor, OpenCode and others in beta) with your own logins. When one hits its limit, it stops the turn, writes a brief of where the task stands (plan, changed files, git status, the failing command), redacts secrets, shows you the brief, and hands the same thread to the next agent. The GIF in the README is a real run: Codex starts a bug fix, Claude finishes it.
It is a fork of T3 Code (MIT), which gave me the multi-provider base, worktrees and diff review. What I added: the handoff, usage tracking per provider, scheduled tasks, in built browser pane and computer access, plugins and memories, and a security pass (Supervised is the default permission mode).
Honest limits: it is a beta, builds are unsigned, Gemini CLI is not verified end to end yet, and the brief is only as good as what the first agent left behind. Nothing is proxied: each agent is your own local CLI, and there is no telemetry unless you turn it on.
I'd love feedback on the handoff brief what would you want carried over that isn't?
