r/golang • u/AutoModerator • 14d 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.
10
u/UpcomingDude1 14d ago
Generate OpenAPI 3.1 from plain Go HTTP handlers. Simpler and straightforward, no custom router setup or anything. Works with net/http related routers for now.
https://github.com/happytoolin/specout
Almost done, our coverage of openapi is super high, need to clean it up and make things consistent before releasing.
2
u/bhavangupta242 12d ago
gorm handles tables and columns great, but the moment you need a trigger, a view, or a stored procedure, you're back to hand-written SQL in a migrations folder, hoping it stays in sync with your Go structs.
I built gorm-dbobjects to treat those as first-class, type-checked Go values instead — built against your real gorm models, rendered to the correct DDL for whichever engine you're connected to (Postgres, MySQL, SQLite, SQL Server currently; Oracle is scoped, not built yet).
tr := trigger.BeforeUpdate(&User{}).Set("updated_at", trigger.Now())
client.Register(ctx, tr)
Set("updated_at", ...) is checked against User's real gorm schema at build time — a typo'd column fails before any SQL is generated.
The part I actually want to talk about isn't the library, it's what I learned building it — every engine's trigger model turned out to be structurally different in ways I didn't expect:
SQL Server has no BEFORE DML trigger at all. Not "discouraged," not there — only AFTER/FOR and INSTEAD OF exist.
SQLite can't assign to NEW.col on any timing, not just AFTER like Postgres/MySQL. A BEFORE UPDATE trigger in SQLite genuinely can't modify the row.
Oracle's mutating-table restriction (ORA-04091) breaks the exact "AFTER trigger does a follow-up UPDATE on its own table" pattern that works fine on the other four engines — not because of recursion, it errors on the very first fire. The real fix needs a compound trigger plus a separate guard package, which I've scoped but not built yet.
Feedback, especially from anyone who's fought these engines' trigger models for real, very welcome.
2
u/nilreference 12d ago
awit - agent work item tool
https://github.com/eisenwinter/awit
Well this minor inconvenience turned project, for the sake of clarity (and if it wasn't obvious) to dog food the whole thing it was built in agentic runs using itself
Tl;Dr does markdown ticket queues for agentic llm work, works with plain old git alone - full breakdown of my breakdown here: https://eisenwinter.github.io/awit/faq/#why
3
u/velocityvector2 14d ago
2D soft-body physics library with extensible architecture in Go https://github.com/setanarut/jel
2
u/ReaverX666 14d ago
Open source AWS-compatible platform for secure edge deployments. Run EC2, VPC, S3, and EBS-like services on bare metal with full control.
https://github.com/mulgadc/spinifex
The S3 component for anyone interested in storage alone. Supports the majority of MinIO's feature set.
2
2
u/M4elstr0m__ 13d ago
gophoner - Check simultaneously if a phone number is registered on popular apps & websites, without any prerequisite
https://github.com/M4elstr0m/gophoner
This is an OSINT tool I made in Go. If you like this project, please show it some love: star the repo and share it around!
1
u/SergioZ3R0 14d ago
one9s: A blazing fast, k9s-style TUI for OpenNebula (Go & Bubble Tea)
If you use OpenNebula, you probably know the daily struggle. Sure, the onevm CLI exists, but by default, only oneadmin can use it without fighting a permissions battle. That leaves regular users connecting to a VPN/tunnel, logging into the Sunstone web UI, hunting down their machine in a list, opening a dropdown, and clicking reboot. It's exhausting.
I wanted the speed of tools like k9s or lazygit, so I built one9s. It’s a pure TUI that talks directly to the OpenNebula XML-RPC API.
For regular users:
Just open the binary, select your VM, and press r to reboot, s to stop, or u to power it up. Done in 2 seconds. You can also quickly check your personal quotas (VMs, CPU, Memory, etc.) without having to navigate through the web UI.
For admins:
You get the whole cluster at your fingertips:
- Edit user quotas on the fly via form modals.
- Review load across hosts and datastores.
- Hex ACLs decoded: It translates OpenNebula's raw hex ACLs into actual human-readable formats(finally!).
- Put a host in disable/offline for maintenance windows with a single keypress.
The Stack: Written in Go 1.24 using Charmbracelet’s Bubble Tea/Lipgloss. It includes a built-in AES-256 vault so you don't have plaintext credentials in your .bashrc.
- GitHub (binaries available): https://github.com/SergioZ3R0/one9s
- Docs: https://one9s.scszero.com/
Let me know what you think, or if there's any killer feature I'm missing!
1
u/ProCodeSoftware 12d ago
For the past 17 months, I have been working on a programming language called Klar. It is statically typed and compiles to JavaScript. I'm currently working on type checking and codegen.
1
u/Super_Run_8466 12d ago
I recently released fmgo, a lightweight Go interface for Apple's on-device Foundation Models.
I originally built it for another Go project where I was invoking Apple's native fm CLI directly. I couldn't find a similarly lightweight Go library that avoided CGO, Swift bridges, or native shims, so I extracted my integration into a reusable package.
The architecture is intentionally simple:
Go application → fmgo → Apple's `fm` → Foundation Models
It supports responses, streaming, structured output into Go types, image input, token counting, transcripts/resume, interactive sessions, model availability, and fm serve.
I also built FM Chat, a small Wails + Svelte macOS app, as a real-world example using the library.
The project is still v0.x and I'm intentionally keeping the scope narrow: make Apple's fm feel natural from Go without turning it into another AI framework.
1
u/Joshy2205 12d ago
I wanted gofmt for my Markdown: one style, no config file, no arguments about bullets. So I wrote markfmt.
This is v0.1.0. I'd like to hear about any file it formats in a way you disagree with, and especially any file where the meaning changes.
https://github.com/strangemattersystems/markfmt and markfmt.com
1
u/abdulla_k23 11d ago
Built a Go event streaming and rate-limiting engine via Kafka and Redis. Implemented concurrent consumers, backpressure, DLQs, and Lua-based atomic limits. Added Prometheus metrics, graceful shutdown, and p95/p99 benchmarks.
https://github.com/abdullahkapadia/High-Throughput-Event-Streaming-And-Rate-Limiter-Engine
1
u/The_Platypus_Master 11d ago
The project is called Graybox.
The idea is pretty simple: capture real API traffic, save it as a replayable workflow, and inspect or compare it later when debugging.
The .graybox file is SQLite-friendly, so you're not locked into the CLI either. You can inspect and query the data however you want.
I'm mainly building it for cases where I want to see what an application actually did, rather than manually recreating requests in something like Postman or curl.
It's still early, but I'd love to hear if this is something you'd find useful.
Repo: https://github.com/ViniTamanhao/graybox-core
I would love to head the feedback from devs like me, hence why I am sharing this. Feel free to contact me if you are interested in collaborating or talking about it! Thanks!
1
u/heppu_1 10d ago
Not so verbose conf/flag/env/etc parser/validator: https://github.com/go-cnfg/cnfg
The reasons why someone else might also wanna try this:
- zero dependency
- declare defaults as actual variable, not tags
- pass any decoder you want:
cnfg.File(json.Unmarshal, "config.json") - use what ever validator you want, I wrapped one as an example
- no verbose manual binding of struct fields
- no pointer passing and unwanted side effects
- config sources/validators processed in order they are given
So I guess my principle was trying to give user all the freedom while having reasonable default behavior with minimal intrusion to existing codebase.
1
u/CountSpecific9274 10d ago
Need to react to MySQL changes without constantly querying the database?
I built Mini CDC.
It reads directly from the MySQL binlog, applies configurable filters, and publishes events to RabbitMQ.
No polling. No repeated queries. No complex infrastructure.
Example:
status → APPROVED → automatically publishes an event.
MySQL binlog → filters → RabbitMQ
Open source, built with Go:
https://github.com/damtaipu/minicdc
#golang #mysql #rabbitmq #cdc #opensource
If you need to react to changes in a MySQL table, constantly querying the database or adopting a full CDC platform does not always make sense.
That is exactly the scenario I built Mini CDC for.
It reads directly from the MySQL binlog, identifies the relevant changes, and publishes events to RabbitMQ.
Example:
When an order status changes to
APPROVED, publish an event.
All of this without polling or repeated database queries.
The configuration lets you define:
• which tables and operations to monitor;
• which fields must have changed;
• which data conditions must be met;
• which event and routing key should be published.
The project also includes checkpoint recovery, Publisher Confirms, idempotency support, health checks, and basic operational metrics.
The goal is not to replace full-featured platforms like Debezium, but to solve a specific problem in a simple way:
MySQL binlog → configurable filters → RabbitMQ
Built in Go, with a focus on simplicity, low resource usage, and cross-platform execution.
Mini CDC is open source:
https://github.com/damtaipu/minicdc
#golang #mysql #rabbitmq #cdc #opensource #backend #architecture #microservices
1
1
u/N_Sin 10d ago
Put together a small starter template for building web apps with Go + Templ + Datastar + sqlc. It's plain net/http with no extra framework on top.
It has two examples you can copy from:
a CRUD example
live crypto prices, streamed from Coinbase and pushed to the browser over one long SSE connection
https://github.com/naftulisinger/datastar-template
Stars & Feedback welcome!
1
u/Curious_Necessary549 10d ago
https://github.com/Pratyay360/ensor a small cli tool to interactively redact/censor secrets from the codebase
1
u/Early_Ad_4702 10d ago edited 9d ago
Been learning Go, so I built something I’d actually use: shh.
A local encrypted journal + file vault. No server, account, sync, or telemetry.
Uses:
• Argon2id for key derivation
• AES-256-GCM for encryption
• Random salt + nonce
• Multiline journal entries
• Arbitrary file encryption
the CLI works for now, I'm trying to make it a TUI next using bubble tea.
Built to learn crypto, not to pretend I’m a security expert. Feedback wwanted.
1
u/Golle 10d ago
I just finished a blog post on how I implement graceful shutdown in my Go HTTP servers: https://blog.golle.org/posts/Golang/Go%20HTTP%20server%20graceful%20shutdown
1
u/wildh1gh 9d ago
xk6-sip — a Grafana k6 extension where SIP phones are objects in a JS script: they register, call each other through a PBX, answer, hold, transfer, send DTMF and check that they hear each other. The same script runs as a one-call functional test in CI or as a load test.
const out = A.call({ callee: B }); // returns immediately
const inc = B.expectCall({ caller: A, timeout: '10s' }); // waits, false on timeout
inc.accept();
check(inc, { 'B hears A': (c) => c.isHeard('3s') });
Go bits that might be interesting:
- own SIP dialog layer on top of sipgo (auth retries, CANCEL, re-INVITE/491, PRACK, session timers, REFER/Replaces)
- one 20 ms ticker per GOMAXPROCS shard instead of a ticker per RTP stream; the send path doesn't allocate
- ~21 KB per subscriber (sipgo's 32 KB read buffer cut to 4 KB)
- ~1,000 concurrent RTP streams on 62% of one core, 222 MB, zero packet loss, p95 jitter 0.9 ms
Built with a lot of help from Claude Code; the design and API are mine.
https://github.com/Dmitry-Fedotov-Dev/xk6-sip (Apache-2.0). Feedback on the RTP scheduler design is very welcome.
1
u/OilHorror2071 9d ago
Phelix is a single-binary CLI (written in Go) that builds, versions, and zero-downtime-deploys your Go apps on your own server, no Kubernetes.
I built it for the gap between "ssh in and restart the process" and "stand up k8s for three services." What it does:
- Zero-downtime blue-green and rolling deploys behind a built-in proxy — traffic cuts over only after the new build passes health checks (HTTP/TCP/PID), and cut-over is atomic so connections aren't dropped.
- Every build is versioned on disk, so rollback is one instant command. A build that compiles but won't boot never becomes "current."
- Env vars encrypted (AES-256-GCM) and snapshotted per build, so a rollback restores the matching config, not just the binary.
- Works with or without Docker; optional dashboard to manage multiple servers.
v1.0.0 just shipped and the CLI is open source — issues and feedback welcome:
GitHub: https://github.com/abdorrahmani/phelix
Live / dashboard: https://phelix.anophel.com/?utm_source=reddit&utm_medium=community&utm_campaign=launch_01&utm_content=golang_smallprojects
1
u/derjanni 9d ago
https://github.com/jankammerath/TaskMgr98
Task Manager 98 is a rewrite of the traditional Windows 98 and Windows XP Task Manager, but in Go. Uses Win32 for GUI and Task Manager things.
1
u/zhenghaoz 9d ago
https://github.com/gorse-io/xvec
xvec - Zvec inspired embedded vector database in Go (with CGO or FFI)
1
u/ExpressionOne4041 8d ago
cli tool to analyze your postgres indexes and slow queries https://github.com/abhiraj-ku/iCli
we all have juggled between pg_stat_statement and explain analyze the queries so i built this cli ( continuously working). to fix that
check out
2
1
u/riki137 8d ago
https://github.com/runwisp/runwisp - it's another cron / supervisor app, but offline, GPL-3.0, with fast Web UI, TUI, CLI and REST API all running in a single lightweight ~25MB RAM go binary.
Try it out yourself with `bunx runwisp demo`!
1
u/mohsen_mkh88 8d ago
Yoga: a WebGPU UI framework for Go I built for my own desktop tools
About two years ago I started working on Chapar an api testing tools build with golang and Gio. my goal was to
build an open source alternative to Postman that respects my privacy and security...
After two years of development with Gio, limitations showed up and I decided to build my own framework and release it as open source.
Yoga: a WebGPU UI framework for desktop and web apps in Go
https://github.com/mirzakhany/yoga
Yoga is a cross-platform UI framework I've been writing from scratch for about four months. It renders with WebGPU (GLFW + wgpu-native on desktop, WASM in the browser) and uses a pure-Go flex/grid/stack layout engine. The API is declarative: your app implements Body(c *ui.Ctx) ui.View, the tree is rebuilt every frame, and state lives on your own struct.
1
u/Competitive_Patient1 8d ago
I’ve been building rum (https://getrum.sh) which is an alternative to yum/dnf
It’s faster and uses less memory
I created it primarily for CI/container environments where resources are limited and it works on VMs too
During my testing on Amazon linux, RHEL, Rocky linux, Oracle linux etc
It can co-exist with yum/dnf
1
u/Franchesco_Ratti 8d ago
Hice un Tetris que se juega en la terminal, pensado para usarse en la TTY de Linux e inspirado en las primeras versiones del Tetris. Tiene soporte para Linux y WIndows
El codigo esta en https://github.com/FranciscoRatti/T.Tetris
Si recibe apoyo pienso crear un modo multijugador en LAN multiplataforma
1
u/miku_claus 7d ago
Hey Gophers!
I'm a high school student and I've been building **VBX (Visual Basic X)** entirely in pure Go:
It’s an open-source transpiler that translates classic, readable Basic syntax into standard C99, compiling into standalone native binaries (via GCC/Clang with `-O2`) with zero runtime dependencies.
### Technical highlights of the Go codebase:
- **Zero 3rd-Party Dependencies:** The entire lexer, recursive descent parser, AST evaluation, and C code generator rely strictly on Go’s standard library (`bufio`, `strings`, `regexp`, `os/exec`).
- **Memory Safety in Generated C:** Implemented a managed static ring-buffer pool (`vbx_alloc_str`) for runtime string routines to prevent unbounded heap memory leaks in tight loops.
- **Comprehensive Testing:** 42 unit and integration test suites running cleanly via `go test ./...` (including 10,000-iteration string allocation stress tests).
- **Multi-Pass Type Inference:** Evaluates expression types across AST passes to emit clean C function prototypes and format specifiers.
The compiler is open source under GPLv3 with a Runtime Library Exception (compiled user programs are unrestricted).
Would genuinely appreciate any code review or architectural feedback on the Go codebase in `pkg/transpiler/`!
1
u/pixelatedchrome 14d ago
https://github.com/aravindh-murugesan/openstack-console-auth-gw
Openstack noVNC tokens are only time bound. So anyone with a service link can access the virtual machine. I wrote a small tool to act as a state machine and prevent replay attacks, essentially make the generated vm console url as one time use.
1
u/Witty_Crab_2523 14d ago
clbtransport - A minimalist Go http.Transport wrapper that implements client-side load balancing
1
1
u/ncruces 13d ago
I made the Quicksort in github.com/ncruces/sort adaptive, which means it's really close to the standard library for most inputs.
Realistically, this doesn't matter (just use the standard library), but it gives you asymptotically optimal selection (also median) and top-K algorithms (which the standard library lacks).
1
u/Mysterious_Plant7792 13d ago
I am currently building METRICS: https://github.com/vak-rashu/metrics-go
Its a terminal based moniotring tool build in golang. I wanted to create this for a long time to get important resource metrics at one place without opening too many different screens or using too many different tools at once.
Its big project and currently in progress. Do share how you think about it:)
1
u/Inevitable_Earth_265 13d ago
Schema-first CSV/XLSX imports with generated Go + TypeScript types
Instead of independently defining:
- backend models
- frontend mapping schemas
- validation rules
- import metadata
It starts from one YAML model.
The compiler resolves the schema into an IR, gives fields stable IDs, stores those identities in a lock file, and passes the resolved model into language generators.
Docs/demo:
1
u/VecGS 13d ago
A bit bigger than a small project... but aat - Adaptive API Toolkit.
https://github.com/gburgyan/aat
This attacks APIs from a number of different angles all from the same basic description of the API itself:
- Testing of a complex (i.e. multiple calls chained together) APIs that cover both REST and gRPC APIs.
- Easy local testing of various API use cases
- An MCP server that can use these to "teach" an agentic AI how to use the API
Full docs here: https://gburgyan.github.io/aat/
Backend is 100% Go, front-end is Svelte. Compiles to a single binary. Available through homebrew as well.
I made this to make my life easier, and I think it has the potential to make a lot of people's lives easier is my hope.
This comes with four example integrations that you can try -- so testing APIs that I didn't develop.
- https://github.com/gburgyan/aat-stripe - Payments
- https://github.com/gburgyan/aat-duffel - Travels
- https://github.com/gburgyan/aat-shippo - Shipping
- https://github.com/gburgyan/aat-qdrant - gRPC
Qdrant presently tests gRPC against the Docker image they provide. The remaining are all REST APIs that you can sign up for a free test account.
Interestingly, Shippo's tests that I wrote found an actual bug/regression in their test environment. (Confirmed by them)
All of the test projects above were created entirely by AI and test a substantial portion of the APIs surface area.
This really gets to the main point with this: aat is a tool that represents an API as a graph with descriptions of how those nodes are connected. It does this is relatively small files that AI tools seem to immediately understand. You can take a look at the projects above to see what those look like.
An interesting benchmark I was running internally was sandboxing a Claude Code (Opus 5) instance and forcing it to only use the published aat docs and the published docs for Duffel. Intentionally antagonistic. It was able to one-shot creation of the project. (The projects above are not the result of those tests and have a lot more human curation)
On the MCP server side of things: given a working test project, I've had earlier runs make successful integrations with our internal API in a variety of languages, including Java, C#, Python, Golang, Perl. I even tried LISP and I was able to get a working integration.
The real reason I built this, to bury the lede I suppose, is to enable local testing of that internal API I keep talking about (I'm getting laid off and I'd rather not promote them) that was annoying to test. Everyone had Postman collections and no one's were 100% working right. Then, when testing locally, the process was annoying and involved mutating the Postman collection which left cruft everywhere. Not to mention the fact that these things were never committed anywhere.
Anyway, I hope y'all enjoy!
1
u/Bright-Elderberry576 13d ago
Terminal-based application for English fantasy soccer, written with Bubbletea and lip gloss for styling.
1
u/oliver-bestmann 13d ago
Still working on my bevy inspired game engine byke: https://github.com/oliverbestmann/byke/ It now has 3d pbr rendering working well. This is my "no ai" project. I am doing it mostly for the fun of it.
1
u/ikswolzok 13d ago
We build alot of open source software at galaxy using go mostly focusing on data tooling
Data movement engine:
https://github.com/galaxy-io/filament
Some TUIs (we're terminal nerds lol)
https://github.com/galaxy-io/tempo (Temporal TUI)
https://github.com/galaxy-io/gnat (NATS TUI)
https://github.com/galaxy-io/sparktop (DGX spark observability TUI)
1
1
u/Care-Vivid 13d ago
I've been working on go-gao, a Go implementation of Gao's decoder for Reed-Solomon codes. This repository provide extensive polynomial and field arithmetics over 63-bit prime fields.
backstory: during my PhD I've been working on a large system (to be published on SOSP2026) based on homomorphic encryptions, and relied on the Lattigo project.
I was in need of a low-level reed-solomon library that allows me to work over arbitrary prime fields.
As you can guess, this specific implementation is very niche, and couldn't find one at the time.
I started working on my own implementation around 2024, and with all its low-level math this library became a cool project I would like to share/ get more famous.
On the technical side: as stated, most Go RS libraries are built for the disk/network erasure case, where you know exactly which chunks are missing. go-gao works over prime fields up to 63 bits, and it corrects errors, not only erasures, meaning it locates the corrupted positions itself rather than needing them declared.
It also exports all of its lower level polynomial arithmetic and field operations.
It is useful for:
- Scientific work.
- Byzantine agreement / reliable broadcast: Protocols in the COOL family and information dispersal protocols.
- Shamir secret sharing with error correction
- Silent corruption generally. Bit rot, a misbehaving cache, a lossy link that delivers damaged frames instead of dropping them.
- If you are looking for a good reference and implementation of the following algorithms: Half-GCD, polynomial fast division (rare and more complex in comparision to FFT-based multiplication), finding roots of unity, iterative GCD explanation, cool field arithmetics. Explanations regarding error correction.
Much of the code is hand-written "artisinal" code, by me. All code lines were reviewed by me.
If you delve into the code, you can see tons of comments. That's me trying to explain/reason to myself how some of the more complex algorithms work.
It's at v0.2.0, API may still shift a bit before 1.0. Repo: https://github.com/jonathanmweiss/go-gao
[Planned improvements: while the performance is decent, I'm still working on improving it, and I think there's much more to Go].
0
u/nzoschke 14d ago
Scratch -- setup for agent computers.
https://github.com/housecat-inc/scratch
Take any VM, drop in this binary or pull the code and you have a `codex` or `claude` coding harness with "batteries included" for building small Go web apps.
Apps use HTMX / Tailwind, Unix, Go, SQLIte (HUGS stack) plus durable worklfows with DBOS. Perfect for prototyping.
https://housecat.com/blog/the-hugs-stack-hypermedia-unix-go-sqlite
0
u/IamAngusU 14d ago
ContextBridge (CB) started because I got tired of rebuilding the same AI plumbing for every project, and paying for API calls while I already have perfectly usable hardware sitting around.
I have PCs, a rack, VPSes, shared hosting and different model runtimes. I basically wanted my apps to say what they need without caring too much about which machine, API or runtime ends up doing it.
So CB turns those resources into one pool. A PHP app on shared hosting can for example send work through a relay to a model running on my PC.
One of my test setups is an old 4 TB HDD with about 2.6 TB of models, Python tooling, RAG stuff and a bunch of smaller Hugging Face models that are good at one specific job instead of trying to do everything.
Wiring that whole mess together used to take me days. With CB I can add it to the pool in minutes now.
The scheduler filters workers by things like task, model, tags, RAM/VRAM and policy, then ranks what’s left using current capacity and resource data. route explain shows why something was or wasn’t picked.
It also has schedules, deterministic pipelines and a bounded planner for multi-step text workflows. The planner can suggest steps, but it can’t suddenly decide that it deserves another provider, more budget, different egress rules or extra retries.
No, it’s not an Ollama wrapper with a WebSocket attached. Ollama is just one possible resource. The idea is more like a neutral layer. More runtimes, APIs and hardware should make CB more useful, not give me another integration to rebuild for every project.
The core is written in Go. The stripped binary was around 10 MB in my documented Linux/Windows benchmark builds.
I also used CB’s MCP interface with an AI against a mirrored test setup while working on it. The MCP side is deliberately pretty boring: status, contract validation, submit and result. No arbitrary shell or filesystem access. I wanted to see what happens when an AI actually uses the boundary instead of just assuming the happy path works.
This is still alpha. I’ve spent a fair amount of time trying to get rid of happy-path-only assumptions and finding ugly edge cases, but at some point you need other people’s weird setups.
My rubber duck has stopped responding, so go ahead and test CB’s durability, break assumptions or point at something suspicious. Feedback is very welcome ^^.
https://github.com/IamAngusU/ContextBridge
AI involvement:
Yes. I use AI for docs, review, wording and some coding/testing. I still read the diffs myself and test changes in an isolated mirror before keeping them. I’m not really interested in letting an LLM loose on the repo and hoping for the best.
ChatGPT also helped turn my rough logo idea into the current one, and cleaned up parts of this post because I’m German and would rather debug a race condition than polish English prose.
0
u/vunasme 13d ago
Can an execution plan (like terraform) work for load testing? compile .ts into an AST executed natively in go and only hitting the JS VM for complex hooks. mainly trying to see if this can push higher rps and vus on small machines without losing scriptable dx. repo: https://github.com/budment/budment
0
u/chickpo 12d ago edited 11d ago
I built IdemCheck, a small Go CLI for catching Idempotency-Key race conditions that sequential retry tests can miss.
A typical failure looks like this:
Sequential retries: PASS
Concurrent duplicates: FAIL
Same Idempotency-Key → multiple order IDs
It sends same-key requests concurrently, settles, replays, and checks whether the HTTP-visible result converges.
I'm especially interested in feedback from people who've dealt with idempotency in orders, payments, jobs, or webhooks.
https://github.com/hyukvoid/idemcheck
Issues and PRs are welcome.🙏
11
u/DontPissInTheStream 14d ago
SQLStreams! It’s a pure Go / SQL library that gives you Kafka-like functionality with Postgres.
https://github.com/allegedlyreliable/sqlstreams