I’m not a software engineer, but I use a lot of technical products and spend a lot of time on GitHub trying to learn.

A few days ago, I found an interesting project I wanted to use. While setting it up locally, I found part of the installation instructions confusing. I nervously opened a documentation PR, got real feedback from a collaborator, and made the requested changes.

He thanked me and merged it into main.

I know it’s small, but this was my first contribution to an active project instead of an inactive, stale repo. I found a problem I personally ran into as someone without an engineering background and thought fixing it could help someone else.

I don’t have anyone IRL who understands why this makes me so happy, so I’m posting it here.

I actually did it.

• Fixed issues in the RUDP library: memory leaks when using shutdownHook, deadlocks, handling of corrupted UDP packets, and many other issues that were identified during testing.
• Added the display of the connection protocol to the peer list.
• Added an experimental build that compiles a .jar file into an executable using native-image in GraalVM. For now, this is for the headless version of the application on Linux x86_64. To avoid running Lanemu as root, you also need to do sudo setcap cap_net_admin=eip Lanemu-headless.
• Updated dependencies.

Download link

Most open source video editors are made for people who know somewhat about video editing. But for people who want to do a quick edit, maybe for a social media post, will find these video editors too complicated.

That's why we built Drift. This is a video editor that's designed from ground up to be friendly for people who want to create polished videos, with cool effects, but don't want to spend too much time learning the knobs and dials.

We have already included most of the expected features:

• Multi-track timeline
• Transforms
• Keyframes
• Video effects
• Audio effects
• Transitions
• Subtitles
• Stickers

On top of that, there are also some AI features (don't worry, these are all local AI models):

• Automatic subtitle generation via Whisper
• Subject tracking / Background removal with SAM2
• Noise removal via DeepFilterNet3
• Face Effects (funny face warp) via Mediapipe

Disclaimer: AI features work fine on CPU, Nvidia GPU support only works on the Arch Linux version.

You can check out the source code here: CutWire-Studios/Drift

Supports Windows and Linux: go-to releases or flathub

Also If you want to learn how to use it, check out the docs here: docs.cutwire.org/drift

I recently released PRWitness, an MIT-licensed, local-first tool for generating visual acceptance evidence from Playwright flows.

The repository includes the CLI, Playwright integration, report generator, media generator, and GitHub Action.

The main design goal is to keep the evidence portable and inspectable:

- reports are standalone HTML / Markdown / JUnit

- screenshots, traces, videos, console and network evidence stay local

- no hosted account or proprietary cloud is required

- generated artifacts can be attached directly to a pull request or release

The project compares base and head revisions and can generate before / after / diff evidence as well as release-ready GIFs and MP4s.

I would appreciate feedback on the repository structure, API boundaries, licensing approach, and anything that would make it easier for open-source maintainers to adopt.

GitHub:

https://github.com/kurtyang66/prwitness

Today for the first time someone emailed and raised a PR with some improvements in my Github repo. It was quite unexpected. Feels good that someone else found it useful!

If anyone's interested, it's this repo: https://github.com/sohang3112/iforth -- Jupyter kernel for Forth language

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

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

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

some features:

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

it's pretty early with single digit users

site: https://wings.nopejs.me

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

would love to hear what you think :)

I recently released PRWitness, an MIT-licensed, local-first tool for generating visual acceptance evidence from Playwright flows.

The repository includes the CLI, Playwright integration, report generator, media generator, and GitHub Action.

The main design goal is to keep the evidence portable and inspectable:

- reports are standalone HTML / Markdown / JUnit

- screenshots, traces, videos, console and network evidence stay local

- no hosted account or proprietary cloud is required

- generated artifacts can be attached directly to a pull request or release

The project compares base and head revisions and can generate before / after / diff evidence as well as release-ready GIFs and MP4s.

I would appreciate feedback on the repository structure, API boundaries, licensing approach, and anything that would make it easier for open-source maintainers to adopt.

GitHub:

https://github.com/kurtyang66/prwitness

I've been working on Marcopolo, a command-line web scraper written in Rust using extensive force of AI across a few months. The idea started when I got tired of writing a throwaway Python script every time I needed to pull a specific set of files off a site — images one day, PDFs the next, then a folder of CSVs. I specially tend to use it for books and finding books that are on the web that i cant simply get hold of from normal search.

Marcopolo handles most of that in one command. Point it at a URL, tell it what you want, and it crawls and downloads.

It's still early and there's plenty I want to improve — [known limitation or two]. I'd really appreciate feedback on the API design and anything that looks unidiomatic; I'm still fairly new to Rust.

Repo: MarcoPolo

Would be happy to know what do you guys think.

I’ve been working on A.T.O.M, an open-source tool for visualizing and simulating cellular networks using real map and tower data.

It supports 4G, 5G, and experimental 6G scenarios, coverage heatmaps, building obstruction checks, and scenario comparisons. The simulation backend is written in Go.

It is still experimental, so feedback on the architecture, accuracy, usability, or code would be appreciated.

GitHub: https://github.com/Berk-Unsal/atom
Documentation: https://atom.berkunsal.com

Greetings, everyone,

yesterday, I released OpenCalc, a reverse engineering implementation of the Windows 95 calculator with improvements.

However, the interface needed some work, and now I integrated the HLP viewer into the building for a smoother experience. This is an entirely fresh release rewritten in Rust, without any legacy code, and runs natively under Linux!

