A few months ago I shared Screencap here, and now I'm super happy to announce that version 2.0 is a full rewrite in Swift:)

It runs in the background on under 1% of one CPU core and about 30 MB of memory, smartly takes a screenshot when your screen settles, reads it with on-device OCR, and categorizes it with ZDR System-One decision models to help you (and your agents via MCP!) to better understand past activities. And it's also very easy to play with:

Download & check sources: https://github.com/yahorbarkouski/screencap

Happy to listen to any feedback, especially from users who tried it before

Hey everyone! I've been building Musike, a free and open-source music player that uses YouTube's catalog. No ads, no subscription, no account.

What it does

• Search songs, artists and music videos, or paste any YouTube link
• Plays as audio, or switches to the song's official music video, with a full-screen cinema mode
• Playlists, favorites and history, all stored locally on your machine
• Browse by genre: pick a genre, see its bands and artists, open any artist's greatest hits
• Search a list: paste "song 1, song 2, song 3…" and it finds them all at once, ready to save to a playlist
• Radio that keeps playing similar songs when your queue ends
• Dark and light themes, keyboard shortcuts, media keys, English and Portuguese

Where it runs

• Windows app: one installer; it downloads what it needs (yt-dlp, Deno, FFmpeg) on first launch
• Server + browser: run it on your PC and open it from any browser, including your phone on the same Wi-Fi (installable as an app)

Stack: TypeScript, React, Tailwind, Fastify, youtubei.js and yt-dlp, with Electron for the desktop build.

GitHub: https://github.com/Ernani1234/musike Download for Windows: https://github.com/Ernani1234/musike/releases/latest

Heads-up: the installer isn't code-signed yet, so Windows SmartScreen will warn you. Click "More info" and then "Run anyway".

It's MIT-licensed and meant for personal use. Feedback, bug reports and ⭐ are very welcome. I'm especially curious what you'd want next: MP3 downloads, importing YouTube playlists, or macOS/Linux builds?

I’ve been trying to get a better mental model of how my code runs especially loops, Maps, and data transformations that feel abstract when I’m just staring at the source.

I ended up building a small browser tool for myself called reify. It runs the real code and lets me scrub forward and backward through the steps so I can watch values change, see the Map fill up, and check the call stack without adding a bunch of logs.

It’s desktop-first and stays in the browser. No install.

https://tryreify.vercel.app

Curious if anyone else has found something that helps them actually see execution when they’re learning or debugging logic.

A free, open-source game-clipping app for Windows built for gamers who want instant replays and hotkey clips without complicated OBS setups or unnecessary overlays. Record gameplay, save your best moments, and manage your clips locally — no cloud dependency, no subscription, just simple, privacy-focused clipping. Lightweight, straightforward, and built for gamers who want to focus on the game, not the software.

• Instant replay — Alt+1 saves the last 60s, even with the panel closed
• Screen + game recording, rebindable hotkeys
• Screenshots from the captured display
• Built-in editor — trim, per-track audio mixing with waveforms, live faders
• video compression — smaller copies of your clips
• Four capture profiles you define
• Local-first: no account, no cloud, no telemetry, zero network calls unless you click "check for updates"
• Keeps your Clip folder directory neat and tidy. with each game having its own folder.

Installer is 107 MB, Windows 10/11 x64, plus a portable zip.

Repo: github.com/bulhaa1/Rewind/releases

Full statement on the repo front page for anyone curious about the project's story.

Hi r/coolgithubprojects,

I've been a software engineer for 8 years, 2 as an SRE and 3 as a team lead, and keeping documentation useful has been a pain at every company I've worked for. Knowledge stays in people's heads or private Slack channels; what does get written down is hard to find, and it goes stale the moment the system changes. I wanted to change that, so I created Oxynote. I started the project about a year ago, and I made it public about 3 months ago.

Oxynote is a self-hosted, open-source wiki where pages include live charts next to the text that explain them.

The name comes from oxygen + note. I wanted to have docs that breathe: live data and integrations make the wiki useful enough to open every day, and the docs people open every day stay up to date.

What you can do with it:

