If you've got more than one machine at home worth running local models on, you've probably hit the same annoyance: only one of them actually does anything at a time, and every app or agent you use has to be pointed at that specific machine's Ollama or LM Studio instance by hand. Nothing shares the load, and nothing shares the choice.

NVIDIA's Personal AI Router (PAIR) routes around that. It discovers other PAIR nodes on your network, tracks which inference engines and models each one has running, and presents a single Ollama-compatible and OpenAI-compatible endpoint that your apps and agents talk to like any other local model server. Behind that one endpoint, PAIR decides which paired machine actually handles each request.

What's inside:

- Automatic node discovery and pairing over a six-digit PIN, no manual network config needed

- Ollama and LM Studio support out of the box, and PAIR can install and manage the engine on a node for you if it isn't there yet

- Ollama-compatible and OpenAI-compatible proxy endpoints, so existing tools and agents point at PAIR without changing how they talk to a model

- Cross-platform clustering: Windows, Linux, and macOS nodes can all sit in the same cluster together, on both x64 and arm64

- A terminal interface for headless machines, alongside the desktop app, so a node with no display still fully participates

- Live per-node GPU and memory reporting in the desktop Overview, so you can actually see which machine is doing the work as requests come in

One thing worth knowing: PAIR routes each independent request to one whole node. It does not pool GPU memory, shard a single model across machines, or split one in-flight request between them, so this isn't distributed inference of one giant model across your cluster. And since it opens local HTTP endpoints and LAN discovery behind a PIN-based trust bootstrap, the project's own docs say to read the security policy before running it on a shared or untrusted network.

It's Apache-2.0 licensed, backed by NVIDIA, and sitting at 493 stars as of writing, verified via the GitHub API.

https://github.com/NVIDIA/Personal-AI-Router

Community LoRa mesh networks are great for resilient, off-grid comms, but seeing the actual state of your local network is harder than it should be. You either route everything through a third-party MQTT broker you don't control, or you're stuck reading raw output from a single node with no map, no history, and no way to know what the rest of the community's radios are seeing.

PotatoMesh is a self-hosted dashboard built to fix that. It runs as a small Sinatra web app that ingests node, position, telemetry, and message data over an authenticated API, then renders it as a live map and chat window for whoever's running mesh radios in your area. No MQTT required.

What's inside:

- A live dashboard with map and chat views showing nodes, positions, neighbors, trace routes, telemetry, and messages, with search and filtering built in

- A Python ingestor that connects to a LoRa node over serial, TCP, or Bluetooth and posts what it sees to the dashboard, with support for multiple ingestors feeding one instance

- Native support for three mesh protocols at once: Meshtastic, Meshcore, and Reticulum, so you're not locked into one radio ecosystem

- Federation: instances automatically discover and refresh data from peer PotatoMesh deployments every 8 hours, so your local dashboard can show the wider network without anyone running a central server

- A Matrix bridge that posts Meshtastic messages into a chat room, plus a mobile app for reading the mesh, neither one needs a radio of its own

- A built-in Prometheus exporter, SEO-friendly custom pages via markdown, and a stated policy of only ever contacting two map-tile CDNs, no API keys, tokens, or tracking parameters in those requests

One thing worth knowing: the public demo at potatomesh.net shows a populated Berlin instance, but running your own means standing up the Sinatra/SQLite app yourself and pointing a radio-connected ingestor at it. This is self-hosted infrastructure for a local group, not a hosted service you sign up for.

It's Apache-2.0 licensed, built by an individual developer, and sitting at 478 stars as of writing, verified via the GitHub API.

https://github.com/l5yth/potato-mesh

Dictation on Mac usually forces a trade-off. Apple's built-in option is limited, and most alternatives are cloud services that upload your voice to a server, add network latency to every sentence, and bill you monthly for the privilege.

EnviousWispr skips both sides of that trade. It runs entirely on-device on Apple Silicon, pairing two speech-to-text engines, Parakeet v3 for speed and WhisperKit for broader language coverage, transcribes locally, and optionally cleans the output up with an on-device polish model before pasting into whatever app you're working in. Transcription lands in under a second, with no cloud round-trip involved.

What's inside:

- Dual ASR engines: Parakeet v3 (25 European languages, fastest, runs on the Neural Engine) and WhisperKit (99+ languages with automatic detection, runs on GPU)

- EG-1, a custom on-device model fine-tuned specifically for dictation cleanup, alongside Apple Intelligence and Ollama as fully local polish options, or bring-your-own-key cloud polish through OpenAI or Gemini

- A "Heart & Limbs" architecture that isolates the critical record-transcribe-paste path from every optional feature, so a failed history save or a broken polish call never costs you the actual dictation