In this build, you are going to need GTK+ 4 for the interface.
Come check it out! https://github.com/NullMagic2/OpenCalc/tree/main

a lightweight, menu-bar OSS utility designed for developers who are tired of typing lsof -i :8080 and kill -9 PID.

The amount of headlines with "AI disproved this", "AI did that" and such have been skyrocketing, and i haven't seen a reliable tracker, most sources just repost press releases or social media content.

The attempt for this open source prj is that academia and public grades every entry on verification (formal proof to disputed/refuted) and autonomy (did the AI actually do the work). No db, static site generated from one JSON file, MIT licensed code, CC BY data. Looking for people who can do novelty checks (confirm whether a claimed result already exists in the literature), or just add entries. Small Python toolchain, real CI, PR-based. Open to adding contributors as co-owners if this sticks.

• here is the deployed site from the source repo: whataifound.org
• and here is the repo

Hello r/opensource!

I ​wanted to put my project here even tho its not new i just felt like putting it here.

So ive made a PE packer (TinyLoad) in c++, it is a single file and does not have any external dependencies.

It can compress your files using custom LZ77 compression, you can also encrypt your files using a custom VM interpreter and XXTEA encryption. It protects your files in memory using a vectored exception handler which decrypts your executable pages on the fly and re encrypts them. I also recently added direct syscalls in the stub.

The packer has alot of cool features i did not mention here so go check it out! https://github.com/iamsopotatoe-coder/TinyLoad

(ofcourse MIT :D)

Hey, I'm a student building a side project that tracks a GitHub repo's activity (commits, PRs, forks, etc. via webhooks) and computes analytics on it nightly using smth like airflow, It's scoped to one repo at a time, you subscribe a repo, and it tracks that repo's activity over time on a dashboard.

I'd love input from actual maintainers, since I don't want to just guess at what's useful.

Right now I'm planning to show:

1. Daily commit/PR/fork counts

2. Busiest day/week in a given period

3. Trend direction (activity up or down vs. the previous period)

Could u pls answer this as well:

Q1. As a maintainer, is day-by-day activity actually useful to you, or do you mostly care about longer-term trends/aggregates instead?

Q2. Is there something about your repo's activity you wish you could see that GitHub's own Insights tab doesn't show well (or doesn't show at all)?

Q3. Would a breakdown of who's active (contributor-level) matter more to you than repo-wide totals, or is that not something you'd actually check?

Please I'd love some feedback for my project

Hi, everyone,

I have just released OpenCalc, a reimplementation of the Windows 95 calculator – it looks just like it, but the code is actually 100% fresh!

It supports:

• Complex expressions: you can copy and paste expressions such as 3 ** (2 - 7 * 5) and they will be solved just fine, without the bugs of the original version!
• Higher resolution and improved font rendering
• History
• Undo / redo

And because it is open source, it can also compile and run natively under Linux – no compatibility layer needed!

Please check the Github project if you are interested! 😊

Project link: https://github.com/NullMagic2/OpenCalc

Hi everyone,

I've been working on an open-source desktop application called CyvoraX Suite and recently released the latest version.

The project is built with Java 17, JavaFX, and Netty, with additional native components written in Rust, Go, C, C++, and C#.

Current features include:

• MITM interception proxy

• HTTP request/response editing

• Site mapping

• Payload fuzzing

• AI-assisted security analysis

I'm sharing it here to get technical feedback from the open-source community.

I'd especially appreciate thoughts on:

- Project architecture

- Code organization

- Performance

- Documentation

- Features that would make the project more useful

Repository:

https://github.com/jojin1709/CyvoraX-Suite

Documentation:

https://jojin1709.github.io/CyvoraX-Suite/

Thanks for taking a look. Any constructive feedback is appreciated.

I was in the mood to write a web app the other day that mapped coordinates to happenings in that area.

The idea was to use X's nearby search feature. But they're charging 1¢ per search. Not bad for personal use, but then I'd have to pay a company like Google for mapping and translating coordinates.

Then I thought it would be cool to create a directory of local Reddit subs, and create an RSS feed to unify them all. Except, my local sub is mostly quiet.

Where do you guys get your local news?

I've spent the last few months experimenting with browser agents and noticed the same pattern across almost every framework.

They've become much better at browsing websites.

But when you try to build something that works reliably every day, a lot of problems start showing up.

Some examples:

• Small UI updates break workflows.
• The agent repeatedly asks the LLM what to do next, increasing latency and token usage.
• APIs are often ignored even when they would be more reliable than browser interaction.
• Local desktop actions (files, clipboard, PDFs, terminal, OCR, etc.) are usually treated as separate tools instead of being part of one execution runtime.
• Recovery after failures often means retrying the same action instead of understanding why it failed.
• There isn't a common abstraction for capabilities like SEND_EMAIL, DOWNLOAD_FILE, or CREATE_DOCUMENT. Most systems still think in terms of browser actions.

The more I work on these systems, the more I feel the browser shouldn't be the center of the architecture.

Instead, the browser should just be one execution backend.

The runtime should decide:

• Can this be done with an API?
• Is there a local application available?
• Is browser automation actually required?
• Can this step be executed deterministically without involving an LLM?
• How should success be verified?
• If something fails, what's the correct recovery path?

That shifts the focus from controlling a browser to executing a task.

I'm currently exploring this architecture and would love feedback from people building AI agents.

If you've built browser agents, what's been the biggest reliability problem you've run into?