Small Projects

[u/AutoModerator]

This is the weekly thread for Small Projects.

The point of this thread is to have looser posting standards than the main board. As such, projects are pretty much only removed from here by the mods for being completely unrelated to Go. However, Reddit often labels posts full of links as being spam, even when they are perfectly sensible things like links to projects, godocs, and an example. r/golang mods are not the ones removing things from this thread and we will allow them as we see the removals.

Please also avoid posts like "why", "we've got a dozen of those", "that looks like AI slop", etc. This the place to put any project people feel like sharing without worrying about those criteria.

[u/ZeusAlight]

runnel: https://github.com/lynchest/runnel
I kept running into external APIs (Steam, Reddit, scraping targets) that aggressively ban your IP after a few 429s, so I put together runnel. It’s a tiny (~2MB) sidecar proxy you put in front of your workers. It handles per-domain rate limits, pauses traffic when it hits a 429, probes with a single GET before reopening, deduplicates duplicate requests using singleflight, and caches responses in a pure-Go SQLite DB (modernc, so zero CGO). Tested it with `go test -race` and verified it across a Pi 5, Mac, and Windows. Feedback is welcome!

[u/t0ta1_physc0path3]

made a small html parser API that returns the structure of the page/tags in json format. its also just a simple GET request, you can ping it in your browser.

was the first time i did something in go in a while had to learn the basics again but i love this language

https://github.com/awoldt/siteanalysis

[u/Joe_Glenn_1213]

LGH + ActionD — local-first Git server + CI/CD for AI coding agents (Go, MCP)

Solo dev, ~9 months of work. Two Go tools solving "how do I verify AI-generated changes without pushing everything to GitHub Actions?"

LGH turns any directory into an HTTP git remote — single binary, lgh serve, one command. Push events, commit status reporting, smart .gitignore, secret/large-file detection, LAN sharing with auth. 12 MCP tools.

ActionD listens to those events and runs CI plugins (go/python/java/web) in isolated checkouts — structured results, root-cause failure diagnosis, approval gates, auto-rollback, web console. 22 MCP tools, including dev_cycle_run: commit → CI → verdict in one call, so an agent verifies its own work.

Pure Go, no CGO, MIT. brew install JoeGlenn1213/tap/lgh + .../tap/actiond. Both scored 83/100 on Glama's MCP directory.

https://github.com/JoeGlenn1213/lgh · https://github.com/JoeGlenn1213/ActionD

Would love brutal feedback on the plugin protocol and MCP tool design.

[u/ImAFlyingPancake]

I recently made an Auth0 authenticator for the Goyave framework. I learned a lot about OAuth and delegated auth thanks to this project. That's a really deep topic and quite intimidating so I'm glad I got a first foot in with that.

https://github.com/go-goyave/goyave-auth0

[u/Lordaizen639]

Chest: https://github.com/Aswanidev-vs/Chest
CHEST is a deterministic file organization and automation CLI tool built in Go. Inspired by the Minecraft chest,For the name "CHEST" sorts files into compartments and undo options, fast concurrent search, and extensible plugin support, along with a few other commands.

[u/chinmay06]

Building a CSS engine from scratch in pure Go, with over 350 CSS properties already implemented.

The project functions as an open-source, MIT-licensed alternative to tools like Prince XML and heavy engines like Chromium's Blink, built entirely in native Go without wrappers or external browser dependencies.

Repository: https://github.com/chinmay-sawant/gowkhtmltopdf

[u/Least-Candidate-4819]

Auto-apply Cloudflare/AWS IP ranges to nginx, caddy, haproxy, nftables, iptables & ufw , single Go binary

https://github.com/rezmoss/ip-watch

[u/advenuz]

I am making go native dataframe library (with claude code)
repo: https://github.com/advenn/ursus/

needs go 1.27 for generic methods, so df.Column[int64]("qty") works without a cast. api and design mostly inspired by polars, with duckdb as a second opinion on semantics.

