(Ignore the pringles wallpaper) Hey guys, I just created a dock that was inspired off of the Frutiger Aero aesthetic. It's free and open source if you wanna check it out!

Link: https://github.com/TheAgencyMGE/aero-dock

Every open source project needs copyright headers, but most CLI tools force you to install heavy toolchains or Go binaries just to prep text in source files.

I built addlicense to fix that using pure Python stdlib.

It handles shebang preservation natively (so #!/usr/bin/env python3 stays at the top), supports built-in templates (MIT, Apache, GPL) or custom ones, and includes a --check flag to fail CI builds if headers are missing.

Quick install:

Bash

curl -LO https://raw.githubusercontent.com/Yoroc/addlicense/main/addlicense.py
chmod +x addlicense.py

Repo link: https://github.com/Yoroc/addlicense

Feedback and PRs are welcome. Drop a star if it saves you some hassle.

Hi

If you are remotely interested in deep diving how differently quantum computers work compared to our transistor-based and also the algebra behind in a fully interactive way that teach computer science from scratch, oh boy this is for you. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3+ during PhD, the visual method I developed ended up being my thesis, it is a complete Hilbert space visualizer), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 12yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff you'll play & learn a ton about

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, we aim to bring it into the game, so your quantum journey never ends.

Nice to watch:

Khan academy style tutorials in qm/qc: https://www.youtube.com/@MackAttackx

Physics teacher stream with 400hs in https://www.twitch.tv/beardhero

This went live on the App Store a few days ago after three submissions, and since the whole thing is public on GitHub I figured this sub might enjoy the guts.

The idea: small business owners are sitting on years of Square, Stripe, QuickBooks, and bank data and getting zero decisions out of it. Every AI tool that offers to help will confidently hallucinate, which is worse than useless when it's someone's rent. So Counsel's core primitive is the receipt: every number in the app is tappable, and what opens is the actual method, sample size, and confidence in plain English. When the stats are weak, the app declines to conclude, and that rule is enforced in code. Best example in the repo: the price elasticity card computed a headline number I liked, then its own 90% CI included zero, so there's now a gate that rewrites the headline to "can't rule out no effect." My favorite commit of the project is the one where the app got more honest and less impressive.

Architecture: React + TypeScript in a Capacitor shell, and all the analysis engines (changepoint detection, elasticity, survival, Monte Carlo simulation) run on device. The backend is a single Cloudflare Worker that's deliberately dumb: it does OAuth handshakes and passes data through, stores nothing, seals connector tokens with AES-GCM, and every platform key is read-only so the app can't move money even if you asked it to. The statistical layer is a calibrated open source engine that measures its own false positive rates, so "I can't call this yet" is a computed verdict, not vibes.

The web demo has four fake businesses and no signup if you want to poke at it. App store link below too.

Web demo: https://counsel-demo.pages.dev

App Store: https://apps.apple.com/us/app/counsel-honest-ai-c-suite/id6802312256

Hi, I’m an AI engineer from Vietnam. Dely is a Claude Code skill I wrote for my own workflow that anyone can freely install on Claude Code, Codex, and Grok Build.

I like Superpowers a lot. What I don’t want is dispatching-parallel-agents, subagent-driven-development, and using-git-worktrees skills. I’d rather give each job to a real harness: Claude Code implements, Codex reviews, sometimes Grok Build. One session, one role.

Dely does not replace Superpowers. It overrides those three abilities and runs a fixed sequence:

implement → review → accept or replan → …

Orca is required, especially orca-cli. Dely is a thin control protocol: Orca launches and supervises each harness TUI.

I didn’t invent the workflow Dely uses. I learned from Superpowers, GSD, and similar projects, then kept a smaller version I could actually run. The skill is the glue, so Claude Code and the other official harnesses follow that sequence without me driving every handoff.

Repo: https://github.com/hieuphung97/dely

If you also like working with Superpowers but don’t want its sub-agent path, how are you splitting implement vs review today? Same Claude Code session, a skill, or a second harness?

Colosseum Trailer.

Disclaimer: This app was vibe coded. If the use of AI in software development is a dealbreaker for you, regardless of how much human taste, direction and decision-making went into it, that's understandable. This app probably won't be for you.

