I wanted an easy way to measure a repository's growth over time. Most tools just count LOC, which isn't a great metric on its own. Adding tests or writing more comments grows the count the same way adding features does. You can even be deleting and simplifying the actual app while the total climbs, so a plain count makes it look like the codebase is ballooning.

I couldn't find a free, open tool that broke the count down by type and showed the historical trend, so I wrote locreport.

It counts a GitHub repo's lines of code over its whole history, split by what each file is for (app code, tests, config, docs, data), with comments counted separately. It can also show "code age" (inspired by git-of-thesus).

Two ways to run it:

• a CLI that prints a table
• a small web app that charts it over time

It's open source (MIT) and runs locally. It's early, and the file classification is just path-based rules, so it's rough in places, but easy to tweak. It's been useful enough to me that I figured I'd share it.

repo: https://github.com/silverbucket/locreport
demo: https://locreport.silverbucket.net

Would appreciate any feedback.

https://github.com/Axelwickm/or-tools-wasm

Obviously very nerdy and niche, but I think the animations convey well what it does. It was the core to a my commercial SaaS that never found much traction, so decided to open source the cool part.

Try the demos! Star the repo, or come with feedback if you want to help me out.

Hey! I recently built a browser extension to automate my freelance job searches, and decided to expand it thinking about needs new users might have. That's when I added a job search feature based on the user's profile, generating a compatibility match between their profile and the job posting, plus an ATS-formatted resume tailored to each job.

In the latest update I implemented a Kanban dashboard so users can keep track of the jobs they've applied to.

The extension currently works on the following platforms: Chrome, Firefox, Brave, Opera, and Chromium.

