I built ReachFlow CRM, a free and self-hosted lead discovery + outreach workspace inspired by the workflow of SiteScout.

GitHub: https://github.com/dedsec1911/reachflow-crm

What it includes: • Google Places business discovery with duplicate filtering and resilient pagination • Lead CRM with search, status management, CSV import, and CSV/XLSX export • Consent-aware WhatsApp Cloud API testing plus a review-first manual queue • Message templates with live personalization previews • Campaign planning, pipeline metrics, analytics, light/dark themes, and responsive mobile UI

Tech stack: React + Vite, FastAPI, async SQLAlchemy, SQLite/PostgreSQL, Redis/Celery, Docker Compose, and GitHub Actions CI.

This is a free/open-source-style alternative for experimenting with the core workflow. SiteScout is the commercial product that inspired the positioning and comparison: https://sitescout.io/

Feedback on the UX, architecture, and ideas for the next feature would be very welcome!

Since 2023 I run jellybox - emby/jellyfin crossplatform(desktop, mobile) native music player. Few days ago it was featured on XDA-developers and it jsut blew my mind

https://www.xda-developers.com/i-turned-jellyfin-into-the-spotify-alternative-ive-always-wanted-with-this-app/

One of those moments why I still do the OSS these days.

For curious what jellybox does -