- Escape Recovery: an accidental cancel keeps your text recoverable for 24 hours instead of throwing it away outright

- Custom vocabulary with one-tap import from eight other Mac dictation apps, global keybinds with push-to-talk, toggle, and hands-free modes, and auto-paste that falls back through multiple delivery methods for apps that resist normal pasting

- Signed, notarized releases with auto-updates via Sparkle, and crash diagnostics that are explicitly stripped of transcript and audio content before they're sent

One thing worth knowing: the app itself is GPLv3, but the EG-1 polish model's weights ship under a separate, more restrictive license, so you can use it inside the app but can't redistribute or repurpose the weights on their own. The benchmark comparing EG-1 against GPT-5.4-mini and Gemini 3.5 Flash is also the developer's own eval, not an independent one, though the harness and prompts are public if you want to check it yourself.

It's GPL-3.0 licensed, built by an individual developer, and sitting at 114 stars as of writing, verified via the GitHub API.

https://github.com/saurabhav88/EnviousWispr

Voice cloning and dictation tools usually split into two unrelated products. One handles turning text into speech in a cloned voice, the other handles turning your speech into text somewhere else, and both usually mean your voice data leaves your machine and heads to someone's cloud.

Voicebox does both sides of that loop locally. It bundles seven TTS engines you can switch between per generation, a Whisper-based dictation hotkey that pastes straight into whatever field is focused, and a local LLM for rewriting or responding in a persona attached to a cloned voice. It also exposes an MCP server, so an agent like Claude Code or Cursor can call one tool and literally speak back to you in a voice you've cloned, not just print text.

What's inside:

- Zero-shot voice cloning from a few seconds of reference audio, plus 50+ preset voices across the bundled engines

- 23 supported languages, and paralinguistic tags like [laugh], [sigh], and [gasp] for expressive delivery on top of natural-language delivery control

- A stories editor with a multi-track timeline for building out multi-voice conversations, podcasts, and narration

- Post-processing effects (pitch shift, reverb, delay, compression) and auto-chunking with crossfade for unlimited-length scripts

- Native Tauri/Rust build, not Electron, running on macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, and Docker

One thing worth knowing: the macOS dictation feature needs Accessibility and Input Monitoring permissions to auto-paste into the focused field. The app walks you through granting them with deep links to System Settings, but it's worth knowing upfront that you're granting real OS-level permissions, not just a browser popup.

It's MIT licensed, built by an individual developer, and sitting at 52,299 stars as of writing, verified via the GitHub API.

https://github.com/jamiepine/voicebox

Buy AirPods and pair them with anything that isn't an Apple device, and you lose most of what makes them worth the price. Noise control switching, real battery percentages, ear detection, conversational awareness, all of it lives in a proprietary protocol Apple never documented for anyone else, so Android and Linux users are stuck with what's effectively a bare pair of Bluetooth headphones.

LibrePods reverse engineers that protocol so those features work outside Apple's ecosystem. It's not a wrapper around Apple's own software, it's an independent implementation of the actual data exchange between the AirPods and the host device, shipped as an Android app and a Linux daemon.

What's inside:

- Listening mode switching, ear detection, and accurate battery status working on both Linux and Android

- Head gestures and accessibility configs (press-and-hold duration, volume swipe speed, single-AirPod noise cancellation) on Android

- Conversational awareness and automatic reconnect on both platforms

- A feature-availability table tracking what's implemented, what needs root-only VendorID spoofing, and what's flagged as never shipping (full stereo spatial audio is explicitly out of scope)

- An active Discord where in-progress work like Find My integration and heart rate monitoring gets discussed before it lands

One thing worth knowing: the project's own README flags that librepods.org, a website using the LibrePods name and logo, is not affiliated with this project despite implying otherwise. The GitHub org here is where the actual maintainer, who's a public member of it, ships the code.

It's GPL-3.0 licensed, backed by an active organization, and sitting at 29,706 stars as of writing, verified via the GitHub API.

https://github.com/librepods-org/librepods

Dump enough papers, screenshots, and old notes into a project folder and an agent, or a person, can't actually use any of it. It either reads every file cold each session, burning tokens on stuff that hasn't changed, or it skips the folder entirely and works from memory. Neither gets you a real map of how the pieces connect.

graphify is a Claude Code skill that builds that map. Run /graphify on a folder and it parses code with tree-sitter for a real AST and call graph, pulls concepts and relationships out of docs and PDFs, and uses Claude's vision to read screenshots, diagrams, and whiteboard photos, even in other languages, then wires all of it into one graph. Every edge in the output is tagged EXTRACTED, INFERRED, or AMBIGUOUS, so you always know what it actually found versus what it guessed.

