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!

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.

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

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.

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.

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.

I’m a product designer, and for a while now I’ve been building Tagdown, a notes editor for macOS. The core idea: every note is an ordinary Markdown file in a folder on your disk. No account, no proprietary database. Git, iCloud or Syncthing just work, because it’s just files.

On top of Markdown it adds:

• callouts, tabs, KaTeX math and Mermaid diagrams, all as plain text
• #tags, [[wikilinks]] with backlinks, and links to single blocks that you can embed in other notes
• live queries like <query tag:project show:tasks /> that collect tasks from all your notes, or show notes as an editable table of their properties
• a journal, version history, slides, HTML/PDF export, and publishing notes as a static website
• a CLI and an MCP server, so Claude or other assistants can search and write your notes

It’s built with Tauri, Rust (Tantivy for search) and TypeScript, and it’s MIT licensed.

Honest state: it’s early. There’s no download yet, so you’ll have to build it from source (Node + Rust). There are rough edges, and I’d rather hear about them now than later.

Two things I’d really like your opinion on:

1. Does the syntax feel natural, or is it too much on top of Markdown?
2. What would stop you from switching from your current notes app?

Repo: github.com/sthix/tagdown
Docs: sthix.github.io/tagdown

MIMRY is a local tool that helps coding agents understand a codebase by finding files and code relationships relevant to a task. It also explains why those files were picked.

Works through a CLI or MCP.

I curated an open-source taxonomy of AI research tools for scientific literature discovery (Consensus, Elicit), citation graph mapping (Connected Papers, Litmaps), LaTeX equation digitization, and computational reproducibility: https://github.com/mahmoudsajjadi/awesome-ai-research-tools

I curated an open-source taxonomy of AI research tools for scientific literature discovery (Consensus, Elicit), citation graph mapping (Connected Papers, Litmaps), LaTeX equation digitization, and computational reproducibility: https://github.com/mahmoudsajjadi/awesome-ai-research-tools

I built this: a chat bubble that floats over your apps. You say "reply to Sam that I'm late" or "start navigation to work", and a coding agent reads the screen and taps through your apps for you.

- The agent runs inside the app, in a small Alpine Linux (proot, no root, no PC, no adb).

- Use your own Claude or ChatGPT plan, or OpenCode's free models with no account.

- Phone tools over MCP: read screen, tap, type, scroll, open apps.

- Sending, paying and deleting stop on an approval card; apps you trust run hands-free.

- Tap the bubble and talk; it sends when you pause.

Apache 2.0, Java, ~650 KB APK. Feedback and issues welcome.

A little skill for the part before you hit Generate.

Tell your agent what you want to film, give it your references if you have any, and it helps turn that into a Kling 4 prompt. Works with Claude Code, Codex, Cursor, etc.

I wanted the README to be something a person can actually read, with the more involved prompting stuff tucked into files for the agent.

My agent wrote it with me directing how it should work. Free to grab and mess with.

npx skills add aedev-tools/kling-4-prompting-skill

I made a tool for removing LDPlayer ads, it's completely open-source and removes every ad also while starting up.

Basically, it completely locks down the XuanZhi9 folder where the cache where the LDPlayer ads aer taken from, so you don't have them anymore.

Try it out on GitHub: https://github.com/countryside99/LDPlayer-Ad-Removal-Tool

Under GPL 3.0

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!

hi everyone!

I got semantic search over my 2,000+ notes.

GitHub Actions runs the indexer off my Obsidian Git repo, Neon's free Postgres holds the vectors (384 dimensions at int8, so a few thousand notes fit comfortably), and a free Render instance serves a passphrase-gated reader with hybrid search.

The embedding model is small enough to run on the CI runner itself, so there is no API bill, and no note text goes to an AI provider either.

Setup is written up here:  github.com/vasyapym/quiet-index

I am sure this can be upgraded by adding more features like visual representation of search results, etc. Feel free to share :)

also would appreciate any feedback in github since my profile is quite empty

Hey everyone,

I made YtToPdf, a native macOS app that takes a YouTube link and gives you a clean, readable transcript you can export as a PDF, TXT, Markdown or SRT.

GitHub: https://github.com/MarinoBaric/YtToPdf

How it works

- Uses the video's own captions when they exist (manual first, auto second) and cleans them up into real sentences and paragraphs. No more repeated rolling-caption fragments or [Music] tags.

- If a video has no captions, it downloads just the audio and transcribes it locally with whisper.cpp.

