Bookmarks (149)

✉️ ListMonk 5.0: Self-Hosted Newsletter & Mailing List Manager — If you don’t want to pay to use a hosted newsletter system, how about a one binary Go solution? v5.0 introduces a visual drag-and-drop email builder and template editor. (Homepage.)

Bufstream: Kafka and gRPC for the Modern Age — A drop-in Kafka implementation with up to 8x cost savings over self-managed. See how we do it.

Firebase Brings Its Genkit AI Framework to Go — Genkit is a framework for building AI-powered apps from Google’s Firebase team, though it can be used independently of Google’s APIs. Originally for Node.js, it’s now in beta for Go too.

Using the SIGHUP Signal for Configuration Reloads — The OS can send various ‘signals’ to your Go apps and SIGHUP (“signal hangup”) is one of the more interesting ones. Phuong explains its history, what it’s often used for today, and how to catch and handle it.

This 150-Line Go Program is a Full-On Load Balancer — A code-heavy walkthrough of a round-robin load balancer built solely with the standard library. It’s not production-ready, but the author offers some recommendations for moving in that direction.

Is Your Go Application's Postgres Prepared for Your Next High Traffic Event? — Do you feel like your Postgres database is a black box? Watch Postgres expert Lukas Fittl walk through the latest pganalyze features to tune slow queries, catch regressions, and keep Postgres running at its best in this on-demand video.

Using Differential Coverage for Debugging — Russ shows how to generate and diff coverage profiles from passing and failing tests to spotlight code unique to the failure. It’s not foolproof, but it can dramatically narrow your debugging search space.

The Draft Go 1.25 Release Notes — We’re still about four months away from the final Go 1.25 release (expected in August) but, as always, the release notes are being worked on in advance and already provide a useful glimpse into what’s coming.

aerc: A Go-Powered Terminal-Based Email Client — Mix a little Pine with a little Vim and tmux and you get this Go-powered email client that supports HTML emails, PGP signing, IMAP/Maildir/SMTP and so on.

Bufstream: Robust Streaming for gRPC — Meet a cloud-first, drop-in Kafka implementation custom-built for go gRPC streams. Stateless, auto-scaling, schema-aware, and up to 8x cheaper than maintaining your own Kafka stack. Read the Jepsen report.

Cheating the Reaper in Go — How far can you push manual memory management in Go despite its garbage collector? Miguel peels back Go’s GC internals to craft a blazing-fast arena allocator in pure Go—with nothing more than unsafe wizardry—and shows exactly when (and how) you can safely outmaneuver the GC’s reaper.

A No Nonsense Guide to Go Project Layout — Say ‘no’ to overly complicated package structures, says the author, who shares a set of opinions for keeping things tight and focused with the goal of preventing ‘over complication’ in smaller projects.

Doltgres Beta Launch: A Version Controlled SQL Database — As well as dropping lots of great Go articles on their blog, the folks at DoltHub also develop database software ;-) Doltgres is a Postgres-flavored variant of their SQL database that offers Git-style merging and forking, and it’s all built in Go.

🤖 MCP Go: A Go Implementation of the Model Context Protocol — The Model Context Protocol (MCP) is a rapidly growing way to provide a way for LLMs and AI agent based devtools with access to external services. Why let Pythonistas have all the fun when you could be developing your own MCP servers with Go?

Go Event-Driven: Build Backend Systems That Actually Scale — Join 1000+ developers coding real projects in your IDE. No videos, just hands-on practice. Spring cohort opens soon.

🖼️ ImageProxy 0.12: A Caching Proxy Server and Transformer for Image Files — A long-standing project that provides a way to efficiently host image files while also allowing for basic transformations such as resizing, cropping and rotation. v0.12 is the first release in a few years and updates dependencies and adds a module for Caddy.

GoMud: A MUD (Multi-User Dungeon) Server — An in-development open source dungeon game world and library that handles the main concepts associated with MUDs, like maps, inventory and equipment, day/night cycles, etc, and allows players to connect over Telnet or HTTP.

Preventing Accidental Struct Copies — Go lets you copy structs by value, which can cause subtle bugs—especially with locks like sync.WaitGroup or Mutex. This post digs into how a noCopy trick and go vet’s copylocks checker can catch these issues.

Hunting Zombie Processes in Go and Docker — When spawning processes that in turn spawn other processes, you can run into issues where some unwanted processes stick around as zombies. This post looks at one such situation, how containers made it even messier, and how the zombies ultimately got taken out.

Optimizing Heap Allocations — When an (expected) innocuous code change had a 30% performance hit, it led to an enlightening forensic journey into stack vs heap allocation. Point yourself at this article to gain the value of understanding allocations and escape performance regressions.

sync.Pool is Not a Silver Bullet — sync.Pool can reduce allocations and GC pressure, but it’s not a drop-in solution for every case. Jens looks at where pooling shines (predictable, short-lived objects) and when it can backfire.

Using Signals with Go — Signals are asynchronous messages sent to processes to notify them of events like interrupts, crashes or termination, or to trigger certain behaviors. Most languages let you catch signals and act upon them, such as for shutting down a program gracefully, and Go is no exception.

Complete Go for Professional Developers — Craft production-grade APIs with Go, the language trusted by tech giants! Connect to Postgres, implement auth, and write tests that matter. Taught by a Twitch ML engineer who solves real problems with Go daily.

Fuzzing Go Binaries with LibAFL — Built upon the Rust-powered LibAFL fuzzing library, GoLibAFL brings ‘state-of-the-art fuzzing techniques’ to Go developers. This post compares it to existing solutions, shows off some examples, and digs into how they tailored LibAFL for Go use cases.