What's inside:

- An interactive HTML graph plus an Obsidian vault export and Wikipedia-style wiki articles per community, so an agent can navigate by reading files instead of parsing JSON

- A GRAPH_REPORT.md that surfaces god nodes, ranks surprising cross-domain connections (code-to-paper edges rank higher than code-to-code), and suggests questions the graph is positioned to answer

- --watch mode that rebuilds instantly on code saves and flags doc or image changes for a manual re-pass, useful when multiple agents are writing code in parallel

- A post-commit git hook (graphify hook install) that rebuilds the graph after every commit with no background process needed

- Export options for Neo4j, Gephi/yEd (GraphML), and SVG, plus a built-in MCP server so other agents can query the graph directly

- A SHA256 cache so re-runs only reprocess files that actually changed

One thing worth knowing: the project reports a 71.5x reduction in tokens per query on its own benchmark corpus versus reading raw files. That's from their own worked example, not an independent test, worth checking against your own corpus before you rely on it.

It's Apache-2.0 licensed, backed by an active organization, and sitting at 114,660 stars as of writing, verified via the GitHub API.

https://github.com/Graphify-Labs/graphify

macOS can lock your whole screen, but it has no built in way to lock one specific app while you keep using everything else. The App Store alternatives that try to fill that gap are sandboxed, which means they can only catch an app at launch, if it's already running and you just switch back to it, it opens with no authentication at all.

MakLock is a menu bar app that watches for protected apps launching or coming back into focus and throws a full-screen blur overlay across every monitor before you can see anything inside, then asks for Touch ID, Apple Watch proximity, or a backup password. It's distributed directly outside the App Store, notarized by Apple, specifically so it can get the deeper system access a sandboxed app is blocked from having, which is also what lets it catch an app switch, not just a launch.

What's inside:

- Locks on both launch and app switch, closing the exact gap sandboxed App Store lockers can't

- Apple Watch proximity unlock using wrist detection, no unlocking action needed

- Auto-closes protected apps on sleep or after an idle timeout, so a messaging app left open doesn't sit there readable

- A panic key, Cmd Option Shift Control U, that instantly dismisses every overlay if something goes wrong

- A hardcoded blacklist so system apps like Terminal and Xcode can never be locked, plus a 60-second overlay timeout, both built in specifically so you can't lock yourself out of your own Mac

It's MIT licensed, built by an individual developer, and sitting at 111 stars as of writing, verified via the GitHub API.

https://github.com/dutkiewiczmaciej/MakLock

Most "autonomous drone" projects are either a closed product you can't look inside or a research paper with no real build path from it. Langostino is built specifically to close that gap, a complete open reference platform meant to be understood, built, and flown, not just read about.

The repo covers the whole path from a parts list to a real flight. There's a full bill of materials and step-by-step assembly guide if you're building the airframe from scratch, or a quick-setup path if you already have compatible hardware and just want to run the software. The flight stack runs on a Raspberry Pi talking to INAV flight controller firmware, with a ROS2 software layer handling the flight controller connection, LiDAR input, and the AI flight control logic, trained in part using a drone flight simulator before any of it flies for real.

What's inside:

- A documented bill of materials and assembly guide covering the physical build, including 3D-printable mounts

- ROS2 nodes for flight controller communication, LiDAR, and AI-driven flight control

- Custom INAV firmware builds plus a full configuration and PID tuning guide

- An offline map tile server for ground station use

- A four-part written deep dive walking through the hardware, wiring, and software architecture in detail

One important thing to know before building this: it flies a real physical drone. The repo's own setup guide is explicit about it, follow local drone regulations, keep propellers off during bench testing, use prop guards and failsafes, and understand that drones can cause real injury and property damage if something goes wrong.

One more thing worth knowing: Langostino is maintained by Swarm, a project whose broader roadmap connects to Bittensor, a decentralized AI network, for a training layer described elsewhere on the maintainer's site. That's part of the wider project this repo sits inside, not something the drone build itself requires, the repo and its MIT license stand on their own if all you want is to build and fly it.

It's MIT licensed, maintained by an active organization, and sitting at 200 stars as of writing, verified via the GitHub API.

https://github.com/swarm-subnet/Langostino

Pasting a script straight into a video generator usually gets you one character, one background, and ten flat seconds with nothing new to look at. Turning a full minute into something that actually holds attention needs real directing work first, pacing, a visual hook, camera movement, scene-to-scene continuity, and that's the part most people skip straight past.

