EyeOfWeb is a new open-source facial analysis and OSINT platform, an alternative to Pimeyes.
https://github.com/MehmetYukselSekeroglu/eye_of_web/

https://redd.it/1qdg0k5
@r_opensource

Made a small Python tool to scan repos for secrets/junk + install a pre-commit hook

## What My Project Does
repoclean is a small Python CLI tool that helps you scan a repository for common hygiene issues and potential secret leaks before committing/pushing to GitHub.

It can:
- scan for common junk artifacts (e.g., __pycache__, *.pyc, build/dist, etc.)
- scan for potential secrets/token patterns
- remove junk safely (optional)
- run in CI mode with correct exit codes (`repoclean ci`)
- install a Git pre-commit hook (`strict`/`warn` modes)

GitHub: https://github.com/tkwind/repoclean

PyPI: https://pypi.org/project/repoclean-cli/

## Target Audience
People who push code to GitHub and want to avoid accidental leaks / messy commits:
- students / beginners building projects
- freelancers shipping client repos
- small teams wanting a lightweight hygiene check
It’s intended to be usable in real repos + CI pipelines (not just a toy noscript).

## Comparison
There are tools like pre-commit, detect-secrets, gitleaks, and gitignore templates.
repoclean is different because it combines a few “repo sanity checks” into one simple CLI:
- repo junk scanning + optional cleanup
- secret pattern scan
- a single CI command (`repoclean ci`)
- pre-commit hook install without needing to set up pre-commit configs

I’d love feedback from maintainers on patterns to detect / checks to add.

https://redd.it/1qdhls8
@r_opensource

Logtide (Previously Logward): A self-hosted observability platform (AGPLv3). 2-month update.

Hi r/opensource,

Two months ago, I released Logtide to offer a self-hosted alternative to Datadog and Splunk, focusing on data ownership and GDPR compliance.

I wanted to give a quick update on where the project stands and why I made certain choices (especially the license).

**The Project:** It's an observability platform that handles logs, traces (OpenTelemetry), and security detection (SIEM) using PostgreSQL + TimescaleDB

**he Stats (2 months in):** We've hit about 3,000+ Docker pulls and have around 500 active self-hosted deployments. The system seems stable, with our largest user ingesting around 500k logs/day.

**Lessons Learned:**

* **Simplicity wins:** My focus on a one-line Docker Compose deployment brought in more users than any advanced feature.
* **Listen to users:** I spent too much time building features nobody asked for. I'm now pivotting to stability and community requests (like a Go SDK).
* **Trademarks:** I lost 2 weeks of work rebranding from LogWard due to a conflict. Always check trademarks early!


**Why AGPLv3?** This was a crucial decision for me. I wanted to ensure that if a cloud provider decides to offer Logtide as a service, they are obligated to share their modifications. It protects the project's open nature in the era of SaaS.

