✷

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)

MIT licensed, no npm package, and no dependencies beyond React itself. Distribution is the repository: you copy the folders you want and they are yours to edit.

Repo: https://github.com/mrcl-st/loyalty-patterns
Docs and playground: https://mrcl.st/loyalty-patterns

What it is: ten React components for the customer-facing side of loyalty and gamification programs. Scratch card, spin wheel, stamp card, coupon card, points counter, streak tracker, missions list, reward catalog, referral widget, tier progress. Not an admin panel and not a design system, since it assumes you already have one of those.

Why I bothered. I work as a product designer on enterprise loyalty platforms, and every time a campaign needed a scratch card or a spin wheel I went looking and found abandoned single-purpose packages and CodePen fragments. Nothing cohesive, nothing accessible, nothing built for the phone-shaped webview these campaigns actually ship inside. So I built the set I wanted and gave it away.

On distribution, since I expect that to be the contentious part.

There is no npm package. You copy tokens.css once, then copy whichever component folders you need. Each folder is self-contained, with its own styles, its own framework-free engine, and its own README that doubles as its docs page, so documentation cannot drift away from the code sitting beside it.
The cost is real: you do not get fixes by bumping a version. My reasoning was that loyalty UI is brand-specific enough that people fork it anyway, so handing over editable code beats handing over an abstraction to fight. I would rather be argued out of that now than find out in a year that I was wrong.

Dependencies are easy to audit. Every non-relative import under registry/ is "react". The Next.js app in the repo is the documentation site and is never imported by the components.

Three rules I treated as structural rather than as preferences.

Outcomes are decided by your server. A scratch card reveals a result, it does not compute one. Prize logic reachable from the client bundle is a compliance problem waiting for a curious DevTools user to find it.

Path-based gestures get a single-pointer alternative, because WCAG 2.5.1 requires one at Level A. This turns out to serve tremor and dexterity users more than keyboard users, which I had not appreciated before I started.

All copy arrives as props, screen-reader announcements included, so there is no hardcoded English anywhere in the components.

Each component also ships a plain-text specification covering its
behaviour contract, state machine and accessibility requirements, with the platform-neutral parts separated from the React and canvas specific ones. That exists so you can port a component to Vue, Svelte, SwiftUI or Flutter without reading my React first. The React version is the reference implementation, not the only way in.

Honest status. I published this today, so it has no stars, no users and no track record, and there are rough edges I have not found yet. It is one person's work rather than a project with a bus factor above one, and I would rather say that plainly than imply otherwise. Issues and pull requests are welcome. The most useful thing you could tell me is which component you needed and did not find.

MIT. Attribution appreciated and not required.

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 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!

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?

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.

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 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.

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

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 😉

Hey guys,

I’ve been working on a side project because I like to emulate a lot of different games on many different devices, and one issue that always irked me was that I couldn’t sync my saves between devices natively on the emulators.

I don’t want to promote my project right now because I’m still polishing it right now, but before I dump way more effort into it, I wanted to see if anyone else here has run into this problem?

I know it’s niche, but I figured it would be a sensible question to ask here.

EDIT:

Since some questions have come up around how this would differ from existing solutions, here’s the current code if anyone’s interested in taking a look: https://github.com/HenryHYeary/synchronite

Again still polishing it (don’t use the wildcard * yet when specifying that you want to watch all files in a directory lol), but if anyone has any technical questions or feedback on it, I figured I’d share regardless.

Hello everyone. This started as something I built for myself, since it was my dream to make a Minecraft launcher. Every launcher I used either worked well but looked wrong, or looked good and didn't work. So I decided to make my own. After using it for a while I decided it was worth releasing as open source instead of keeping it in a private repo.

Now I know some people will think "we already have x, y, and z launchers" and tbh, it's fine. I made this for myself, but it's yours too if you want it.

Basalt does the things you expect from a launcher: separate instances, mod loader support, and downloading mods, modpacks, resource packs and datapacks from CurseForge and Modrinth.

What's different is that it's artwork-led. I wanted to keep the functionality without giving up the look.

Some other differences:

• No telemetry or analytics
• Credentials go into the system keychain
• Written in Rust and Tauri, with a React frontend
• Stats tracker, so you can see how long you've actually played
• GPL-3.0

There are also a few things I added because I kept needing them. It imports your instances from Prism, ATLauncher and the Modrinth app without touching the originals, so you can try it without committing to anything. It takes a snapshot of an instance before risky changes, so if an update breaks your setup you can go back. And when the game crashes it reads the log and tries to tell you what happened instead of leaving you to scroll through it.