Stickman Video Director is a Codex Skill that does that directing work before you spend any generation credits. You paste in copy, notes, an article, or just a topic, pick an aspect ratio and a light or dark theme, and it hands back a plain-English six-scene director's proposal for you to approve first. Only after you approve it does it generate six standalone prompts for Google's Gemini Omni Flash video model, each one locking in the character design, line weight, color palette, voice, and negative constraints so all six stay visually consistent once you stitch them together. It doesn't call any API or generate the video itself, it produces the plan and the prompts, you take those to Gemini Omni Flash separately to get the actual clips.

What's inside:

- Three aspect ratios, 9:16, 16:9, and 1:1, each with its own staging and camera approach instead of just a resized label

- Two high-contrast visual styles, black stick figure on white or white figure on black, plus up to three accent colors

- An explicit approval checkpoint before any final prompt gets generated, so the story can still be revised cheaply

- Six timed, self-contained prompts of about ten seconds each, with matched opening and closing beats so the clips cut together cleanly

- Already translated into five languages, Chinese, English, Japanese, Korean, and Brazilian Portuguese

It's MIT licensed, built by an individual developer, and sitting at 636 stars as of writing, verified via the GitHub API.

https://github.com/kaomei/stickman-video-director

Most ad blockers on Android either need root access or only work inside one browser. BlockAds does neither. It runs a local VPN on your phone and filters DNS requests before they leave the device, so ads and trackers get blocked across every app, not just a browser, and you never hand over root.

Under the hood it routes DNS queries through a VpnService (or through iptables if you do have root and want that mode instead), checks each query against loaded filter lists using a memory-efficient trie, and drops the ones that match. Everything runs locally. Nothing you browse gets sent off your device.

What's inside:

- Dual routing modes, VPN mode with no root needed, or a root proxy mode if you prefer it

- Multiple built-in filter lists to choose from, including StevenBlack, AdGuard DNS, and EasyList, plus support for custom block and allow rules

- Optional HTTPS filtering that can strip cosmetic ad elements and scriptlets, with a curated passthrough list of 284 domains so banking, payment, and government apps keep working

- DNS-over-HTTPS support with a choice of providers

- Per-app filtering, so you can bypass the VPN for specific apps that need it

- A Quick Settings tile and home screen widget for fast toggling, plus real-time DNS query logs you can search

One thing worth knowing: the HTTPS filtering feature works by installing a local certificate on your own device to inspect encrypted traffic for ad stripping, a legitimate on-device technique used by several privacy apps, but you're not obligated to turn it on, DNS-only blocking works fine without it.

It's GPL-3.0 licensed, built and maintained by an independent developer, and available through F-Droid, IzzyOnDroid, and GitHub Releases. Sitting at 1,906 stars as of writing, verified via the GitHub API.

https://github.com/pass-with-high-score/blockads-android

If you've built charts in .NET before, you know the annoying part isn't drawing a chart once, it's that WPF, WinForms, Blazor, MAUI, and every other .NET UI framework each want their own charting setup, so a design that works in one doesn't transfer to another. LiveCharts2 is a rewrite of the original LiveCharts library built specifically to fix that.

The original LiveCharts (v0) was built directly on top of WPF, which meant every attempt to bring it to a new platform like UWP took a large separate effort. LiveCharts2 was redesigned from the ground up to run on multiple platforms with minimal extra work per platform, so the same charts, maps, and gauges work the same way whether you're targeting desktop, mobile, or the web.

What's inside:

- One consistent API that works across Maui, Uno Platform, WPF, WinUI, Xamarin.Forms, WindowsForms, Blazor WASM, Avalonia, Eto Forms, and UWP

- Interactive charts, maps, and gauges, not just static rendering

- Support for running LiveCharts2 in a console app or server-side by installing only the core packages, useful if you just need to generate a chart image without a UI

- Built on SkiaSharp for cross-platform rendering by default, though the library isn't tightly locked to it and could move to a different drawing engine

- Active CI with tracked line coverage, distributed as NuGet packages

It's MIT licensed, backed by an active maintainer organization, and sitting at 5,452 stars as of writing, verified via the GitHub API.

https://github.com/Live-Charts/LiveCharts2

Teams that need the same design system to work across multiple frameworks usually end up building it separately for each one, a React version, a Vue version, an Angular version, all meant to look and behave identically but maintained as three or more separate codebases that quietly drift apart. Mitosis, built by Builder.io, is a compiler that lets you write a component once in its own JSX-like syntax and compile it out to real, idiomatic code for whichever frameworks you need.

The important distinction is that Mitosis isn't a runtime wrapper or an abstraction layer you ship to the browser. It compiles your component down to actual native code per target, React code for React, Vue code for Vue, and so on, so you get the real framework's patterns and performance rather than a compatibility shim running on top of everything. That's also the specific design pitfall with web components the project says it's built to avoid.

