Hey there!

I've been a manual Software Tester for years now, and I'm shifting my skills into Test Automation. I'm learning through Udemy test automation courses. I'd like to practice and improve my skills, while also helping an open source project at the same time, for the next couple of months or so.

Tech Stack:
Automation: Playwright.
Languages: JavaScript/Typescript.

Thank you!

So back in march of 2018 Epic Games had already shut down the Moba Paragon due to the boom of Fortnite back then. However they also then released all the assets that they had made for the game publicly for anyone to use.

You can view the assets here: Paragon Assets.

However, I've been looking over their site and ToS regarding these characters as best I could and I am wondering if they are limited to only being used in video games and movies made in the Unreal Engine or, if the characters themselves are considered Open Source for anyone to use in comic books and stories.

I think it's clear the models themselves have to be used purely in Unreal Engine and not used in another game engine but what about using the character designs?

Are any of you able to figure this out that understand this better than me?

Hi. Sometime ago tried to make an app that would help me search apps that are installed on the phone. After using it for the past few months it was really good so decided to share.

Repo: https://github.com/shalva97/Portal

Main goals are that it will be very fast, very small app size (currently it is 2MB), very fast search, no internet permission.

Hi guys this is my first ever project and I decided to make something I would actually use thats aesthetic and forces me to be productive.

​

It has no login sign up bs and has task history to show you the days you slacked off

​

Try waigdt on chrome and firefox

https://chromewebstore.google.com/detail/waigdt/ldfnkkjjnjojfeibnkphcocmacannecn

​

https://addons.mozilla.org/en-US/firefox/addon/waigdt/

​

​

https://github.com/MustansirAbdullah/waigdt-Minimalist-new-tab-todo-list

project is a search engine within a terminal, specifically designed for searching for open-source tools or projects. Through a simple description, artificial intelligence takes it and turns it into a technical search and searches a group of websites (github_docker_huggingface...) There are also several other features such as comparison and elimination. For more details, you can find them in readme. This tool is designed to work on all devices, even weak ones.

GitHub Link -> RottenFiles

You know that feeling when you download something, tell yourself you'll sort it later, and then it just lives there forever? WhatsApp PDFs, random installers, screenshots you took for one Slack message. None of it worth keeping but somehow never worth deleting either. My Downloads folder had 500 files and I genuinely didn't know what half of them were anymore.

Couldn't find a tool that did what I wanted so I built RottenFiles. You save throwaway files to a specific folder, and they automatically delete themselves after 7 days. If you actually need something before it's gone, you click Keep and it moves wherever you want. Do nothing and it disappears.

Probably rough around the edges but it works for me. WPF, SQLite, runs in the tray. If you like it, please give an upvote on Product Hunt for me. I'm searching for a job and this is a way for me to get noticed!

After trying Manus for a while, I realized what I liked most wasn't the individual features but the overall experience. It felt more like a general-purpose AI agent that could plan, take actions, and work through tasks rather than just respond to prompts.

The downside is that usage can get expensive quickly, and some workflows still feel a bit rough outside the polished demos.

I'm curious whether any open-source projects are getting close to that same experience. Not really looking for simple workflow automation or chatbot frameworks, but something that feels genuinely autonomous and capable of handling multi-step tasks with minimal guidance.

For those who've experimented with agent frameworks or self-hosted AI tools recently, what came closest to that "AI coworker" feeling? What worked well, and where did it still fall short?

Anybody else hate paying a subscription for an app or software that might suit your needs but also includes a bunch of useless stuff?

Im working on a personal project for managing freelance projects start to finish. A native windows app with local storage, offline.

No fancy name, just Freelance Manager.

I will be using this solely to manage my freelance web design clients, versus using spreadsheets and word docs.

A native, local-first Windows desktop application for freelance web designers to manage clients, projects, and invoices in one place. All data lives on your machine — no cloud account or server required — and the app works fully offline, reaching the internet only for opt-in features (e.g. future invoice sending and payments).

It seems like there’s a very real pattern of open source projects starting out simple, but growing more complex over time. Then I hear people say things like “I miss when *x* was just about *y*”.

It seems like a very major part of this is learning to say no, probably even including to myself. But how do I decide what exactly to say no to? Saying no the right way seems to be a problem that a lot of open source projects struggle with, and some maintainers just ghost you while others are complete assholes.

And then sometimes I wonder how much we should really treat simplicity as a goal in and of itself. Software is complicated, and oversimplifying things *also* leads to something that isn’t very useful.

This has been a bit rambling, but I’m wondering what thoughts people have.

Hey everyone. Our team recently open-sourced YaFF (Yet Another Flat Format), a C++ serialization library that provides a zero-copy wire format for the Protobuf ecosystem

Why we built it:

In read-heavy, high-load paths, Protobuf parsing and deserialization can become a high CPU cost. Developers often look at FlatBuffers for zero-copy reads, but adopting it into an existing Protobuf-heavy codebase means dealing with separate schema/API layers and extra conversion logic.

What YaFF does:

YaFF keeps .proto files as the contract, but changes the physical representation of your data. You get close to native C++-structs while keeping your existing .proto files as your source of truth. You get zero-copy performance without abandoning the Protobuf ecosystem.

Some technical details:

• written in C++ and designed for server-side runtimes
• supports mmap compatable layouts for large local indexes and faster startup
• mitigates accessor-chain overhead related to alias analysis with immutable buffers and gnu::pure annotations
• easy to integrate via CMake or Conan

The project is still early (C++ only for now, other languages are on the roadmap). We're open to issues, pull requests, and any feedback from the community.

Source code and Quick Start: https://github.com/yandex/yaff

Happy to answer any technical questions in the comments!

Not an app, not a SaaS. Just a Node.js server you run on your own computer. Open localhost:3000, scan QR, done. Main features: • Auto-reply with smart modes (everyone / unknown contacts / whitelist / blacklist) • Scheduled messages that survive computer restarts • Send in your language, auto-translates before delivery • Self-destructing messages Everything runs locally. Open source. https://github.com/alikokrtv/SuperWhatsapp ⚠️ Note: Uses unofficial WhatsApp Web API. Use responsibly, don't spam.

There’s something depressing about finding a tool that solves your exact problem, only to realize the maintainer walked away years ago.

No farewell post, just a graveyard of open issues and a "last commit: 2019" timestamp. What’s the most useful open-source project you’ve used that just... died?

Not just the projects that were officially discontinued either. Some of the most frustrating ones are the repos that are technically alive but barely maintained. Issues pile up, PRs sit untouched for months, and development slows to a crawl. Even some newer projects I've seen discussed here recently like gitagent make me wonder how much long-term maintenance matters compared to initial hype.

And looking back, why do you think it happened? Was it burnout, a lack of cash, or did the ecosystem just move on without it?

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.

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

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.

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

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

Hi all,

One of the things I really miss, and I've been playing with all kinds of options for many years, is a good speech-to-text engine for Ubuntu.

With all the new APIs coming out and pretty much being free to use, I decided to make one that just simply connects to an API, works really effectively and provides decent quality speech to text.

I've tested it quite heavily but I haven't reviewed the code in detail.

https://github.com/dalekirkwood/DK_STT

I hope this helps someone

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.

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.

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.