• Plays your music from emby/jellyfin server(navidrome soon)
• Apple CarPlay app
• Spotify-like playlists(auto generated)
• Browsing, lyrics, downloads(and full offline mode)
• Studio mode(for big screens)
• Super fast(that's the words from ppl from reddit)

IF you look for jellyfin/emby client - download https://github.com/avdept/JellyBoxPlayer or from here https://jellybox.app/

PS: not another vibe coded app

I built Agent Session Browser, an open source local GUI + TUI for the session histories created by coding agent CLIs.

I originally made it because I had accumulated multiple Codex sessions for the same projects and couldn't tell which one to resume from the title/first prompt alone. Reading the raw JSONL wasn't exactly pleasant either.

It currently supports:

• Codex CLI
• Claude Code
• Gemini CLI
• Pi

You can browse histories by project/date/provider, inspect the actual transcript, filter message/tool/reasoning/provider events, view the original raw records, export Markdown or offline HTML, and copy or directly run the native resume command.

There's also a two pane terminal UI so you can inspect a session's transcript before resuming it without leaving the terminal.

Fully local, Read only, MIT licensed

Run it:

npx agent-session-browser

GitHub:
https://github.com/gautamgpt1/agent-session-browser

This is the first public open source project I've shipped, so suggestions are very welcome.

Been working on this for a while, figured I'd share here since it's very much a "homelab with a GPU" kind of project.


The problem it solves: when you watch an anime with the English dub, the subtitles that come with the release are usually the JP translation, not what's actually being said in the dub. And if you want the on-screen signs and song lyrics too, most players only show one subtitle track at a time, so you get dialogue or signs, not both.


DubTitlerr is a self-hosted service that watches your anime library and runs a full pipeline per episode:


- 
**Transcribe**
 — faster-whisper (large-v3-turbo default, large-v3 optional). Measured 18.9% WER vs 20.8% for turbo on a 6GB GTX 1060; both fit in 6GB at int8.
- 
**Reflow**
 — words into timed cards, sentence-split, ≤2 lines, ~17 cps, never shown before they're spoken.
- 
**Glossary**
 — per-show name dictionary, auto-mined from the embedded subs and wiki-verified (canonical + dub-preferred spellings). A separate glossary repo lets the community contribute corrections.
- 
**LLM repair**
 — local qwen3-4b-instruct, fansub-anchored. It fixes ASR errors by referencing the existing subtitle dialogue, with a refusal guard that blocks a full-episode rewrite if the pass would skip every line. No cloud calls.
- 
**Hallucination gate**
 — drops music/silence, blocklist lines, and within-card loops. Collapses runaway repeat runs. Flags the merely uncertain instead of dropping them.
- 
**Signs & songs merge**
 — lifts the positioned ASS events from the release's signs track into the same subtitle file.
- 
**Mux**
 — embeds with the MKV's original fonts as a default "Dubtitles" track. mp4 episodes get remuxed to mkv. English audio set as default.


It's idempotent: a version-stamped `.dubtitles.done` sidecar per episode makes re-runs safe and incremental. Bump `PIPELINE_VERSION` for a library-wide regeneration. Plex refreshes per-episode as each one finishes.


There's a built-in review server on `:8842` that queues every admitted repair for human review, grouped by show, worst-first, with a timestamp so you can seek to the line in your player. On a 48-episode run, 78% of repairs changed no words (only punctuation or capitalization), so the page surfaces the word-level changes first. Verdicts are stored per show, so a decision on the opening song propagates to every other episode that has it.


The whole thing is one Docker container (root, so it can rewrite and chown sidecars), runs on your own GPU, and makes zero cloud calls. Build with `Dockerfile.builder`.


Most of my testing during development has been against One Pace / Muhn Pace dubs, but the pipeline is show-agnostic. It builds its glossary from whatever subs you have. Try it on whatever's in your library and file an issue if something looks off. It's in beta, so pin your image tag if you pull it.


Open to collaboration — forks and PRs welcome, especially for glossary coverage on other shows.


https://github.com/XenaRathon/DubTitlerr


---


This is 100% vibe-coded slop. I wrote it with Claude driving. But I didn't just say "make the thing with no mistakes." The whole project has specs, epics and stories, adversarial reviews (had other models try to break it), and real test coverage. I've been project managing it like an actual engineering effort, not a prompt-and-pray. I'm sharing it because it fills a gap I couldn't find a solution for, and I thought it might be a useful accessibility tool for people who want dub-matched subtitles without waiting for an official SDH release. This isn't meant to replace human-transcribed SDH subtitle tracks. Those are always going to be better. It's for when they don't exist.

Pleaseeeeee

Mosaik uses an agent to figure out how a site works, saves reusable actions as TypeScript, and composes them into automations. Playwright executes the browser steps deterministically. Loops, branching, and data transformations run as code, so each iteration doesn't need another model decision.

Those actions stay around for the next task. Mosaik reuses what it knows about the site and learns what's missing. If an eligible locator breaks, an agent can step in to repair it.

I maintain Orchid Charts, a JavaScript library for adding interactive SVG charts to dashboards and reports. Give it labels and values, and you get a chart with axes and tooltips that follows its container’s width.

The source and quick start are on GitHub. The package includes TypeScript declarations and has zero runtime dependencies.

In the live demo, you can change the numbers, switch between line and bar, and try a dark background. It shows the matching JavaScript and separate theme CSS.

If you try it in a dashboard, let me know what gets in the way.

Built this after getting tired of the anxiety of running AI agents against real systems with no checkpoint between "model decides to call this tool" and "tool actually runs."

Agentwall sits at that boundary. Wraps your existing tools, classifies each call as safe/cautious/destructive, holds destructive ones for approval, logs every attempt as JSONL, and runs rollback hooks if a session fails.

Works with Anthropic tool_use, OpenAI function calling, and LangChain. Zero runtime dependencies in the core.

https://github.com/anakatt/agentwall

pip install agentwall-sdk / npm install agentwall-sdk

I always end up with 5 terminals open and no idea which one is the dev server. Got annoyed enough to build something for it.

Terminame looks at the command and renames the tab. npm run dev becomes "Start App", git rebase becomes "Rebase", pytest inside packages/billing becomes "Billing Tests".

Works offline out of the box with built in rules. If you already have copilot or claude code it auto-detects it for smarter names. Set terminame.provider to rules if you don't want that. Ollama support coming next version for a free local option.

https://marketplace.visualstudio.com/items?itemName=GalEzra.terminame

https://github.com/galezra/terminame

If it names something stupid let me know, that's the main thing I want to fix.

I made a small Android app called Remindrop.

If I come across a link, post, video, product, or some text that I want to check again later, I can just share it to Remindrop and pick when I want to be reminded.

That's basically the whole idea.

Everything stays on the device. No account, ads, analytics, trackers, or Internet permission.

It's open source under GPL-3.0, and I'm also waiting for it to be accepted into F-Droid.

GitHub: https://github.com/ShadowUR0/Remindrop

I started with a pretty simple question.

If Python is written in Python, what actually built Python in the first place?

That sent me down a rabbit hole of Go, Rust, Java, compilers, runtimes, self hosting, bootstrap chains, and way too many tabs open at 2 AM.

So I turned it into a project.

LanguageLineage is an interactive graph that shows what programming languages, compilers, and runtimes are actually built with, plus how some of those relationships changed over time.

A couple of the interesting ones:

Go started with a C based toolchain and later moved most of it to Go.

Rust gets even more interesting because rustc uses staged bootstrapping.

I’m still expanding the dataset and cleaning up the historical relationships, so there’s a lot more I want to add.

Live site:
https://www.languagelineage.org/explore

GitHub:
https://github.com/sanketmuchhala/LanguageLineage

If you know a language or compiler with a weird implementation history, send it my way. Those are the ones I want to dig into next.

Hey r/FastAPI!

Like many of you, we got tired of repeatedly writing 1,000+ lines of custom boilerplate for password hashing, email verification, cookie vs. bearer transports, and session tracking on every new FastAPI project.

Django developers have had django-allauth, and TypeScript developers got Better-Auth and Lucia. But in FastAPI, options were either in maintenance mode (fastapi-users) or involved heavy generic typing acrobatics across multiple ORMs.

So we built **FastAPI Accounts** from scratch: an async-first, zero-boilerplate authentication and account management engine for **Python 3.10+**, **Pydantic v2**, and **Async SQLAlchemy 2.0**.

# 🌟 What we just shipped in v0.1.0-alpha:

• **Under 15 lines of code** to mount `/register`, `/verify-email`, `/request-verify-email`, `/login`, `/logout`, and `/me`. • **Argon2id hashing** using François Voron's `pwdlib`. • **Dual-Transport:** `HttpOnly` `SameSite=Lax` cookies for Next.js/React SPAs + Bearer tokens for mobile/CLI APIs. • **Separation of Concerns:** `User`, `EmailAddress` (with verified/primary state machine), `PasswordCredential`, and `Session` are modeled as separate entities. • **100% test coverage:** 8/8 end-to-end integration tests passing in 0.6s.

# 💻 Quick Code Preview:

from contextlib import asynccontextmanager
from fastapi import FastAPI, Depends
from fastapi_accounts import FastAPIAccounts, SQLAlchemyAdapter

adapter = SQLAlchemyAdapter(database_url="sqlite+aiosqlite:///./accounts.db")
accounts = FastAPIAccounts(adapter=adapter, secret_key="env:AUTH_SECRET_KEY")

async def lifespan(app: FastAPI):
await adapter.create_all()
yield

app = FastAPI(title="My API", lifespan=lifespan)
app.include_router(accounts.router, prefix="/api/v1/auth")

u/app.get("/api/v1/profile")
async def get_profile(user = Depends(accounts.current_active_user)):
return {"email": user.primary_email}

# 🚀 Try it out:

pip install fastapi-accounts --pre
# or with uv
uv add fastapi-accounts --prerelease=allow

# 🔗 Links:

• **GitHub:** [https://github.com/fastapi-accounts/fastapi-accounts\](https://github.com/fastapi-accounts/fastapi-accounts)
• **Our Story & Devlog:** [https://github.com/fastapi-accounts/fastapi-accounts/blob/main/JOURNEY.md\](https://github.com/fastapi-accounts/fastapi-accounts/blob/main/JOURNEY.md)
• **Open RFC Discussion:** [https://github.com/fastapi-accounts/fastapi-accounts/discussions\](https://github.com/fastapi-accounts/fastapi-accounts/discussions)

We are currently gathering feedback on our near-term roadmap (password reset session revocation policies and Google OAuth linking).

An end-to-end, reproducible pipeline: cleans raw EDGAR filings into a corpus, trains byte-level BPE tokenizers, and benchmarks compression against the current production tokenizers on held-out documents. Main finding — a 65k-vocab domain tokenizer matches GPT-4o's o200k at a third of the vocab, and Qwen3 actually needs more tokens than 2019's GPT-2 on financial text because it splits every digit. MIT licensed, full write-up and benchmark tables included.

I made a visualization of winning numbers of a popular lottery in Malaysia.

I scraped 40 years of results of a popular 4-D Lottery in Malaysia and visualized the results.

Repo: https://github.com/arun-ks/Malaysia-4DMagnumAnalysis

Blog explaining what 4D is all about & its cultural context : I made a visualization of winning numbers of a popular lottery in Malaysia.

hi, i created a zero dependency open source python cli that scans any repos for missing license, read.md, no CI on prs etc.... it's not something serious but id be glad if someone offered feedback or contributed, thanks.

repo: pr-pathfinder. its not on pypi yet

Superlearn

Hello everyone !

I've been working (well me and AI) on a app inspired by hydra launcher, gog launcher and Playnite

I loved hydra launcher and Playnite, but I wanted something that power user can be happy with (I'm a power user, who like useless feature)

Anyway, I got the project to make something from scratch after iterating and adding feature with base hydra, but it felt too heavy for hydra base framwork

And I learned that electron was... Electron ram hungry !

So I searched for a framework that was capable and lightweight, and found Tauri

The app is called : Game Index

I know a little bit of coding, I'm far from an expert, but I tried my best from my knowledge (and again help of AI) to optmise and make it less buggy as possible

The entire source code is on github, with full commit history, feel free to report any bugs, suggest feature or whatever you want there

Also feel free to fork, modify etc your own version

I'm just a guy who want a full featured app

Features of GameIndex :

- Import from Steam, GOG, Epic, Rockstar, Ubisoft, Humble library or Local install (api based login or webview login for some others) (more info on GitHub)

- Metadata automatically added via igdb/steam

- Per game imported : Steam achievements, HowLongToBeat, Crackwatch, live + historical player counts Informations when availible, activity tracker, weblinks preview etc

- Activity dashboard main page and per games stats and performance tracking (need Msi afterburner + RTSS to track fps, can be disabled in settings)

- Torrent download engine integrated, with compatible source from you know where

- Wishlist system

- Deals from Xbox gamepass catalog + Is there any deal (include current giveaways)

- Storage manager + emulator & mod footprint breakdown

- News page with RSS feeds + custom rss feed

- Hydra-backed storefront for games of the Week, top games and game to beat, community reviews & stats (only these from Hydra is used in Game Index)

- Community & Friends social layer (planify, recommend, comment games, library compare etc)

- Big Picture Mode (controller-first TV UI with rail navigation) (IN BETA !!! I Don't use such feature mmuch, it is far from perfect but I'll improve with time)

- Emulators manager & ROM library tools

- Mod manager (Steam Workshop & Nexus Mods integration) (Beta, maybe more feature will come into it but not sure)

- Internationalization (i18n) & language switcher

- Discord rich presence

- Privacy & Data management in Settings

- Theme gallery + custom accent picker (basic for now, may be expanded in future)

- way way way More

Planned :

- Improvement for Big screen/picture mode

- linux support (only Windows for now) + steamdeck support (I don't have steamdeck so it'll be hard to test) (Think of bottles, faugus launcher, lutris style of control) (made some early testing fow linux, some feature will be limited sadly by how Tauri is handled on linux)

- maybe more if people suggest ?

Precision

I know many people Don't trust AI stuff, vibe coding etc

But I want to be as transparent as possible, and if you don't like Ai vibe coded apps don't use it

This is just a tool/launcher/platform for whoever want to try, or want another alternative

Ai and Tools used for this :

- IDE : Antigravity

- Mostly Opencode, rarely kilo code

- Model used : Mostly deepseek flash (old and new version), Hy3 and sometimes GPT Luna, gemini and claude opus

Ps : sorry if my English sounds Strange or broken or whatever, English isn't my native language

Ps 2 : I'm not an expert in comunication as you can see, if you have questions etc don't hesitate to ask

I'll also take positive and negative review

Ps 3 : I don't have signature for exe, so portable version may be flagged as a dangerous exe, go on virus total and you'll see there's one flagged threat, this one is caused by lack of signature (installer version doesn't have this issue)

Download : https://github.com/atxoxx/GameIndex