Every week, GitHub surfaces projects that push the boundaries of what’s possible — sometimes by solving practical problems, sometimes by asking “but what if we did that?” This week’s selection runs the full gamut: a Rust compiler compiled to C, a Wireshark-style debugger for MCP traffic, an embedding-based duplicate finder, a comprehensive local LLM hardware guide, and a ray tracer that runs entirely inside a SQL query engine.
Here are five repositories that caught attention this week, what they do, and why they matter.
1. jamesob/local-llm — A No-Nonsense Guide to Running SOTA Models at Home
~700 stars · Shell · Created July 3, 2026
Most “run LLMs locally” guides hand-wave the hard parts: which GPUs to buy, how to wire them together, and what kernel parameters actually matter. This repository skips the fluff and documents a real, working $40K rig built around four RTX Pro 6000 GPUs totaling 384 GB of VRAM, along with a practical $2K entry-level path using dual RTX 3090s.
What sets it apart is the depth of operational knowledge. The README covers PCIe switch configuration for peer-to-peer GPU communication, the specific GRUB parameters needed to prevent NCCL hangs (iommu=off), ACS disable for clean P2P traffic, and GPU power limiting strategies for running high-wattage silicon on standard residential circuits. It includes ready-to-run Docker configurations for serving models like GLM-5.2 via vLLM, with documented throughput numbers (~80 tokens/s at 460K context length).
For anyone who has wondered what it actually takes to run near-Opus-grade models without depending on an API provider, this is the reference document. The hardware BOM alone — including eBay-sourced DDR4 systems and indie PCIe switches from c-payne.com — saves weeks of research.
2. FractalFir/crustc — The Rust Compiler, Translated to 46 Million Lines of C
~360 stars · C · Created June 28, 2026
rustc written in Rust is one thing. The entire Rust compiler translated to pure C — 46 million lines of it — is something else entirely. That’s what crustc delivers: a functional Rust compiler you can build with GCC and make, no Rust toolchain required.
The project is a showcase for cilly, a Rust-to-C transpiler that’s been in development for three years across fourteen iterations. The key innovation is that cilly doesn’t assume a specific C compiler or platform. Instead, it generates “witness” programs that probe what the target compiler supports — type sizes, alignment rules, keyword availability, even whether _Thread_local exists — and then produces C code tailored to that specific environment.
/* This compiles if and only if our C compiler supports _Thread_local */
_Thread_local int KEYWORD_TLS_SUPPORTED;The practical motivation is supporting obscure and legacy hardware. If a platform has a C compiler but no LLVM backend — and many embedded and retro systems fall into this gap — cilly can potentially bring Rust to it. The transpiler is also network-transparent: it can talk to a C compiler running on a remote machine over TCP, which elegantly solves the cross-compilation bootstrap problem.
3. kerlenton/mcpsnoop — Wireshark for MCP Traffic
~180 stars · Go (MIT) · Created June 27, 2026
The Model Context Protocol has become the standard way to connect AI agents to external tools, but debugging the actual wire traffic between clients and servers has been surprisingly painful. The official MCP Inspector connects as its own client, which means it never sees the real interactions between your actual client (Claude Desktop, Cursor, Claude Code) and your server.
mcpsnoop takes a different approach: it’s a transparent proxy that sits in the real data path. You wrap your server command with it, and every JSON-RPC frame — requests, responses, notifications, even server stderr — appears in a live terminal UI. When a tool call silently doesn’t happen, or a capability mismatch causes a hang, you can see exactly where the chain breaks.
Beyond passive observation, the tool adds a replay feature: any captured tool call can be re-run against a fresh, isolated server instance, which is significantly faster than reproducing a scenario through the full client. The capability inspector shows exactly what the client and server negotiated at handshake. A filter query language (tool:, status:, dir:, kind:) narrows the stream. It’s a single Go binary with no runtime dependencies.
4. rafal-qa/slopo — Finding Semantic Code Duplication with Embeddings
~200 stars · Python (AGPL-3.0) · Created June 2, 2026
Traditional duplicate code detectors find exact or near-exact matches — copy-pasted blocks with minor variable renaming. slopo targets a harder and arguably more valuable class: code that’s semantically similar but written differently, sitting far apart in the codebase, often across different modules.
The approach is straightforward but effective. Every code unit (function, method, class) gets an embedding vector calculated via a configurable model provider. Pairs with close embeddings become candidate duplicates, ranked by both semantic similarity and physical distance in the codebase. The output is a cluster report designed to feed into an AI coding agent, which can then determine whether each cluster represents a genuine duplication worth refactoring.
uv tool install slopo
slopo init # create config template
slopo index # parse code units
slopo embed # calculate embeddings
slopo analyze # generate duplicate reportSupporting ten languages — Python, TypeScript, JavaScript, Java, Kotlin, C#, Go, Rust, PHP, and Elixir — and integrating with any LiteLLM-compatible embedding provider, slopo slots into existing workflows. The slopo.ignore.txt pattern lets you mark reviewed clusters as false positives and regenerate the report, creating an iterative cleanup loop that pairs naturally with AI-assisted refactoring.
5. ClickHouse/RayTracer — A Path Tracer Written Entirely in SQL
~80 stars · Created June 27, 2026
Some projects exist because they solve a problem. Others exist because they answer a question nobody thought to ask. RayTracer falls firmly in the second category: it renders 3D scenes with reflections, shadows, constructive solid geometry, and procedural terrain — all from a single SQL query running inside ClickHouse.
The technical approach is a masterclass in bending SQL to do things it was never designed for. Each pixel (times each sample) is a row, produced by numbers_mt(width * height * samples). 3D vectors are Tuple(Float64, Float64, Float64) values manipulated through ClickHouse’s built-in functions. The ray bounce loop — normally an iterative algorithm — is implemented via arrayFold over range(maxDepth), keeping each row independent so the render parallelizes across all CPU cores. The output writes directly to ClickHouse’s native PNG format.
The scene geometry is surprisingly rich: cylinders for straight letter strokes, ray-marched tori for curved letters, spheres with CSG difference operations for a chrome planet, and a fractal Brownian-motion terrain with marched shadows and distance fog. It’s a reminder that SQL, given enough determination, is accidentally Turing-complete in all the right ways.
Wrapping Up
This week’s projects span the full spectrum of developer ambition. local-llm documents the unglamorous engineering reality of running frontier models on consumer hardware. crustc asks whether Rust can reach platforms LLVM doesn’t touch. mcpsnoop fills a real gap in the MCP ecosystem. slopo applies embedding models to a problem that’s resisted clean solutions. And RayTracer proves that SQL can do literally anything, given sufficient creativity.
What ties them together is that none of them wait for permission. They’re practical, opinionated, and built by people who hit a wall and decided to build a ladder instead. That’s the kind of energy that makes open source worth following.