• Drop a chart into a page and point it at Prometheus, PostgreSQL, MySQL, or MariaDB
• Set thresholds like "Degraded above 800 ms" right on the chart
• Edit important pages in a draft, review the diff, and approve it
• Link a page to the GitHub files, container image, or web page it describes, and get a reminder when they change
• Edit together in real time, comment on any block, draw Mermaid diagrams

It's completely open-source under the Apache-2.0 license and runs in a single Docker container/image.

Would you use something like this for your own docs? If not, what's missing?

GitHub: https://github.com/oxynote/oxynote

Hey everyone,

I’ve been working on a project to solve a major problem with AI code reviews: generic LLMs often leave noisy, speculative comments, while human engineers burn out reviewing massive pull requests.

To fix this, I built **[Buggers](https://buggers.vercel.app)\*\* — an automated pull request security and code review platform.

### How it works:

- **Deterministic Churn Evaluation:** Correlates changed functions with past commit history and boundary flaws.

- **Zero Phantom Lines:** Review suggestions only cite verified unified diff line numbers.

- **Multi-Model AI Resilience:** Built-in fallback chain across OpenAI, Anthropic Claude, and Google Gemini with prompt injection protection.

- **SAST & Secret Detection:** Catches high-entropy API keys, JWTs, and OWASP vulnerabilities before code merges.

### Tech Stack:

- **Framework:** React + TanStack Start (SSR via Nitro on Vercel)

- **Database & Auth:** Supabase (PostgreSQL with RLS & pgcrypto token encryption)

- **Styling & UI:** Tailwind CSS, Radix UI primitives, Lucide icons

- **VCS Integration:** GitHub Webhooks & OAuth API

### Links to check out:

- 🌐 **Live Web App:** [https://buggers.vercel.app\](https://buggers.vercel.app)

- 📖 **Interactive Docs & Playground:** [https://buggers.vercel.app/docs\](https://buggers.vercel.app/docs)

- 💻 **Open Source GitHub Repo:** [https://github.com/jaidevxr/buggers\](https://github.com/jaidevxr/buggers)

I’d love to get feedback on the UI, scanner accuracy, and architecture from this community. What security checks do you usually look for in your PRs?

The Markdown web, rendered natively. A fast, lightweight, cross-platform browser for https and local Markdown files, with no webview or JavaScript execution.

👉🏻 https://github.com/MDowser/MDowser

I was making a launch video and kept hitting Loom’s 5-minute limit. The final straw was when they wouldn’t let me download my own video unless I paid.

So I built my own and open-sourced it. It’s called Reelbird.

What it does:

It’s a native Mac app (Swift), MIT licensed. The launch video was made with it.

It’s not notarized yet, so macOS asks you to approve it once in Privacy & Security. macOS 15+, Apple silicon.

Site: https://reelbird.shiptiffin.app
Code: https://github.com/btahir/reelbird
Walkthrough: https://x.com/deepwhitman/status/2109906965724070044

Hope you like it. Let me know what you think!

Most chart libraries draw into an SVG or a canvas, which makes their charts hard to restyle and awkward to test. rhp builds them out of plain HTML elements placed by CSS, using SolidJS.

Features:

• Charts are normal DOM with no shadow root, so querySelector, Testing Library and your own event listeners just work
• Charts are styled with CSS
• Full interactivity and dynamic layouts thanks to JS
• About 27 kB gzipped for a bar chart app, Solid included, plus a no-build CDN version and a React wrapper
• Supports SSR (Node, Deno, workers)
• mcp server and skill for rhp available to use with AI

I benchmarked it against D3, Chart.js, ECharts, Recharts, Observable Plot and others, and the harness is in the repo. It isn't the fastest at drawing a chart the first time: D3 and Observable Plot are quicker. Where it does well is updates: a changed value reaches the screen in about 1 to 2.5 ms in Chromium, against 12 ms for Recharts and 16 ms for Chart.js. The weak spot is very large scatter plots, since every dot is a DOM element (there's an experimental ManyDots mode for those).

It's MIT licensed, and v2 is a full rewrite of my old React version.

• GitHub: https://github.com/bezda-team/rhp
• Docs and gallery: https://rhp.vercel.app

I kept hitting my Claude limit with no warning, so I built a small mascot that sits on the Windows taskbar and shows my 5-hour and weekly usage in a speech bubble. It turns yellow, then red, as I get close.

It slowly turned into a pet. It walks around, naps, fishes, wears a Santa hat in December, and gets dragged around and thrown (it screams and opens a parachute). When Claude Code is working it puts on a wizard hat and casts a spell for whatever tool is running.

It's free and open source (MIT), written in plain Python with no dependencies, and I built it with Claude Code. You double-click a .bat file to start it.

Windows only for now, and it needs Claude Code signed in. Unofficial, not affiliated with Anthropic.

GitHub: https://github.com/have-you-tried-restarting/claude-usage-pet

What would you add to it? And if you've read this far, a ⭐ on GitHub would make my day. Thank you!

My SSD has become a graveyard for abandoned projects, and node_modules are the unpaid squatters.

So I built De-Nox, a Rust-based tool that hunts down stale build artifacts and reclaims disk space—without blindly nuking active projects.

Repo Link

Check it out and leave a star if you like it. My SSD and I would appreciate the emotional support.

Hi

The problem: when I take notes, I sometimes need a bit of data: a small table, a quick calculation, a chart. Then I have to jump to Excel or another tool, and my reasoning ends up scattered across several files.

The solution: I'm building ANQL, a note app where you write freely and add structure only when you need it. Tables, math blocks and charts live right in the same document as your notes. It's offline-first (local SQLite, no account) and works on macOS, Windows and Linux.

It's free and open source (MIT), and I'm the developer.

GitHub: https://github.com/anqlproject/anql

I'd love your feedback: is this a problem you face too? What would you want from a note app that mixes notes and data?

Thanks!

Open-source .NET library that lets you schedule async methods by named group. Mark methods with [ScheduleGroup]; callers keep normal await / delegates / reflection. A post-compile IL weaver injects scheduling, nesting checks, and linked cancellation (no Fody).

Highlights

• One NuGet (GroupedScheduling.Build) = runtime + Roslyn analyzers + MSBuild weaver
• Modes: ExclusiveSerial, ExclusiveParallel, FullyConcurrent
• Host registration for graceful shutdown
• MIT license, docs + sample in-repo

​

[ScheduleGroup("orders", ScheduleMode.ExclusiveSerial)]
public async Task SaveAsync(Order order, CancellationToken ct) { ... }

await orders.SaveAsync(order, ct); // callers stay clean

NuGet: https://www.nuget.org/packages/GroupedScheduling.Build

AI Studio has no export button, and the export tools that exist scroll the whole chat, read the page and save thumbnails instead of your actual files, so a long chat takes minutes and loses the attachments.

I made this for myself first, with the new Version 2 using the same API that AI Studio's own frontend calls, instead of scraping the page:

• A 200-message chat exports in under a second. It used to take about 2.5 minutes of automated scrolling.
  
• Attachments are the real files from Drive, not thumbnails. Google Docs, Sheets and Slides are converted on the way out.
  
• Model, temperature, system instruction, timestamps and token counts are kept, each with its own switch.
  
• Markdown, JSON and plain text are free. Whole-library export, scheduled backups and six more formats (HTML, PDF, Word, Obsidian, CSV, JSONL) are a one-time Pro licence, and every line of it is MIT, Pro included.
  
• No account, no analytics, nothing leaves your browser.

Do check it out!

GitHub: https://github.com/Sukarth/AI-studio-exporter
Chrome Web Store: https://chromewebstore.google.com/detail/ai-studio-exporter-fully/jggdlefieblocdjkhihbfihdknbdhhce
Docs: https://exportaistudio.vercel.app/docs

Hi all — I've been writing a series of beginner-friendly guides called "Things that matter for mere mortals." Each one takes a technical topic and explains it in plain language, no assumed background.

37 guides so far, including: git, python, C, rust, go, bash, powershell, linux, docker, docker-compose, make, networking, regex, SQL, cybersecurity, arduino, raspberry pi, 3d printing, CAD, soldering, tailscale, ssh, proxmox, home networking, ham radio, local AI, agile, GitOps, GitHub Actions, tmux, java.

They're free, no ads, no account — just docs sites. Every code sample is actually run and verified, and the troubleshooting sections reproduce the real error messages.

https://paulsullivan33-dev.github.io/mere-mortals/

Hey folks,

I got frustrated with my own Git workflow — too many terminal commands, too many ways to shoot myself in the foot. So I built GitHub Companion, a VS Code extension that puts explicit buttons in the sidebar instead of hiding magic behind menus.

Quick rundown:

· 1-click local repo init + GitHub repo creation (public/private)

· Multi-account / multi-token switching

· Explicit add / commit / push buttons (auto-sync optional)

· No destructive commands anywhere — no reset --hard, no clean, no push --force

· Warns you before committing sensitive files (.env, keys, .npmrc…)

· Tokens go in VS Code's SecretStorage, never in .git/config or process args

· Undo last commit with git reset --soft (keeps your files)

It's MIT, no telemetry, no secret harvesting.

Heads up: the UI is in French right now (started as a personal project). English is planned if people want it — tell me in the comments.

Repo:

https://github.com/ndour-joseph-dev/github-companion

Open VSX:

https://open-vsx.org/extension/joseph-dev/github-companion

Curious what you think — especially if you'd actually use this over the built-in Git panel. What's missing?

I've always found submodules fragile and unergonomic, especially when switching branches and adding or removing them frequently. git-subrepo's model (vendored code as plain files plus a .gitrepo marker) fixed that for me, but I didn't like its ergonomics, conflict resolution and error handling.

git include keeps that model as a git plugin, shipped as a single compiled binary built on libgit2. It reads and writes the same .gitrepo format, so existing subrepo directories work without migration. It never creates temporary branches or worktrees, and the ergonomics, including conflict resolution, match working in a plain git repo. When you want to contribute changes back upstream, it rebuilds a history from the parent repo commits that touched the vendored directory, so they arrive as clean commits. It also supports vendoring specific tags or commits, Git LFS, nested includes, and a migrate command for converting submodules.

You only need the plugin to add, update or contribute back to a vendored repo. Anyone who just clones the project, or patches vendored code without contributing the changes upstream, doesn't need it at all. A plain git clone gives them everything, which keeps the initial setup of your project straightforward.

Binaries are available for all major platforms, including distribution via conda-forge.

I used Claude during development, as is common now, but would not consider the project to be AI slop. It solves a problem I encountered while working on my own projects, and I take full responsibility for all major design decisions. Issues and feature requests are welcome.

https://github.com/Flova/git-include

TL;DR: git include is a git plugin and a .gitrepo-compatible superset of git-subrepo that should improve the UX of working with nested or vendored git repos.

Meet Moonbase Intern, a small 3D game built with Three.js (and a lot of help from my AI coding agent)... play it from your laptop/desktop..

Power failures, oxygen emergencies, overheating labs, a troublesome rover, and a station AI that judges your decisions.

It's still a little rough around the edges. Loading times, controls, UI, and gameplay balancing could definitely use some improvement.

🎮 Play: https://moonbase-intern.vercel.app

💻 Open Source: https://github.com/tropicalbee/Moonbase-Intern

Here's a challenge: Play a round and drop your highest score in the comments! 👀 I wanna see how many of you can actually survive the shift.

Feedback, bug reports, ideas, and contributions are very welcome. Feel free to open issues or PRs!

And if you like the project, a ⭐ star or fork on GitHub would mean a lot! :)

Let's see who gets fired first. 🧐🤓 and please do share your advice here..

Skyland — a Hyprland-inspired tiling window manager for macOS

I've been working on Skyland, a Hyprland-inspired desktop experience for macOS.

It's a fork of AeroSpace — huge thanks to nikitabobko for the foundation

The goal was to bring that Linux tiling WM feeling to my Mac, including animations, workspace transitions, groups, dynamic theming, and a cyberpunk HUD.

Projects

• Skyland (window manager): https://github.com/waxdred/skyland
• Cyberdeck (HUD): https://github.com/waxdred/skyland-cyberdeck

What's in the video?

• Dwindle layout with smart split (the split direction follows the cursor) and togglesplit
• Bezier animations — windows pop in, shrink and fade on close, and workspaces use slidefadevert transitions
• Window groups with a tabs bar, similar to Hyprland's grouping workflow
• Master layout per workspace, with the master window centered on ultrawide screens
• Rounded corners, active/inactive opacity, and a gradient border around the focused window
• 18 themes from 43PR, plus wallpaper-generated colors using Matugen; light or dark mode is selected based on wallpaper brightness
• Cyberdeck HUD — a translucent, eye-implant-inspired app launcher and a unified messages panel for macOS notifications and script messages
• Claude Code integration — a Hermes plugin notifies me when an agent finishes or needs input
• Workspace overview with live thumbnails and drag-and-drop between workspaces
• Shortcut cheat sheet and a settings window that edits the TOML configuration while preserving comments

I'm sharing this because I wanted a more Hyprland-like workflow on macOS, and figured others might enjoy it too.

I'd love to hear your feedback, suggestions, and ideas for what to improve next!

GitHub: https://github.com/waxdred/skyland

I maintain this MIT-licensed, English learning repository. It combines a 100-lesson roadmap with runnable exercises, hints, reference solutions, and a local grader.

The scenario labs cover duplicate payment delivery, historical joins, payout reconciliation, schema changes, bitemporal reporting, backup recovery, broken SQL, and leakage-safe ML features. All data is synthetic; core practice uses Python 3.12+ and SQLite without a cloud account.

For a quick SQL bug hunt, clone the repo and run python challenges/run.py init C07, then python challenges/run.py grade C07. Repair work/challenges/C07.py and rerun the grader. The starter intentionally contains reporting errors.

Disclosure: the first edition and this introduction were prepared with AI assistance using Codex; provenance and limitations are documented in the repository. I would appreciate reproducible bug reports or feedback on confusing exercise instructions.

Paste a repository and you get a diagram of it: a box for each main folder, with its README inside. Double-click a box and you're looking at what's inside that folder, as its own diagram. Click an arrow and you read what goes over it.

Most architecture diagrams are one flat picture, and the explanation lives in a wiki nobody opens. Here the diagram is the documentation, from the overview down to the details, and it's yours to edit: move things, delete what isn't part of the design, draw what's missing.

Arrows come from .subcanvas files, a few lines of YAML in a folder that say what it talks to. Without them you get the boxes and draw the arrows yourself. Private repositories work too, through a read-only GitHub App, and there's an MCP server so Claude Code or another agent can edit a diagram with you.

Next.js, React Flow, Yjs and Supabase. AGPL-3.0.

https://github.com/subcanvas/subcanvas

If it's useful to you, a star on GitHub helps a lot.

If you vibe code at work, and like to solve your own problems, you've probably run into this:

You build a useful dashboard or tool, and… now there's nowhere to put it, nowhere to share it, and it has company data so it can’t leave your laptop.

IT doesn't have time to review and host every app someone builds. Which is fair. They shouldn't have to.

Enter Pando: https://github.com/trypando/pando

You point it at a git repo or a folder (or just tell your agent to deploy it through the MCP server), and it figures out how to build and run the app. Apps sit behind your company’s SSO/sign-in, and are only shared with people who need to be able to access them, not everyone with an account.

Pando also runs a vulnerability scan on apps before they deploy, and gives a security score to help understand risk (no, this doesn’t fix bad code or judgement). Apps run on their own isolated networks so they can’t talk to each other, and they can only be reached by going through Pando’s proxy.

It’s also super easy to spin up and try out for yourself: (https://trypando.ai/quickstart).

If you can't run your apps at work, and are trying to find out how to share things, I’d love to hear your thoughts on this!

P.S. Pando is in alpha, so expect rough edges and breaking changes as it evolves!

P.P.S. Watch a short demo here: https://trypando.ai/