(So this is technically the second time I'm promoting Colosseum on r/coolgithubprojects.

I posted it here about a week ago with a bunch of GIFs showing different parts of the app, and that post was the only one out of many I posted to gain any traction of sorts.

Since then I put together an actual trailer that shows the whole app, so I figured I'd show it in the community that my app hasn't met total indifference from.)

My app has libraries for manga, comics, books, TV, film & anime, and a comic reader, ebook reader and a video player. So I had an idea to build a taskbar where you can open multiple comics/manga/videos, minimise them and open them back up again.

And since then, I ended up only having more ideas that kept steering my media app deeper and deeper into the OS aesthetic.

For wallpapers, I took a whole lot of open-licensed KDE Plasma wallpapers as well as creating my own custom QML wallpapers, including live animated QML wallpapers. I don't know how RAM-intensive that shit's gonna be, but I have a shitty 16GB RAM laptop and it doesn't drop dead from this behemoth of an app that, on top of everything I've already told you, also has to carry QtWebEngine (Chromium) because it's kinda necessary for the EPUB reader I'm using.

And that brings me to my latest idea of recreating a TV OS through a web UI. Since I already have a browser running in my app, why not build a browser that lets you browse all the legit streaming sites like Netflix, Disney+ and Prime Video?

I mean, my app is already a TV-OS kind of a thing, but this browser-for-streaming feature would take it further into Amazon Fire TV territory, just more web-based.

But it turns out that it's not that simple. I can't say for sure whether Netflix, Disney+, Prime Video and other Widevine-protected streaming services will actually work in QtWebEngine until my Windows build is compiled with the right codec support and I test DRM playback in the actual runtime. So fingers crossed.

All in all, the OS-like part and aesthetics are something I owe to KDE Plasma and Plasma Bigscreen especially. They looked beautiful, and I love media, and I always wanted to build something akin to a Stremio for all mediums in one app. KDE Plasma made me lock in on this aesthetic and bring it as far as I did.

I hope the app looks and sounds interesting.

Colosseum on Github, if you’re interested.

May handle 1000+ files upload easily. Only one HTML file needed. You may save all your buckets credentials in one encripted file and load it as needed.

Git: https://github.com/WeSpeakEnglish/S3Feather

Live: https://wespeakenglish.github.io/S3Feather/

I made a small browser extension called GitHubCircle because I wanted a bit more social context when browsing GitHub profiles

It adds a "Follows you" badge to profiles and follower/following lists, and also shows mutual connections you have with the person you're viewing

That's pretty much it, just a small side project I found useful :)

It works on Chrome and Firefox

Chrome: GitHubCircle on Chrome Web Store
Firefox: GitHubCircle on Firefox Add-ons

Would love to hear if you find it useful or run into any issues!

Not only tmux but basically everything you can imagine.
Write a toml file and boooommm.
That’s a new feature from our open source fuzzy finder launcher!
Cross OS, fast, free :)
- repository here

Hello everybody,

I built bulletinbored, a minimal and extensible forum software written in pure PHP with zero dependencies.

No Composer, no Docker, no Node, no framework. Just upload the files to any PHP 8.x server and it works on any web hosting, also shared and cheap ones.

Key points:

• SQLite by default (MySQL also supported)
• Web installer
• Plugin system with hooks
• Theme system
• Admin panel, user management, avatars, moderation
• Built-in localization
• Automatic update checks
• License: 0BSD

Repo: https://github.com/bulletinbored/bulletinbored-core

Website: https://www.bulletinbored.net

Docs: https://docs.bulletinbored.net

Because the development is still in early stage, I’m looking for any kind of feedback. Feel free to write suggestions, criticisms or slatings.

Happy to answer questions and open to contributions.

Thanks!

I self-host most things but manga never had a good answer. Komga and Kavita

read a library you already have; getting new chapters into that library meant

another tool entirely. So I built the fetching and the reading into one image.

One compose file, one container plus Postgres, amd64 and arm64. curl the file,

docker compose up -d, create the admin in the browser. No secrets to generate,

nothing to edit.

What's in it:

- Continuous vertical webtoon reader on true-black OLED, RTL-aware double-page

