Hey everyone! I recently launched Melo, a free and open-source Android music player that brings Spotify and YouTube Music together in one app.

No ads, clean UI, and completely open source.

Didn't expect 700+ downloads and 40+ GitHub stars in under 24 hours 😭

Still improving it, so I'd love your feedback, suggestions, and bug reports!

📥 Download APK: https://github.com/aarush-io/melo/releases/latest

⭐ GitHub: https://github.com/aarush-io/melo

I built a free and open-source alternative to the gpui-kit DataTable for live data: 11x faster

About 15 years ago I worked with a derivatives trading team at one of the biggest investment banks in the world. A trader watches quotes, and positions update in real time. Nothing off the shelf survived that stream, so we had our own hand-written grid in C#.

I rebuilt the idea in Rust on gpui-kit. It is open source now.

100k rows x 40 columns at 10k updates a second: 1.4 ms a frame on an M3 Pro.

11x faster than the built-in DataTable on the same load.

Sorting, filtering, grouping and totals run in the background. The UI thread only paints.

Selection follows the row, not the position, so it stays put when the rows re-sort.

Nine demos run in the browser: live quotes, a trading desk, a broker app, every satellite in orbit, transport in Munich and Helsinki, Wikimedia edits, ships via AIS and an on-call console.

Repo: github.com/GigLaboCom/gpui-kit-grid

Demos are here

I got tired of a certain app drifting toward commercialization, so I re-created my own version.