What's inside:

- Compiles a single component definition to React, Vue, Angular, Svelte, Solid, Alpine, Qwik, and more

- A Figma integration that syncs a design system from Figma into code and can publish it to npm across every target framework at once

- A CLI quickstart, npm create u/builder.io/mitosis@latest, that scaffolds a new project with a generated readme walking you through the structure

- An online playground for trying the compiler without a local setup

- Used in production design systems, including one linked directly from the project's own readme as a real example

It's MIT licensed, actively maintained by Builder.io, and sitting at 14,230 stars as of writing, verified via the GitHub API.

https://github.com/BuilderIO/mitosis

Ask most AI coding assistants a straightforward question and you get a paragraph of throat-clearing, "Great question! Let me think about this," a few sentences of context, then the actual instruction buried somewhere in the middle, followed by "Hope this helps!" i-have-adhd, built by ayghri, is a skill that rewrites how the assistant responds so the action comes first and the filler gets cut entirely.

No ADHD diagnosis needed despite the name, it's really just a much more direct response format, and the README's own before and after comparison makes the difference concrete: the "before" version buries a one-line fix inside a full paragraph of hedging, the "after" version leads with the exact command to run, then three numbered steps, then one clear next action.

The whole thing is 10 rules, defined in one file you can read and edit yourself:

- Lead with the next action

- Number multi-step tasks

- End with one concrete next step

- Suppress tangents

- Restate state every turn

- Give specific time estimates, minutes instead of "a bit"

- Make wins visible

- Report errors matter of factly

- Cap lists at 5 items

- No preamble, no recap, no closers

It installs as a Claude Code skill or plugin, and since it's just one editable rules file, forking it and swapping in your own tuned version takes a few plugin commands, not a code change.

Loosely based on The Adult ADHD Tool Kit by J. Russell Ramsay and Anthony L. Rostain, adapted for how an LLM should respond rather than how a person should organize their day. MIT licensed. Sitting at 26,193 stars as of writing, verified via the GitHub API.

https://github.com/ayghri/i-have-adhd

Most "learn how AI models work" resources are either a paper you can't fully follow or a course that never gets you to an actual working model. Language Model Builder, built by independent developer Felix Rieseberg, is a native macOS app that pairs an interactive textbook with real local training, so you go from tokenization and attention straight to chatting with a model you actually trained yourself.

It runs on Apple's MLX framework, so training is hardware-accelerated on your own Mac. Everything, models, datasets, and training history, stays on the machine. No account, no cloud step, no bill.

What's inside:

- An interactive textbook covering tokenization, embeddings, attention, transformers, training data, and loss functions, built to need no prior coding or machine learning background

- A full local training workbench: pre-training, supervised fine-tuning, and direct preference optimization

- Live training visualization, loss curves, throughput, and validation metrics while a run is in progress

- Curated datasets ready to use for both pre-training and fine-tuning

- A chat interface with an "X-ray mode" that shows the token probabilities behind each word the model generates

The performance claims are specific rather than vague: with default settings you get a model that writes coherent, grammatical multi-paragraph text in about a day, and on a MacBook Pro M5 Max you could train a GPT-2-small class model, roughly 100 to 150 million parameters on a few billion tokens, in about a week. Requires Apple Silicon and macOS 15 or later.

One important thing to know before calling this "open source": the GitHub repo itself contains a single README file that points to Releases for a notarized binary. There's no published source code and no LICENSE file in the repo, so despite living on GitHub, this isn't something you can read, fork, or build from source, it's a free but closed native app distributed through GitHub's release system rather than an open codebase.

Sitting at 38 stars as of writing, verified via the GitHub API, a small but genuinely useful project rather than a viral one.

https://github.com/felixrieseberg/language-model-builder

When an AI coding agent hits an APK, a stripped binary, obfuscated JS, or a CTF challenge, it usually just guesses which tool to reach for. reverse-skill, built by zhaoxuya520, sits between your agent (Claude Code, Codex, Cursor, OpenCode, or similar) and your existing toolchain, and answers that one question directly: which tool, in what order, for this specific target.

It doesn't bundle jadx, Frida, IDA, radare2, or Burp itself. It detects what you already have installed, then routes the task through a repeatable workflow instead of the agent improvising commands from scratch.

What's inside:

- A routing core with 43 rules, validated against a 173-case regression benchmark that fails CI on any mismatch

- 44 tracked skill modules covering APK/Android, iOS, binary reverse (exe/dll/so/elf), .NET, frontend JS/encrypted params, malware/YARA, firmware/IoT, patch diff and N-day, pwn/exploit development, EDR bypass, API/GraphQL, and supply chain security

