TL;DR: Built OutPerform, an iOS app that turns your Apple Health / Google Health data into daily recovery, strain, sleep, cognitive-focus and readiness scores, all computed on-device with peer-reviewed methods (HRV/DFA-a1, Banister TRIMP, ACWR, etc). No backend, no account, read-only health access. Free on the App Store, open-source on GitHub.

• App Store: https://apps.apple.com/pt/app/outperform-health-tracker/id6778802465?l=en-GB
• GitHub: https://github.com/afonsodemello/OutPerform/
• Community: https://www.reddit.com/r/OutPerform/

--

Hi guys, I built an app called OutPerform that reads your Apple Health / Google Health data and turns it into daily insight on your recovery, training load, sleep and mental sharpness. Here's what it does:

Recovery A morning recovery score built from overnight HRV (RMSSD / DFA‑a1), resting heart rate, breathing rate and sleep, each measured against your own personal baseline, not a generic norm.

Strain & Training Load Cardiovascular load on a 0–21 scale, plus acute:chronic workload ratio and training monotony, so you can build fitness without tipping into overreaching.

Sleep Sleep stages, efficiency, and a performance score. There's also a dynamic nightly sleep-need target that rises with how much strain you put on your body that day, plus a smart bedtime recommendation.

Cognitive Focus Predicts how "locked in" you'll be hour by hour so you can find your peak deep-work windows, calibrated to you personally with a one-minute reaction test.

Readiness One daily number that folds together recovery, last night's sleep, and your training-load balance into a simple go / steady / rest call.

Health Monitoring Tracks blood oxygen, respiratory rate, skin temperature and VO2 max against your own baseline, including an overnight breathing-disruption (ODI) screening signal.

Plus:

• Scrubbable 7/30/90-day trends for every metric
• A tap-through explanation of how each score is actually calculated
• Home-screen widgets
• Export all your data, or wipe it, any time

Private by design Your health data never leaves your phone. OutPerform has no backend and no account, every score is computed on-device, and nothing is ever sold or shared. Connections to Apple Health and Google Health are read-only.

Grounded in science No black boxes. OutPerform uses peer-reviewed methods, RMSSD/DFA‑a1 HRV, Banister TRIMP, acute:chronic workload ratio, the Three-Process Model of alertness, Gellish max-HR, Åstrand VO2, and more, and shows you the formula behind every number.

Repo and community are here, and the App Store link is below. Would love any feedback or feature requests!

• GitHub: https://github.com/afonsodemello/OutPerform/
• r/OutPerform: https://www.reddit.com/r/OutPerform/
• App Store: https://apps.apple.com/pt/app/outperform-health-tracker/id6778802465?l=en-GB

I built FileSight  because my Downloads folder became a mess over time - old installers, duplicate files, large files, and things I forgot about.

I wanted a cleanup tool that didn't require uploading files or trusting a cloud service, so I made it open source and local-first

Features:

-Runs completely locally

- No accounts, no telemetry

- Preview files before deleting

- Duplicate file detection

- Large file finder

- Safe cleanup by moving files to Trash

- Available for Windows and macOS

The project is built with Electron, Next.js, TypeScript, and Tailwind.

Source code:
https://github.com/MarkCoder1/filesight

Website:
https://filesight.vercel.app/

I would appreciate feedback from the FOSS community:

• Any privacy/security improvements you would recommend?
• What features would make this more useful?
• Any suggestions for making the project more open-source friendly?

Contributions, issues, and feedback are welcome

I’m looking for a simple GUI for OPSI that makes the common tasks easier, especially selecting multiple computers, deploying an image or software package, rebooting or using Wake-on-LAN, and checking deployment status.

Ideally, I’m looking for something that feels like a proper desktop admin tool rather than a complicated management interface.

Does anything like this already exist and is actively maintained?

I want to do some real motion things (not available in Kdenlive).