Hoard of the Rings: Extracting Data From a Cheap Activity Tracker — Tony picked up a cheap activity tracking (heartrate, steps, etc.) ring and figured out how to use TinyGo to read its outputs. A fun yet practical use for TinyGo!

Mockery v3: Create Mock Implementations of Interfaces — With the very bold claim of Mockery v3 being able to make “obsolete all other interface-based code generation frameworks” in the Go world, the author has a good go at explaining why. If you’d rather just see the facts and give it a go, the homepage is a good place to start.

Bufstream: Robust Streaming for gRPC — Meet a cloud-first Kafka implementation custom-built for go gRPC streams. Plus, Bufstream is Jepsen‑tested.

Vite Backend Integration for Go — A way to integrate a Vite-based frontend with a Go-based backend app.

Faster Shuffling in Go with Batching — Put down that deck of cards.. ‘shuffling’ here refers to moving the contents of an array about. It is based on expensive random integer generation. Here, Daniel offers up a couple of algorithms that speed things up by 2-3X compared to Go’s standard Fisher-Yates shuffle.

Genanki: A Go Library for Generating Anki Decks — Anki is a popular tool for flashcard, spaced attention style learning.

go-i18n 2.6: Translate Your Go Program Into Multiple Languages — A package and tool for translating Go programs into different (natural) languages. v2.6 now requires Go 1.23+.

GitHub MCP Server: GitHub's Official MCP Server — As the Model Context Protocol continues to move toward industry-standard status for giving AI agents more powers to interact with things outside their usual sandbox, GitHub has released its official server, which you can integrate with VS Code and Claude Desktop. It supports loads of tools for issues, PRs, repos, and more.

Go Panicked Again? Yeah, Sentry Saw It—and Kept the Receipts — Goroutines are great—until one quietly dies. Sentry catches panics, traces them back, and gives you full context. 👉 Try it free before your next deploy gets weird.

Chroma 2.16: Pure Go Syntax Highlighting — Take source code and turn it into syntax highlighted HTML, ANSI colored text, or just grab the raw tokens in JSON. Brings most of the features of Pygments to Go and can use Pygments’ lexers and styles too. There’s an online playground where you can try it out.

Porting Tailscale to Plan 9 — A fun story from former Go core team member Brad Fitzpatrick on Tailscale’s April Fools’ Day project to port Tailscale to Bell Labs’ 1980s Plan 9 OS. It was no joke, though, and actually works, despite the Go compiler’s support for Plan 9 having some “bitrot.”

Life as a Go Developer on Windows — Go officially supports Windows as a first-class platform, but supporting a product across numerous operating systems still requires some work. For Windows that means juggling WSL quirks, file system oddities, toolchains, and platform-specific code.

Does Your Postgres Database Feel Like a Black Box? — Are you prepared for the next high-traffic event? Join us April 16 to explore pganalyze features that tune slow queries, catch regressions, and keep Postgres running at its best.

More Predictable Benchmarking with testing.B.Loop — Go 1.24 introduced a new way to write benchmarks that avoids common pitfalls like accidental dead-code elimination and inaccurate timings. If you want faster, more accurate, and more intuitive benchmarking, this is for you.

A Guide to Optimizing for High Performance in Go — An in-progress collection of technical articles aimed at helping Go developers write faster, more efficient apps. The initial focus is on common patterns like object pooling, struct field alignment, and using worker pools, with a guide to high-performance networking set to follow soon.

asciigraph: ASCII Line Graph Rendering Library — A longstanding library for rendering basic line graphs in ASCII text, such as at the terminal, all with no dependencies.

Revive 1.8: A Faster, Configurable, Flexible Linter for Go — A drop-in replacement of golint that aims to provide a little more structure, configurability, and performance. It’s used by numerous large Go projects and libraries. The README on the GitHub repo explains how it differs to golint.

urfave/cli 3.1: A Declarative Way to Build Go CLI Apps — The manual outlines all of the key features, but think shell auto-completion, option parsing, help text, etc.

Introducing ls-lint: A File Structure Linter — Billing itself as an ‘extremely fast file and directory name linter’, ls-lint is a Go powered tool for enforcing some structure over a project’s filesystem and naming policies. GitHub repo.

When is it OK to Panic in Go? — One of the Go proverbs is “Don’t panic,” which isn’t just good life advice but also saying not to use panic for normal error handling. Alex explores panic and some times when you should use it.

2X-40X Faster Docker Builds with Blacksmith — With a one-line code change, Blacksmith can make your Docker builds incremental by mounting your Docker layer cache into your GitHub Actions runner. Blacksmith is used by 300+ companies like Ashby, Clerk, and Mintlify.

Goodbye Core Types, Hello Go As We Know and Love It — A look at Go’s evolving type system, revealing how the abstraction of core types (introduced with generics in Go 1.18) complicated otherwise straightforward language features, and how their removal in Go 1.25 is set to simplify both the spec and everyday coding. (Hacker News reactions here.)

The First Newsletter Dedicated to Product Engineers — Learn strategies and tactics you need to succeed as a product engineer (and build products users love).

The Right Way to Do Data Fixtures in Go — If you don’t have a strategy for data fixtures from the start, problems can show up in ways that make testing brittle. Here are some tips to get started on the right foot and prevent the need to fix your fixtures later.

Physix.go: A Simple Physics Engine for Go — An interesting project from a high school student (who explains the background to this project here) providing basic physics capabilities when using Ebitengine.

How and Why PlanetScale Built a VM in Go — PlanetScale is a well known cloud based MySQL host that uses the Go-powered Vitess MySQL scaler. This article covers the tale of building a virtual machine in Go to work with the SQL ASTs produced by their SQL parser and how it’s as fast (or sometimes faster) as MySQL’s own C++ approach.