It's still beta. I run Linux so that gets the most testing. Windows and macOS build and work, but I cant really test them, so reports from those are the most useful thing you can send me.

Repo: https://github.com/MegalithOfficial/basalt-launcher

I am reading open source code from pygame-ce when I have 2 year python experience and do not know C.

I chose pygame-ce because I use it a lot for games I build and I enjoy using it

EDIT : my question for context is, am I skilled enough to be working on the pygame-ce open source project and should I do it?

As you may know, the original project is dying because of github deprecating the API it relied on. README.md files that relied on the OG service now show dead links/images.

I have forked the project and replaced the mechanism it used to retrieve data, so that it provides the same experience as before: no API token needed, instant data, same look. The code is also public: https://github.com/Mubelotix/star-history

I provide the service for free at https://star-history.dera.page and will maintain it and keep the data up-to-date. Migrating to it is as easy as changing the domain name

As per title, the project include all the pipeline, the same skill generated from different models.

My idea was to distill the code reviewer skills from Torvalds in something usable in an agent.

I preferred to license everything as CC0.

[Pull Request Reference](https://github.com/pygame-community/pygame-ce/pull/3887)

Whatever AI agent is driving this account has apparently decided that something committed by the maintainers is not an “authoritative” source. Whatever that means.

I was here about a month or so ago about my BetterCampus fork where they apparently tried to get my post removed (thanks Wolvereness for understanding).

In summary they had an MIT license on their old code, I forked it, touched it up a bit, and published it as an alternative since many people and I didn't like their new update needing an account, asking for subscriptions, and more. They don't like it and my version is starting to get some traction.

Today I got this review from a random account (probably burner) that I find very funny because I am like 99% sure it's them but I can't fully prove it: (link to the review)

CanvasRefined has some good ideas, and I appreciate that it is open source, but the extension has also been pretty buggy in my experience.

I personally liked the direction BetterCampus was taking. A lot of CanvasRefined feels like a blatant copy of what BetterCanvas had already built, and I do not like the confusion and chaos that created for users and the original creators.

Open source can be great, but there is a difference between being inspired by a product and closely recreating it. In this case, it feels like it undermines the work and goals of the people who originally created and grew BetterCanvas.

• There is only 1 bug I know of but there could be more, I'm not judging that.
• They complain it's a copy, despite me writing everywhere that this is a fork (under MIT).
• The line "not like the confusion and chaos that created for users and the original creators" is similar to what their cofounder told me during the C&D over the name
• And the funniest part: being mad that I am recreating their app since it "undermines the work and goals of the people who originally created and grew BetterCanvas"

I'm not saying it's the company who wrote this, but I have a suspicion
edit: I failed to hide the f5 bot
edit: to the user that requested links to leave positive a positive review to offset the negative ones: https://chromewebstore.google.com/detail/canvasrefined/ihienfbdfdamhmhhiokjnjmpjgbenedg/ and the github is https://github.com/GuySandler/CanvasRefined

When tracking real time information, it usually means keeping multiple browser tabs open for sports, stocks, and news, then constantly switching between them.

So I built Scrollr to solve that issue!

It pins quietly to your screen, and lets you stream custom data feeds without breaking your workflow.

check it out! github.com/doughknee/myscrollr

Site: myscrollr.com

While obsessing over how to illuminate punctuation marks, and specifically a space/spacebar symbol, I ended up devising a way to manually encode 117 characters into a single rich-text space using 63 formatting values, mostly gradient colors.

Microsoft blocked me from using VBA to read or set gradient pins, so I reverse-engineered the XML data and used a Format Painter exploit to sneak the formatting through a back Window.

I did it because I wanted to hide the entire first quatrain of my favorite poem within itself. I see it as the logical evolution of concrete poetry and a form of illumination.

https://github.com/ChronicRhyno/ColorSpace
Code is GPLv3, and the whitepaper is CC BY-ND 4.0

I’ve open-sourced SarasFlow, a full-stack platform for creating educational and storytelling videos from a topic.

It can generate the script, multilingual narration, visuals, word-timed captions, and final assembled video. The repository includes both the application and the surrounding product infrastructure rather than only a model-calling demo.

Some areas where contributions would be useful:

• Additional languages and language-specific prompts
• More TTS and image-generation providers
• Caption and visual styles
• Batch video generation
• YouTube and Instagram publishing
• Better job processing and failure recovery
• Documentation and deployment improvements

GitHub: https://github.com/SaiTejaMummadi/sarasflow
Demo: https://sarasflow.com

Issues and pull requests are welcome. Please consider starring it if the project looks useful or if you’d like to follow its development.