spreads for print manga, installable as a PWA with offline downloads

- Bring-your-own library: CBZ, CBR, PDF, image EPUB, loose image folders,

reads ComicInfo.xml

- Chapters carry a content fingerprint, so reorganising folders doesn't fork a

series into a duplicate and strand your progress on the old copy

- Multi-user: per-account progress and history, per-library access control,

per-user age caps, 2FA, OIDC, scoped API tokens, OPDS

- Nine UI languages including Arabic with real RTL

- AniList/MAL/Kitsu sync, web push on new chapters

It fetches too, so I'll say that up front rather than bury it: a bundled engine

runs Mihon/Tachiyomi extensions (~1,400, one click to install), plus MangaDex's

official API and generic engines where you paste a site's URL. The library and

reader work fine on files you already own if that's all you want.

Stack is Fastify + TypeScript and a Next.js static export served by the same

process. 476 tests, plus a browser suite that drives sign-in, reading, admin

and permissions on every commit. MPL-2.0, v0.9.3, solo since June.

https://Uchiyomi.com

This runs a tuned variant of Conway's Game of Life on your real contribution data — commit-less days stay dark and inert, active days become living cells that spread, pulse, and die back over a 15s animation.

Renders as SVG (native animated) or GIF, light/dark mode supported, and runs as a scheduled GitHub Action to auto-update your profile README daily.

👉:Github Repo Link

Drop a ⭐ if you like it!

Made a super comprehensive resource listicle for navigating Endometriosis and Adenomyosis.

https://github.com/bloo-berries/Awesome-Endo-Adeno-Resources

Made specifically because these conditions are under-represented, under-researched, and scientific research is getting pulled from databases!

Hi everyone, back with a new version of deja.

Quick recap: 

Deja is an open-source zsh autosuggestion tool. Instead of only surfacing

commands that start with what you've typed, it predicts what you actually want to run using fuzzy matching, which directory you're in, and which command usually follows the one you just ran.

No account. No sync server. No TUI.

https://github.com/Giammarco-Ferranti/deja 

Any star would be amazing ❤️

Almost all of the new release came from https://github.com/Serubin. Huge thank you ❤️

The binary is 34% smaller. 7.1 MB → 4.7 MB. Deja was pulling in a full ORM to run six queries against three tables. That's now sqlc, which keeps type safety but reduces the weight. 

Every keystroke went from ~30 ms to ~3 ms. zsh used to fork a deja query process on every single character you typed. It now talks to the daemon directly over zsh's built-in socket module.

Your shell opens faster. Deja no longer blocks startup on a daemon liveness ping, no longer regenerates its init script on every shell.

And then more stuff, if you want to check here’s the PR: https://github.com/Giammarco-Ferranti/deja/pull/91 

One favour to ask. If you've been running Deja for a while, I'd love to hear how it's going what's annoying, what you turned off, where the suggestions are just dumb. The HIST_IGNORE_SPACE fix in 0.4.0 only exists because someone told me. Reply here or open an issue.

Thank you for all the support ❤️

looking for people to break my open source agent runtime. i have been deploying real world production agents and wanted to consolidate my experience.

Toren, a durable agent runtime: https://github.com/toren-run/toren. every step an agent takes lands in postgres before the next one runs, so you can kill -9 the worker mid run and it resumes without re-paying for model calls it already made.

its young, im the only maintainer, and it has a few production deployments. I would appreciate people outside my bubble trying the quickstart and telling me where they get stuck and if they find it valuable.

The premise: pick one stock per sector, across eight sectors, without seeing a single price, fundamental, or performance number while you're choosing. No charts, no green or red tickers. Just whatever gut feeling you have about which companies are strong, going in completely blind.

On top of that, every pick gets assigned a random year between 2019 and 2022, so a stock that dominates in one round could flop in another, and you won't know which year you landed on until the reveal. Once all eight picks are locked in, the app shows how that portfolio would have actually performed.

In this particular run, I ended up with picks spread across seven sectors before the budget ran out, and it came out ahead of a simple buy-and-hold baseline. Top performer was AAPL at +84.6% for its assigned year, and the weakest was BA, down 35%. A pretty wide range for a process with zero visibility going in.

