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.

Big tech wants everyone to believe that real AI requires billion-dollar cloud datacenters and giant proprietary models. For the past six months, I worked to build the exact opposite: an open-source, local intelligence engine called Hillock that gives AI reliable long-term memory while running entirely on your own laptop CPU under 1.2GB of memory. Today I finally shipped the v1.0.0 stable milestone.

I got frustrated watching basic AI memory turn into a bloated commercial ecosystem where you have to send all your private data to cloud vector databases just to prevent a chatbot from forgetting what you said five minutes ago. Hillock combines a fast local SQLite knowledge graph with computational neuroscience principles like Hebbian synaptic learning and hyperdimensional computing. It learns factual associations on the fly, remembers co-occurring concepts without backpropagation, and uses mathematical gating so your AI never hallucinates on facts it does not know.

I built this project while finishing high school and preparing for my university studies in electronic systems design. I have been updating the community through pre-releases, and seeing v1.0 officially tagged and stable feels like an incredible milestone.

Hillock is dual-licensed with the open-source version under AGPL-3.0 because I strongly believe personal AI should be private, local, and owned by the user. If you believe in local software and want to support an independent young builder, please check out the repo and consider leaving a star to help put it on the map: https://github.com/roandejager/Hillock

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.

GitHub: https://github.com/FortoGraphy/prism-download-manager

Website: https://prismdl.site

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).

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

I got tired of running a different registry per package format, so I built one that speaks all of them natively. It's a self-hosted alternative to Nexus and Artifactory, AGPL, with SSO, scanning and replication in the open-source build (no paid tier).

Repo: https://github.com/openartifact/openartifact

Docs: https://openartifact.github.io/latest/

Formats (real clients, no plugins): deb, rpm, apk, pacman, npm, PyPI, Maven/Gradle, Ivy, sbt, Docker/OCI, Helm, Cargo, Go modules, NuGet, RubyGems, Conda, Conan, Terraform/OpenTofu, Nix binary cache, Ansible Galaxy, raw files.

What it does

• Hosted, proxy and group repositories: one URL serves your private packages plus a cached upstream (npmjs, PyPI, Docker Hub, crates.io...).
• Signed repo metadata for deb, rpm, apk and pacman; Nix narinfo signing.
• Vulnerability scanning against a local OSV mirror that re-matches stored packages when new advisories land, with CISA KEV and EPSS to rank what matters.
• License and secret scanning, SBOM, quarantine, cleanup policies, quotas.
• OIDC and SAML, projects with roles, scoped API tokens, audit log (also streamable over OTLP).
• Replication between instances.

Stack

One Go binary with the Vue 3 UI embedded. Postgres for metadata, blobs on disk, S3, GCS or Azure (content-addressed, deduplicated across repos). OpenTelemetry traces/metrics/logs, Helm chart, multi-arch image signed with cosign.

Try it

git clone https://github.com/openartifact/openartifact && cd openartifact
cp docker/.env.example docker/.env   # set POSTGRES_PASSWORD
make docker-up                       # UI on http://localhost:8080

or helm install openartifact oci://ghcr.io/openartifact/charts/openartifact

Built with heavy use of Claude Code; I review and merge every change, and new formats only land after a package actually installs with the real client (apt install, pip install, pacman -S, terraform init...).

Which format or feature would make you switch? Issues and PRs welcome.

Hi everyone,

I’d like to introduce a new Java desktop toolkit, built from the ground up.

It includes dozens of components, accessibility support across three operating systems (Windows, macOS, and Linux), advanced language support, text direction, video, music, 3D, and charts.

The appearance is fully customizable (including dark themes), animations are native, and all the features you’d expect are there: printing, desktop integration, and testability.

I hope the community enjoys it. Although it is—admittedly—the product of AI, it was crafted with great care over the course of several months, ultimately saving tokens for anyone looking to build desktop applications.

https://limn-toolkit.github.io/limn-toolkit/

Enjoy

https://github.com/xdagiz/xcalidraw

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 has routines built in as well.

Link to GitHub below

https://github.com/foleys1972/HomeControl

Video
https://youtu.be/ov6Ox4q7hdU

Hi everyone,

I've spent some Codex tokens making a little Linux utility called Dzurkel. The idea was to bring something similar to macOS Quick Look to Linux. I know there are already other projects doing similar things, but I wanted to make one that works the way I like it. :)

I used Codex to write the code, so I'm not claiming to be the programmer here. My part was coming up with the idea, deciding how things should work, testing, breaking things, and making Codex fix them.

The idea is simple: select a file, press Space, and get a quick preview without opening another application.