**Repo:** [https://github.com/logtide-dev/logtide](https://github.com/logtide-dev/logtide)

**Docs:** [https://logtide.dev/docs](https://logtide.dev/docs)

If you have questions about self-hosting or the stack (SvelteKit 5 / Fastify), let me know

https://redd.it/1qdj22l
@r_opensource

Bringing Open Source into Open Standards with ProtocolSoup

RFCs are what brought about the standardization of the internet, open specs that anyone can read and implement.

While the standards remain open, there is an increasing divide in understanding as proprietary SDKs and enterprise offerings abstract away the standards into flow charts and decision trees.

I built Protocol Soup because I wanted a way to showcase what really goes on in authentication protocols, e2e, real flows against real infrastructure.

It's an open-source sandbox where you can run real OAuth, OIDC, SAML, SPIFFE/SPIRE and SSF (Shared Signal) flows against a built-in IdP, real server infrastructure and WebSocket-powered inspectors showing raw HTTP traffic in real-time as you step through a flow.


Live site: https://protocolsoup.com

GitHub: https://github.com/ParleSec/ProtocolSoup



Stack: Go backend, React frontend, WebSocket for real-time inspection. You can run locally as well through Docker w/ some byo requirements

Feedback is welcome and greatly appreciated whether you're experienced in navigating identity protocols or are just starting to learn.

I plan to build this out continuously through refining current protocol implementations, enhancing RFC richness, and adding new protocols too :)

https://redd.it/1qdk72x
@r_opensource

VictoriaLogs: fast and easy to use database for logs, which can efficiently handle terabytes of logs
https://github.com/VictoriaMetrics/VictoriaLogs

https://redd.it/1qdm8bx
@r_opensource

Built a TUI Download Manager in Go that outperforms aria2

I have always been interested in how download managers work? how they handle concurrency, multiple connections. My college internet sucks so I have used almost all major download managers.

IDM is solid but paid, closed-source, and for Windows. Most open source options like XDM are not being maintained actively. Some of these apps are also heavy weight desktop apps.

I wanted something lightweight and fast. So I decided to build one in Golang to really understand networking, concurrency, and low-level file handling. As a second year student I knew very little about these things before this project.

So I built Surge. It supports

* Parallel connections,
* Resumable downloads,
* Beautiful TUI built with Bubbletea and Lipgloss

Benchmarks: On my setup (1 GB file, \~360 Mbps connection) surge is 1.38x faster than aria2 and as fast as XDM and FDM. This project has exceeded my expectations and I am proud to share it.

GitHub: [https://github.com/junaid2005p/surge](https://github.com/junaid2005p/surge)

I’m a student developer and this is my attempt to give back to the FOSS community. I’m actively looking for feedback, bug reports, and contributors.

**tldr**: Built an open-source terminal download manager in Go to learn concurrency + networking. It ended up \~1.4x faster than aria2 in my tests.

https://redd.it/1qdnmo6
@r_opensource

spdxconv: a program to convert existing licenses and copyrights into SPDX
https://git.sr.ht/~shulhan/spdxconv/

https://redd.it/1qdognd
@r_opensource

I didnt know how bad AI slop app posts are

I haven't checked reddit in a few months but i got on to (your going to hate me) advertise the android app i am making entirely with ai. but now that i see the hate and the reasons behind it i will keep my app for my self. i will only advertise/publish it if i still use it and have learned enough about coding to rewrite/fact check the entire code. i doubt that will ever happen.

AI coding agents are amazing If used as a tool for experienced developers. If an app is entirely vibe coded, like mine, it should only be used by that creator. then if the creator keeps using the app they should learn how to actually code.

Thoughts?

https://redd.it/1qdr729
@r_opensource

Opensourcing is the best what you can do for your project

Recently, I built the Github profile visualizer (paste profile link => get your shareable profile in seconds, evergreen pet-project type that has been built million times) and posted about it on reddit. Gained some attention on it (from 0 to 250+ stars in few days), yet so much comments, critics, suggestions. That is the best what I could get! I have made so many fixes, shipped so many features that redditors suggested.

So, my message: do not be shy to share your projects!!!

Your pet project could be someone else's inspiration, a helpful reference, or just a product they genuinely love.

Repo: https://github.com/whoisyurii/checkmygit

https://redd.it/1qdqmrj
@r_opensource

Andro Open Source PDF editor?

Looking for an Android open source PDF editor. I've looked everywhere and cannot find anything.

https://redd.it/1qdtt8n
@r_opensource

Elide - A fast, multi-language OSS Runtime

Elide is a runtime (like Node or Bun) that lets you use JavaScript, Typenoscript, Python, Kotlin, and Java together in one application and runs them significantly faster than their standard runtimes.

Imagine your project has a React frontend, a Python ML pipeline, and Java backend services. Instead of stitching these together with APIs and microservices, they can run in a single process, import each other's code directly, and share data.

We saw the JavaScript ecosystem expand while Python and Java developers got left behind with fragmented tooling. Node.js took over because it was easy but it locked teams into one language and left performance on the table.

Elide is unique because its the only runtime built on GraalVM (instead of V8), so you get access to npm, PyPI, and Maven in one project, compilers that run 10-20x faster with no warmup time, and a memory-safe runtime that closes a whole set of security vulnerabilities.

Now technically, were not faster than some JS runtimes like Bun, but that's a reality we want to make happen really soon!

I've gotten great feedback from JVM developers and were really trying to get as many eyes on this as possible so that we can continue to improve and build for the dev community. (I've realized that when trying to promote my projects its not necessarily what you say as much as it is where you say it.)

Questions and critiques are always welcome.

Github: https://github.com/elide-dev/elide

https://redd.it/1qdxg1h
@r_opensource

How Do You Balance PRs, Docs, and Contributors? I'm overwhelmed.

Hi everyone,

For context, I'm a maintainer of Img2Num, an open source image vectorization project I’ve poured a lot of time into. I’ve written a ton of guides and documentation) in Docusaurus to help people get started, but it honestly feels like it’s not working. People still get things wrong, and I’m left wondering if the docs are bad or if contributors just aren’t reading them. The worst part is that I don't want to come off as rude or hounding them for things they don't want to do - since the project is still small, I'll take what I can get.😅

Here’s where I’m really struggling:

- PR headaches: Asking contributors to make small changes (like following PR templates or adding a few lines of documentation) feels like such a huge ask. I don’t have the time to clean up other people’s code, but I also can’t just close PRs for new features because they’re often important issues I opened myself. Yet somehow, contributors often ignore my requests for tiny changes, leaving me stuck.
- Finding genuinely helpful contributors: Many PRs feel like "Look everyone, I contributed to OSS!” rather than actually improving the project. And when someone does submit something valuable, I still have to chase my tail to understand their code (which is usually filled with redundancies). It’s exhausting to waste hours on a review that could've been so much faster if there was a bit of documentation - especially for advanced C++ changea.
- Coordination overload: Coordinating issues, reviewing PRs, planning releases… it feels like juggling too many balls at once. We haven’t even had a first release yet because I changed the goalposts from building an app to a library, and now there’s more work to do. But so many PRs duplicate work instead of using reusable utilities in the codebase, which drains my time because I have to understand their implementation, then ask them to use the existing one or change it myself.

Honestly, it sometimes feels impossible to keep the repo moving forward without burning out. I’m starting to question if this is just how GitHub OSS works, or if I’m doing something wrong with my approach.


How do experienced maintainers handle these problems?

What do I need to do to:
- Get contributors to follow documentation and PR guidelines without discouraging them?
- Separate AI-written PRs from genuinely valuable contributions?
- Coordinate a growing repository that’s changing direction?
- Keep releases and features moving when you’re basically the only one driving the ship?

I’d love to hear your strategies, or even just some moral support or new perspectives. Right now, maintaining this project feels a lot harder than I expected, and I could use some guidance. I sometimes feel like I don't want new contributors because it's less painful for me to just implement whatever it is.

Thank you for your time. I hope you have a wonderful day!

https://redd.it/1qe12wp
@r_opensource

Replacement for Google Play Books

I'm getting really tired of Google Play books not reading out PDFs to me. It only does read aloud for ePub files for some reason. There might be other file types, but I don't know what they are.

Is there another Android app that is free (as in libre) and open source that allows me to highlight a section, and attach my own comment to that highlight, as well as read the whole document out to me?

It needs to be able to get it to read out PDF files for me. I also need to take notes for class inside of the book to be able to mark where things are, and remember what I thought about the specific text I highlighted. It needs to be able to search the text in the book, and it would be nice if it could search my notes.

I'm running a Google Pixel 6 Pro.

I also tried converting PDFs to ePubs, but it won't work for certain PDFs that are made mainly of images with selectable text. It also just refuses to upload those to Google Play Books.

Sorry if this is too specific.

https://redd.it/1qdzn6p
@r_opensource

Gommitlint - A CLI tool for linting commits written in Go

My second Goproject. I needed a CLI commitlinter, and non of the available ones filled my needs and had the functions I wanted. (Conform from Siderolabs came close). So here is my take.I would say it turned out pretty ok, even if there is still cleanup and polish to do before 1.0. Also did a GithHub- and a Forgejo Action to go with it. I did an effort to follow good Open Source practices etc. Read more here, and you'll find the links too. https://itiquette.codeberg.page/posts/gommitlint-release/ Will continue to polish it of course! Cheers!

https://redd.it/1qe8q3f
@r_opensource

[GPL-3.0] I built an open-source, bloat-free image viewer to replace Windows Photos. Written in C++23.

I am the developer of **QuickView**, a lightweight, open-source image viewer for Windows.



I'm posting today because I just released **v3.0**, which is a massive rewrite of the core engine. My goal was to create something significantly faster than the default Windows Photos app, specifically for handling heavy formats like RAW, PSD, and EXR.

**The Source Code (GPL-3.0):**[https://github.com/justnullname/QuickView](https://github.com/justnullname/QuickView)

**Why is it different?** It's not an Electron app wrapper. It's built with modern **C++23** and uses a **Direct2D** native rendering pipeline. We just released v3.0.5 with a new "Quantum Stream" architecture that separates UI and decoding threads, meaning the interface never freezes, even when loading huge 100MB+ RAW files.

**Key Features:**

* ⚡ **Instant Startup:** Opens almost instantly.
* 🎞️ **Format Beast:** Supports everything from standard JPG/PNG to modern **JXL/AVIF** and pro formats like **RAW/EXR/PSD**.
* 🎮 **144Hz+ Ready:** Pan and zoom are incredibly smooth, utilizing SIMD (AVX2) acceleration.
* 🛠️ **Geek Tools:** Includes a real-time RGB histogram and a "Photo Wall" overlay mode (press T).
* 🍃 **Portable & Free:** No installation needed, no ads, just one EXE.

It is completely **free, portable (single .exe), and has no ads/telemetry**.

I'd appreciate any feedback on the new rendering performance!

Download available on the GitHub Releases page.

https://redd.it/1qe9wtp
@r_opensource

Maintainers & contributors: How can I make my project docs clearer?

Hey everyone!

I’m maintaining Img2Num. It started as an app that turned images into color-by-number SVGs, but now it’s shifting focus to being a raster-to-SVG vectorization library.

I’ve written a bunch of docs, guides, and rules for contributors, but people still get confused or miss steps. I’d love some honest feedback on making the project easier to understand and contribute to.

Some things I’d like feedback on:

\- Are the setup and usage instructions clear enough?

\- Do the contributing guidelines make sense, especially around CI and formatting rules?

\- Does the docs explain the project purpose and structure well now that the focus has shifted?

\- Any general tips to make it more approachable for first-time contributors.

Repo link: https://github.com/Ryan-Millard/Img2Num

Thanks a ton for any suggestions!

https://redd.it/1qefdvl
@r_opensource

Open sourcing my research paper

I have submitted my research paper on IEEE transactions on signal processing. I wanted to open source the paper on arxiv. what are the steps to follow and what are the things to take into consideration.

The submitted paper at IEEE is still under review, Area Editor has been assigned and Successful manunoscripts will be assigned to an Associate Editor.

provide me some guidance , as this is the first time i am publishing a research paper.

https://redd.it/1qell0t
@r_opensource

I built an open-source job tracker to organize my job search

Job hunting is exhausting. Between crafting tailored resumes, tracking multiple applications, and remembering which stage each one is in, it's easy to lose track of everything. I experienced this firsthand during my own job search, and like any developer facing a problem, I decided to build a solution. I would love to hear your feedback!

🛠️ Stack: Next.js 16, Supabase, TypeScript, Tailwind

Live: jobapplytracker.com

GitHub: https://github.com/berkinduz/job-apply-tracker





https://redd.it/1qesakt
@r_opensource

Am I Cheating?

So, I'm running a smaller-sized open-source project on GitHub with around 1.2k stars (interestingly enough, it's neither a dev tool nor a library, but a super niche, consumer-facing educational tool that I host online).

Recently, I've had the idea of automatically generating "good first issues" for the repo to encourage growth and drive traffic to the project. The issues are so dead simple that anyone with 0 experience in our tech stack or even programming in general can come in, get them done in under a minute, open a PR and be done with it.

Lo and behold, the repo has gotten 100+ new, one-and-done contributors and an according number of stars and forks, to the point where I feel that I'm cheating the system and GitHub's algorithm by doing this; the automatically-created "good first issues" are monotone and brain-dead at best, and even though their contents technically reach the end-users, these issues/contributions provide no real meaningful value other than consistently and artificially inflating my repo's star/fork/contributors count.

So, am I cheating? All feedback welcome.

https://redd.it/1qiuagx
@r_opensource

I made a documentary about Open Source in Ukraine and around the world

Hey all, I wanted to share with you a documentary I just published yesterday called "Gift Community: A Story About Open Source." I visited the Open Source community in Los Angeles, Denmark, India ... and, yes, Ukraine. I met legendary developers like Mitchell Hashimoto (HashiCorp, Terraform, Vault, etc., now Ghostty), Poul-Henning Kamp (FreeBSD, Varnish/Vinyl), and Kailash Nadh (Zerodha). Along the way, I slept in an air-raid shelter, flew in Mitchell's private jet, and ventured out into Bangalore traffic. In the doc I tried to weave it all together into a story about "the deeper meaning of Open Source." Let me know how I did. :-)

https://www.youtube.com/watch?v=tOn-L3tGKw0

https://redd.it/1qj9bnt
@r_opensource

Pedro Organiza: a deterministic, non-destructive, review-before-apply music library organizer I’ve been building It is a local-first music library organizer for people with big, messy collections

Hi everyone,

For the past months I’ve been building a personal project called Pedro Organiza — a desktop tool to analyze, clean, and reorganize large music libraries in a safe, deterministic, review-before-apply way.

It started as a personal need: I have a very large, messy music collection with duplicates, inconsistent tags, broken albums, and many years of accumulated chaos. Existing tools were either too automatic, too destructive, or too opaque for my taste.

So I decided to build something with a very strict philosophy:

No silent destructive actions
No “magic” operations you can’t inspect
Always analyze → review → apply
Local-first: your music never leaves your machine
Deterministic behavior: same input, same result

# What Pedro can already do

Current core features:

Recursive scanning of large libraries (tens of thousands of files)
Metadata extraction using Mutagen
Fingerprinting and hashing of files
Intelligent alias normalization (artist/noscript/album variants)
Duplicate detection using:
File hashes
Metadata similarity
Fuzzy matching
Clustering of potential duplicates and aliases
Two-phase workflow:
1. Analyze & propose actions
2. Review in UI
3. Apply explicitly

The UI lets you:

Browse and search your entire library from a local SQLite DB
Edit tags individually or in bulk
Inspect duplicate clusters before touching anything
See exactly what will be changed before executing

Backend is Python (FastAPI + CLI tools), frontend is React.

# Design philosophy

Some principles I’ve been following very strictly:

No automatic deletions
No irreversible actions without review
Transparency over convenience
UI-first for non-technical users, but CLI still exists
Additive database schema (no forced rescans when schema evolves)

In short: Pedro is meant for people who care deeply about their music and don’t trust black boxes.

# What’s work-in-progress right now

Currently working on:

Polishing the startup / first-run UX
Improving performance with very large libraries (50k+ tracks)
Refining alias normalization and cluster quality
Better progress reporting and logging in the UI
Tag side-panel for faster metadata editing

# Planned next features

Some ideas already planned for future versions:

Background watcher for new files
Drag & drop support in the UI
Album art fetching and management
Export filtered views as playlists (.m3u, etc.)
Packaging for Windows / macOS / Linux (AppImage, .exe, .dmg)
Flatpak release

Longer term:

Plugin system for custom analyzers
Optional online metadata providers
Better visualization of library health

# Project status

Actively developed
Not “1.0” yet, but already usable
Open-source (license still being finalized)
Currently running on Linux, Windows support in progress

I’m not trying to build a commercial product — this is a serious long-term open-source tool for people with large, messy collections.

# Looking for

I’d really appreciate feedback from people who:

Have large music libraries
Have tried tools like beets, MusicBrainz Picard, MediaMonkey, etc.
Care about safe workflows

Questions I’m particularly interested in:

What’s your biggest pain point organizing music?
What features do you miss in existing tools?
Would you prefer more automation or more control?

If there’s interest, I’m happy to share screenshots, design notes, and such once the next milestone is published.

You can check it out (work in development, so expect regulra updates)
https://github.com/crevilla2050/pedro-organiza/

Thanks for reading — and thanks in advance for any feedback.

https://redd.it/1qje7mb
@r_opensource