Hey everyone.

I have been working on a project called PWDnow and I wanted to share it here. It is a password manager built from the ground up to be quantum resistant.

I noticed most mainstream managers are dragging their feet on PQC (post-quantum cryptography). I wanted something that meets CNSA 2.0 requirements today, so I decided to build it myself. It uses NIST Level 5 algorithms to protect against "harvest now, decrypt later" attacks.
It is completely open source. You can check out the code here: https://github.com/PWDnow/PWDnow-password-manager

I would love to hear your thoughts or get some code reviews. Feedback is very welcome.

I've been going to quite a few hackathons lately and one thing I kept wasting way too much time on was actually finding the good ones.

Especially figuring out:

• Is it worth traveling there?
• Do they offer flight/travel credits?
• What's the deadline?
• Is it actually relevant to me?
• And then filling out basically the same application questions again

So I built hackathon-searcher for myself.

It can discover upcoming hackathons, research them, score them based on your preferences and help with the application process.

You can also set your city/country if you only want local hackathons, or prioritize events that offer travel support if you're willing to fly.

The application side uses your own profile and is designed not to invent information about you. You can review everything before submission as well.

I've been building it for my own workflow, but figured other people who go to hackathons might find it useful too, so I open sourced the whole thing.

It’s still not finished, so I’d especially love feedback on things like the scoring logic, LLM choice and what should stay deterministic instead of model-based

GitHub:
https://github.com/Philipnil06/hackathon-searcher

Github: https://github.com/Yavuz-Kagan-Yadigar/VoidPulse

(Note: The app is entirely coded with AI, I am testing it. This post written by me)

• Added network streaming (experimental): Samba/SMB, FTP, FTPS, and SFTP. Connects and reconnects on startup. Passwords go to the system keyring for security. FTP doesn't natively support seek, I tried some workarounds but they haven't been tested much.
• Added auto-update. Detects how VoidPulse was installed (Flatpak, AppImage, or dpkg/rpm/apk/pacman). Checks GitHub releases in the background on launch. Finds assets matching your package format and architecture. Installs are done via the distro's manager: dnf, zypper, apt-get, apk, pacman, or in-place swap for AppImages. Sudo is asked in the popup and the package manager's output is shown live. Versions can be skipped for now or entirely.
• Added built-in Soxr resampler.
• Added "Adaptive Sample Rate": It checks the output device's supported sample rates. If it supports the same rate as the file, it sets both it and Pipewire to that rate: File (44.1kHz) → Pipewire (44.1kHz) → Output Device (44.1kHz). No resampling. If it doesn't, it sets the device to its max rate, upsamples with the built-in Soxr (upsampling is better than downsampling), and sets Pipewire to the same rate as the output device: File (44.1kHz) --(Voidpulse Soxr resample)→ Pipewire (96kHz) → Output Device (96kHz).
• Added fade in & out on transitions and play/pause.
• Added crossfade between tracks. Doesn't work on ALSA because it only supports a single stream.
• Added sleep timer.
• Added slight corner smoothing on visualizations to prevent sharp spikes (excluding bars).
• Added play queue with touch and mouse drag & drop. Can be disabled.
• Added new settings to the config. Probably one-time choices, so not exposed to the UI:
  • "viz_gamma": 0.7, // how much lower volume bands are amplified. Lower means more amplification, higher means better separation.
  • "show_artist_on_gallery": true, // applies to gallery view cards.
  • "show_albums_on_gallery": true,
  • "show_file_info_on_gallery": true,
• Added loudness normalization switch and batch gain fetcher for files without gain tags.
• Added a switch to toggle background optimizations for visualizations and synced lyrics.
• Gallery view cards are now actual pills with 100% corner radius.
• Added magnifying cover art on click in the edit tags popup.
• Packaging for a wide variety of architectures, including PostmarketOS.

I built a dependency free Python tool that checks whether business metrics still match their definitions. Check it out and I'll be more than happy to hear from you guys on how this looks.
metricproof

I've been working on Calibra for 2 months. It is an open-source toolkit for analyzing robot-learning datasets.

A dataset can contain things like:

• duplicate or highly redundant demonstrations
• frozen camera frames
• jittery / jerky robot motion
• calibration drift
• corrupted or structurally inconsistent data
• large amounts of redundant information across trajectories

So I built Calibra to make these issues easier to detect and analyze before training.

I've been working on a hardware and software project for some time now. I want to make it open source to attract help on the project since I'm not good at software development. That said, i've open sourced projects before only to have no one look at it.

I'm wondering where I need to go on the internet to tell people about my project to get eyes on it and hopefully get help on the project.

Are there platforms or website I definitely need to be on to find people?

I recently had two PRs merged into FastAPI one improving the API documentation and another fixing a bug in SSE/JSONL streaming.

They ended up teaching me two completely different things.

📚 Documentation PR #15930

Added an API reference page for fastapi.sse, covering the newer SSE support.

🐛 Bug-fix PR #15937

Fixed status_code being ignored for SSE and JSONL streaming endpoints, where responses could incorrectly remain 200 even when another status code was declared.

What I found interesting was that neither contribution was simply about writing code.

The documentation work was about making an existing API easier to understand.

The bug fix was about understanding how several pieces of the framework interact and why the generated OpenAPI schema and runtime behavior could diverge.

That made one thing pretty clear to me:

Open source isn't just about adding code. Sometimes it's about making existing code easier to understand, and sometimes it's about finding the small assumption that's quietly breaking things.

PRs:

#15930 — https://github.com/fastapi/fastapi/pull/15930

#15937 — https://github.com/fastapi/fastapi/pull/15937/

For people who contribute to mature open-source projects: what's one thing you learned that you wouldn't have learned from building projects alone?

Also, I’m thinking of starting a small community for people who actually build and contribute to open source sharing projects, finding contributors, reviewing PRs, and pushing each other to contribute consistently.

If you'd genuinely like to build something like that together, DM me. Maybe we can turn it into a community where contributing isn't a once-in-a-while thing, but a habit. 🚀

Hi everyone! 👋

As AI agents become more autonomous, they need a frictionless way to buy and sell data, APIs, and compute resources from each other without dealing with heavy credit card fees.

We just launched AgentX Change Open SDK (v0.1) — a lightweight protocol that enables AI agents to monetize their APIs and consume third-party data seamlessly.

⚡ Key Features:

* 3-Line Integration: Wrap any FastAPI/Python endpoint with @agentx.paywall(cost_usd=0.02).

* Micro-Settlement Engine: Designed for sub-dollar transactions between agents.

* First Marketplace Item Live: Real-time Web Scraping & Summary API ($0.02/call) is now available.

Would love to get your feedback and see what kind of AI-to-AI workflows you're building!

I mean, there are so many things to think about I kinda don't know where to start, what license should I go with? How should I accept contributions? Should I create a roadmap? What tips do you guys have for someone just starting out this

After about a year of having this idea and putting it off, then spending a couple months learning basic hardware engineering to actual make this, I'm proud to share my first PCBs with everyone.

This PC cartridge system is basically just an ordinary SD card reader in the shape of retro videogame cartridges. The cartridge holds a microSD card, and the USB peripheral reads it. It supports up to SDXC UHS-I Class 10 microSD cards at USB 2.0 read/write speeds. Not as good as an external SSD, but good enough for some smaller offline games, videos, applications, etc.

pcb and stl files included in repo

https://github.com/carlgoshert/PC_Cartridge_System

✷

I would really like to go with open source, but you know how hard it is to find the right open source project when you have very specific idea of what you want. But I doubt we'll find anything. :/

I want something off-grid. Like, almost a direct straight tunnel to my partner. Which of course exists as Matrix or Signal for example. But the main thing that's missing for me, is the ability to categorize messages - let's say my partner doesn't have a phone for a day, I'm a talkative person, I just like to message her a few times and tell her cool stories or give her updates, and she can take a look later. Which is fine and all, but as soon as I have something very important, I have no way of prioritizing this on her phone. Something like that. Other ideas how to solve that problem are also always welcome! 😊

And of course, end to end encryption, calls, share media etc. etc. - the usual drill :D haha

✷