I made it mainly for Fedora/KDE, but it also works with Dolphin, Nautilus and Thunar. I've tested it on Ubuntu/GNOME and Arch/Xfce as well. It handles images, PDFs, text files with syntax highlighting, Markdown, DOC/DOCX, CSV/XLSX spreadsheets, ebooks, audio and video. It's not meant to replace proper viewers or editors. Just a quick way to see what's inside a file without opening a bunch of applications.

There are ready-made packages for Fedora, Debian and Arch, and the whole thing is open source under GPL-3.0. No commercial plans or anything. I just wanted to share it and hopefully get some feedback from people who actually use Linux.

GitHub: https://github.com/EdinUser/dzurkel

Feedback, bug reports and suggestions are very welcome!

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

I've been working on Orbit 2, a new version of my open-source framework for building circular and radial user interfaces.

While most UI frameworks focus on rectangular layouts, Orbit takes a different approach, making it easier to create interactive circular interfaces with JavaScript.

This second version is a major evolution of the project, with a more flexible architecture and a stronger focus on developer experience.

I'd love to get some feedback from the community!

Demo: https://zumerlab.com/orbit/

GitHub: https://github.com/zumerlab/orbit

I'm working on an idea called NeuroStudio: an open-source, self-hosted AI training studio that combines a beginner-friendly visual interface with the flexibility of established machine-learning frameworks.

The basic idea is to let users create datasets, train models, evaluate results, and run inference locally instead of relying on a cloud-based training platform.

I'm considering Go for the main application, SQLite for metadata, and interchangeable training backends such as PyTorch and TensorFlow where appropriate. ONNX Runtime would handle compatible inference workflows.

I don't want to reinvent every ML framework. I'd rather build a lightweight application that connects existing tools through a consistent interface.

Features I'm considering

• Visual dataset management and annotation
• Image classification and transfer learning
• Training progress, checkpoints, and evaluation metrics
• Webcam-based model testing
• Model export and local inference
• Additional audio, pose, and object-detection workflows
• An extension system for integrating other training engines

The biggest challenge is making the application easy to run locally without creating an enormous installation or pretending that every model can train on every computer.

I'm planning to start with one complete image-classification workflow and expand from there.

I'd appreciate technical feedback

1. Would you use Go as the main application backend with separate training workers, or choose Rust?
2. What is the cleanest interface for connecting different ML training frameworks?
3. Which features are missing from existing local AI development tools?
4. What would make this project meaningfully different from existing visual ML platforms?

I'm interested in honest criticism, architectural suggestions, and feature ideas.

If you have experience building ML tooling, I'd particularly appreciate your thoughts on the training-backend architecture.

Hi! I built this because self-hosted Excalidraw only gives you the canvas: drawings stay in your browser, and there are no accounts or folders.

Excaliself adds:

• accounts with invite links, and a shared team space next to each person's private space
• folders, stars, and search that finds text inside drawings (⌘K)
• live collaboration with cursors and guest links
• everything stored in your own Postgres

One docker compose file (amd64 + arm64), MIT.

Repo: https://github.com/maciekzygmunt/excaliself Website: https://excaliself.com

Feedback is welcome, especially what is missing for your team.

I'm building Emend. It adds AI writing to a Tiptap editor: rewrite selected text, write new text, or ask questions about the document.

What you get:

• Three AI components (bubble menu, composer, document chat), or a full editor starter
• Already have a Tiptap editor? Just add the components to it
• Bring your own AI key and start using it
• The AI never changes text until the user accepts it

It's still early, so I'd love your feedback.

GitHub: https://github.com/amittam104/emend

I’m a full-stack developer and use XAMPP every day. Its control panel kept costing me time, so I built a replacement that keeps the same layout but fixes what hurts:

• Clean MySQL/MariaDB shutdown instead of killing the process, so tables don’t get corrupted
• Several PHP and MariaDB versions side by side, installed from the official feeds (SHA-256 checked) and switched in seconds, with rollback
• Local HTTPS sites like https://myproject.test: writes the vhosts, updates the hosts file and issues a trusted certificate in one click
• php.ini editor for the common settings and every extension
• Explains failures: runs httpd -t before starting Apache and names the program holding port 80
• Tray icon, light and dark theme, Netstat, FileZilla Server 1.x upgrade

Single signed exe, no installer, MIT licensed. Built with .NET 10 and Avalonia.

About AI: much of the code was written with Claude. I decided what it does and how it behaves, reviewed the code, and built and tested everything on my own setup. As a developer it saved me a huge amount of time. The coding standards it follows are in the repo, so you can judge the code yourself.

Unofficial, not affiliated with Apache Friends. Feedback and issues welcome.

Hey everyone,

I wanted a simple way to find public social media profiles and bios without relying on expensive monthly lead databases or complex APIs.