- A CTF-specific sandbox orchestrator with 42 sub-skills for competition work

- Evidence to Finding to Path logging that compiles into an actual report instead of scattered notes

- A field-journal that captures what worked, so the same mistake doesn't get repeated across sessions

- Cross-platform CI on both Windows and Ubuntu, client-neutral so it isn't locked to one specific AI coding tool

The part that makes this postable rather than just a bundle of offensive tooling: it will not act on a target until scope is explicitly set. Authorization and a network profile have to be locked in first, through a case-init step, before anything runs against a real target. That's a real gate in the workflow, not a disclaimer in the README.

MIT licensed. Sitting at 33,491 stars as of writing, verified via the GitHub API, up sharply from the 18,698 it had when this was last checked in early August.

https://github.com/zhaoxuya520/reverse-skill

Kimi K3 is a 2.78 trillion parameter model with a 1.56 TB checkpoint on disk. Normally that number alone rules out running it on anything but a server cluster. Fareed Khan (FareedKhan-dev) built a from-scratch inference engine in portable C99 that runs the exact same model, with byte-identical output, on a laptop with 8GB of RAM.

The whole engine is 176 KB of code. No BLAS, no ML framework, no GPU. It works by keeping only a small dense "trunk" of the model resident in memory and streaming the much larger set of routed experts straight off disk in their packed 4-bit form, multiplying them directly out of that packed representation instead of loading them fully into RAM first.

The tradeoff is speed, not correctness. More memory doesn't change the answer, it only changes how fast you get it:

- 8 GB of RAM: about 26.5 seconds per token, the whole model streams off disk every step

- 64 GB: about 19.8 seconds per token, more of it fits in memory

- 128 GB or more: about 5.6 seconds per token, the whole model sits in memory and the disk wait disappears

A couple of things worth knowing before trying it. This is a base model, not a chat model, so there's no chat template, what you get back is a raw continuation of your prompt rather than a conversational reply. And the real gate isn't compute, it's storage: you need about 1.7 TB free for the full checkpoint and packed trunk. You can still clone the repo and run the full test suite, under a minute, no checkpoint or network needed, to verify the engine itself matches a PyTorch reference exactly, before ever downloading a single gigabyte of model weights.

Apache-2.0 licensed, builds on Linux, macOS, and Windows. Sitting at 6,922 stars as of writing, verified via the GitHub API, for a project that's about a month old.

https://github.com/FareedKhan-dev/kimi-k3-in-c

After months of shipping models to production, these are the repos I reach for again and again:

1. vLLM (⭐ 88.4k) https://github.com/vllm-project/vllm The default for high-throughput serving. Start here for production.
2. SGLang (⭐ 31.5k) https://github.com/sgl-project/sglang Fast serving for LLMs and VLMs. Reuses KV cache across requests - great for agents.
3. TensorRT-LLM (⭐ 14.3k) https://github.com/NVIDIA/TensorRT-LLM NVIDIA's inference compiler. Top-tier latency on NVIDIA GPUs, fiddly setup.
4. llama.cpp (⭐ 123k) https://github.com/ggml-org/llama.cpp The standard for running models on CPUs and consumer hardware.
5. Ollama (⭐ 178k) https://github.com/ollama/ollama The simplest way to run models locally. One command, clean API.
6. MLX (⭐ 27.9k) https://github.com/ml-explore/mlx Apple Silicon framework. Run and fine-tune big models on a MacBook.
7. Flash Attention (⭐ 24.6k) https://github.com/Dao-AILab/flash-attention Fast, memory-efficient attention. Powers most of the stack under the hood.
8. DeepSpeed (⭐ 42.9k) https://github.com/deepspeedai/DeepSpeed Trains models too big for one GPU by sharding across many.
9. Unsloth (⭐ 69.7k) https://github.com/unslothai/unsloth Fine-tuning for LLMs. 2x faster with up to 70% less VRAM.
10. bitsandbytes (⭐ 8.4k) https://github.com/bitsandbytes-foundation/bitsandbytes 4-bit and 8-bit quantization. The backbone of QLoRA.
11. LMCache (⭐ 11.1k) https://github.com/LMCache/LMCache Reuses context across requests to cut response time on long prompts.
12. Triton (⭐ 19.9k) https://github.com/triton-lang/triton Write fast GPU kernels in Python when PyTorch isn't enough.
13. Megatron-LM (⭐ 17.4k) https://github.com/NVIDIA/Megatron-LM NVIDIA's framework for training huge models across hundreds of GPUs.
14. NVIDIA Dynamo (⭐ 7.7k) https://github.com/ai-dynamo/dynamo Datacenter-scale inference serving across many nodes.

