Meet OpenTerminal: a self-hosted financial dashboard with real-time quotes, candlestick charts with technical indicators (RSI, MACD, Bollinger, VWAP...), a live sector heatmap, a stock screener, crypto tracking, macro/yield curves, options chains, time & sales tape, live financial news TV, and an auto-updating market recap, all running on data sources that are 100% free and public (no API key required, no subscription, no vendor lock-in).

It also has a built-in AI assistant powered by Claude, drop in your own Anthropic API key and ask it to interpret a chart, explain an indicator, or summarize what's moving a stock, grounded in the live data already on your screen.

Why I built this: professional-grade market terminals cost $2,000+/month. Most of the data is publicly available if you know where to look, you just need the engineering to stitch it together into something usable.

Tech stack: Next.js 15 + React 19 + TypeScript on the frontend, Node/Express on the backend, lightweight-charts + D3 for visualization, Claude for the AI layer, and a fallback-chain architecture so if one data source rate-limits you, it automatically fails over to the next.

It's fully open source. Clone it, run it locally, make it yours.

⭐ Link to the repo https://github.com/ErTasselli/OpenTerminal

It takes a finished illustration and animates the text, outlines, and fills drawing themselves in sequence.

Runs locally on CPU, no API key needed. Python library + CLI, MIT licensed. Works best with clean drawings on white backgrounds.

https://github.com/masihsultani/whiteboard-animator

Would love feedback on how the animation looks.

WorldFixture gives developers a company to build, test and demo software against, instead of wiring up real accounts or maintaining a pile of unrelated mocks.

npx worldfixture up starts a fake SaaS company locally with 99 people and 30 days of history. It includes Slack, GitHub, email, Notion, Stripe, S3 and application data, all representing the same company. Maya in Slack is the same Maya commenting on a GitHub PR and sending email. Customers, projects, invoices and conversations carry across services.

Your software talks directly to the local services. Mail uses SMTP/IMAP, S3 is S3-compatible, and Slack, GitHub, Stripe and the other services expose APIs shaped like the real providers.

The company also keeps moving. Emails arrive, PRs get comments, Slack conversations continue and payments happen. You can pause time, advance it, inspect what happened or reset everything back to the same starting point.

I originally built this for DropLive, where I run disposable demos of open-source projects. I found that getting an app running was only half the problem: an empty CRM, inbox or Slack workspace still makes for a terrible demo. WorldFixture grew out of trying to fix that.

Everything runs locally and it is Apache 2.0. It is still early, and the provider APIs are incomplete. I am adding operations as I find real projects that need them.

I would love people to try it with something real and tell me what breaks. What service would make it useful for something you are building?

https://worldfixture.com/

https://github.com/ben-ic/worldfixture

What it is built on

I am using existing open-source implementations where that makes sense rather than rebuilding every service from scratch:

• emulate.dev for Slack, GitHub, Stripe and several other provider APIs
• SeaweedFS for S3
• Cyrus IMAP for mail
• SQLite for local state

WorldFixture adds the shared company and identities, history, scheduled events, clock, reset behavior, Workbench, and the extra pieces needed to make those services behave like parts of the same environment.

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

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

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’m building JSON Semantic Diff, an open-source JSON comparison tool that tries to understand array identity instead of comparing objects purely by position.

For example, it can infer keys like id, sku, or composites like store + sku, so reordered objects don't turn into a wall of false changes.

The matching is deterministic and explainable - no AI/fuzzy matching - and everything runs locally in the browser.

It’s still early/alpha, so feedback and weird JSON examples that break the matching are very welcome.

• GitHub: https://github.com/cchandurkar/json-semantic-diff
• Demo: https://jsonsemanticdiff.dev (has examples)
• npm: https://www.npmjs.com/package/json-semantic-diff

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.

Stackray is a website/url scanner that shows the technologies it detects, DNS records, subdomains, and other OSINT details.

Check it out: https://stackray.app

There's a Railway deployment template for one-click deployments of your own private instance. The app is MIT-licensed. Reports of missed technologies or incorrect detections would be useful.

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

im not sure if this is the right home and sure someone will tell me if it isnt. so, I use GH a lot for work and a bit personally - and I have been sitting on a domain I bought a few months back trying to think of a project to use it. naturally, this idea had to have something to do with GitHub.

so i made this thing: https://src.ms/start

basically dev's can get short names on a few domains (src.ms, 3nx.dev, mygit.uk, etc) and can either:

• point them at an IP that changes (dyndns, updates go through cloudflare, usually live in a few seconds)
• or just redirect them somewhere (301/302, the service handles it so you don’t mess with certs)

the whole point for me was that i wanted something i could drive from a script or CI without fighting a web UI. so the API is deliberately dumb and curl-friendly – one endpoint does create/update, you just PUT a json blob with a bearer token. keys are scoped read-only or read/write. nothing fancy.

login is github oauth only (no password forms, or security leaks/hacks). analytics for the redirect campaigns are server-side only, no client trackers, just the usual country/asn/time stuff.

it’s still in beta and gated behind a waitlist. if anyone wants to poke at it and tell me what’s broken or missing, i’ll give permanent free pro-level accounts to people who actually use it and give feedback. I added a bug log into the GUI for ease of reporting. https://src.ms/betatest

anyway… yeah. that’s it. happy to answer questions or take “this is stupid, do it this way instead” comments. or tell me to go .... off! All good! ;-)

Cheers,

Iscanic

Github : https://src.ms/iscanic

Superlearn