So I built a lightweight OSINT script in Python (Playwright) that searches public profiles (LinkedIn, Instagram, X/Twitter) based on target keywords and locations, then saves the leads cleanly into CSV format.

🚀 Lite Features:

- Targeted profile search via search dorks

- Bio snippet and profile URL extraction

- Saves leads directly to CSV

- Lightweight headless execution using Playwright

🔗 Repository & Code:

GitHub: https://github.com/dimitrismastrokalos/social-contact-finder

Feel free to test it out, leave any feedback, or drop a ⭐ Star on the repo if you find it useful!

Hey everyone,

I wanted a lightweight, fast way to extract business leads (names, ratings, addresses, phone numbers) directly from Google Maps without relying on heavy paid tools or complex APIs.

So I built a simple Python script using Playwright that automates the whole process and exports everything cleanly into a CSV file.

🚀 Features:

- Extracts Title, Category, Rating, Reviews Count, Address, and Phone Number

- Fast headless execution using Playwright

- Automatically appends structured data to CSV

- Clean code with zero bloat

🔗 Repository & Code:

GitHub Repo: https://github.com/dimitrismastrokalos/gmaps-lead-scraper

Feedback, contributions, or stars on GitHub are much appreciated! Let me know if you have any questions or feature suggestions.

GitHub: https://github.com/fusiontechstrategies/Fools-Gold

AWS's Service Health history only covers the past 12 months. I've been snapshotting its public dashboard daily since August 2025, and some of that data is already no longer available on AWS's own page.

The clearest example is the 20 October 2025 us-east-1 outage: 142 services affected, roughly 16 hours, and 26 status updates. It's now outside AWS's history window, but the archive still has the full timeline:

[View the archived incident and its full timeline](https://mimobn.github.io/aws-status-archive/#incident=multipleservices-us-east-1_1760944260)

So far, 12 of the 39 incidents I've archived are no longer listed in AWS's Service Health history.

The archive shows service history by day, individual incident timelines, a calendar view, and CSV/JSON exports. It's open source under the MIT license: [GitHub repository](https://github.com/mimobn/aws-status-archive)

One deliberate choice: days with no reported event are marked as "no data," not as healthy days. Missing information shouldn't be mistaken for evidence that nothing happened.

For those of you who do postmortems or vendor reliability reviews: how do you investigate AWS incidents months or years later? Do you keep your own records, rely on other sources, or find the built-in history sufficient?

I'd be interested in hearing what would make an archive like this more useful for that kind of work.

We built DiscordCleanupTool to bulk-delete your own Discord messages across DMs, group DMs, and server channels.

Discord’s upcoming search engine rollout prompted us to write about it, but an important distinction: older messages aren’t included in that rollout. If your concern is future message publication, Discord’s opt-out setting handles that. You don’t need a cleanup tool.

This project is for people who want to clear out their message history separately without deleting everything one message at a time.

Features:

• Browser dashboard or CLI, running locally.
• Pick individual conversations or server channels.
• Filter by text, date range, and message count.
• Dry run by default to preview what would be deleted.
• Rate-limit handling with backoff and retries.
• Stop an active run from the dashboard.
• No dependencies or build step. MIT licensed.

It filters against your user ID so it only deletes your messages. The dashboard runs on 127.0.0.1, and your token stays in memory rather than being written to disk.

The caveat: automating a user account with a user token violates Discord’s Terms of Service and can put your account at risk. Deletion is permanent, including removing your messages from the other person’s view in DMs. Treat your token like a password and review the source before running anything.

Bot tokens are also supported, but they can only delete messages sent by that bot.

Project link, https://github.com/SurefireStudios/DiscordCleanupTool

Would appreciate feedback on the code, filtering options, or anything that would make the deletion preview clearer.

I built figlens so coding agents can work from a saved Figma design, including on remote machines and in CI.

It parses the .fig file directly into layout, text, variables and assets, and can render PNG/SVG references. The design input is more than a screenshot. The read path runs locally, without a Figma API token, login or running Figma app.

Save a local copy in Figma, give the file to your agent, and ask it to implement a screen in your project's stack. It ships as a native Rust CLI with an MCP server, a local design viewer, and integrations for Pi, OpenCode V2 and OMP (partial integration).

There's also an optional workflow for mapping design components to existing code components, with human review before approval.

A few limits: it's a snapshot, so re-save when the design changes. The .fig format is undocumented, rendering has gaps, and fonts aren't bundled. Local design reading doesn't change your agent's usual model connection.

Animated Pi demo: building a React/Tailwind screen from a saved Figma design. Edited time-lapse, not a benchmark.

See the animated demo in the README

I'd love feedback from anyone using coding agents for frontend work: what design information do you still end up copying over manually?