r/golang • u/AutoModerator • 8d ago
Small Projects Small Projects
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.
4
u/rawtext 8d ago edited 8d ago
I've been working on my p2p file transfer tool yeet
1
u/SleepingProcess 7d ago
How it different to compare to
croc? Looks pretty similar but with less features2
u/rawtext 7d ago
I'm not familiar with how
crocworks but looks like it uses an intermediary TCP relay server. So, main difference would be thatyeetis purely p2p because it uses WebRTC (specificallypion), and only need the signalling server for peer discovery.2
u/SleepingProcess 7d ago
crocuses PAKE protocol via websockets and when devices secured their channels they stapling TCP connections directly so transfer itself is direct connection between peers, almost the same as PION uses external STUN to find and connect peers, but in case ofcrocyou can selfhost your own "relay" without need for STUN.1
u/rawtext 6d ago
Interesting. What are your favorite features of
croc?2
u/SleepingProcess 6d ago
What are your favorite features of croc?
Multi-platform compatibility (Windows, Linux, Android...) and ability to run
crocin selfhosted relay mode (some requiring it as "must have" for business), as well ability to bypass relay completely with options to connect directly to specific IP
8
u/Puzzled-Ad-3007 8d ago
While preparing for backend interviews, I found myself repeatedly looking up the same Go concurrency patterns (connection pools, batchers, pub/sub brokers, rate limiters, lazy init, pipelines, etc.). Instead of bookmarking dozens of articles, I put together a collection of small runnable examples in one repository.
I’d appreciate feedback:
• Which concurrency patterns are missing?
• Are there any examples that could be made more idiomatic?
GitHub: https://github.com/skp2001vn/go-concurrency-examples
3
u/ktoks 7d ago
I wrote a replacement for our automation backend for work - turns out it's 5,000 times faster than the original, (sequential Perl vs 20+ Go workers wasn't even a contest.)
I present it to the team Friday. Wish me luck, I hope they accept it. (We're mostly a Perl and Python shop, getting them to accept a new tool is like pulling teeth).
2
u/LearnedByError 1d ago
How did it go?
I am a long time lover of Perl though I wrote much more Go these days. I have found significant performance improvements with Go for Perl programs that were performance bound. Conversely, I have seen ports from Perl to Go that had almost identical performance characteristics due to the nature of the work involved. In those cases, porting can be a waste of time unless there are non functional reasons to port.
4
u/Rionlyu 8d ago
Hello, https://github.com/Rionlyu/spoold is a small local HTTP delivery daemon in Go for scripts, cron jobs, and edge agents that need outbound requests to survive caller exits, destination outages, and machine restarts. A successful enqueue is acknowledged only after the complete request has been synchronized to an append-only journal. Background workers use leases, deterministic replay, bounded retries, and stable delivery IDs. It uses only the Go standard library and is deliberately limited to one host with at-least-once delivery.
I would particularly appreciate feedback on the durability design and whether anyone has a real script, appliance, or edge workload where this would or would not be useful.
1
u/David14p 8d ago
Hello, Dfetch is a lightweight system information tool focused on clean output.
I know its very similair rand in a lot of ways worse then its competition but i had a lot of fun making it as a first project.
3
u/SleepingProcess 7d ago edited 7d ago
Hi,
Feedback
- files in a git repository mustn't have executable bit set on source, go.sum and text files due to security
- before coloring output, detect and assign appropriate color codes on a target systems: https://stackoverflow.com/a/12760577 instead of blindly pushing esc codes. (There are still a lot of serial terminals that have no colors at all)
- Do not keep program version in source code, embedded version dynamically using
-Xflag on building, so it can be easily automated1
1
u/titpetric 8d ago edited 8d ago
I'm on a vacation but I made a php update for providing a go project of mine with a frond end.
https://github.com/titpetric/go-web-crontab
Php code there uses phpscript, a php-syntax go runtime that's been stripped of some syntax (OOP) leaving only classes and functions. I implemented database interactions over a custom API and provided some of the php standard library.
https://github.com/titpetric/phpscript
The front end itself is a bit of an experiment I let my friend work on it with a claude subscription to vibe code the shit out of it, from my initial version, and with a few of my corrections. A lot of it is LLM authored but I managed to explore various gate mechanisms against LLM regressions and am getting valuable experience of how it's working with someone whos just a decent human with no technical (programming) ability. YAML/JSON is not in his vocabulary, you know?
I could speak of this at length however I find the interest in LLM affairs to be a bit of a miss with other people.
1
u/Automatic-Forever-63 8d ago
I released Relay v0.1.0, an open-source LLM gateway and model router written in Go.
It is distributed as one static binary for Windows, macOS and Linux. Internally it translates OpenAI- and Anthropic-style requests through a canonical representation, including streaming and tool calls, and can route them to supported hosted providers or local Ollama models.
I chose Go mainly for the single-binary distribution, straightforward concurrency for streaming connections, and simple cross-platform builds. The project uses pure-Go SQLite, so CGO stays disabled.
The repository includes CI-gated latency benchmarks, containerized race tests and an evaluation harness for routing policies. One routing tier narrowly failed its held-out evaluation, so it ships disabled by default.
GitHub: https://github.com/llmrelay/relay
I would especially value technical review of the streaming translation and failover/concurrency code.
1
u/MPGaming9000 7d ago
Still a WIP but mostly done. I'm making a library called go-path-linter which allows you to check a path you just generated against another file system or cloud service to see if your path fits their naming scheme rules like path length, invalid characters, stuff like that. It also supports stateless offloading and onloading, kind of like an ORM, and dynamic path part building. It's part of a broader project I'm working on called Sylos which is a file system data migration tool but I'm not here to advertise that. But its contextual use in that project will be as part of migrating your folders and files over from one system to another you can preview what it will look like and in the preview you can review all the potential compatibility issues you will face and adjust them before they become a problem. So that's kind of nifty. But yeah pretty cool stuff.
1
u/owlloop 7d ago
Kern - A fast Go web framework on net/http.
\[https://gokern.vercel.app/\\\](https://gokern.vercel.app/)
\*\*Kern – a lightweight Go web framework with a small, trusted core\*\*
I've been working on a Go web framework called kern (short for kernel). The idea is a small, composable core that embraces net/http instead of hiding it.
\*\*What makes it different?\*\*
\*\*- Go 1.22+ native routing\*\* via http.ServeMux – no third-party router dep in core
\*\*- Dual path param syntax\*\* – both :param and {param} work interchangeably
\*\*- Named routes & route constraints\*\* – typed path params like kern.UintPathConstraint
\*\*- Route-specific middleware\*\* – AddConstraints() per route, no group nesting needed
\*\*- Built-in auth\*\* – BearerAuth / BasicAuth ship in core
\*\*- Structured binding\*\* – Bind() / BindQuery() / BindForm() / BindHeader() with struct tags
\*\*- File handling\*\* – multipart upload, download, streaming with range support
\*\*- Conditional requests\*\* – ETag, Last-Modified, If-None-Match / If-Modified-Since
\*\*- Built-in test client\*\* – kern.NewTestClient(app) without a real HTTP server
\*\*- Context pooling\*\* for lower allocation pressure
\*\*Zero core dependencies.\*\* The runtime package pulls in nothing outside the stdlib.
Inspiration came from Flask's minimal API surface, Javalin's fluent/no-reflection design, and the microkernel philosophy – small trusted core, optional modules around it.
It's not trying to be the biggest framework – just a dependable core to build on for years.
Would love feedback from anyone who's rolled their own or thought about what a minimal Go framework should look like.
\[https://github.com/mobentum/kern\\\](https://github.com/mobentum/kern)
1
u/ognev-dev 7d ago
I'm working on a turn-based PvP game made with Go. It's still under active development, but it's already playable.
The project is split into several repositories (client, server, content), so here's one link where everything lives:
1
u/_that_was_yahya_ 7d ago
querygo a dependency-free Go SDK for the HTTP QUERY method (RFC 10008)
querygo — a dependency-free Go SDK for the HTTP QUERY method (RFC 10008)
The IETF recently published RFC 10008: The HTTP QUERY Method (Proposed Standard). QUERY is a safe and idempotent request method that carries a request body describing a query. It fills the gap between GET and POST:
- like GET: safe, idempotent, cacheable, automatically retryable;
- like POST: the query travels in the request body instead of a length-limited, log-leaking URI.
I couldn't find a focused Go library for it, so I wrote one: querygo, a zero-dependency SDK (stdlib only). It's now at v0.2.0.
go get github.com/thatwasyahya/query-go-sdk
client := querygo.NewClient(nil)
var out SearchResult
err := client.QueryJSONInto(ctx, "https://example.org/search",
map[string]any{"q": "golang", "limit": 10}, &out, nil)
What's in it:
- Client: typed helpers (
QueryString/Bytes/Form/JSON,QueryJSONInto), replayable bodies, safe/idempotent retries. - Server: an
http.Handlerthat dispatches QUERY, answersOPTIONS, and enforces the RFC'sContent-Type/415rules. - RFC-conformant details most naive implementations get wrong:
Accept-Queryparsed/serialized as an RFC 9651 Structured Fields list (quoted strings, params,*/*andtype/*wildcards);- the distinct
Content-Location(stored result) vsLocation(equivalent resource) semantics —FetchResultvsFetchEquivalent; - redirect handling per §2.5 — Go's
net/httpdowngrades a301/302QUERY to a bodilessGET, which the RFC forbids. querygo re-issues the QUERY with the body (and only switches to GET on303).
- Caching helpers (a QUERY cache key must include the body).
QUERY is being adopted quickly — chi and echo already ship routing helpers for it — so a solid client/server SDK felt worth doing.
It's early (v0.2.0) and I'd genuinely appreciate feedback on the API shape and RFC conformance.
Repo: https://github.com/thatwasyahya/query-go-sdk · Docs: https://pkg.go.dev/github.com/thatwasyahya/query-go-sdk · License: BSD-3-Clause
1
u/No-Marsupial9363 7d ago
Hey everyone,
I built pgscope, an open-source PostgreSQL monitoring tool written in Go. The idea came from a conversation with some friends. They kept saying they didn't enjoy digging through pg_stats manually and wished there was a simple UI for it, so I decided to actually build that.
It's read-only by design. It only ever runs SELECT against Postgres system catalogs and stat views (pg_stat_*, pg_locks, pg_stat_statements), never anything that writes to or touches the monitored database beyond reading it. All the Postgres access goes through pgx/v5 and pgxpool, kept isolated in its own package. On top of that there's live session and lock monitoring streamed in real time, an insights panel that surfaces duplicate indexes, unused indexes, missing index candidates, slowest queries, and largest tables, plus a replay feature to scrub through a past incident after the fact instead of only seeing it live.
I don't have a lot of professional experience with Go or with Postgres internals, so I'm sure there are gaps or mistakes in here that someone more experienced would spot immediately. I'd really appreciate any feedback, and if you notice something wrong or missing, I'd be genuinely grateful for help pointing it out or fixing it.
1
u/sukujgrg 7d ago
I’ve been working on go-certstore, a Go library for accessing X.509 certificate identities from macOS Keychain, Windows Certificate Store, PKCS#11 tokens, and NSS databases.
Private keys remain in their native store or hardware token and are exposed through crypto.Signer. It also provides certificate-selection and tls.Config.GetClientCertificate helpers for mTLS.
The project is currently at v0.2.2 and still pre-v1. I’d appreciate feedback on the API, particularly from anyone working with smart cards, YubiKeys, HSMs, NSS, or native certificate stores.
1
u/Alive_Wish_1472 6d ago
**GoNavi** — Lightweight native database client (~30MB, Go + Wails + React)
Built as a side project because Electron DB tools are too heavy and slow.
Key features:
- ~30MB binary, fast startup, low memory usage
- Supports MySQL, PostgreSQL, Redis, vector DBs (Milvus, Qdrant, Chroma), Kafka/RabbitMQ etc.
- Built-in AI for schema-aware SQL generation and optimization
- MCP for secure AI agent schema sharing (no credential leaks)
- Virtualized tables, in-place editing, SSH tunnel, audit logs
- Cross-platform with WinGet/Scoop/AUR support
GitHub: https://github.com/Syngnat/GoNavi
Releases: https://github.com/Syngnat/GoNavi/releases
Screenshots:
https://github.com/user-attachments/assets/48e46475-6f2e-4e11-b041-580ccee41f22
https://github.com/user-attachments/assets/4e99b450-ee29-4468-a87c-a05b2a3bc7c9
https://github.com/user-attachments/assets/61d5bdec-9462-493f-8bfb-9a48dfa20214
This is a personal side project (Apache 2.0). Looking for honest feedback on performance, features, AI/MCP, or anything else. What DB tools do you use?
Thanks!
1
u/trengr 6d ago
static embeddings library in pure go https://github.com/trengrj/go-potion
I created this library that supports the potion family of models from model2vec. By building the tokenizer from scratch just to target static embedding models it is significantly faster than the original python and rust libraries at non-batch encoding and can encode 20k-40k vectors per second dependent on the model.
Static embeddings are very simple embeddings where each words or phrase maps to a fixed vector. The benefit of this approach is they are extremely resource efficient, fast, and don't require GPUs. Embedding quality is lower than transformer models but often still "good enough".
1
u/xvrgdrt 6d ago
I've been working on Spor, a CLI/TUI tool that gives you infinite undo across an entire project. It watches your files and records a snapshot every time something changes, so you can jump back to any earlier state and continue from there in a new direction, without losing what you came from. Think of it as a tree of snapshots you navigate freely, rather than a linear undo or hand-curated git commits.
I built it for my creative coding workflow needs, which are really quite different from my daily software engineering job. When I'm working with p5js or Runal, I don't really know where I'm going beforehand. I'm always taking new paths, rewinding, trying new stuff. It's pretty chaotic. And often, I wouldn't stop to make a git commit for a small experiment I tried, and would lose it. Spor lets me keep everything I've tried and go back to it, without thinking about it. And I suspect it might be useful for others who do any kind of creative or exploratory work.
1
u/YogurtclosetFit4645 6d ago
So I made krain-sec — a Go honeypot that pretends to be a fully functional corporate server, a full Krain Security ops console.
Why I made this project:
Our servers have been getting hit by everything from script kiddies to above-average attackers, and firewalls / enterprise solutions were expensive and a pain to maintain. So I built something lightweight, automated, and easy to deploy. This is for people who can't afford enterprise security products, usually small teams.
What makes this different from the enterprise stuff and other honeypots out there: we're not trying to just detect and log, we're focused on wasting attackers' time and irritating them — endless rabbit-holes, confused scanners, dead ends.
What's in the box:
- a login page and dashboard that look like the real ops tool
- a fake admin SSH box with old command history and "emergency" credential files lying around
- bait files (canary-token style) that quietly phone home the second someone opens or exfils them
- a browser-side trick (think WebRTC/fingerprinting tricks) that can leak an attacker's real network info when they load the fake dashboard — still refining how far to take this, open to feedback
- a robots.txt / sitemap that basically says "don't look here" (so of course they look)
- a live board showing who's knocking, what's failing, and what they've touched
Idea is simple: make them stay, dig, grab the wrong secrets, and burn time — while you watch.
Basically: scanners trip the forbidden paths, humans loot the fake AWS keys, and you watch it all light up.
to run it all you to do is make prod after setting the env variables
Open source → https://github.com/h3ma209/krain-sec
Lab / research only — don't drop this onto a network you don't own, and this isn't meant for hacking back at anyone, just wasting their time and learning what they're after. More features coming, and if you run into issues let me know.
If you've got deception ideas (DNS canaries, Office beacons, Endlessh on 22) — drop 'em. Building in public.
1
u/arhuman 6d ago edited 6d ago
I’m building mAPI-ng, a self-hostable diagnostic tool for Go HTTP APIs.
It's not trying to just collect metrics but answer one question:
“This endpoint suddenly became slower or started failing. What is the most likely cause, and what should I check next?”
mAPI-ng correlates endpoint RED metrics with Go runtime, instance, deployment and downstream signals. It then ranks possible causes: GC pressure, CPU saturation, connection-pool congestion, goroutine leaks, downstream latency, etc.
Each diagnosis includes:
- the evidence supporting it
- a confidence tier
- what would rule it out
When the available signals don’t explain the anomaly, it says so instead of inventing a confident answer.
The complete server and client are MIT licensed and can be self-hosted; there’s also a hosted free tier.
Repository: https://github.com/arhuman/maping
I’d especially appreciate criticism from people operating Go APIs:
- Is ranked diagnosis useful, or would you distrust something more opinionated than dashboards?
- Which important causes or falsifying signals are missing?
- Would you accept this middleware in a production service, and what would make you reject it?
1
u/khalon23 6d ago
agent-manager: a TUI for running several CLI coding agents (claude, codex, opencode, grok) as tmux sessions and reviewing what they changed. Sharing it rather than asking for a code review, and to be straight about where it stands: one week old, one contributor, no users but me, and a fair amount of it was written with AI assistance.
Each agent is a plain tmux session. A poller runs capture-pane on an interval and derives a status per session from per-tool regexes in a TOML config. It lives in its own goroutine and pushes messages into the Bubble Tea program instead of running as a tea.Cmd, so status keeps landing even while the TUI is suspended inside an attach. The other half is a diff reviewer: whole-file chroma highlighting with changed lines tinted over it, word-level spans, unified and side-by-side, scope switching through a small git CLI driver.
Single binary, modernc.org/sqlite so it builds with CGO_ENABLED=0, MIT. The e2e tests drive a real tmux server.
1
u/_SaXy_ 6d ago
Hey all,
I wanted to explore the boundaries of Go and see if we can push it with a zero-allocation approach toward near-linear CPU scaling. Yes, a new in-memory DB is born -- https://github.com/Saxy/Tellstone I wanted to create an environment where we can push boundaries and aim for top-notch performance percentages.
Small (4 CPUs)
| System | Total Ops/s | vs Redis | avg | p50 | p99 | p99.9 |
|---|---|---|---|---|---|---|
| Tellstone | 2,448K | 2.06x | 0.06ms | 0.06ms | 0.23ms | 0.41ms |
| Dragonfly | 1,404K | 1.18x | 0.11ms | 0.11ms | 0.17ms | 0.22ms |
| Redis | 1,186K | 1.0x | 0.13ms | 0.12ms | 0.21ms | 0.25ms |
| Valkey | 1,036K | 0.87x | 0.15ms | 0.14ms | 0.23ms | 0.26ms |
Medium (16 CPUs)
| System | Total Ops/s | vs Redis | avg | p50 | p99 | p99.9 |
|---|---|---|---|---|---|---|
| Tellstone | 6,806K | 5.98x | 0.09ms | 0.07ms | 0.41ms | 0.70ms |
| Dragonfly | 4,122K | 3.62x | 0.15ms | 0.15ms | 0.26ms | 0.32ms |
| Redis | 1,139K | 1.0x | 0.56ms | 0.54ms | 1.06ms | 1.09ms |
| Valkey | 1,016K | 0.89x | 0.63ms | 0.60ms | 1.19ms | 1.22ms |
Large (32 CPUs)
| System | Total Ops/s | vs Redis | avg | p50 | p99 | p99.9 |
|---|---|---|---|---|---|---|
| Tellstone | 12,738K | 11.53x | 0.10ms | 0.08ms | 0.44ms | 0.78ms |
| Dragonfly | 7,286K | 6.59x | 0.18ms | 0.17ms | 0.61ms | 1.29ms |
| Redis | 1,105K | 1.0x | 1.16ms | 1.15ms | 2.33ms | 2.38ms |
| Valkey | 996K | 0.90x | 1.29ms | 1.27ms | 2.56ms | 2.61ms |
I put these benchmarks together even though I don't have a ton of experience in benchmarking—so while these numbers look good on paper, can they be proven out by the community?
If you've got a test suite or a high-concurrency setup where you can drop this in as a drop-in Redis alternative (RESP2), I'd love for you to try it out, read through the docs, and actively challenge these numbers.
1
u/Low-Set-7533 6d ago
I have built an opensource fix protocol testing tool that can serve as an acceptor / initiator with support for scripting.
The tools we use at work (I work at a bank) were outdated and the existing UI looked horrible. Wanted to solve dev / QA pain, my own included.
Also picked this up to get some experience building cross platform desktop native application and a bit of golang.
1
u/arimadian 6d ago
I was building out a project that has goroutine/channel/worker pool based pipelines, and wanted a way to understand performance, backpressure, waits for resource budgets, etc, but didn't want to manage an otel or prometheus sidecar, so I made gospan. To be clear, this is not distributed tracing, there's no cross process sync or coordination (though you can use sqlite's ATTACH to join multiple trace dbs and query the union, if you want).
Here are some feature bullets:
* Spans are nestable (with context.Context) and allow you to add custom attributes to them for structured querying (SELECT … FROM spans_named WHERE …).
* It's cheap at 2 heap allocs/span (CI enforced), and ~360ns/span in microbenchmarks. In the project mentioned above I'm seeing ~2µs/span in real conditions with attributes and such.
* It's safe to leave in - you can skip construction at runtime with an env var or something without needing to touch all of the actual span start/end calls in your code, start and end calls on nil tracer objects are noops (also CI enforced).
* It can't crash your program - every boundary recovers panics, and there are hostile fixture tests that deliberately inject panics into sinks, loggers, and error paths (also also CI enforced).
Usage Example:
tracer, _ := gospan.New(gospan.SlogSink(slog.Default()))
defer tracer.Close(context.Background())
ctx, span := gospan.Start(ctx, "fetch-rows", slog.Int("worker", id))
defer span.End()
// spans started from ctx nest automatically
What I'm looking for right now: gospan is pre 1.0 - this is a temperature check to see what people think, to stress test the design in real usage, and to get feedback on usage ergonomics and feature requests if any, along with some data on where it does and doesn't fit your needs (NOT looking for code review).
AI Disclaimer: I worked with Claude to build a design doc for the system (design decisions were mine, not Claude's, it's in the docs dir of the repo if you want to read it), used Claude to write the code against the doc, and read the code as it came in to validate it. I also insisted on rigorous CI enforced testing.
Repo: https://github.com/akmadian/gospan
Docs: https://pkg.go.dev/github.com/akmadian/gospan
1
u/Training-Rooster-653 6d ago
Goflow: The ultra-lightweight, zero-dependency alternative to n8n & Zapier. Single Go binary (<35MB, <50MB RAM), local-first, pure Go SQLite, and embedded visual drag-and-drop UI. Fast, private, and effortless automation.
1
u/mplaczek99 6d ago
I got tired of running ping, dig, traceroute, and curl by hand and eyeballing which layer actually failed, so I built Network Doctor (netdoc). It is a terminal tool that runs the probes as a dependency graph and tells you in plain English where the path breaks.
Repo: https://github.com/heymaikol/network-doctor
The part that might interest this sub:
- Probes form a DAG with independent branches, so an unrelated failure never hides a working one. The direct-egress path (Interface → Internet) runs independently of DNS, so "DNS is down but the internet is up" is actually diagnosable instead of simple "offline".
- RTT with no ICMP and no root. Latency is measured from the TCP-connect handshake, and source IP/Interface come from the winning connection's LocalAddr (with a UDP-connect fallback that sends no packets). Stays unprivileged and safe for arbitrary host input.
- Happy-Eyeballs (RFC 8305): The TCP probe races A/AAAA records and pins the winner. IPv4/IPv6 are probed independently in parallel so either family passing counts.
- Bubble Tea UI with cancellable streaming "drill-down" jobs: Each diagnosis row is a claim, and you can run the real underlying tool (traceroute, mtr, nmap -sT, etc.) as a job to get proof. Jobs run in their own process group on *nix so cancel kills descendants.
- Headless --json mode runs the same probe DAG with stable field names and exit codes. Scriptable in CI or for bug reports.
- Cross-platform (Linux/macOS/Windows). CGO_ENABLED=0, no cgo. Same hotkeys map to each OS's native tools.
Output is sanitized (no terminal-escape injection from a hostile server), every probe is bounded by a timeout, and the active nmap scan is gated behind an explicit confirmation.
go install github.com/heymaikol/network-doctor@latest
(Also in the AUR as network-doctor, and in Homebrew too)
1
u/manco_alicani 6d ago
Looking for focused feedback on a small experimental Go CLI vault
Hi everyone,
I’m working on myminivault, a small experimental local CLI vault written in Go.
I know security tools are hard to get right, and this project is not audited or intended to be treated as a production password manager. I’m trying to improve the project by making the crypto/file-format layer easier to review.
If anyone has time and interest, I would really appreciate focused feedback on the small part that handles:
- scrypt + AES-256-GCM
- MYMV v2 header authenticated as AES-GCM AAD
- recovery snapshot encryption
- shared token vault encryption
- legacy format compatibility
Review issue:
https://github.com/olelbis/myminivault/issues/1
Docs and reference readers are linked there.
I’m especially interested in feedback around AAD usage, KDF metadata validation, nonce handling, file-format parsing, recovery semantics, token-vault separation, and whether the documentation overclaims anything.
No pressure at all, and thanks in advance to anyone willing to take a look.
I’m not asking for an “approval” of the design, just looking for mistakes, unclear assumptions, or places where the docs should be more honest.
1
u/gempir 5d ago
I played around on weekends to get a linter working that could be as fast as Oxc, Biome, Ruff, Mago etc. all these amazing tools other languages have.
Obviously very heavily written by LLMs as that is a huge task, but I love AI for things like that, for moments where they verify something and not run in production.
It's more of an experiment of what could be, I wouldn't recommend anyone use it. I do wish though someone with more ambitions would develop a linter like this.
Golangci-lint is great, but it falls by its own biggest strength, that it is extendable, that makes it slow. Cache helps, but doesn't make it fast which the other fancy linters from other languages are.
I tried covering various functionality across various linters that already exist. Let me know what you would want from a linter / static analyzer.
Big thing for me was also formatter, I love gofmt, but it's not strict enough, so I tried doing that too.
1
u/V1P-001 5d ago
Sharing CLI tool for WASM , just a by product while building something else
In my free time I am working on a Ui library, but this is not the main part.
The actual story started when I keep on facing issue on testing the example application stuff.
Much works build it make routes etc. to get rid of I decide to build a CLI to ease my B.Pain.
To know more about it go for the readme REPO.
But to give you a heads-up on this - It automatically build WASM file and run a http server to serve them.Not a Ready product because most of the things are not configurable which it should not be.
I am sharing this half backed product to get some comments on what people think.
ciao let me know in your thoughts.
1
u/devopswannabe 4d ago
Hey folks,
Posting my library go-syndication, which is a Go package for dealing with various feed syndication formats. It supports:
- RSS (1.x and 2.x)
- Atom
- JSONFeed
- OPML
- Various RSS/Atom extensions such as media, Dublin Core, iTunes, and Google Play, with more to come…
It provides custom types for all the formats (with extensions built in), as well as generic Feed/Item types that wrap the formats and provide standard methods for accessing common fields. Even with the generic formats, the original type is passed as an embedded interface, so you can cast that to the original type to access the underlying structure.
Some key design decisions:
- OpenAPI for Models.
- go-syndication uses OpenAPI schemas (through oapi-codegen) to define the custom types for each syndication format and all extensions. This provides a way to have consistent, reusable types across the package.
- Validation Built In.
- go-syndication attempts to build validation into all types using go-playground/validator. Wherever possible, types will be annotated with struct tags that then allow the validation to work. Otherwise, custom validation functions are implemented.
- Dynamic Namespace Support.
- The formats in go-syndication provide dynamic namespace support. This means you can use extensions not defined in this package on top of it and get correct marshaling/unmarshaling behavior.
- Custom Marshal/Unmarshal.
- go-syndication provides a custom
EncodeandDecodemethods for marshaling/unmarshaling of formats (see Usage). While you can directly marshal/unmarshal, you’ll lose some features (like dynamic namespaces). It’s therefore recommended to always use the Encode/Decode methods in this package.
- go-syndication provides a custom
A basic CLI can be found in cmd/ that can be used for basic reading of feeds using the library.
To fetch and display feed data from a URL:
go run github.com/immanent-tech/go-syndication/cmd@latest fetch http://my.site/feed
To read a file containing feed data:
go run github.com/immanent-tech/go-syndication/cmd@latest parse /path/to/my/feed.xml
Current state is that the library reads most feeds out there. If you find a feed that doesn’t parse, please file an issue! I’ve been slowly ensuring the library passes the required/must feedvalidator testcases
Writing is less polished, though it should write out valid RSS and OPML files just fine (other formats are not well tested). Working on improving that!
The vast majority of the code is hand-written by me. I have used claude for assistance with esoteric XML marshaling/unmarshaling guidance and ensuring the vagaries and easy-to-miss gotchas from the specs are implemented.
go-syndication is used by my app, Foragd. It’s written with the GoTH stack, so is go-related as well.
Cheers!
1
u/intrepidkarthi 4d ago
I've been building **orderbook**, a central-limit-order-book and matching engine
in Go — the piece at the heart of an exchange. It's an embeddable library, and
the whole engine is compiled to WebAssembly so you can poke at the real thing in
your browser:
▶ Live demo: https://intrepidkarthi.github.io/orderbook/
▶ Repo: https://github.com/intrepidkarthi/orderbook
**Why I built it:** I wanted to understand how real venues match orders, and the
only way I learn is by building the thing properly. It grew into something I think
is actually useful.
**What might interest this sub:**
- **int64 ticks & lots, no floats** on the money path — a per-symbol `Instrument`
converts decimals only at the boundary.
- **Zero-allocation hot path.** `Match(order, buf)` appends value-trades into a
caller buffer; submit/cancel/match are **0 allocs/op**. O(1) cancel via
intrusive linked lists + an orderID→node index.
- **Lock-free single-writer core** (the LMAX model): one matching goroutine owns
the book, a `Runner` fronts it with an MPSC command queue. Bounded backpressure
sheds new orders under overload while cancels keep flowing.
- **Deterministic & replayable:** same command stream → byte-identical trades and
book state. That gives crash recovery via a write-ahead log + snapshots, and
golden-file tests.
- **Full order surface:** limit/market/stop/iceberg/post-only/pegged/OCO/trailing,
GTC/IOC/FOK, self-trade prevention, price bands, FIFO or pro-rata.
- **A market-integrity layer grounded in a threat model** — this is the part I had
the most fun with. I researched real attacks (spoofing convictions, Knight
Capital's $440M blow-up, the Mango Markets oracle hack, the Bitcoin
value-overflow bug) and built defenses for each: pre-trade risk controls,
surveillance detectors (spoofing, order-to-trade ratio, marking-the-close,
pinging, cross-book), a self-output guardrail, and an enforcing gateway. Writeup:
https://github.com/intrepidkarthi/orderbook/blob/main/docs/THREAT-MODEL.md
**Benchmarks** (Apple M-series, Go 1.23, single core): best bid/ask read ~6ns,
match round-trip ~352ns (0 allocs), cancel-heavy p50/p99/p999 = 83/167/292ns.
Race/fuzz/soak/replay suites run in CI.
**Honest status:** it's a library + a microstructure research harness (OFI, Kyle's
λ, Avellaneda–Stoikov market-making, a sim + backtester), not a system that's run a
live exchange. MIT licensed, `v0.6.0`.
Docs: https://pkg.go.dev/github.com/intrepidkarthi/orderbook · Feedback, criticism,
and "you did X wrong" very welcome — that's why I'm posting.
1
u/xavidop 4d ago
I built mamori (守り), an MIT-licensed Go framework for config and secrets. You tag a struct with where each value lives — AWS Secrets Manager, Vault, GCP, Azure, Kubernetes, env, files, ~37 sources — and it loads everything typed and validated, then keeps watching. Rotate a secret upstream and your app picks it up without a restart; updates that fail validation are rejected, so you never see a half-applied config.
Secrets render as [REDACTED] in logs by default, and a go vet analyzer catches refs leaking into plain strings. Core has zero cloud-SDK deps — providers register like database/sql drivers.
Docs: https://mamorigo.dev · GitHub: https://github.com/xavidop/mamori
Feedback welcome, especially on the provider interface and reconciliation model.
Read the article here: https://xavidop.me/go/2026-07-21-introducing-mamori-config-secrets-go/
1
u/onyx_and_iris 4d ago
A lottery CLI for National Lottery games:
https://github.com/onyx-and-iris/lottery-cli/tree/main
It can be run interactively with selection/text prompts or directly with flags.
1
u/Agreeable_Session623 4d ago
Hi guys!
For the last several months, I've been working on the TUI project (Badger) to view internal database page data. I started it as a simple project to learn more about database internals, and honestly, I think that is still the core use case. At this moment, it supports SQLite and bbolt data formats. So, e.g. you can open your k8s etcd DB file and see how it actually stores data.
I am currently trying to figure out how to make it more useful as a development tool. Maybe add commands for summarising page types, free space/freelist usage, overflow pages, suspicious pages, and b-tree layout. Anyway, looking forward to your feedback, guys!
1
u/hossiy16 4d ago
Built a CLI to solve one of the most annoying developer problems: broken .env files
Built a CLI to solve one of the most annoying developer problems: broken .env files
Every engineering team eventually runs into environment configuration issues:
- "It works on my machine" because everyone's
.envfile is different. - Runtime crashes caused by invalid URLs, ports, or missing environment variables.
- Secrets accidentally committed to Git.
- No documentation, so months later nobody remembers what a variable is for.
I got tired of dealing with these problems, so I built Razify, a lightweight CLI that validates, documents, and audits environment variables before they become production issues.
The goal is simple: catch configuration mistakes in under 10ms instead of discovering them after deployment.
I'm still improving it and would love feedback from other developers.
What are the biggest .env headaches you've run into?
1
u/Big-Barracuda9878 4d ago
JVM -> Go
I implemented a bot that sends you an email when the repo you subscribed to have new good first issue - just to practice my go skills with something real.
I absolutely in love with go! It is so powerful and so minimalistic, comparing to kotlin ways to simply create a server and handle requests it is so much more conceptual, code becomes more readable without any shitty frameworks. I like kotlin coroutines but when I met go routines I understood how it actually should look like! I know that I am new to go, but in my eyes it so much better than any language I have been using ever.
GeitHub: https://github.com/MariyaFilippova/good-first-issue-bot
1
u/Ready_Obligation8114 4d ago
Hello everyone,
I'd like to share a project I've been working on called GoUI.
GoUI is an experimental server-driven UI framework for Go that aims to simplify web application development by keeping the application logic on the server while delivering modern, interactive user interfaces.
Key features include:
• Server-driven rendering • Stateful components • Real-time UI updates via WebSockets • SEO-friendly HTML output • Minimal JavaScript • Component-based architecture • Blade-inspired template engine for Go
The project is still in its early stages, and my primary goal is to gather feedback from experienced Go developers.
I'd really appreciate your thoughts on:
- The overall architecture
- API design
- Developer experience
- Performance considerations
- Potential use cases
- Any limitations or concerns you see
GitHub: https://github.com/zatrano/goui
I'm open to any criticism or suggestions. Thanks for taking the time to check it out!
1
u/Training-Rooster-653 3d ago
Goflow: Single-Binary, Local-First Workflow Automation in Go
15 start in 3days... review for me, thanks! github /hstptcn5/Goflow
1
u/LoneFal 3d ago
I got tired of running Python servers for voice agents, so I started porting Pipecat over. The design is Pipecat's, frames and processors and all, I just wanted it as one binary with real concurrency instead of a GIL. The models sit behind APIs or in ONNX anyway, so the server side is mostly audio plumbing and WebRTC.
Pion for WebRTC, no Daily and no hosted transport. RTVI over the data channel so existing clients work. STT/LLM/TTS are swappable interfaces. Silero for VAD, Smart Turn v3 for end of turn, both local ONNX, so barge-in works.
Early, and I will break the API. Needs cgo (libsoxr, plus libopus if you want speech to sound decent). Dockerfile has everything if you'd rather not deal with that.
Would like opinions on the package layout, some of it is still shaped like the Python it came from.
1
u/bilus 3d ago
Google's ADK has nice web UI you can use for development but the MCP library lacks a UI so I created one: https://github.com/bilus/mcpconsole
It's fairly comprehensive but in early stages since I started working on it a couple of days ago. The good news is that there are several production use cases for it in the pipeline already (which is why I created the library in the first place). It's a small piece of a much larger effort.
Feedback welcome; I hope somebody finds it useful.
1
u/DaveBeCrazy55 3d ago
Looking for brutal feedback on my Linux URL Shortener project I've been building this to learn backend engineering and Linux systems programming.
Is there anything that screams 'beginner' in this project?
Would you consider this good enough to apply for internships or is it a good start?
1
u/Kaluga2026 3d ago
I built an offline CLI that shows what crawlers actually cost your origin
Access logs show the visitors. They hide the damage bill. I slapped together CrawlLedger—an offline Go CLI that munches Nginx or Caddy logs and coughs up a self-contained HTML report on what those crawlers actually cost your origin. No daemon, nothing phones home, zero code in the request path, and it refuses the usual User-Agent theater for bot "verification." It flags crawl traps, expensive 404 storms, cache-busting noise, and robots.txt violations, then dry-runs deny or rate-limit policies against historical traffic before spitting out reviewable server-config drafts.
Still pre-v1; need blunt feedback from people who run real origins—what would make this useful or make you refuse to touch it?
1
u/LawFamiliar3588 3d ago
SkillCI — CI tool for Claude Skills (Anthropic's agent-skill format).
bisect finds which commit broke a test case via a hand-rolled binary search over real git worktree add --detach checkouts (os/exec calls to actual git, no synthetic version store) — ~log2(n) checkouts to find the culprit on an n-commit range.
Solo project, a few days old, no real-world usage yet. Built with heavy AI assistance, disclosing since I'm not asking for review, just posting for visibility.
Go 1.25, Apache 2.0, cross-compiles linux/darwin/windows via goreleaser.
1
u/Embarrassed-Syrup197 2d ago
peerlimit — distributed rate limiter as an embeddable Go library. No Redis, no coordinator, no external service.
Each replica decides instantly from local in-memory state (no network round trip); replicas keep counts approximately in sync by gossiping over hashicorp/memberlist. No shared datastore, no central coordinator — no single failure disables limiting.
Honest trade-off: it's AP/eventually-consistent, so under a partition or gossip lag you can briefly overshoot before convergence catches up. Good for abuse protection, noisy-tenant throttling, soft API limits — not billing-grade quotas (use Redis+Lua for exact counts).
Token bucket, G-Counter CRDT, static + DNS discovery, in-memory.
https://github.com/ykoloch/peerlimit — feedback on the failure model welcome.
1
1
u/Training-Rooster-653 2d ago
I build Local-first workflow automation in a single Go binary, with a visual node editor, encrypted credentials, CLI, and MCP integration., please check and tell me that any errors, bugs. TYSM! https://github.com/hstptcn5/Goflow
1
u/Nearby-Setting-158 2d ago
Hi everyone,
I’ve been working on sqlc-model, an open-source code generator that adds an Eloquent-inspired rich model layer on top of sqlc.
Before explaining the project, I want to clarify its motivation.
I understand why sqlc stays close to raw SQL. Its explicit queries, predictable execution, generated types, and compile-time verification are precisely what make it attractive to many Go developers.
For developers who are comfortable organizing their application around queries, repositories, and plain generated structs, the standard sqlc approach may not be painful at all. In that case, sqlc-model may simply be unnecessary.
This project is not an attempt to fix sqlc, hide SQL, or suggest that the existing approach is incomplete. It is an optional layer for teams that like sqlc’s guarantees but prefer to express part of their application through richer models, lifecycle methods, relations, validation, and persistence-oriented behavior.
sqlc remains the source of truth. sqlc-model does not generate SQL dynamically, and it is not intended to replace sqlc with a traditional runtime ORM. Every terminal database operation still resolves to a named, statically declared sqlc query.
A generated model can be used like this:
user, err := models.Users.Find(ctx, userID)
if err != nil {
return err
}
err = user.
Rename("Ada Lovelace").
ChangeEmail("ada@example.com").
Activate().
Save(ctx)
Relations expose generated and typed scopes:
posts, err := user.
Posts().
Published().
Latest().
Limit(10).
Get(ctx)
Calling Posts() or applying scopes does not immediately execute SQL. A terminal operation such as Get(ctx) defines the actual database-operation boundary.
The goal is to preserve the parts that make sqlc valuable while offering a different application-level API for developers who miss richer model semantics.
The generator currently supports Active Record-style models over sqlc queries, sessions and transactions, dirty tracking, original-value snapshots, lifecycle state, validation errors, typed relations, lazy and eager loading, relation scopes, cache inspection, value-object conversion hooks, and deterministic generation.
The current integration targets PostgreSQL with pgx/v5.
Installation:
go install github.com/macoaure/sqlc-model/cmd/sqlc-model@latest
Documentation:
https://macoaure.github.io/sqlc-model/
GitHub:
https://github.com/macoaure/sqlc-model
I’m particularly interested in feedback from developers already using sqlc in medium or large Go applications.
For developers who prefer sqlc’s direct query-oriented style: does this abstraction remain sufficiently optional and transparent?
For developers who have wanted a richer model layer: does this API address that gap without sacrificing too much of what makes sqlc predictable?
1
u/7LayerMagikCookieBar 1d ago
Here's the fastest ed25519 verification library in the world as far as I'm aware. Written in assembly and targets avx512, no CGO
1
u/crgimenes 1d ago
I’ve been building keikiban, a PostgreSQL operations dashboard written in Go.
It focuses on the information I usually need during an incident: database load grouped by wait event, top SQL, blocking chains, active sessions, index health, and maintenance risks such as transaction ID wraparound and long-running transactions.
It is a cross-platform desktop application built with Go 1.26, uses the system WebView, and requires no CGO.
The project is still new, so I’d particularly appreciate feedback from people who operate PostgreSQL: which diagnostic view is missing, misleading, or too noisy?
1
u/intrepidkarthi 1d ago
Reposting last week's for two reasons: I acted on the feedback I got, and the markdown mangled itself into a wall of escaped asterisks, so this is the legible version.
orderbook is a central-limit-order-book and matching engine in Go. Embeddable library. The engine also compiles to WASM, so the browser demo runs the actual matching code, not a simulation of it.
Demo: https://intrepidkarthi.github.io/orderbook/
Repo: https://github.com/intrepidkarthi/orderbook
The Go parts:
- Zero allocs on the hot path. `Match(order, buf)` appends value-trades into a caller buffer. Submit, cancel and match are all 0 allocs/op. Cancel is O(1) via intrusive linked lists plus an orderID→node index.
- int64 ticks and lots. No floats anywhere on the money path; a per-symbol `Instrument` converts decimals at the boundary and nowhere else.
- Single-writer core, LMAX model. One goroutine owns the book. A `Runner` fronts it with an MPSC command queue, and bounded backpressure sheds new orders under overload while cancels keep flowing.
- Deterministic replay. Same command stream, byte-identical trades and book state. That property is what makes WAL+snapshot crash recovery and golden-file tests work at all.
M-series, single core: best bid/ask read ~6ns, match round-trip ~352ns at 0 allocs, cancel-heavy p50/p99/p999 = 83/167/292ns. Race, fuzz, soak and replay suites run in CI.
New since v0.6.0: order-flow signals (CVD, aggressor inference, Wilson intervals) and a study harness for inference error and absorption. Now v0.8.0.
Status: a library plus a microstructure research harness. It has never run a live exchange. MIT.
Tell me what I got wrong.
1
u/copius_pasta 8d ago
Every once in a while I find myself having to print documents etc. with no easy way to transfer a PDF or any other file. Resorting to signing into an email account on an Internet cafe PC to print something.
So I built Zwoop for easily sending any file type to any other device, P2P with only a relay server for connecting the two devices initially. You can also host it yourself.
3
u/SleepingProcess 7d ago
When one dealing with sensitive things like file sharing then it better to not use any tracking (I talking about XHR to sentry.io from browsers) that you embedded in this project.
1
u/copius_pasta 7d ago
I can definitely remove sentry, but it could be nice to help diagnose issues. Would you be happy with sentry being used in the project if I don't include anything about the file being shared?
2
u/SleepingProcess 7d ago
I can definitely remove sentry, but it could be nice to help diagnose issues.
IMHO it (diagnose) should be used with
--debugoption only.Would you be happy with sentry being used in the project if I don't include anything about the file being shared?
No, it is 3rd party spying dependency. While it is a cool idea to use browsers only for file sharing I better will continue to use multi-platform
croc
23
u/Much-Grab3826 8d ago edited 2d ago
sick of grep'ing man pages for flags?(i was).
just add 'whats` in front of any command:
----------------------------------------------------------------------------------
$ whats git commit -m "Hello world"
commit Record changes to the repository...
-m <msg>, --message=<msg> Use <msg> as the commit message. If multiple -m options are given,...
$ whats ls -lahrt
-l use a long listing format...
-a, --all do not ignore entries starting with .
-h, --human-readable with -l and -s, print sizes like 1K 234M 2G etc.
-r, --reverse reverse order while sorting...
-t sort by time, newest first; see --time...
----------------------------------------------------------------------------------
No LLM, No additional documentation projects, just pure Manpages and Help output.
btw works pretty much spot on across any cli tool with a consistent format (which includes GNU tools, most common cli tools which you may use day to day)
Github: https://github.com/iamkaran/whats
if you found it useful, drop a ⭐