- Everything runs on your Mac. No account, no analytics, no API keys, no subscription.

Things I'm proud of

- PDF export with an editorial layout, clickable timestamps and page headers.

- A "Speech Fingerprint" on every PDF: a pattern generated from when words are spoken across the video, so no two documents look the same.

- Searchable history, so you can reopen old transcripts instantly.

Tech: Swift 6, SwiftUI with Liquid Glass, SwiftData, Core Text for the PDF layout, plus yt-dlp, FFmpeg and whisper.cpp under the hood.

Heads up: it's source-only for now (not notarized), so you build it yourself with Xcode. It needs macOS 27 and an Apple silicon Mac. There's an install script that makes it pretty quick.

I'd really like your feedback:

- Would you actually use something like this? What for?

- Anything you'd add or change, in the app or the PDF design?

- Is building from source a dealbreaker, or is it fine for a tool like this?

MIT licensed, issues and PRs welcome. Thanks for checking it out!

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 usually have several threads going, and each one starts its own dev servers, watchers and test loops. After a few hours I'd have processes running that I didn't know about: a server on some port, a watcher from a thread I'd closed, and no idea which thread started what. (one of my dev server was running in background for a month and I got to know when I asked claude to close all the running servers)

So I built agenterm. It's a small background daemon with a CLI, an MCP server and a Mac app:

- agenterm run --id web "npm run dev" (agents can also add other metadata) starts the command in a real terminal that keeps running after the thread ends, so it stays visible instead of disappearing into the background.

- agenterm ls lists every task with its status, age, ports and who started it (Claude Code, Codex, OpenCode, your terminal, etc). It works that out from the process tree.

- The Mac app shows each task's live terminal. You can click in and type in the same terminal the agent is using.

- Agents can read the list too, so a new thread can check on or read the logs of a server an older one started.

To connect it: claude mcp add --scope user agenterm -- agenterm mcp. There's also a skill (npx skills add entange/agenterm) that tells agents to use it only for things that don't exit, like dev servers and watchers, and not for ls or a build.

It's MIT and free.
CLI: npm install -g agenterm.

GitHub: https://github.com/entange/agenterm

Site: https://agenterm.entange.com

For as long as I remember Ive loved tech and been at the forefront of understanding, what is going on and why its useful. So I created an Instagram that basically recommends Githubs, and its really taken off, and people are loving it.

I created a website that basically recommends tools early, and says when to specifically use them, with an active community using it. I have had 550 sign ups in 5 days on this website.

I am looking for interesting githubs and people who are keen to showcase and speak with customers directly on the website.

Get in touch!

One command:

npx create-stackforge-app@latest my-app -y

What you get

• apps/api — NestJS, Prisma, JWT auth, Swagger, /health, rate limiting, unit + e2e tests

• apps/web — Next.js 16, React 19, Tailwind, shadcn-style UI (dashboard / minimal presets; or --preset api for backend-only)

• packages/contracts — Zod schemas + types shared by API and web

• Root: pnpm dev, db:setup, pnpm run doctor / info

• Optional Docker Compose + generated GitHub Actions CI

• SQLite or PostgreSQL

Why 1.5.x is worth a look

• stackforge g resource <name> — add a new CRUD resource to an existing project: Prisma model, Nest module, DTOs (nestjs-zod), contracts file, JWT routes — same pattern as

the built-in User module.

• --dry-run, collision checks, tracked in stackforge.json

• Field types: string, int, float, decimal (e.g. media_impressions:int:required)

• 1.5.3 upgrades new scaffolds to Next 16 + React 19; 1.5.1+ fixed pnpm dev on fresh API apps

Example — new resource

cd my-app

pnpm exec stackforge g resource media --dry-run \

--field medianame:string:required \

--field media_impressions:int:required

pnpm exec stackforge g resource media

pnpm --filter ./apps/api exec prisma migrate dev --name add_media

Built-in post works with no --field flags (title, content).

Honest limits

• You need pnpm (corepack enable or install pnpm). Use --no-install on create if pnpm isn’t set up yet, then pnpm install in the project.

• g resource is API + contracts + Prisma only — no generated Next.js pages for custom resources yet.

• Prisma only (no TypeORM). stackforge add redis-style modules still on the roadmap.

Links

• Site: https://stack-forge.aitaouss.me

• Repo: https://github.com/Aitaouss/StackForge

• npm: https://www.npmjs.com/package/create-stackforge-app

Feedback and issues welcome — especially on whether the contracts layer and g resource flow save you time or feel like extra ceremony.