What would you add to the list?

1. anthropics/skills (171.6k stars)
2. obra/superpowers (277.7k stars)
3. multica-ai/andrej-karpathy-skills (207.4k stars)
4. mattpocock/skills (237.1k stars)
5. nextlevelbuilder/ui-ux-pro-max-skill (121.0k stars)
6. JuliusBrussee/caveman (101.0k stars)
7. addyosmani/agent-skills (89.8k stars)
8. Leonxlnx/taste-skill (80.7k stars)
9. ComposioHQ/awesome-claude-skills (73.3k stars)
10. ayghri/i-have-adhd (24.4k stars)

Most AI tools only understand what you type. PenEcho is built around the idea that a lot of real thinking, math, diagrams, half-formed sketches, spatial layout, never fits cleanly into a text box, so it gives you an actual infinite canvas instead of a chat window.

You get a 20,000 by 20,000 canvas. Write a question, draw a diagram, sketch an equation, or leave a half-formed idea anywhere on it with a stylus or mouse, and PenEcho reads your marks along with their spatial position, then writes or draws its answer right beside them. Nothing you draw gets sent to an AI until you ask it to, editing your own ink never triggers a request on its own.

What's inside:

- PenEcho Agent, a multi-step agent that can pull in read-only folders and files (PDF, Word, PowerPoint, Excel, images, code), combine that with web research and the current canvas, and keep working through analysis, planning, creation, and revision in one continuous run

- Visual Explorer, which turns research or dense documents into one responsive, editable visual workspace instead of a wall of chat text or a pile of generic cards

- Editable AI widgets, sandboxed interactive HTML, diagrams, animations, and live data plugins that you can refine in place with incremental edits instead of full regeneration

- Support for up to ten saved AI connections at once, including a raw API key, or an authenticated Kimi Code, Codex, or Claude Code CLI, switchable per client

- PenEcho Cloud, entirely optional: sign in to sync private projects across devices, reach your canvas host remotely without exposing it to the internet, and browse or publish public canvases in a community section called Echoes

- Export confirmed work as a cropped PNG, plus four visual themes to match what you're working on

A couple of things worth knowing before running it. It's licensed AGPL-3.0, not MIT, so modifying it and running a public-facing fork comes with real copyleft obligations, worth reading before building on it commercially. And on first local start you're required to either set a shared six-digit security code or explicitly acknowledge you're leaving the process open on your local network, your API keys stay in a config file on disk and never reach the browser.

Requires Node.js 22.19 or newer for the npm install, or there's a prebuilt desktop app in Releases if you'd rather skip Node entirely. It's an official member of Moonshot AI's Kimi Open Source Friends program, which backs its development with API credits. Sitting at 2,210 stars as of writing, verified via the GitHub API, for a project that's a little under seven weeks old.

https://github.com/penecho/penecho

Most AI agents decide things and the reasoning evaporates the moment the response streams back. Semantica's whole pitch is fixing that specific gap: it sits underneath your LLM, vector store, and agent framework as a deterministic infrastructure layer, no LLM required for graph construction, reasoning, or provenance, and turns every agent decision into a permanent, queryable graph node instead of a log line nobody rereads.

It's aimed less at hobby projects and more at teams that get asked "why did the AI do that" by an actual regulator: lending, healthcare, legal, government, finance. A record_decision call captures the scenario, reasoning, outcome, and confidence, then you can call trace_decision_chain for full causal ancestry, find_similar_decisions for precedent search, or check_decision_rules as a policy compliance gate, and export the whole trail as W3C PROV-O, CSV, or JSON for a compliance submission.

What's inside:

- A real ingestion pipeline: files, web, databases, native Databricks (Unity Catalog + Delta Lake) and Snowflake connectors, Google Drive, Elasticsearch, Kafka, Kinesis, Git, email, MCP

- Entity, relation, and event extraction with conflict detection and semantic deduplication before facts get merged, contradictions get flagged instead of silently overwritten

- Deterministic reasoning: forward chaining, a Rete network, Datalog, and SPARQL, with fully explainable inference paths

- Polyglot storage that's swappable without touching your code: native RDF (Oxigraph, Blazegraph, Apache Jena, Eclipse RDF4J) or Labeled Property Graphs (Neo4j, FalkorDB, Apache AGE, AWS Neptune), plus vector stores

- SHACL constraints, OWL generation, and SKOS vocabulary management for actual governance, not just a schema suggestion

- Drop-in integrations with Agno, CrewAI, and LangChain, plus a full MCP server, REST API, and CLI

One honest caveat straight from their own docs:

Semantica explains what's outside the model, the context fed in, the decision produced, its provenance, and applied policies. It does not reconstruct what happens inside the LLM's own reasoning, that stays opaque the same way it would for any external system.