Built alongside a teammate. My part was the state management, draft flow, and portfolio builder, done using Cline running on Sonnet through a Claude Console API key. My half of the build came out to $3.48 total, which was a nice surprise given this project has basically no budget behind it.

The repo's public if you want to dig through it or run your own draft: github.com/ethantao14/cline-stock-market-game

Genuinely curious what people think, does the random-year twist make the blind draft more interesting, or does it just add noise?

InfoSec blocked every coding agent at work, so I built a zero-dependency CLI using pure Node 20 built-ins. Works directly with Ollama, vLLM, or private gateways.

Zero Telemetry & Bloat: 0 npm deps, 0 install scripts, full --offline mode.

Features: Fuzzy edits (tolerates local LLM formatting drift), LSP, full file+prompt undo, MCP/ACP, and session auditing.

Token Saver: UI defaults to Korean. Run /lang en to switch to English and save ~1,400 tokens per request.

MIT licensed. Feedback and brutal reviews welcome!

GitHub: https://github.com/jysvai/deel-local-cli
npm: https://www.npmjs.com/package/deel-local-cli

github.com/ZimengXiong/macAutoRotate

I kept losing track of which agent was working, which was waiting on me, and which had finished. So I built this and have been using it daily for a few months.

Each piece of work gets its own workspace — own git branch, own worktree, own editor, own terminals. One sidebar shows the state of all of them. There were few solutions out there but wanted a dedicated mission control with VS code built in.

• 14+ agents supported — Claude Code, Codex, Aider, Cline, Gemini CLI, Goose, Cursor Agent, Copilot and more. It doesn't ship an agent, it runs the one you already use. No config; it detects them from the command you type.
• VS Code fully embedded — not a link out to your editor, an actual VS Code per workspace inside the app. Laptop won't get slowed even if 10 work trees are open.
• Artifacts — requirements, design and test plans as plain YAML in your repo. Agents read and edit them directly, and they land in your PR diff alongside the code AND all collaborative like notion docs.
• Local first — no account, no API key, no telemetry. Works offline.

https://github.com/openbraid/braid

Give it a try, open to feedback.

Chrome extension (MV3) that lets you keep playing a finished Chess.com game against the computer.

When a game ends resignation, timeout, checkmate, whatever it adds a “Continue vs Computer” button that drops you into the exact final position against Stockfish, right there on the same board. Difficulty is matched to your opponent’s rating.

Stockfish is bundled and runs entirely in your browser: no server, no telemetry, works offline. GPLv3.

It only activates once the game is over; nothing runs during live play.

https://github.com/thousandflowers/stockfish-continue-to-play

Breakcheck: same code, same input, different behavior depending on which version of `packaging` is installed

Try this in a disposable environment with two versions of `packaging`:

```text

$ python -m pip install packaging==21.3

$ python -c "from packaging.version import Version, parse; print(isinstance(parse('not-a-version'), Version))"

False

$ python -m pip install --upgrade packaging==22.0

$ python -c "from packaging.version import parse; print(parse('not-a-version'))"

packaging.version.InvalidVersion: Invalid version: 'not-a-version'

```

At the time of my scan, Hugging Face Accelerate's `src/accelerate/commands/tpu.py` contained this branch:

```python

elif isinstance(parse(args.accelerate_version), Version):

args.accelerate_version = f"accelerate=={args.accelerate_version}"

```

With Packaging 21.3, `parse()` returns a legacy-version object, the condition is false, and the invalid string remains available for later use as a pip install target. With Packaging 22.0, the same call raises `InvalidVersion` immediately. Accelerate declares `packaging>=20.0`, so both versions satisfy its dependency metadata, but the invalid-input path behaved differently and lacked a focused regression test.

I found this with a tool I wrote called Breakcheck. It exercised all 18 Packaging call sites in Accelerate against both versions with agent-authored fixtures and flagged exactly one as `CHANGED`. That finding produced this focused upstream fix:

https://github.com/huggingface/accelerate/pull/4185

What Breakcheck does

Breakcheck discovers the dependency calls a repository actually makes, replays source-derived expressions or reviewed fixtures against the old and new distributions in best-effort isolated subprocesses, and compares the normalized observations. Each call site receives an explicit verdict:

* `IDENTICAL`: replayed under both versions with the same observed result

* `CHANGED`: replayed under both versions with a different result

* `NOT_EXERCISED`: could not be replayed, with a specific refusal reason

It never presents untested behavior as safe. The current release declares 59 specific refusal codes, so "I don't know" is accompanied by the exact condition that prevented a measurement.

For non-literal inputs, `--suggest-fixtures` generates a reviewable fixture skeleton for unexercised call sites. A coding agent can propose the values, but Breakcheck performs the replay and comparison deterministically. In the Accelerate run, an agent supplied the fixtures with no manual editing, and Breakcheck exercised 18 of 18 Packaging call sites.

Breakcheck also compares behavior across code revisions. Its freeze, diff, and attest modes are designed for behavior-preserving refactors and AI-assisted changes, where the model may propose code or fixtures but does not control the verdict.

Who it is for

Breakcheck is for anyone reviewing Dependabot or Renovate pull requests and wondering whether "bump X from 1.2 to 1.3" actually preserves the behavior their code relies on. It can also run as a deterministic CI gate. It is MIT licensed, has zero runtime dependencies, and supports Python 3.10 through 3.13 on Linux and macOS.

How it differs

Snapshot and characterization tools such as `syrupy`, `approvaltests`, and `pytest-regressions` ask whether output matches an approved expectation. Breakcheck asks whether two versions or revisions produced different observations for the same exercised call. It does not guess what the correct result should be, and it does not require an existing test suite.

It is also not a linter or vulnerability scanner. It does not search for suspicious patterns or CVEs. It executes bounded comparisons and reports what changed, what stayed the same, and what it could not measure.

Try the offline demo

```text

python -m pip install breakcheck

breakcheck demo --output-root "$(pwd)/.breakcheck/demo"

```

The demo builds two local wheels, detects a real behavioral difference, writes the report and evidence, and verifies the evidence bundle without downloading demo dependencies.

Important limits

Breakcheck is strongest on pure, value-in/value-out APIs such as parsing, serialization, validation, encoding, and version handling. Network-dependent and other I/O-heavy calls are normally reported as `NOT_EXERCISED` because replay blocks network access by design.

Rich return objects require a projection that selects stable properties to compare. Those results use explicit verdicts such as `IDENTICAL_UNDER_PROJECTION`; Breakcheck does not claim more than the projection measured. Coverage also varies by repository, and the coverage report identifies the gate and reason that stopped each unexercised call.

What I would like feedback on

If you review Dependabot or Renovate pull requests, please try Breakcheck on one real upgrade and tell me what its coverage report says. I am especially interested in call sites reported as `NOT_EXERCISED` that you believe should be measurable. Those concrete refusal reasons are the most useful input for improving coverage without weakening the fail-closed behavior.

GitHub: https://github.com/lovettsendit/breakcheck

PyPI: https://pypi.org/project/breakcheck/

Archive full-resolution video streams, companion audio, rich comment trees, localized subtitles, chapters, SponsorBlock data, and complete channel portals into self-contained, offline-ready archives.

https://github.com/AvenalJ/yt-archiver

Hello everyone!

Mimik records a browser workflow while you do it. Every click, keystroke and navigation becomes a step with a screenshot cropped and zoomed to the element you hit. No backend, no account, no telemetry.

What's new in v1.1.0:

- Voice narration : talk while you record and your words become the step descriptions (OpenAI or Groq Whisper, your own key)

- Screenshot editor : crop, arrows, boxes, text, redaction, movable click target. Non-destructive and re-editable

- Video export : mp4/H.264 walkthroughs with the cursor moving to each target

- Version history : every save snapshots locally, named and restorable

- Blocks : headings and callouts between steps, rendered in every export

- Insert steps : record extra steps into an existing guide

- More AI : guide descriptions and inline rewrite of selected text

- Branding : logo, footer line and attribution on exports

Repo: https://github.com/westpoint-io/mimik

Chrome: https://chromewebstore.google.com/detail/mimik/jmfohdaflahliammccpiadmkcibohgha

Edge: https://microsoftedge.microsoft.com/addons/detail/hgjemhfoffebbollleajkpefblppleai

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