Its main selling (it's free, heh) points are:

- Minimal interface. The toolbar and window borders can both be disabled. Keyboard is enough to control most of the app. F1 opens the list of keyboard shortcuts. Drag-and-drop images or folders straight into the app.

- Small memory footprint.

- Portable. It stores its settings file into the same folder the executable resides, nor does it write any configurations anywhere within Windows/user paths, or registry.

- Support for JPEG, PNG, WebP, TIFF, BMP, GIF, ICO, QOI, DDS, HDR, TGA, and Netpbm images. Animated GIFs play automatically. Not the most extensive support, but enough for a basic user.

- Zoom, pan, and rotate images. Embedded EXIF orientation is applied automatically. Different modes for zooming (Fill, Fit, Fit Height, Fit Width, Lock Size, Auto).

- Run slideshows with fixed or random intervals, shuffle, repeat, and an option to let animated GIFs play through at least once.

- A playlist view with sorting by name, or shuffling. Drag and drop the files to change the order as you like. Playlists can be saved and loaded into files.

- Rename, copy, move, and recycle files or reveal them in Explorer.

- Smooth image browsing, thanks to a caching system.

Windows only, sorry. The app uses Windows APIs, so compiling for other platforms would require some rewriting.

MIT Licensed.

AI Disclosure

The app was developed with the aid of several AI models, including OpenAI's GPT-6 Astra, GPT 6.1 Sol, Mistral's Mistral Large 4, Z.ai's GLM 5.3 and GLM 5.3-Flash, and Deepseek's DeepSeek-V4.1-Flash.

Hope someone enjoys it. Let me know if you do!

RustedGlass (GitHub)

Most OCR libraries work great until you start asking uncomfortable questions:

Does import trigger a network request? Where are the model weights stored? Why does a simple OCR task need hundreds of megabytes of dependencies?

I wanted something different, so I built wormOCR - a lightweight, fully local OCR engine for printed and handwritten English.

The goal was simple: make OCR small, fast, predictable, and genuinely offline.

What makes it different?

• No surprise downloads: import wormocr never triggers a network request.

• Explicit model downloads: Run wormocr download once to get the weights.

• Verified weights: Downloaded from a pinned GitHub release and checked using SHA-256.

• Fully local inference: No cloud APIs, telemetry, or network dependency.

• MIT licensed: Open source and free to use.

Two models, different trade-offs

How fast is it?

Measured on my laptop:

Single-line inference (wormocr-2M):

• CPU: ~14 ms end-to-end.

Full-page inference (same 3 digital pages):

The model weights range from 8.7 MB to 33.5 MB, compared with approximately 132 MB for the PaddleOCR medium stack in my comparison.

These are my own measurements on a small test set, not a comprehensive benchmark. Hardware, configuration, and preprocessing matter.

Try it yourself

pip install wormocr
wormocr download

from wormocr import OCR

ocr = OCR()
result = ocr.predict("invoice_line.png")

print(result.text)

Where it stands today.

Clean printed text and receipts are strong. Messy notes and historical handwriting are usable, but still challenging.

Currently:

• English printable ASCII only.

• Classical page-layout detection using projection profiles, rather than a large learned detector.

• Two model sizes with different speed/accuracy trade-offs.

I'd rather be transparent about what doesn't work than market this as a universal OCR solution.

GitHub: https://github.com/arjun988/wormOCR

PyPI: https://pypi.org/project/wormocr/

I'm particularly interested in feedback from people working on OCR, computer vision, edge AI, and offline-first software.
If you find this interesting or think it could be useful, I'd really appreciate a ⭐ on GitHub. It helps the project get visibility and motivates me to keep improving it.
Feedback, issues, PRs, and stars are all very welcome!

Would you actually use an OCR engine this small in a production application? What would you want to see improved first?

I used yt-dlp and ffmpeg GUIs a lot and I was tired that every app has a lack of something, no option to convert for Discord here, no download feature here, no way to select specific segments to download here. And there are many of other things missing in this apps, too.

So I built Pulsar. App that merges three aspects: downloading, converting and compressing. And has every major option. You can choose format, quality, bitrate, codec, download thumbnail and subtitles, skip sponsors, compress by CRF, size or percent and many many other features which other projects do not have within a single application.

What it have?

• Downloader -> choose video/audio format, quality, codec, download a time range, skip sponsors, grab subtitles, embed metadata/thumbnail/subs, use browser cookies, set custom filename.

• Converter -> Convert video, audio, image, font and archive and set your bitrate or codec change before you start. 55 total formats supported.

• Compressor -> compress by percentage, target file size or quality (CRF) and see the estimated output size before you start.

• Queue -> add as many jobs as you want and start everything at once, with thumbnails and progress.

• Presets -> for each tool, so you don't have to re-pick the same settings every time

• Light/dark theme and multiple languages (translations are in TOML, so adding one is easy)

Why another one?

Most tools I found do just one of these things. Pulsar is meant to cover the whole "get a file, change it, make it smaller" workflow without ads, accounts or uploads to the server. The whole app runs on the efficient Rust language and small Pulsar-Bridge (yt-dlp wrapper that max out its performance) instead of heavy, slow Electron that many of these apps have today.

GitHub: https://github.com/FuzjaJadrowa/Pulsar

NetPulse is a self-hosted monitoring panel for home and small office networks. It runs on your own hardware, keeps the data in a local SQLite file and has no accounts and no cloud. AGPL-3.0, free as in freedom and free as in beer.

What it does, in short:

- Fleet view: routers, APs and SNMP switches with CPU, memory, temperature, uptime, WAN traffic and latency.

- Live topology: wired and wireless clients, managed and inferred switches, Proxmox hosts with their guests nested, WireGuard tunnels.

- Clients: classified by type, with band, signal and first time seen.

- Wi-Fi: roaming view (usteer), 802.11r status, channel analyzer with the neighbouring networks drawn on the spectrum and a congestion score per channel.

- WireGuard peers and AdGuard Home stats.

- Alerts: native Web Push, ntfy, Telegram, outgoing webhook.

- MQTT with Home Assistant discovery, and a read-only MCP server for AI assistants.

- Reports, scheduled firmware upgrades for vanilla OpenWrt, and a rack planner (labs preview, off by default).

- Multi-user, ES/EN, installable PWA.

Vendor integrations. OpenWrt is the native path, and everything else is an external pusher from the Integrations page: MikroTik over the RouterOS binary API, Asuswrt/Merlin running on the router itself from /jffs, and UniFi polling a local controller.

- Repo: https://github.com/gnacho/netpulse

- Web: https://netpulse.cloudless.club

- Demo: https://demo.netpulse.cloudless.club

- Integrations: https://github.com/gnacho/netpulse-integrations

- License: AGPL-3.0

I have a bad habit. I start a course with a lot of energy, a YouTube playlist, a Udemy course, a PDF book, and after a week I stop. I forget where I was, which video, which page. And nobody notices, so nothing pushes me to go back.

So I built inPace with Claude Code. It's free, open source, and everything stays on your device.

What it does

- Put any course in one place: a folder of videos (even if it's messy, it sorts them), a PDF book (every chapter becomes a module), a YouTube playlist, or a course from the free library

- It remembers the exact second of the video and the page of the book where you stopped

- Pick someone you trust to check your progress: a friend, a sibling, a mentor. When you finish a module you send them a "milestone" with your work, your quiz score and an explanation in your own words. They approve it or not

- Milestones are signed with a key on your device, so you can't edit them later or fake the date

- A free library with 52 courses and 20 learning paths (Python, JavaScript, C#, Git and GitHub Actions, Docker, ML, and more), with written lessons and optional videos from freeCodeCamp and Harvard

- Reminders, notes on any line of a lesson, races with friends, and a little turtle called Tempo who grows a garden while you study

How Claude helped

- Claude Code was my pair programmer for the whole app: the Python server, the pages, the Android app, the release pipeline. I decided what to build and how it should feel, Claude wrote most of the code with me, and I reviewed and tested every change

- Tests were the key. Every feature came with tests, and now there are 237 of them that run on every push on Windows, Mac and Linux. When Claude broke something, a test caught it before a user did

- I asked Claude to test like a real user: open the app at phone size, take screenshots, and look at them. That's how we found the welcome tour was broken on phones

- Claude also wrote the free courses in the library. I made it run every code example, check every YouTube link, and check its own facts. It even caught two wrong facts in its own first draft

- The app itself works with Claude too: "Make a course with AI" gives you a prompt, you paste it into Claude, paste the answer back, and you get a full course with lessons, tasks and quizzes. No API key and no cost

It runs on Windows, Mac, Linux and Android. No account, no server, no ads.

Download: https://mahmoudyosrimahmoud13.github.io/inPace/

Code: https://github.com/mahmoudyosrimahmoud13/inPace

It's my first post here, so any feedback is welcome, good or bad. And if you try it, tell me what was confusing in the first 5 minutes, that's what I'm fixing next 🙏

Hey everyone,

I wanted to share a project I've been building called Gami.Fied. It is an open-source, self-hosted gamification engine that lets you add progression and reward systems to your web or mobile apps without having to build everything from scratch or send your users' data to a third-party paid service.

How it works Your app just sends basic activity events to the API (like lesson_completed or post_created), and the rules you set up in the dashboard automatically turn those events into XP, levels, streaks, achievements, or points.

What is included right now (v1.2.0)

• Rules engine: A visual editor to set up conditions and rewards, plus a simulator so you can test your rules before making them live.

• Progression: XP, custom levels, daily and weekly streaks (with automatic freezes), tiered badges, and multi-step challenges.

• Points & Reward Store: Virtual currencies with expiring points and a built-in store where users can redeem rewards or coupon codes.

• Leaderboards & Social: All-time, daily, weekly, and monthly leaderboards, weekly leagues with promotion and relegation, friend lists, and referral codes.

• Notifications & Integrations: In-app notifications, email reminders, push notifications, webhooks, and ready-to-use connections for Discord, Slack, Stripe, and GitHub.

• Admin Dashboard: Manage everything in one place with analytics, staging environments to test changes safely, and easy JSON export/import for your setup.

Try it out

• Website, Docs & Live Demo: https://gami.fied.cc (You can spin up a temporary workspace right in your browser without signing up)

• GitHub Repo: https://github.com/gami-fied/gami.fied

How it was built I started this project by hand and also used Claude to help speed up development across the codebase, dashboard, docs, and tests. You can run the whole thing on your own server using Docker Compose. The main server and dashboard are licensed under AGPL-3.0, and the TypeScript and React SDKs are MIT licensed so you can safely use them inside any closed-source app.

I am actively working on this as a solo maintainer, and more updates with new features are coming soon. If you check it out, I would love to hear your feedback or any ideas on what I should build next!

P.S. The integrations, webhooks and platform admin panel are disabled for the demo site. To test them, you need to host it yourself.

GitHub: https://github.com/lingdojo/kana-dojo

As someone who loves both coding and language learning (I'm learning Japanese right now), I always wished there was a free, open-source tool for learning Japanese, just like Monkeytype in the typing community.

Here's the main selling point: I added a gazillion different color themes, fonts and other crazy customization options, inspired directly by Monkeytype. Also, I made the app resemble Duolingo, as that's what I'm using to learn Japanese at the moment and it's what a lot of language learners are already familiar with.

Back in January, I even applied to Vercel's open-source software sponsorship program as a joke. I didn't seriously expect to win, and did it more out of curiosity, and yet my project somehow won.

Anyway. Why am I doing all this?

Because I'm a weeb.

Source: https://kanadojo.com

どうもありがとうございます

https://oposs.oetiker.ch/thinfloe

I've been building Relay, a self-hosted event-driven runtime for declarative apps.

The idea is to provide some of the developer experience I like from AWS Lambda and EventBridge, but on infrastructure you control.

One thing I didn't want was to force everything into the function model.

An app can use event-driven functions where they make sense and run something like FastAPI or Express.js as a persistent service when that's a better fit.

The goal isn't to reproduce AWS service by service.
It's to keep useful serverless and event-driven abstractions while making them self-hosted and independent of a specific cloud provider.

Relay currently runs on Docker and uses Redis for its event infrastructure.

GitHub: https://github.com/sergiors/relay

I'd be interested in feedback on both the programming model and the architecture, especially from people already running event-driven workloads outside the major cloud platforms.

built a random forest classifier while learning classical machine learning and model deployment

the project classifies 7 dry bean varieties using 16 numerical features

what's included:

• 100 trees with entropy splitting

• 5-fold cross validation: 92.54%

• test accuracy: 92.06%

• GridSearchCV for hyperparameter tuning

• FastAPI REST API and HTML/CSS interface

• Docker and automated pytest tests

• confusion matrix and feature importance plots

the README includes reproducible training instructions and evaluation results

github: https://github.com/Vaibh37/dry-bean-random-forest

would appreciate technical feedback. if you find it useful, consider starring the repo ⭐

Hey everyone, I'm the developer of Opensteer. I built it because I wanted a personal agent to work locally on my computer with all my existing apps, accounts, and files already on my Mac, and I wanted it to work with different models, including the subscriptions you already pay for.

Opensteer is free and open-source. You can connect your phone through our mobile app and your other computers to control your agents remotely. It also streams your browser and apps directly, so you can basically work on your phone on the go.

We also decided to build a built-in browser so you can use Opensteer as your main browser and have your agents collaborate on all your work. It can of course use your computer to work in your desktop apps too. It's super easy to get set up and started. No need to spend hours integrating everything.

The latest Mac download (0.1.638 beta) is signed and notarized by Apple.

AI disclosure: AI tools helped build Opensteer! And I built a lot of Opensteer in Opensteer. Thanks Claude, GPT Sol/Astra, and Muse Wonder (surprisingly)

GitHub: https://github.com/steerlabs/opensteer
Mac download: https://github.com/steerlabs/opensteer/releases/download/v0.1.638-insider/Opensteer-mac-arm64.zip

Feel free to try it out, and would appreciate any feedback. Thanks!

The demo is one real Claude Code session on an Android emulator, shown at 15x. I asked for a large pepperoni pizza from the Domino's nearest Leicester Square. Claude worked through the real dominos.co.uk checkout in six and a half minutes. At "Buy with GPay", phonedriver held the tap and asked me. I said no, and nothing was charged.

What it is

phonedriver is an MCP server and a CLI. The agent gets the screen as a short numbered text list, taps by number, types and swipes, and gets back only the lines that changed. It works with Claude Code, Codex, Cursor or any MCP client.

How it works

• Android: it pushes a small helper over adb and starts it as the shell user, the way scrcpy does. No root, nothing installed on the phone, no accessibility service to switch on.

• iPhone: it uses its own XCTest runner.

• Speed: reading the screen takes 13 ms, against 2.2 s for adb shell uiautomator dump (median of 50 runs on an emulator; the method and the raw data are in the repo).

• The Pay check: it asks before it taps Pay, Place order, Transfer or Delete account. The model cannot answer that question for you.

It also found two bugs I hid in a signup form in 49 seconds, and wrote the steps to reproduce them.

Where it is weak

• iPhone needs a Mac with Xcode.

• The Pay check reads button labels, so it misses a button that is only an icon.

• The real devices I have tested are a HONOR X8, two iPhones and an iPad.

Rust, AGPL-3.0, no account, no telemetry. Claude Code wrote nearly all of the code. The design decisions, and what I rejected, are logged in docs/decisions.md.

claude mcp add phonedriver -- npx -y phonedriver mcp

https://phonedriver.dev
https://github.com/hridaya423/phonedriver

Hi everyone! I’m a CS PhD student, and I built Shortlist for my own job search. I wanted to spend less time checking company websites and reading openings with the wrong seniority, location, or requirements. I’m sharing it for other students and job seekers facing the same problem.

You give it your resume, preferred roles, locations, and dealbreakers. It watches your chosen companies, scores new openings against your background, and explains each match.

The part I’m most excited about is handling unfamiliar career pages. Shortlist first looks for a supported job board or structured job data. If those fail, an LLM agent attempts to identify the board or create an extraction recipe. Shortlist checks the result against the live site and saves it for later runs.

What it does:

• Reads Greenhouse, Lever, Ashby, Workday, and other company job boards, plus SimplifyJobs lists.
• Explains matched skills, missing skills, and dealbreakers alongside each score.
• Filters obvious mismatches before model calls and remembers processed jobs to reduce repeat work.
• Uses your good-fit and poor-fit ratings as examples for future scoring.
• Sends Telegram alerts and includes a local dashboard for matches, application stages, and notes.
• Optionally fills application forms for jobs you select, using stored answers. By default, it leaves submission to you.

It runs on your computer with Python and SQLite. No Shortlist account or server setup. Scoring uses your chosen Claude Code or Codex CLI login, or an Anthropic or OpenAI API key. Your resume and preferences go to the selected model.

I’d appreciate feedback on match quality and career pages it struggles to read. New job board adapters and company lists are welcome too.

I maintain OpenShelf, a small open-source project for indexing research posted on personal sites and lab blogs. The repo includes the Python feed collector, the screening pipeline and the static site builder. The site publishes Atom and JSON, so you can also use the index without the frontend. The source links go to the authors’ websites.

Repo and build instructions: https://github.com/chenxiachan/openshelf

The diagram shows how the pieces fit together. I’d be interested in a simpler way to discover quiet academic feeds without polling every site on every run.

Hi everyone! I'm **Lennes Daniel Varela Poveda (LennesVP)**, an independent systems technician and Systems Engineering student, and I want to share **TREMEND Toolkit V3.3**, an open-source desktop suite built in Python (`CustomTkinter`) that unifies over 95 diagnostic, maintenance, networking, and defensive cybersecurity tools into a single responsive interface.

🔗 **GitHub Repository:** https://github.com/LennesVP/TREMEND

### 🛠️ What does TREMEND Toolkit V3.3 include?

* **🌐 Network & OSINT (31 Modules):**

* Autonomous network repair (Winsock, TCP/IP stack, DHCP forcing, and malicious proxy purge).

* **Cyber Teams Command Center (#31):** Live Purple Team simulator (`Attack <-> Defend`), Blue/Green Team SOC & firewall monitor, `crt.sh` subdomain exposure auditor, Yellow Team static code analyzer (SQLi, XSS, LFI, RAM tampering), and White Team ROE report generator.

* **Senior Password Hashing Lab (CyberChef style):** Demonstrates `hashlib.scrypt` + 128-bit CSPRNG Salt + constant-time `hmac.compare_digest` verification, plus Base64/Hex/Binary decoding.

* Multi-threaded TCP port scanner, Sniffnet traffic visualizer, Geo-IP OSINT radar (Leaflet dark-mode maps), and RFC 5322 email header Anti-Phishing analyzer (SPF/DKIM/DMARC).

* **🧹 Maintenance & Automation (20 Modules):**

* **4-in-1 File Automation Suite:** Organizes messy folders by type with 1-click Rollback/Undo, classifies invoices chronologically (`YYYY-MM`), renames hundreds of files with their real modification date (`YYYY-MM-DD_filename`) in under a second, and isolates duplicates via `SHA-256` hashing.

* Deep disk cleanup (including `Windows.old` removal, `%TEMP%`, Prefetch, and DISM/SFC kernel repair), dynamic Virtual Memory (`pagefile.sys`) calculator based on physical RAM, and a Browser Hygiene shield with anti-2FA session cookie purge.

* Real-time Panic Mode (`EmptyWorkingSet` RAM liberation) and interactive storage tree radar.

* **🖥️ Hardware Diagnostics & Forensics (21 Modules):**

* Heuristic Anti-Keylogger hunter (cross-references established TCP connections against `Authenticode` digital signatures), RAM Integrity Shield (forces Kernel `ASLR` + `DEP` and hunts memory injectors), Binary X-Ray analyzer (Magic Bytes, EXIF, Strings, SHA-256), and S.M.A.R.T. disk health reader.

* Native Windows Sandbox manager, PnP hardware error Auto-Dorker, and Chromium SQLite History Visualizer (renders an HTML5 Chart.js dashboard).

* **📦 Software & Technical Support (25+ Modules):**

* Deep Uninstaller & Leftover Hunter (scans `AppData` and Registry hives + online `winget` updater) and Pre-Format Software Cloner (exports/imports clean `.json` and `.csv` inventories).

* **USB Forensic Vaccine:** Removes write protection, rescues files hidden by shortcut malware, and immunizes `autorun.inf`.

* **Android ADB Optimizer:** Cleans gigabytes of hidden app caches and old thumbnails via USB without touching personal photos or chats.

* Native Windows AI OCR screen scanner (with 3x Lanczos upscaling), local AI background remover (`U-2-Net` / `rembg`), and a built-in Cognitive Voice Assistant.

**Author:** Lennes Daniel Varela Poveda (`LennesVP`)

I'd love to hear your technical feedback, ideas for V3.4, or any suggestions! If you find it useful, a ⭐ on GitHub helps a lot.

I built Nuvo, a free and open source (AGPL-3.0) music player. Linux is the main platform, Windows is supported, and the macOS build needs testers.

What it does:

- Plays YouTube, SoundCloud and local folders in one queue

- Synced lyrics, karaoke, and word timing on your own CPU with a local Whisper model

- Home mixes ranked on your machine from your plays and likes, with a reason next to each pick

- Imports playlists by link or from Spotify CSV, Soundiiz, TuneMyMusic, Google Takeout, M3U, XSPF and TXT

- Statistics with a listening history you can pause, export or delete

How it's put together: the Electron window (React) does the screens and playback, and a Rust daemon (nuvo-core) owns the library, ranking, imports, local files and lyrics. They talk over a unix socket with a per-launch token. The library is SQLCipher with the key in your system keyring, and the audio cache is encrypted too.

The lyric timing runs Whisper in pure Rust (GGML parser, mel spectrogram, encoder and decoder on gemm, DTW over the alignment heads), with no whisper.cpp and no GPU. The benchmark scripts are in scripts/bench/, and the README lists every run, including where Nuvo loses.

I build it alone and use AI coding tools; the design, the review and the tests are mine, and the tests are in the repo.

Download: https://github.com/Ziuziuk-Denys/Nuvo/releases/latest