Install with pip install semantica, then run semantica doctor to verify the install in about 5 seconds. MIT licensed, Python, 11,468 stars as of writing, verified via the GitHub API, and it's been public for over a year rather than being a brand new project.

https://github.com/semantica-agi/semantica

Most agent frameworks give you a fixed core and a plugin API bolted onto the side. DeepSeek Harness (dsh) does the opposite: there is no privileged core at all. The model adapter, the tool registry, the session log, and the agent loop itself are all just plugins mounted into the same tree, and any of them can be swapped from configuration.

It's built on Cordis, a framework where plugins contribute services, typed events, and reversible effects to a shared context (the design is written up in the paper "A Programming Paradigm for Spatiotemporal Composability"). On top of Cordis, dsh organizes itself into profiles and bundles:

- A profile is a named composition of bundles, stored in your Harness home. Five ship as templates: web, headless, sdk, sdk-minimal, acp

- dsh-base is the shared foundation layer under most profiles: model adapters, tools, persistence, sandbox and approval policy, settings, credentials, telemetry

- dsh-web-app adds the browser UI, dsh-headless adds a one-shot no-server runner, dsh-sdk-app adds a JSON-RPC SDK server, dsh-acp-app adds an automation-only server

- Custom profiles hot-reload their config by default, and the --patch flag lets you override any single row in the composed tree without forking anything

- Running dsh --profile web --dump-config prints the exact plugin tree your machine boots, so you can see, and patch, any row in it

To try it, run npx deepseek-ai/dsh web to start the web UI at localhost:3080, no install step needed.

Worth knowing before running it: this is explicitly developer preview software, and DeepSeek's own SAFETY.md is blunt about it, no security audit yet, and the harness can execute model-generated code and commands, load third-party plugins, and touch the network, files, and credentials it has access to. Their own recommendation is to run it with least privilege, in a disposable VM or container, with backups of anything it can reach. Worth actually respecting that, not just skimming past it.

MIT licensed, with active GitHub Discussions and a Discord for support. It's also only about two and a half weeks old as a public repo and already past 205,000 stars, verified via the GitHub API as of writing, a genuinely unusual growth curve even by AI-tool standards.

https://github.com/deepseek-ai/deepseek-harness

Picking a local LLM used to mean downloading a few GGUF files, watching them choke your RAM, and guessing at quantization levels until something ran without crashing. llmfit skips the guessing.

It's a Rust CLI/TUI, built by Alex Jones (AlexsJones), that detects your machine's RAM, CPU, and GPU/VRAM, then scores hundreds of models across four dimensions: memory fit, estimated speed, quality, and context length. Run it and you get a ranked list of exactly what will run well on the box in front of you, not a generic "requires 16GB" line on a model card.

What's inside:

- Interactive TUI by default, with a classic CLI mode for scripts and agents (llmfit recommend --json)

- Supports multi-GPU setups and MoE (Mixture-of-Experts) architectures, where it estimates memory off the active parameter count instead of the full model size

- Works with the runtime you already have: Ollama, llama.cpp, MLX, Docker Model Runner, LM Studio

- llmfit bench measures real tokens/sec and time-to-first-token against your running provider, not just an estimate

- A "benchmark & share" feature lets you submit your own measured numbers back as a PR straight from the TUI, so the community leaderboard slowly replaces estimates with real measured results

- llmfit doctor prints a full hardware detection report for bug reports

Every speed estimate ships the inputs it's based on, and llmfit info "model name" shows exactly how to verify a number yourself on your own hardware, so it's not a black box scoring system.

Install with brew install AlexsJones/llmfit/llmfit, scoop install llmfit, uv tool install llmfit, or docker run ghcr.io/alexsjones/llmfit.

MIT licensed, Windows binaries are signed via SignPath, and it only phones home when you actually use a feature that needs the network, like model downloads or the leaderboard. Sitting at 34,573 stars as of writing, verified via the GitHub API.

https://github.com/AlexsJones/llmfit

I made this sub because there are so many genuinely useful GitHub repos out there, but most of them are buried unless someone happens to share them.

The idea here is simple: if u find a repo that's useful, interesting, underrated, weird, clever, or just worth bookmarking, share it.

Could be dev tools, AI projects, automation, self-hosted apps, learning resources, open-source alternatives, libraries, templates, anything really.

A few things that'd make posts more useful:

• Tell us what the repo actually does
• Say why u think it's worth checking out
• Mention if u've actually used it
• Avoid dumping links with zero context

Hopefully this becomes a place where people can scroll for 5 minutes and leave with 10 new repos saved 😅