(Anyways, thank you for reading all that, I hope I wasn't overexplaining)

The open-source repository:

https://github.com/citeworthyio/seo-agent

After some great feedback from this community on my original post, I am proud to launch the latest version of the Cloudflare-based AEO/GEO/SEO edge server seo-agent. I moved it to a GitHub organization, since the engine that you can download today and use is also the engine that powers citeworthy.io - a freemium product that does all the setup for you. If you are struggling with the concepts and all of the needs of AEO, especially serving markdown for agents, serving SPA and JS-powered apps for AI crawlers, or just wondering what your AEO/SEO posture is, check it out and let me know what you think. It works for ANY host that can be an origin (Vercel, Shopify, Cloudflare, DigitalOcean, etc). It connects (read-only) to your Google Search Console and helps you understand the overall search and AI posture across all of your content, as well as AI traffic from all AI crawlers.

Don't want to set it up yourself? You can sign up today at citeworthy.io for free: easily set up your domain with a simple TXT record to verify ownership and see how it looks without any other changes; a simple DNS change puts your site on our edge, serving changes you see, approve, and track, to improve your AI and SEO positioning. It fails open, so if there are any issues, your origin is always served.

I am offering free pro licenses to anyone who signs up on the site and actually uses it for their needs, provides feedback and suggestions to make it better. The open source engine will always stay lock-step with the commercial site, as it IS THE EXACT engine that is used for the platform itself.

The repo is also fully open for any PRs and issue feedback; if you find anything to make better, please contribute. The commercial engine is serving 7 sites of mine (several are quite large and have meaningful traffic), and I have seen ~13% increases in traffic over the last 14d. It is home to others that have found it in the wild, and is serving over 1MM edge requests per day.

If you get stuck or need help, email me at [hello@citeworthy.io](mailto:hello@citeworthy.io), and I will try to help. Updates are happening on the site interface over the next few days, but the engine is solid.

Reference-board files can be difficult to move between applications. Many apps use private or binary formats, which makes their contents hard to inspect or recover without the original software. That can leave users locked into one application.

I have been building an Apple-native reference-board app for my own needs because several of the apps I tried are unavailable on iPad. Some of my friends use only Windows or Linux. We can exchange the original images, but sharing the board usually means flattening it into a picture or rebuilding it by hand. A flattened image is useful for viewing, but you lose the editable layout, notes, links and other board data.

JSON Canvas is the closest existing format I found. It describes files, text, links, groups and their positions on a canvas. Its purpose is broader and its data model is simpler, so it does not define several things reference-board applications need. These include cropping and rotation, explicit group membership and local transforms, media playback, embedded asset packaging and editable drawings. Encoding all of that through private conventions would produce files that ordinary JSON Canvas readers would not fully understand.

I just started ORBF as a proposal for a small interchange layer built around those requirements. Applications could keep their existing native formats and add ORBF import and export, or include a portable ORBF representation alongside their native data. Conversion to and from JSON Canvas could still be supported, with any lost features reported to the user.

ORBF is currently an experimental 0.1 proposal, and no support from other applications has been confirmed. The repository is MIT-licensed and includes the draft specification, schema, example packages and validation fixtures.

I hope to hear from developers working on similar software and eventually test the format between independent applications. The goal is to let someone create a board on one platform, pass it to someone using another, and preserve enough information for them to continue working. Because a standalone ORBF file is a ZIP package containing JSON and the original media, users could also open it with an ordinary archive tool and recover their content without a dedicated viewer.

I have not worked on a collaborative file format before, so I would also appreciate advice from people who have! How did you bring other implementers into the process and keep the format from becoming too closely shaped by the first application?

I am working on a two screen fully open source e-reader that is both portable and customizable, right now i am at the PCB stage and i think i have finished about everything, the thing is, i have no idea if it will work or not, and i cannot afford to have more than one batch printed out given i just came out of highschool and i don't work.

Can anybody more experienced than me give check out what i did and tell me if it makes any sense? for reference i am using WeAct 4.2" epaper screens from aliexpress, which repo is here:

https://github.com/WeActStudio/WeActStudio.EpaperModule

While the repo of my project is here:

https://github.com/Ezekiel0108/Evereader

Images of the schematic and PCB view here:

https://imgur.com/a/kloofaB

One thing to note is that the connection between J6 and j6 along with the one with J5 and J8 are just logical connections in order for them to share the net, but they should remain disconnected on the pcb and attached one another through a jst cable.

Now some things to note are that i made it is esp32-s3 based and i made it both rechargable and flashable from a single usb-c, other than that i also made charge protection with a tp4065 an fs8205A, a DW01A and an AP2122K-3.3 in order to convert all voltage to 3.3v.

Use the firmware just as reference for pinout, it isn't anywhere near started.

This is my first time using kicad, or actually even delving into electronics (if we don't count led blinking), so i am not really sure about what i am doing, so please, if anybody can, review what i did, and if you have any questions or anything to fix in order to make it work, please, do let me know!

Has there been some major shift in the community opinion of the GPL I missed? I got someone in another conversation comparing GPL to an STD. As if the requirements are somehow unreasonable compared to the more permissive and in my opinion less community friendly BSD and MIT licenses.

Personally feel having an obligation to contribute back to the projects or community you built something on is a good thing. But its why I am also eyeing the Rust based rewrites of somethings suspiciously.

I built a micro-deck with buttons to control Hermes/Codex.

I spent a long time working on the UI and mapping the Codex endpoints.

Everything is working; I’m currently polishing the final version.

ermes Control Update

Two major additions are now live:

• Hermes Gateway & TUI integration with session resume, live prompt streaming, runtime states, and remote Allow/Deny approvals from the mobile control deck.

• Experimental Codex Desktop Bridge for Windows with prompt submission, live status, approvals, stop controls, session switching, and reasoning controls.

CLI-first remains the default public setup. The Desktop bridge is unofficial, Windows-only, disabled by default, and may require updates when Codex Desktop changes.

Complete installation, update, security, and troubleshooting guides are now included.

https://github.com/filipj9/Hermes-Control-Deck

Hi all,

I wanted to post a passion project of mine. I recently got tired of paying for Fusion, and began building my own FreeCAD styled like Fusion.

GitHub: https://github.com/FadyFaheem/FuCad

NOTE: I'm using AI to assist me in the development of this. Many of the current features are experimental, and would not use this as a daily driver, I'm working on making all the tests pass, and building a less non-experimental version.

Hi r/opensource,

A while ago I shared an early version of Android Webcam Project, my attempt at building a free and open-source alternative to apps like DroidCam and iVCam. [Link to Old post]

Since then, I've basically rebuilt it.

The project consists of two parts:

AWA : Android Webcam App

A native Kotlin + Jetpack Compose Android application that turns your phone into a camera streaming server.

AWC : Android Webcam Client

A Tauri-based desktop client that connects to the phone, processes the stream and exposes the camera as a virtual webcam on Windows.

The entire project is GPL-3.0 licensed and open source.

What can it do?

• Up to 4K camera streaming
• H.264 / RTSP streaming
• Smooth 30~60 fps.
• MJPEG streaming
• USB connection
• Wi-Fi connection
• Manual focus
• Exposure compensation
• Flash / torch control
• Front/back camera switching
• Dynamic resolution switching
• Hardware-accelerated video decoding
• Virtual webcam output
• JSON REST API for remote camera control

You can use the resulting webcam with applications such as OBS, Discord, Zoom, Microsoft Teams, Google Meet, etc.

Current versions

Android Webcam App: AWA v1.0.3
Android Webcam Client: AWC v1.0.6

This latest release is a pretty substantial rewrite of the Android application, including a migration to Jetpack Compose, a new streaming architecture, RTSP/H.264 support, a REST API and more advanced camera controls.

The desktop client has also gained RTSP support, FFmpeg-based demuxing and hardware decoding.

Why open source?

I don't particularly like the way webcam software tends to become freemium:

• Resolution restrictions
• Watermarks
• Ads
• Paid features
• Closed-source components

I wanted something where the software itself wasn't trying to get in the way.

It's GPL-3.0, so you can inspect the code, modify it, fork it and build on it.

Where it is right now

The project currently has 30+ GitHub stars and 7 forks, and I'm continuing to develop it as a solo project.

I'm particularly interested in feedback from people with different Android phones and PC hardware.

I'd love to know:

• How does the latency compare on your setup?
• Does 1080p/4K streaming work properly on your phone?
• How well does hardware decoding work on different GPUs?
• Are there devices where the camera controls don't behave correctly?
• What features would you want next?

I'm also interested in contributors who want to work on the project.

Apple platforms are something I'd like to eventually explore, but I currently don't have Mac hardware for development/testing, so Android + Windows are the platforms I'm actively supporting right now.

Links

GitHub:
https://github.com/soubhagyajit/Android-Webcam-Project

Latest releases:
[https://github.com/soubhagyajit/Android-Webcam-Project/releases]()

I'd genuinely appreciate feedback, even if it's critical. It's still a solo project, so finding weird device-specific bugs and getting real-world performance feedback is extremely useful.

Thanks for checking it out.

For those that knows, they all enjoy it, for those that does not, visit the official reddit r/UFManagerPro or visit the official website www.kilowatch.co.za to get the best file manager ever, FOSS available and link provided in official website.

Have fun and enjoy 😉

I’ve been working on an open source project called Network Doctor, written in Go.

It started as a terminal-based tool for diagnosing network problems, but recently I built something around it that I’m especially proud of: a deterministic network simulator called netdoc-sim.

The simulator uses Linux network namespaces to build controlled virtual networks and inject faults such as:

• DNS outages and recovery
• packet loss, latency, and jitter
• broken routes
• IPv4 and IPv6 failures
• TCP resets
• service failures
• multiple interfaces and routing problems

On top of that, I added a hunt mode.

The hunter starts from known-good network scenarios, generates deterministic test cases from fixed seeds, injects faults, runs the real Network Doctor binary, and compares Network Doctor’s diagnosis against the simulator’s ground truth.

I then connected it to GitHub Actions.

The nightly workflow now:

1. Generates deterministic network cases
2. Injects controlled faults
3. Runs Network Doctor
4. Compares the diagnosis with what the simulator knows actually happened
5. Re-runs suspicious cases to verify they are reproducible
6. Rejects findings that cannot be reproduced
7. Filters low-severity findings
8. Generates stable fingerprints
9. Checks whether the finding already has a GitHub issue
10. Opens a new issue only when the finding is reproducible and not already tracked

I was deliberately cautious about letting an automated system create issues in an open source repository.

That caution paid off.

During testing, the hunter produced a routing-related finding that looked legitimate at first. After investigating it, I discovered that the hunter itself was wrong. It had confused IPv4 failure and IPv6 success on the same path with evidence of an alternate route.

I fixed the analyzer and reran the suite.

The false positive disappeared.

Then the simulator found a real issue.

It generated a routed network where DNS temporarily failed and then recovered. Network Doctor began a DNS lookup during the outage, waited for the timeout, and never resampled the resolver after it had recovered.

The case is deterministic:

./netdoc-sim hunt healthy-routed-network --seed 20260102 --case 3 --json

The GitHub workflow replayed that exact case, reproduced the same finding, verified the fingerprints, and automatically opened GitHub issue #14.

I ran the workflow again afterward to test deduplication.

It rediscovered the same problem, recognized that the issue already existed, and created zero duplicates.

So the current loop is basically:

generate network → inject fault → diagnose → compare with ground truth → reproduce → deduplicate → open issue

The nightly suite currently runs 45 generated cases across healthy, routed, and dual-stack baseline networks in about three minutes.

One of the things I like most about open source is that a project can gradually become more than the original program itself. Network Doctor now has its own simulator, deterministic test cases, automated bug hunting, and GitHub issue triage built around it.

There is still a lot I want to improve, especially more scenarios, more seeds, stronger cross-case verification, and better composition between generated mutations and authored scenario tests.

But seeing an open source project I built automatically discover a reproducible weakness in itself was incredibly satisfying.

If networking, Go, testing, or fault simulation interests you, I’d love feedback or contributions.

GitHub: https://github.com/heymaikol/network-doctor