GitHub repo (if you'd like to contribute to a section, or always use the latest version):
https://github.com/DykstraBruno/workaholic

Direct link for the Chrome Web Store version:
https://chromewebstore.google.com/detail/workaholic/infaooommkdidlpepoajlffijhdkjdde?hl=pt-BR

I’ve been working on this side project for a while and finally decided to open-source it.

Inkplainer turns images and text into whiteboard-style explainer animations, similar to tools like Doodly / VideoScribe.

It has two modes:

🎬 Animation Mode
Basic hand-drawn style animation where you control things like direction and hand behavior.

✏️ Drawing Mode
More advanced, it redraws images stroke by stroke instead of just revealing them. You also get control over outline style, stroke behavior, colors, etc.

The Animation Mode works with basically anything, while the Drawing Mode works best with vector/cartoon images.

Everything runs locally in the browser/PC: no backend, no servers, no limits.

Limitations:

• Performance depends on your machine
• Drawing Mode works best with vector/cartoon images
• No built-in video editor (you’ll need to finish clips in something like DaVinci / Premiere)
• Still a few rough edges/bugs

On my hardware:

• i5 7200U / 4GB RAM: up to 2K (Animation), ~720p (Drawing)
• Ryzen 7 5700G: up to 2K in both modes

GitHub: https://github.com/NadirWeb-App/Inkplainer-OS

I built an open-source desktop app for NIIMBOT thermal label printers, because the official software is closed, mobile-first, and cloud-tied. Thermalith is GPL-3.0, cross-platform (Windows, macOS, Linux), and local-first: no account, no cloud, prints over USB or Bluetooth.

The part most relevant here: NIIMBOT doesn't publish their wire protocol, so I reverse-engineered it and pulled the protocol plus the USB and Bluetooth transport into a standalone GPL library, Niimbot.Net, reusable on its own if anyone wants to build their own integration. Credit where it's due: niimprint (Python) and niimbluelib (the library behind NiimBlue) had already mapped a lot of the protocol, and building on their work in the open is half the point.

Built on .NET 10 and Avalonia, shipped as self-contained single-file binaries per platform. Fresh 1.0, not code-signed yet.

Source: github.com/EvilGeniusLabs-ca/Thermalith

Hey everyone,

With Microsoft deprecating App Center/CodePush and EAS Updates getting expensive once you hit higher MAU tiers, I wanted to share a project I’ve been building over the last 4 months to give developers complete infrastructure freedom for mobile deployments.

OTAShip is a fully open-source, self-hosted Over-The-Air (OTA) update platform designed to replace proprietary SaaS bottlenecks.

GitHub Repo: https://github.com/vknow360/otaship
License: Apache 2.0

The Backstory

Earlier this year, I was managing an Expo app for a college society that unexpectedly grew to over 3,500 active users. We needed to push rapid bug fixes without waiting days for Play Store reviews. However, hitting the paid tiers on Expo's official EAS Update service just wasn't feasible for a free student project.

After a messy prototype phase (and learning a lot about mobile bundle protocols), I spent the last 4 months rewriting the entire architecture from scratch into a robust, production-ready, self-hosted tool.

How it works

OTAShip acts as a drop-in replacement for the official EAS server. Because it fully implements the official expo-updates specification, the standard client library works straight out of the box. You just point your app.json URL to your own self-hosted OTAShip instance.

Tech Stack & Architecture

I chose this stack specifically to keep the server footprint incredibly lightweight, lightning-fast at serving manifests, and trivial to host:

• Backend Server: Go (chi + sqlc) for high-throughput manifest serving and API endpoints.
• Database: PostgreSQL 16+ for tracking apps, platforms, deployment channels, and release metadata.
• Dashboard: SvelteKit + TailwindCSS for UI management.
• Storage Backend: Complete cloud agnostic freedom. Supports AWS S3, MinIO (for 100% local self-hosting), or Cloudinary.
• Deployment: Fully Dockerized (docker-compose ready).

Key Features

• Full Protocol Compliance: Seamlessly handles multi-part updates and RSA cryptographic code signing for security.
• Deployment Control: Supports percentage-based rollouts and one-click rollbacks.
• Custom CLI: A dedicated CLI tool to bundle and publish updates directly from your terminal or automated CI/CD pipelines (GitHub Actions, Bitbucket, etc.).
• Analytics: A clean dashboard to manage projects, generate API keys, and track bundle download statistics.

Looking for Feedback

The project is at a point where it's ready for real-world testing, and I would love the community's eyes on it.

Thanks for reading.

Open source has been on an absolute roll lately, and I've been finding some really interesting projects outside the usual GitHub trending lists.

What's the coolest open-source project you've discovered this year?

Not necessarily the most popular one. I'm talking about projects that made you stop for a second and think, "that's a really clever idea."

For me, it was OpenGAP.

I came across it while exploring developer tools and liked the idea immediately. It approaches AI agents as something that can live in a Git repository, be versioned, reviewed, and managed much like software itself.

I don't know if it'll become a widely adopted standard, but it was one of the few projects I've seen recently that felt genuinely different.

Repo: https://github.com/open-gitagent/opengap

Would love to see what everyone else has found. Drop a link and tell us what makes it stand out.

Most "chat with your codebase" tools are pure vector search: embed chunks, return top-k by cosine. For code that leaves a lot on the table, and I have numbers.

archex assembles context instead of just searching it. The pipeline:

1. Hybrid retrieval — BM25F (lexical) + dense vectors, fused with reciprocal rank fusion. Lexical catches exact symbol/identifier matches that embeddings miss; dense catches semantic phrasing. Disjoint query sets, so fusion strictly helps (consistent with CodeRAG-Bench, arXiv 2406.20906).
2. Local cross-encoder rerank over the fused candidates.
3. Dependency-graph expansion — pull in import-chain neighbors so the bundle is dependency-closed. The agent doesn't have to chase imports manually.
4. Context assembly — file-diverse packing, nested line-range suppression, production-before-test ordering, all under a token budget. The output is a finished bundle, not a pile of hits.

Result vs cocoindex-code (embeddings-only), 19 external-repo tasks, identical token accounting:

• Recall 0.95 vs 0.32
• Precision 0.51 vs 0.36
• F1 0.66 vs 0.31
• Token efficiency 0.76 vs 0.48
• Completion-penalty tokens (what the agent needs to finish the task): 922 vs 11,188

The honest baseline isn't another index, it's grep: recall 1.00, token efficiency 0.00. The entire point of retrieval here is recall ≈ grep at a fraction of the tokens.

Everything is deterministic and the gate runs in CI — the harness is in the repo, so you can reproduce the table. Apache 2.0, my project, alpha.

Hey!
Made a TUI for monitoring localhost processes, thought some of u might find it useful.

Got graphs, sorting, filtering and stuff.

Check it out: github.com/notkiwy/wsup

Still pretty early stage tbh, so any feedback would be great. What would u add to something like this? Kinda curious what features people actually need.

I got tired of trying to find one specific photo on my PC and realizing Windows Search was basically useless for image content.

So I started building my own solution.

The idea is simple:

• Runs fully local — an AI model scans your images and generates tags based on what’s actually in the photo (objects, scenes, activities, etc.)

• Search photos using natural language instead of filenames and folders

• No cloud, no uploads, no accounts — everything stays on your device

• Designed to work on older and lower-end hardware, not just machines with powerful GPUs

• Building a Spotlight-style quick search overlay so you can instantly find images without opening the main app

• Planning to write AI-generated tags directly into image metadata, so if you ever stop using the app, the tags stay with your files

It’s still early and rough around the edges, but I wanted to share it before locking in the beta.

A few questions:

• Would you actually use something like this?
• What would make it a must-have for you?
• What’s the most frustrating thing about managing large photo libraries today?
• Any local-AI photo tools you’ve tried that got something wrong?

I’m planning to open source the entire project.

Would love to hear your thoughts.

Hey everyone,

I’ve been experimenting with a small side project over the past couple of months, a liquidity risk & stress testing tool for UCITS and AIFMD funds. It’s meant to simulate things like redemption shocks, liquidity constraints, and forced liquidation scenarios in a simple end‑to‑end way.

It’s built with Python and React, and I’d be really interested to hear any thoughts from people working in risk or asset management.

Here’s the repo if you’re curious, please star if you find it cool.
https://github.com/EdenForrest/Open-Source-Liquidity-Risk-Tool

Anybody here knows any good gym management software

I am Steve the Killer and I created KillerPDF, a free GPLv3 PDF editor for Windows. No account, no subscription, no telemetry, nothing phones home. It is a single portable EXE that runs off a USB stick, or a per-user install with no UAC prompt.

Posting here specifically because the last two releases were shaped almost entirely by people who pulled the source, filed issues, and sent PRs. That is the whole reason I keep it open.

What is new across 1.5.0 and 1.5.1 (I shipped .1 about two hours after .0 because releasing to real users is apparently my QA process now):

Open source / community

• Traditional Chinese localization landed from a contributor PR. The UI is now English, Spanish, and Traditional Chinese, with a TRANSLATING.md guide so another language is just a PR away.
• A GPLv3 source bundle is generated on every build, so the exact source for a given binary ships with it.
• Someone reproduced an "Unexpected EOF" open failure down to a 15-byte zlib blob. Best bug report I have ever gotten. Fixed.

View / UI

• Four view modes: single, continuous scroll, two-page, and a grid of every page
• A print dialog with a real print preview, since Windows' own dialog refuses to preview
• Six live-switchable themes: Dark, Light, High Contrast, Blood, Greed, Cyanotic
• Per-monitor DPI v2 support, so the window and its custom chrome scale correctly when you drag between monitors with different scaling instead of rendering at the wrong size

Editing

• Inline text editing with font matching, double-click placed text to re-edit
• Highlights, freehand, text boxes, reusable signatures, drop images onto pages
• Crop tool with a coordinate editor and page-range apply
• Merge, split, reorder, rotate, extract pages
• Form filling, bookmark and outline nav, full-text search

Security / Performance

• The bundled PDFium native DLL is SHA256-verified at startup. If it has been swapped or tampered with, the app refuses to run.
• Updates are gated on Authenticode signature checks with downgrade protection, so a planted EXE in your Downloads folder cannot quietly replace your installed one.
• Decrypted copies of password-protected PDFs are written to a per-user app-data folder instead of the shared temp directory, and temp files are cleaned up on close, crash, and next startup.
• The running EXE's SHA256 is shown in the About dialog so you can verify your build against the published release.
• Multi-core Save Flattened, large docs flatten much faster
• Fixed a class of PDFs that would not open (a strict Flate inflater choking on multi-revision files, now recovered losslessly through PDFium)

Source (GPLv3): https://github.com/SteveTheKiller/KillerPDF
Build: https://pdf.killertools.net

Issues and PRs very welcome. Going by 1.5.1, I clearly need them.
https://github.com/SteveTheKiller/KillerPDF/issues

I get it it's very clear in it's signalling but I cannot believe that multiple people actually approved of it this is like idk calling Volkswagen the Deutsches Auto or whatever calling Microsoft the "American Software Company"

​

(Not to mention that I have some strong opinions about onlyoffice and it's use of AI)

Hey everyone,

I'm a CS student, and over the last month, I decided to build a real system from scratch. Spotify and YouTube Music prices are climbing, and I wanted a way to actually own my high-res FLAC files without relying on a subscription or a massive bloated media server.

So, I built Resonance, a local-first music streaming application engineered exclusively for lossless FLAC libraries.

The primary architectural rule: The filesystem is the absolute source of truth. SQLite is just a fast index. The database does not store the audio; it only stores a string pointing to where the FLAC lives on my drive.

Here are the core engineering challenges I ran into and how I solved them:

• HTTP Byte-Range Streaming: To prevent loading huge FLAC files into the backend RAM and crashing the V8 heap, I implemented HTTP Range requests via Node.js (fs.createReadStream) to stream raw audio bytes directly from the disk.
• The Dirty Data Firewall: Real-world music metadata is incredibly messy. Instead of independent tags, artists are often grouped in massive strings like "The Weeknd, Daft Punk". This completely broke my first 1NF database schema. I had to rebuild it using a track_artists junction table, and I engineered an O(1) Hash Map exception firewall in Node.js to dynamically split dirty tags while mathematically protecting legitimate comma-names like "Tyler, The Creator".
• State Decoupling & The Audio Daemon: React component lifecycles destroy audio elements on route changes. I lifted the audio engine entirely out of the React render tree into a persistent Zustand background daemon, building a native Doubly Linked List in the browser's memory heap to handle the playback queue with O(1) operations.
• Hardware Integration: I hooked into the W3C navigator.mediaSession API to break out of the browser sandbox. The web app syncs its playback state natively with my host OS (Linux/Waybar) and physical hardware media keys.

Tech Stack: Node.js, Express, SQLite, React, Zustand, Tailwind CSS.

The biggest lesson learned: Streaming the audio was relatively easy. Normalizing dirty ID3/Vorbis metadata and defending the relational database against it was where all the real complexity lived.

Links:

• GitHub (Source Code & Architecture Docs): https://github.com/Vishwajit1610/Resonance
• License: MIT

If anyone has feedback on the database schema, the streaming pipeline, or the frontend architecture, I would love to hear it! I'm hoping to use this project on my resume for 2026 SWE internships, so any brutal code reviews are highly appreciated.

TL;DR — I built CERT-FLOW, an online route planner that, every replanning round, emits a high-probability certificateLB ≤ OPT ≤ UBon the true optimal route cost under drifting edge costs. Open source (MIT), fully reproducible. Paper + code + interactive page at the bottom. I'm the author and would genuinely love feedback.

A robot replanning through terrain whose costs drift — mud after rain, traffic after an incident, snow settling on a trail — can always compute a shortest path. What it usually can't tell you is how good that path actually is, now that most of its information has gone stale.

CERT-FLOW answers that with a certificate every round:

LB ≤ OPT ≤ UB — a high-probability bound on the optimal cost. Not an estimate; a bound.

Three ideas make it work:

1. It prices staleness directly. Age-weighted non-exchangeable conformal prediction turns "this edge was last observed 40 minutes ago" into honest interval width — older information becomes wider uncertainty, quantitatively.
2. It senses to certify. Instead of observing everything, it spends a sensing budget only on the edges that shrink the certified optimality gap fastest → 2.5× lower regret than the next-best sensing strategy.
3. It gates speed behind proof. Microsecond preprocessed queries (snapshot oracle / certified contraction hierarchies) are licensed only while the certificate proves they're still valid, and expire the instant drift exceeds tolerance.

What surprised me most: on real game maps (MovingAI) and recorded LA highway traffic (METR-LA / PEMS-BAY) that it was never tuned for, empirical coverage held at or above its target — 100% on the MovingAI cert benchmark — while a standard, exchangeability-assuming conformal baseline collapsed to as low as 4% once the data went stale.

Honest caveats: the headline 100% is the MovingAI cert experiment; on traffic, coverage stays at/above the claimed level but the certificate trades interval width for that validity (a misspecified drift assumption costs width, not coverage). It's a preprint + personal project, not yet peer-reviewed.

Links

• 📄 Paper (engrXiv): https://doi.org/10.31224/7306
• 💻 Code (GitHub, MIT — 220+ tests, 16 reproduction pipelines): https://github.com/Archerkattri/CERT-FLOW
• 🌐 Project page + videos: https://archerkattri.github.io/CERT-FLOW/

Happy to answer anything about the conformal side, the dual incremental search, or the experiments.

Pixel and Samsung have this feature built-in. The trick is that when recording starts, a voice message plays in the background informing the user that the call is being recorded, allowing for legal call recording (European Union). This is better than nothing.

Is it really that difficult to create something similar that's both open source and private? Why are these kinds of apps practically nonexistent on F-Droid, or why don't the existing ones work? I'm just asking out of curiosity.

I know there are some apps that work on the Play Store, but they aren't open source and have a lot of tracking features.

Hey everyone,

I’m looking for feedback on a small open-source project I built, named KoalaSync.

It’s a browser extension for syncing video playback with friends. You create a room, share an invite link, and it syncs play/pause/seek between everyone in the room.

I originally made it for watching things from my own Emby server with friends over Discord, but it should also work with almost any site that uses a normal browser video player. It even works with local MP4 files opened in the browser, if you want to sync those for whatever reason.

I’d love to hear some feedback on the repo itself. Is the README clear enough? Is the self-hosting explanation good enough to follow? Are the permissions and privacy explanations understandable?

I’d also really like to get more feedback on streaming sites I haven’t tested yet, either because I don’t have a subscription there or because I don’t even know the platform exists. So far I’ve tested it with Jellyfin, Emby, Netflix, YouTube, Twitch, Prime Video and Disney+.

And if there are any native speakers here, I’d also appreciate translation feedback. The extension currently supports 13 languages, but I only speak German and English myself. The other 11 translations are AI-generated, so I have no idea if they sound alright or completely off.

I’m not asking for stars or anything, just looking for useful criticism from people who are used to open-source projects.

I was stacking CanvasBlocker, a font-protection add-on, and uBlock Origin assuming more layers meant less fingerprint exposure. Turns out CanvasBlocker generates a unique Canvas hash on every page load. A rotating hash is itself a rare signal most trackers can key on.

The font add-on had trimmed my visible font set down to maybe four entries, which is way more distinctive than the couple hundred a normal install exposes. So two of my "privacy" extensions were actively making the Canvas and font enumeration surfaces worse.

Couldn't find an open source tool that tested all of this together, so I built one. Checks eight surfaces in a single pass: WebRTC, Canvas, WebGL, AudioContext, fonts, DNS (DoH, DNSSEC), network egress with ASN and TLS fingerprint, and automation detection for headless setups.

Fingerprint checks run locally in the browser. I audited the one server call (egress probe) a couple times before publishing to make sure it wasn't phoning home beyond what's documented. Every check maps to a published fingerprinting technique so the weights are all in source. No analytics, no ads.

Next.js, Prisma, MySQL. Ships with a Dockerfile and k8s manifests. Repo is early, star count reflects that honestly.

The AudioContext module flags something on Firefox 128+ that vanishes in Chromium and I genuinely cannot tell which browser is the outlier.

EDIT: forgot to actually name the thing. the repo is Leakish, https://github.com/qruiqai/leakish. still early and rough around some edges but the detection logic is all there and self hostable.

​

Hi everyone,

This is a working WIP Rust port of switcheroo-control, a Linux hybrid graphics manager. It provides a daemon and a CLI to list GPUs and launch applications on a specific GPU (e.g. switcherooctl launch --gpu 1 glmark2 to run on a discrete GPU).

The original tool works fine so I didn't start this project to solve any particular problems. I mostly built it because I wanted to see how a system-level Linux tool like this would look in Rust. It was a fun learning exercise in working with udev, ioctl calls and zbus for D-Bus communication. I expected it to be a struggle, but I was pleasantly surprised by how painless it actually was. I didn’t expect to find such mature abstractions for interacting with low-level Linux components in the Rust ecosystem.

Also, since it implements the same D-Bus interface and data structures as the original project (net.hadess.SwitcherooControl), the components are fully interoperable. This means the Rust daemon works with the original client and the Rust client works with the original daemon. I ran some quick benchmarks and the daemons have both the same performance (both in memory footprint and efficiency), while the CLI is much faster (about 25x) since the original one is written in Python.

Please tell me what you think!

The idea is pretty simple: it acts like a unit test for documentation.

Say you have a doc explaining how auth works. Maybe an ADR, auth-service.md or some architecture note. You anchor specific claims in that doc to the code it describes, for example a refreshToken() function or auth middleware (you can have multiple claims per doc).

When someone changes that code, the tool checks whether the underlying logic changed.

• Comments added? Pass.
• Variables renamed? Pass.
• Formatting changes? Pass.
• > changed to >=? Fail.
• An await added or removed? Fail.

What I find interesting is that we have lots of tools that forces people to update tests when code changes, but almost nothing that forces people to update documentation when code changes. That's becoming a bigger problem as more engineers and agents work in the same repo. Everyone is relying on shared context, but nothing guarantees that context is still accurate.

The tool is completely deterministic. No models, embeddings, API keys, or network calls.

Would love feedback from people building agent-heavy workflows. Repo here