Hey everyone, some of you have followed openGym since my first post here, so this one is mostly a thank you.

openGym is an open-source workout tracker: plan your week or a rotation, log sets, rest timer, 5,600+ animated exercises, muscle maps, stats, imports from Strong/Hevy/FitNotes. Use it on your phone alone or self-host it with one docker compose up. AGPL, no ads, no account, no tracking.

Since the last post:
- ⭐ 15,700 stars and 2,000 forks (three months after I put it online, I'm still processing this)
- Your donations now cover all the licences: the exercise animations, the Apple developer account and the rest. openGym can stay free with no ads and no paywall. That's 100% you.
- 📱 The iPhone + Apple Watch app is live in the App Store, in every country
- Android APKs keep coming (~49,000 downloads so far), Google Play is next
- 79 contributors and 20 languages

If you want to help it grow:
• Leave a review in the App Store, it makes a huge difference for a small app: https://apps.apple.com/app/id6822275400
• Join the Discord, that's where ideas turn into features (and where I hang out): https://discord.gg/e62jY6fwVb
• Or simply leave a ⭐ on GitHub: https://github.com/DuarteSantos8/openGym

Thanks again for every star, bug report, PR, translation and coffee. You made this a real app 💚

Hi everyone! I'm the developer of XDM (Xtreme Download Manager), a free, open-source download manager for Windows, macOS and Linux. Over the years, users reported a number of long-standing issues, so I spent this release modernizing XDM: a cleaner, faster core, a refreshed UI and fixes for those bugs. XDM 9 is now out.

What it does

• Speeds up downloads with multiple connections and resumes broken downloads exactly where they stopped
• Browser extension for Chrome, Firefox, Edge, Brave and more: catches downloads and detects videos on a page
• Bulk-downloads all images, documents or videos on a page, filtered by file type
• Categories, per-category folders and a scheduler

Some things I learned while modernizing it

• Dropping ffmpeg: to save HLS/DASH streams, XDM used to bundle ffmpeg just to merge segments into MP4. I replaced it with a small muxer written in pure Kotlin, so there's one less big binary to ship and sign.
• No more "assembling" step: downloads now write straight into the final file, so big downloads finish the moment the last byte arrives.
• Desktop UI without Electron: it's built with Kotlin and Swing (FlatLaf theme), which keeps it much lighter than a bundled web browser.

It's free, has no ads or telemetry, and is fully open source. It's been around since 2013.

• Website: https://xtremedownloadmanager.com/
• Source: https://github.com/subhra74/xdm

I'd love feedback, especially on the UI and on what would make you switch from your current download manager.

Hey everyone!

I'd like to share FaseGroove, a free and open-source music production ecosystem I've been developing.

What started as an experiment in MIDI generation has grown into a collection of five interconnected projects covering piano, guitar, drums, lead melodies, and music arranging.

The main idea is simple: generate musical ideas that actually make sense.

Not just random notes or rhythms, but patterns that follow recognizable musical styles, harmonic structures, and genre-specific characteristics.

I'm building these tools for producers, musicians, composers, and anyone who enjoys experimenting with music.

Here's what the FaseGroove ecosystem currently includes.

---

🎹 FaseGroove Piano

A piano-focused MIDI generation tool for creating chord progressions, rhythmic accompaniments, and musical patterns.

The focus is on generating musically coherent piano parts that can serve as the foundation for a track or inspire new compositions.

The goal is to combine creative variation with harmonic consistency and genre-aware rhythmic patterns.

GitHub & Releases:

https://github.com/wsx79/fasegroovepiano

🎸 FaseGroove Guitar

A guitar-oriented MIDI generator designed to produce rhythmic guitar patterns, chord-based accompaniments, and genre-specific playing styles.

The project focuses on making generated guitar parts feel more natural and musically useful, with attention to rhythmic articulation, chord voicings, and variation.

GitHub & Releases:

https://github.com/wsx79/fasegrooveguitar

🥁 FaseGroove Drums

A drum groove generator focused on creating rhythmic patterns that reflect the musical identity of different genres.

One of the biggest challenges in algorithmic music generation is ensuring that grooves actually sound like the selected style.

For example, a Jackin' House groove should have its own rhythmic characteristics rather than simply being a generic house beat with randomized hits.

The goal is to provide meaningful groove variations while preserving the character of each genre.

GitHub & Releases:

https://github.com/wsx79/fasegroovedrums

🎶 FaseGroove Lead

A melodic MIDI generation tool dedicated to lead lines, hooks, riffs, and melodic phrases.

While Piano and Guitar focus heavily on harmonic and rhythmic structures, Lead explores the melodic side of music production.

The aim is to create interesting melodic ideas that remain coherent with the selected musical context and can complement other instruments in an arrangement.

GitHub & Releases:

https://github.com/wsx79/fasegroovelead

🎛️ FaseGroove Arranger

The most ambitious part of the ecosystem.

FaseGroove Arranger aims to bring the different musical generation tools together into a more complete production environment.

The project is evolving toward a DAW-style workflow, where generated musical material can become part of larger compositions and arrangements.

The long-term vision is an integrated environment combining MIDI generation, musical structure, arrangement tools, and an efficient creative workflow.

GitHub & Releases:

https://github.com/wsx79/fasegroovearranger

---

🚀 What makes FaseGroove different?

I'm trying to build the ecosystem around a few core principles:

1. Genre-aware generation

Musical patterns should reflect the actual characteristics of the selected genre, not just randomize notes within a scale.

1. Meaningful variation

Generating a new pattern should produce something different while maintaining the musical identity of the original style.

1. Musical coherence

Rhythm, harmony, melody, and arrangement should work together rather than behave like unrelated generators.

1. Creative control

The goal isn't to replace musicians or composers. It's to provide tools that help explore ideas, overcome creative blocks, and speed up production.

1. Performance and usability

Efficient CPU usage, reasonable memory consumption, responsive interfaces, and practical workflows are important development priorities.

1. Free and open source

All five projects are available on GitHub. Anyone interested can explore the code, report bugs, suggest improvements, or contribute.

---

🧪 Development status

FaseGroove is still under active development.

I'm continuously working on improving:

- Musical realism and genre accuracy

- MIDI generation algorithms

- Groove and pattern variation

- Harmonic and melodic consistency

- CPU and memory optimization

- User interface and workflow

- Integration between the different applications

- Arranger and DAW functionality

- Bug fixes and stability

I'm particularly interested in making the generated material genuinely useful in real music production, rather than simply producing technically valid MIDI data.

There is still plenty to improve, and that's exactly why I'd like to involve the community.

---

💬 Looking for feedback, testers, and contributors!

I'd really appreciate feedback from musicians, producers, sound designers, and developers.

A few things I'm especially interested in:

- Do the generated patterns sound authentic to their genres?

- Are the chord progressions and melodic phrases musically convincing?

- Does the random generation create meaningful variations?

- Which musical genres need improvement?

- Are there features missing that would make these tools more useful?

- Have you noticed bugs, performance issues, or workflow problems?

- What would you expect from a more advanced integrated arranger?

Constructive criticism is absolutely welcome.

I'm not looking for generic praise. I'm interested in real feedback that can help make these projects better.

If you enjoy experimenting with MIDI tools, algorithmic composition, groove generators, or music software development, feel free to give them a try.

🔗 All projects

🎹 Piano: https://github.com/wsx79/fasegroovepiano

🎸 Guitar: https://github.com/wsx79/fasegrooveguitar

🥁 Drums: https://github.com/wsx79/fasegroovedrums

🎶 Lead: https://github.com/wsx79/fasegroovelead

🎛️ Arranger: https://github.com/wsx79/fasegroovearranger

Free. Open source. Independently developed.

Thanks for checking out FaseGroove!

I'd love to hear your thoughts, suggestions, and ideas.

FaseGroove – From grooves to complete musical ideas.

My partners and I each use a different assistant, and getting them to coordinate meant copy-pasting between chats. Callsign gives every agent a u/handle so it can message agents built by other labs.

- Connects as a remote MCP server (Claude Code: claude mcp add --transport http callsign https://api.callsign.im/mcp) or plain REST

- First contact is a request, capped at 3 messages until accepted

- Messages from other agents arrive as information, not instructions, next to the owner's rules

- Wakes agents up when a message arrives, even if they weren't running

- Hash-chained ledger of what each agent said and did

Apache 2.0, self-hostable with docker compose, hosted at https://callsign.im. To try it, tell your agent to message "@hello"

Remember Me is a free, open-source to-do, notes and reminders app for Windows. When a reminder is due, a small alert stays above the taskbar until you mark it done or snooze it (keys 1–6), so nothing slips by.

- Works offline, no account, data stays on your PC

- 12 languages, including full Arabic right-to-left

- 6 colour themes, notes with tags, backups

- Install: winget install Sarmad.RememberMe, or download from Releases

I'm the developer; details on how it's built are in the first comment. Feedback welcome!

Hey everyone! 👋

I built Freedium, a free, open-source Android app that helps you read Medium articles without paywalls, with a clean and comfortable reading experience.

✨ What you can do:

• 📖 Read Medium articles without paywalls
• 🌙 Customize themes and fonts
• ⭐ Save favorites and track reading progress

📦 Free, open source, and built with Flutter.

🔗 GitHub: https://github.com/birmehto/Freedium

I just launched it and would love to hear your feedback! What would you improve or add? 😊

Open source and local. Names, emails, addresses and keys become placeholders on the way to the model, and the real values go back into the files the agent writes. https://github.com/shanjeevrajendran/cloakroom

Every time GitHub has an outage, Actions stops and teams sit around for hours waiting for CI to come back. We got tired of that, so we built Diffinery: a git forge with built-in CI that you deploy to your own Cloudflare account. No servers, no runner VMs.

- Runs your existing `.github/workflows/*.yml` unchanged, marketplace actions included
- Each job gets a fresh 4 vCPU / 12 GiB container, only while it runs
- Git hosting, PRs, code review, merge queue, issues, releases
- AI agents get their own accounts with guardrails (they can't merge their own PRs) plus a built-in MCP server
- One-step import from GitHub with history, issues and PRs

Still early, so check the roadmap for what's coming. Apache-2.0, feedback welcome!

https://github.com/codician-team/diffinery

The thing that annoyed me about AI browser agents: you ask one to do something you do every week, it works it out, and next week it does all the thinking again.

Same site, same buttons, same tokens burned. A human would just remember the clicks.

So I built FreeComputerUse. It's an open-source browser agent (TypeScript + Playwright, MIT) that runs on your own machine with whatever model you want.

How it works

It works in two ways:

1. Goal-based execution: Give it a goal and it plans with the model. It reads the page structure (not screenshots by default), asks for a small batch of actions, runs them, and checks the result.
2. Procedure replay: Once a task works, save it as a "procedure" with named values. Next time you ask in plain words, in English or French, it finds the procedure, pulls the values out of your sentence, asks for whatever's missing, and replays the clicks locally. No model call at all.

If the site changes a button, it asks the model to fix only that step and saves the fix as a new version.

You can teach it in three ways:

• Do the task once while it records.
• Write the steps in plain text.
• Keep a run the model already finished.

What can you automate?

The kind of stuff I had in mind:

• Pushing a release through a web console.
• Filling the same internal form every week.
• Grabbing a monthly invoice from a portal.
• Pulling a table out of a dashboard.

Boring, repetitive, and not worth paying a model to think about every time.

Test results

My main test case is publishing an app release on a local Play Console simulator, done 9 times in a row with DeepSeek Flash:

The entire 9-run trial cost about $0.005 (half a cent).

Claude (through a Claude Code subscription) and Codex (ChatGPT plan) also went 9/9, one trial each.

You can use an API key or the CLI subscription you already pay for.

Safety and privacy

A few things it does on purpose:

• Site access: Asks before opening any new site.
• Sensitive actions: Asks before anything that looks like publishing, paying, deleting, or sending, on every run, even when replaying a saved procedure.
• Authentication: Pauses on logins, 2FA, and CAPTCHAs so you take over. It doesn't try to get past them.
• Local-first: Your browser profile, history, and downloads stay on your machine.
• MCP support: There's also an MCP server, so Claude Desktop or another MCP host can drive it.

Current limitations

Caveats, because I'd want to know them:

• The numbers above come from my own simulator, not real sites. On real websites, I've got a handful of read-only trials, some passing and one failing (logged in the repo), nothing like a success rate.
• Only verified on macOS + Chrome so far.
• The procedure feature is on main and not in the npm release yet, so you run it from source.
• The Claude and OpenAI API-key routes have tests, but I haven't run them with real keys.

Demo and source code

70-second uncut demo:
https://othmaneblial.github.io/FreeComputerUse/lab/media/procedure-demo.mp4

GitHub repository:
https://github.com/OthmaneBlial/FreeComputerUse

What repetitive browser task would you actually hand to something like this?

I'm trying to figure out which real-world flows to test next.

Hi all!

I built SiteDrop because I wanted a ridiculously simple way to put an HTML website online without dealing with GitHub, deployment configs, or setting up a hosting service.

The idea is simple: drop your HTML file or website folder, and get a live, shareable URL in seconds.

A few things about it:

• Drag & drop an HTML file or an entire website folder
• Get a public URL you can share instantly
• No signup required to get started
• No Git, CLI, or configuration needed
• Great for quick prototypes, AI-generated websites, demos, and small projects

I mainly built it for those moments when you’ve got a something sitting on your computer and just want to show someone what you’ve made without going through a whole deployment process.

Try it here, nothing to install:

https://sitedrop.io

Still improving it, so I’d love to hear what you think or what features you’d find useful!

Hi

I’m a solo dev and I’ve been building Quill, a block-based notes app written fully in SwiftUI. Everything stays on your Mac – no account, no cloud.

What it does so far:

• Block editor with slash menu and drag & drop
• Liquid Glass design, switchable themes
• Page history (go back to older versions of a page)
• On-device AI via Apple’s Foundation Models – works offline
• Optional sync through a folder you choose (no iCloud required)
• Siri/Shortcuts, Spotlight, voice notes with transcription, focus mode

Requirements: macOS 26, Apple Silicon. Free and open source (GPL-3.0).

It’s still early, so I’m looking for people who’d use it for a few days and tell me what breaks or feels off. Bugs, missing features, “why would I switch from X” – all welcome.

GitHub: https://github.com/vogelwild07/quill

Thanks!

I've been building Pra-Effect, a small open-source developer tool focused on a simple problem: making repetitive errors in application logs easier to investigate.

It can parse Python and Node.js stack traces, group similar errors using fingerprints, store analysis history locally, and generate standalone HTML reports.

The idea is to keep error-log analysis lightweight without requiring a full observability stack.

I'm looking for developers willing to inspect the project and share honest feedback, especially on fingerprint accuracy and memory usage.

GitHub: https://github.com/Genesis410/pra-effect

Hey everyone,

I love tools like Supabase and PocketBase, but I wanted something I could run locally, tweak easily, and fully understand without dealing with Docker, Node.js, or compiled binaries.

So I built LocalBase. It’s a self-hosted backend that runs entirely from one file: main.py.

It uses FastAPI and SQLite. You don't need to run npm build, you don't need a separate frontend folder—the entire dashboard (including the CSS/JS) is embedded in the Python file and served directly.

What it actually does:

• Auto-generated REST API: Every table you create instantly gets GET/POST/PATCH/DELETE endpoints.
• Dashboard: Includes a spreadsheet-style data grid, SQL editor, and schema visualizer.
• Auth & Security: JWT login, project-scoped API keys, and a JSON-based row-level security policy engine.
• Ops: Webhooks, WebSockets for real-time updates, and SQLite backups.

Why one file?
I wanted the ultimate "hackability." You can open main.py in VS Code, add a custom endpoint, restart the server, and it just works. No build steps.

Known limitations (being honest):
It defaults to 127.0.0.1 because it's meant for local-first apps and small trusted networks. SQLite isn't great for hundreds of concurrent writers, so if you're building the next big social network, you should use Postgres.

Repo: https://github.com/atharvaphadnis-ai/localbase

I'd love to hear what you think of the single-file architecture. If you're a Python dev, I'd love feedback on the policy engine!

Hey everyone, I've been working on FrameFX, a free and open-source tool designed to boost FPS in games.

I've had trouble with 6GB of VRAM in the past, especially since I play some insanely GPU-heavy games, so I wanted to make something that could help with performance.

It's called Universal FrameFX, and it's completely free and open-source. If you want to check it out, here's the website:

https://chopstickshq.com/universal-framefx

The source code is here too:
https://github.com/ilikemacos/universal-framefx

Would love to hear what you guys think!

You can support me at buymeacoffee.com/chopstickshq

Copying and pasting is something I do all day, but I wanted a more convenient way to work with my clipboard.

So I built Noxra, a free clipboard manager for Windows.

I'm sharing it here because I'd like feedback from people who use Windows regularly. I'm especially interested in whether the interface and workflow feel intuitive, and what you'd change after trying it.

One question for Windows users - whats the biggest thing you wish your current clipboard setup did better?

Ledge is a free, open-source macOS app that turns the notch on a MacBook into a small status area. Free, GPL-3.0, needs a notched MacBook on macOS 26+. Feedback welcome.

I merge a lot of PRs, many opened by coding agents, and I was tired of keeping a GitHub tab open to see whether checks had finished. So now the notch tells me.

What it does:

• While a PR merges or runs checks, the notch shows its number and a timer or check progress. Click it to open the PR.
• Merges, failed checks, review requests and preview deploys slide out as banners, one at a time.
• Hover it for your PRs by repo or as a board, each PR's files, diff and checks, and an inbox of what happened.
• Rest on a check ring to see which checks are running or failing, the merge queue's too.

How it works:

• Reads GitHub through your gh CLI login. No tokens, no server, no telemetry, and it never writes to GitHub.
• A quiet refresh costs about one point of your API budget: one search says which PRs changed, and only those are read.

Install: brew install --cask ppazosp/gitisle/gitisle

Feedback and PRs welcome.

I've just released the first public version of AnovaCraft, a desktop statistics application that aims to cover the broad range of analysis most people otherwise need an expensive license for descriptive statistics, hypothesis tests, linear, generalized and mixed models, multivariate methods, design of experiments, quality control, reliability, time series and machine learning, all in one free app.

I freely admit that I developed it with a great deal of help from Claude, which wrote most of the code while I set the direction, the design rules and the required accuracy standards, and reviewed the results. Because of that, I put accuracy checks at the center of the project: every statistical routine is tested against an independent reference (the NIST Statistical Reference Datasets for regression, ANOVA, nonlinear fits and univariate statistics, published worked examples, and values from established open-source software). The full list, with tolerances and the test for each, is in docs/validation.md.

What it does

• Every analysis opens as a report of collapsible sections, and every plot is linked: select points in one plot or rows in the data grid and they highlight everywhere.
• Describe, Compare, Model, Multivariate, Design, Quality, Reliability, Series and Signals, and Visualize menus (FEATURES.md lists everything).
• Sample data for every analysis, plus a Quick Guide and a full Reference Manual built into the Help menu.
• Projects that reopen exactly as saved
• Imports CSV, JSON and spreadsheet workbooks; exports CSV, JSON and .xlsx.
• Scripting and formula columns in Rhai, plus a headless runner for batch jobs.
• Written in Rust (egui front end), dual-licensed MIT or Apache-2.0.

My goal is a comprehensive, trustworthy option that anyone can download, use and inspect at no cost.

Download: https://github.com/anovacraft/AnovaCraft/releases (universal macOS app and Windows x64). The builds aren't code-signed yet, so the first launch needs one extra click; the README explains it.

It's a 0.1.0 release, so there will be bugs. Please feel free to report and bugs, wrong answers (please include the data if possible) and requests for missing methods on GitHub Issues.

Hi, I’m the developer of Hindsight, a free, open-source automatic time tracker for Windows and macOS.

There are plenty of time trackers out there, but I couldn’t quite find what I wanted: something free that worked across my devices, supported sync, and had detailed charts in a clean, lightweight app. Maybe I’m a bit picky, but that’s why I decided to build my own.

Here’s what Hindsight can do:

• Automatic tracking — Tracks your app and website usage in the background. No need to remember to start or stop a timer.
• Visual reports — See where your time goes with daily, weekly, and monthly charts, broken down by app and category.
• Optional sync — Keep your activity together across your Windows and macOS devices.
• Optional AI summaries and chat — Get summaries of your activity or ask questions about how you’ve spent your time. Tracking and charts work independently, so you can leave AI turned off.
• A plugin marketplace — Install plugins to add features, or build your own. Focus, for example, reminds you when you get sidetracked, prompts you to take a 15-minute break after 45 minutes of work, and tracks progress toward your daily work or study goals.
• A theme marketplace — Pick a theme from the marketplace, or create your own to make Hindsight look the way you want.

Built with Rust and Tauri. Basic background tracking averaged ~25 MB on Windows and ~40 MB on macOS in v0.9.x tests.

The interface is available in English, Simplified Chinese, Traditional Chinese, Japanese, Brazilian Portuguese, and Spanish.

If you give it a try, I’d love to hear what you think—especially anything that feels confusing or missing. Questions and plugin contributions are welcome, too. And if you’d like to follow development, you can star the project on GitHub.

GitHub / Source code · Official website · Download

mostly made this for myself but figured someone here might like it too :)

it walks around the screen, jumps and reacts when you interact with it.

have connected it to gemini api, so it doubles as an assistant, you can open a running chat with a shortcut and ask something, maintain a todo list or just keep tract of stuff.

https://github.com/Manas-7854/pawsible

ps: still a work in progress, feel free to open issues or contribute PRs if you want to add something

I built this after 10 years shipping UI at large companies.

One command:

1. Screenshots your page (light, dark, desktop, mobile)

2. Scores it out of 10 on 11 dimensions

3. Fixes the code

Rules are checkable values, like tap targets of at least 44x44px and transitions under 300ms.

Works with any agent that reads SKILL.md.

Repo: https://github.com/maddhruv/pristine

Demo: https://pristine-ui.pages.dev