Enhanced reflection for Go using DWARF debug information to extract function parameter names, enabling automatic struct generation and semantic function calls.

A principled CORS middleware library for Go, designed to be both easier to use and harder to misuse than existing alternatives.

Minimal, customizable, and neofetch-like weather CLI inspired by rainy, written in Go

Go implementation of JSON Web Tokens (JWT).

- Docker v2: simpler, multi-arch ready via buildx (alpha)
- Image Attestation: digest files for verifying Docker builds
- Makeself: self-extracting installer support
- Go 1.25: updated Go compatibility
- Version Sorting: smarter semantic tag handling
- New Features & Fixes: bun targets, templating, retry logic, SBOM, various bug fixes and enhancements

A few weeks ago Anton Zhiyanov published the blog post Expressive tests without testify/assert. It's a good and well thought-out post, and I recommend giving it a read if you haven't already. In the post, Anton makes the argument for not using packages like testify/assert for your test assertions, and instead creating your own minimal set of assertion helpers to use in your tests. In fact, so minimal that there are only 3 helpers he uses: AssertEqual, AssertErr and AssertTrue.

Imagine a bustling airport with a limited number of runways (CPU cores). Thousands of flights (goroutines) need to take off and land efficiently. How do you prevent chaos and ensure no flight is stuck on the tarmac forever? Go’s answer to this air traffic control problem is its ingenious GMP scheduler. It’s the silent maestro conducting the orchestra of your concurrent code. In this article, we’ll move from the control tower view down to the runway tarmac, exploring how Goroutines (G), OS threads (M), and Processors (P) collaborate to keep your application’s traffic flowing smoothly, even during peak load.

Go’s concurrency story is powered by a user space scheduler built around three entities: G, M, and P. Understanding how the scheduler maps millions of goroutines onto a limited number of OS threads helps you write services that scale, diagnose latency spikes, and avoid resource pitfalls.

Go’s interfaces are very funny. Rather than being explicitly implemented, like in Java or Rust, they are simply a collection of methods (a “method set”) that the concrete type must happen to have. This is called structural typing, which is the opposite of nominal typing.

Go interfaces are very cute, but this conceptual simplicity leads to a lot of implementation problems (a theme with Go, honestly). It removes a lot of intentionality from implementing interfaces, and there is no canonical way to document that A satisfies1 B, nor can you avoid conforming to interfaces, especially if one forces a particular method on you.

It also has very quirky results for the language runtime. To cast an interface value to another interface type (via the type assertion syntax a.(B)), the runtime essentially has to use reflection to go through the method set of the concrete type of a. I go into detail on how this is implemented here.

Because of their structural nature, this also means that you can’t add new methods to an interface without breaking existing code, because there is no way to attach default implementations to interface methods. This results in very silly APIs because someone screwed up an interface.

Surf is a powerful, feature-rich HTTP client library for Go that makes working with HTTP requests intuitive and enjoyable. With advanced features like browser impersonation, JA3/JA4 fingerprinting, and comprehensive middleware support, Surf provides everything you need for modern web interactions.

Zek is a prototype for creating a Go struct from an XML document.

GoQueue is a flexible background job processing library for Go applications, designed to handle workloads of any scale with multiple backend options.

A powerful, real-time log analysis terminal UI inspired by k9s. Analyze log streams with beautiful charts, AI-powered insights, and advanced filtering - all from your terminal.

Previous posts Why Go is not my favourite language and Go programs are not portable have me critiquing Go for over a decade.

These things about Go are bugging me more and more. Mostly because they’re so unnecessary. The world knew better, and yet Go was created the way it was.

For readers of previous posts you’ll find some things repeated here. Sorry about that.

This Go package provides commonly used components for terminal based user interfaces.

Serilog-inspired structured logging for Go with message templates, rich formatting, and native Seq support

Mangle is a programming language for deductive database programming. It is an extension of Datalog, with various extensions like aggregation, function calls and optional type-checking.