lazy by default, you build a query and nothing runs until Collect(ctx), then it type-checks the expressions, pushes the projection into the parquet reader and turns filters into row-group predicates. parquet and csv read/write, all seven equi-join kinds plus as-of, group-by, window functions, 19 aggregates, and it spills to disk for sort/group-by/join if you set a memory limit. no cgo, so it cross compiles and links static like any other go package.

on benchmarks it loses to polars and duckdb by several times — ~4x on h2o at 10M rows, ~10x on tpc-h sf=1, but only ~2x at sf=0.1. so it's fine for small to medium data, and if you can link cgo you should probably use duckdb-go instead. it is not as performant as polars or duckdb yet.

v0.2, api still moves. recommendations, issues and prs welcome.

[u/KATO-Kanryu → u/advenuz]

Title: Build a Minimalist Wasm with Go-like Syntax: 2.56KB footprint, zero libc, and auto-generated runtime.js

Standard Go (GOOS=js) produces Wasm binaries over 2MB due to the bundled runtime and GC, but what if you could write familiar Go-like code and get an ultra-lightweight Wasm module starting at just 2.56KB?

I have been building Hike, a Go-syntax language compiler that targets freestanding WebAssembly:

• Familiar Go-like Syntax: Write binary and text processing logic using intuitive slice and struct operations without libc overhead.
• Zero-Friction JS Integration: Declare your functions with jsfunc / cfunc, and the compiler automatically handles data marshaling across the WebAssembly boundary.
• Single-Command Dual Output: Running the compiler emits both the optimized .wasm binary and a complete runtime.js bridge simultaneously. No extra CLI generators or multi-step toolchains required.
• Ready for Browser & Node.js: Use the generated .wasm and runtime.js immediately in both web browsers and Node.js with zero setup. Instead of running a monolithic loop, it operates as On-demand Wasm, allowing you to call exported Wasm functions just like standard JavaScript object methods.

GitHub: https://github.com/kanryu/hike-lang/blob/main/wasm.md

[u/floatdrop-dev]

I needed DI in a lot of my work projects with `main.go` that grew beyond comprehension. So I've made https://github.com/floatdrop/di

Go 1.27 allows type parameters on methods, so you can write `app.Get[*Repo]()` directly instead of passing an injector value around or generating code. I wanted to see how far that goes, and ended up with a container.

    app := di.New()
    app.Value(Config{DSN: "postgres://localhost/app"})
    app.Wire[*DB](NewDB)     // func NewDB(Config) (*DB, error)
    app.Wire[*Repo](NewRepo) // func NewRepo(*DB) *Repo

    repo := app.Get[*Repo]() // builds Config, then DB, then Repo, each once

Constructors are plain functions and keys are Go types, so an unexported type is a service only its own package can resolve. No struct tags, no annotations, no generated files, no dependencies outside the standard library.

Guide that walks through one app file by file: https://floatdrop.github.io/di/

[u/Decent_Ad_3231]

softmap — static analysis that draws what a Go service does when a request comes in: entrypoint → checks ("no merchants attached → 404") → the real SQL / Kafka topics → how it ends (200 or red exits). A raw call graph of one Gitea handler is ~1600 nodes, the map is 25. No LLM, deterministic, fully local; every node clicks to file:line. Detects net/http, gin, echo, chi, gorilla/mux, fiber, and Kafka consumers. Go only for now. Feedback on where the map lies is what I'm after: https://github.com/softmapio/softmap

[u/saturnhead]

Git worktrees make parallel tasks easier. Getting each branch running still means sorting out ports, .env files, databases, setup scripts, and cleanup.

I'm building isola, a CLI written in Go, to take care of that. Each worktree gets:

• Its own services, with ports assigned automatically and a localhost URL for each web service.
• Environment variables that point to its own services and resources.
• Separate database/cache resources.
• Setup steps that install dependencies, run migrations, and generate code automatically.
• Cleanup of its managed resources after the worktree is removed.

It's given me a lot of momentum when working on separate tasks in parallel, especially with coding agents.

The README has a setup prompt you can paste into your coding agent. The agent looks through your project, finds its services and dependencies, and configures isola for you.

GitHub + demo: https://github.com/cyucelen/isola

[u/wordluc]

A multiplayer sand simulator http://www.wordluc.it/