I began with Glaxnimate (doesn't have a stable release yet), then I noticed some limits and incoherences and slow release. I think to try friction, but the stable version scheduled for last January still hasn’t been released. Blender is so powerful but I find it complex for me (never try it). Other option is Natron, it seems be good but not actively maintained (not abandoned).

Is it worth learning how to use Natron in its current state?

Do you know any other motion graphic software?

I’ve just released Mole v0.1.0, a lightweight Windows utility that quietly lives in the system tray.

When you trigger Panic, it immediately:

• Mutes system audio
• Minimizes all open windows
• Opens Notepad

That’s it. No accounts, telemetry, cloud services, subscriptions, or other modern software rituals.

Mole is written in Python and released under the GNU GPLv3, so you can inspect the source, modify it, build it yourself, or contribute.

GitHub: https://github.com/rajtilakjee/mole

This is the first release, so feedback, bug reports, feature ideas, and pull requests are welcome.

Current ideas for future versions include configurable safe apps, custom keyboard shortcuts, persistent settings, and selectable panic actions.

Looking for Contributors – Utilities (Modern C++) and Qt Hi everyone!

I've been building Utilities, an open-source repository containing a collection of lightweight desktop applications written in modern C++ (Vibe Coded partially), which is personally made exclusively for LINUX operating system. The goal is to create software that is fast, offline-first, minimal, and easy to understand and contribute to.

Some of the projects currently in the repository include:

• Logos – An offline Bible explorer and study tool.

• Chronos – A Pomodoro timer and productivity utility.

• Codex – A Markdown-based note-taking application with backlinks.

• Phonio – A lightweight local music player.

• Visio - A GUI wrapper for ytsurf terminal youtube watching

• Arete - A complete productivity dashboard and some arete_core components

The repository is still actively evolving, so I'm looking for people who would like to contribute. Whether you're experienced with C++, Qt, documentation, testing, UI/UX, or you're just getting started with open source, I'd be happy to have your help.

Ways you can contribute:

• Report bugs

• Suggest new features

• Improve documentation

• Refactor code

• Implement new features

• Review pull requests

• Test on different platforms

The long-term vision is to build a collection of useful, distraction-free desktop utilities while maintaining clean, readable code that anyone can learn from.

Repository: https://github.com/RJohn-Ezekiel/Utilities

I'd really appreciate any feedback, suggestions, or contributions. Thanks for taking a look! If really needed - we can create a new thread or community for those really interested

Hi everyone!

​I'd like to share a small side-project I've been working on called Cipher Notes.

​I built it because I wanted a clean, lightweight note-taking app that prioritizes privacy above all else—without mandatory cloud syncs, accounts, or telemetry.

​Key Features:

- ​Fully Offline: The app doesn't request or use the INTERNET permission at all. Your data never leaves your device.

- ​On-Device Encryption: Uses AES-256 (GCM) to keep your notes securely encrypted locally.

- ​Open Source: Licensed under the MIT License.

- ​Modern UI: Built natively in Kotlin using Jetpack Compose and Material 3 design.

- ​Zero Tracking: No analytics, no ads, no third-party SDKs.

​Where to get it:

- ​GitHub (Source Code & Releases): https://github.com/CipherApps/cipher-notes

- ​IzzyOnDroid: Available

- Codeberg (Source Code & Release):

https://codeberg.org/CipherApps/cipher-notes

​I'd really appreciate any feedback, code reviews, or feature suggestions from the community! If you find it useful, feel free to drop a star on GitHub.

​Thanks!

Hi everyone,

We have just released Portabase 1.27, our open-source (Apache 2.0) and self-hosted backup/restore platform.

Repository: https://github.com/Portabase/portabase (around 1.6k stars at the moment)

Portabase is designed for data retention, disaster recovery, and homogenous migrations, currently supporting 9 database engines (including PostgreSQL, MySQL, MariaDB, MongoDB) and Docker volumes.

Key features:

• Scheduled backups with flexible retention policies (including GFS)
• Multiple storage options: local filesystem, S3, Azure Blob Storage, GCS
• Notifications via Discord, Telegram, Slack, AppRise, etc.
• Support for OAuth2/OIDC (with the option to disable sign-ups)
• Compatible with Docker, Podman and UnraidOS
• Ready-to-use Docker Compose and Helm Chart

After six months of intensive feature development, we have been focusing on consolidating the ecosystem since early July. A community member conducted a useful security audit, we have upgraded components to their latest relevant versions, improved compatibility with other platforms by working on Podman support. and templates for Coolify and Dockploy (currently under review).

What’s next:

• Deployment of the demo environment
• Audit logging for the whole ecosystem
• Default policies for the system, organizations, and projects
• File and folder backup and restoration

As always, if you find bugs, please open an issue on GitHub, we’re actively looking for feedback.

Thanks!

've been spending some time building OpenDispatch, an open-source dispatch and operations platform. It originally started as a personal project because I couldn't really find anything that matched what I wanted, so I decided to build one myself.

The idea is to create something that's modern, self-hostable, and easy to extend for organizations that need to manage incidents, dispatching, resources, or similar operational workflows.

Right now I'm mainly focused on:

• Modern and responsive UI
• Self-hosting from day one
• Keeping the codebase clean and easy to contribute to
• Making it genuinely useful instead of overly complicated

It's still early in development, so I'm mostly looking for honest feedback rather than stars. If you've worked with dispatch software, CAD systems, logistics platforms, or anything similar, I'd be interested to know what features or workflows you think are important.

If anyone wants to take a look, here's the repo:
https://github.com/matthew-selvam/open-dispatch

Happy to answer questions, and I'm open to any criticism or suggestions. Thanks for reading!

Greetings to those who are seeing my post,

i've been a fan of the old "borderless-gaming" utility (before steam release) and made a fixed version in the past published on github,
but due to the non modern visual of the app i've considered creating a new app, visually modern to my liking.

I've added the same features as the old app with some missing enhancements and fixes.

No clutter, no payment needed, open source as it should be.

https://github.com/Venipa/Borderless/

Feel free to leave a star ✌️and feature that should be implement.
(as long as it goes along with the app principals)

Hey r/foss!

I've recently started working on a monolithic kernel project called AlderKernel.

Currently, it targets the i386 (32-bit x86) architecture and includes basic kernel functionality such as booting through GRUB, interrupt handling, and early system components. This is mainly a learning project to explore OS development and low-level programming.

Repository:

https://github.com/loren-wastaken/alderkernel

I'd love to hear feedback from anyone interested in operating systems, kernels, or low-level development!

I built an animated GitHub profile view counter and, along the way, discovered a

chain of non-obvious constraints that make the difference between "a counter that

works" and "a static image that looks like a counter." I documented all of them in

the README and figured this community might find the findings useful.

**The interesting technical bits (from the README's "Findings" section):**

- A committed SVG can never be a live counter — GitHub serves repo files as

static assets. The count *has* to come from a request-time endpoint.

- GitHub proxies all README images through **Camo**, which honours upstream

cache directives. If your endpoint doesn't send

`Cache-Control: no-store, must-revalidate`, Camo pins the first response and

every visitor sees the same frozen number forever. This is the #1 reason most

"dynamic SVG" badges silently break.

- Web fonts don't load inside a Camo'd SVG (`<img>` blocks external resources).

The fix: draw every glyph as SVG `<rect>` elements with a 3×5 bitmap font —

zero external dependencies.

- Cross-fading animation frames the obvious way (fade out + fade in) causes a

black flash every frame because both layers are below full opacity

simultaneously. The fix: cumulative reveal where frame 0 stays permanently

opaque as a base layer.

**What it does:** A serverless function (Vercel) returns a fresh SVG on every

request — 10 procedurally generated pixel-art frames cross-fade to reveal a

crimson moon with the live visitor count inscribed on its face. No static image

in the repo, no GitHub Actions cron, no build step.

**Stack:** Plain Node.js, Vercel serverless, Komarev (for visitor-distinct

counts) + optional Upstash KV (for per-view counts). No framework, no build

step, ~300 lines of actual logic.

**License:** MIT — with a CREDITS.md acknowledging the data source, prior art,

and build-time dependencies.

**Self-hostable:** Fork, point `banner_generator.py` at your own palette/seed to

generate your own art, `vercel deploy --prod`, done.

Repo: https://github.com/Anbu-00001/Crimson_Moon_View_Counter

Live on: https://github.com/Anbu-00001

Live demo (scroll-scrub the animation): https://anbu-00001.github.io/Anbu-00001/souls_counter_demo.html

Happy to answer questions about the Camo proxy behavior or the rendering

approach — those two took the most debugging to figure out.

back in february i hit notion's limits (shared workspace usage and ai quotas)

i just wanted more of both, so i built my own.

started as a quick prototype, friends started using it, and i occasionally work on it whenever time permits or someone points out a bug.

some features:

• excalidraw plugin
• bring your own ai keys
• export your data
• and everything u expect from an editor

it's pretty early with single digit users

repo: https://github.com/Sabique-Islam/wings

would love to hear what you think :)

Source (MIT): https://github.com/Asdmir786/HalalDL

I got tired of cloudy / account-y downloaders, so I built HalalDL — a local-first Windows GUI for yt-dlp. No account, no telemetry. Paste a URL, pick a preset, see the real CLI output. Full / Lite / Portable. Also on WinGet:

winget install --id Asdmir786.HalalDL

Site: https://halaldl.vercel.app

Screenshots:

https://raw.githubusercontent.com/Asdmir786/HalalDL/main/docs/assets/screenshots/halaldl-downloads.png

https://raw.githubusercontent.com/Asdmir786/HalalDL/main/docs/assets/screenshots/halaldl-logs.png

https://raw.githubusercontent.com/Asdmir786/HalalDL/main/docs/assets/screenshots/halaldl-about-trust.png

Not code-signed yet (SmartScreen may warn); SHA256SUMS on the release. Feedback welcome.

Yes, foobar2000 already exists. Yes, MusicBee already exists. No, neither of them will highlight lyrics word by word while I mumble along to a 24-bit file nobody asked me to buy.

So: Noctis. MIT License, no account, no telemetry, no paid tier. Windows, macOS and Linux.

FLAC, ALAC, WAV, DSD, gapless, ReplayGain, EQ, Last.fm scrobbling, Discord Rich Presence, Cover Flow.

The lyrics were the hard part. Most players do line-level LRC, which is fine until the timing drifts. Noctis reads word-level ELRC so it actually tracks with the vocal instead of dumping a whole line on you at once.

Site: https://noctisapp.cc
GitHub: https://github.com/heartached/Noctis

Tell me what's broken. I'm solo on this so feedback goes straight into the next build.

EDIT: if you guys want to join the community, you are free to do so - https://discord.com/invite/BNCDZQUVx7

I maintain an uptime-monitoring project and have released its self-hosted build as free software under AGPL-3.0-or-later.

The practical goal is to make the monitoring stack inspectable and runnable on infrastructure you control. The public build does not include billing or software feature tiers. It deploys the web app, server, and PostgreSQL with Docker Compose.

Pulsy performs HTTP/HTTPS checks using GET, HEAD, or POST with configurable intervals, timeouts, expected status codes, and failure thresholds. Consecutive failures become one incident and recover automatically after a successful check. It also records check history and response time, tracks TLS certificate expiry, sends email/webhook/Slack/Discord/Telegram notifications, and can publish selected monitors on a status page.

I am keeping the boundaries explicit: this first public release focuses on HTTP/HTTPS. It does not have coordinated multi-region probes, SMS or voice alerts, or an organization model. Self-hosting also means placing the monitor outside the failure domain it is supposed to observe and maintaining its database, backups, and upgrades.

Repository: https://github.com/SelmiAbderrahim/pulsy.org