Bookmarks (129)

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

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.

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!

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.)

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.

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.

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

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.

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.

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.

Go on the PlayStation 2 — If you like tinkering with consoles and shoe-horning Go into new (or old?) environments, this post is for you. It involves TinyGo, C, and a lot of trial and error.

go-profile: A Port of Brendan Gregg's eBPF profile.py — eBPF opens up a way to do profiling in a faster, more direct way on Linux (details here) and this is an initial incomplete attempt to port a Python-powered eBPF profiler to Go.

gocodewalker: A Way to 'Walk' Directories of Code — If you want to walk through a nested set of directories in a code repo while respecting .gitignore, this is for you.

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.

Goavatar: Generate Unique, Symmetric Identicons Based on a String — Given a string (like a username, say), this generates very basic icons in a deterministic way that you could use for a little added visual recognition.

golangci-lint v2: A Fast Linter Runner for Go — A tool for running Go code linters (about 100 of them!), quickly, in parallel, with caching, YAML configuration, IDE integration, and more. There are some helpful migration instructions if you’re upgrading from v1.

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.

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.

Traversal-Resistant File APIs — Among the lesser known new features in recent versions of Go are some ways to improve file system security when end user input might have an impact on file paths your app tries to access, including os.Root, filepath.IsLocal, filepath.EvalSymLinks and filepath.Localize. A must read.

Participle: A Simple Library for Defining Parsers — Provides a straightforward yet idiomatic way to define parsers in Go using a familiar approach of using struct field tags to define a grammar, so if you’ve used encoding/json before, you’re well on your way.

DiceDB: A Reactive, In-Memory Database Optimized for Modern Hardware — A new Go-powered database! Dice is a reactive database where your clients subscribe to receive changes immediately and it seems to take a lot of inspiration from the Redis approach being both in-memory and with simple Redis-like commands. GitHub repo.

golang-set: A Simple, Well-Tested, Generic Set Type — “Until Go has sets built-in…use this.” The latest v2.8 release adds support for Go 1.23’s range-over-func iteration.

doomgeneric: Doom, Ported to Go? — If classic 90s FPS Doom can be ported to JavaScript and made to run inside a PDF, a Go port should be a piece of cake, right? Here’s a little slice of magic involving using the ccgo C-to-Go compiler. Don't get too excited though as it's a limited proof of concept and Linux only, but it's neat to see...

Go Structs and Interfaces Made Simple — An introduction (or refresher) of Go’s core building blocks when it comes to working with data types and structs – an approach that differs somewhat from those favored in object oriented languages like C++ or Java.

TypeScript's Go Port Already Leading to Optimizations for Go — Last week’s big news was about the TypeScript compiler being ported to Go for performance reasons. A neat side effect of such a large project entering our ecosystem is the increased potential for even more performance improvements for Go itself, something that has already begun to occur..

📅 Live Workshop: Build Production-Ready Apps with JavaScript & Go — Join Maximiliano Firtman next week (online or in-person) for a 3-day workshop, learning how to build real-world, fully functional web apps using vanilla JS & Go. Create performant, scalable apps.

Were Multiple Return Values a Mistake for Go? — An interesting technical post critiquing the effects of one of Go’s earliest design decisions. This is an area where opinions will differ strongly, but the author thinks Go sorely needs to support tuples.

RobotGo: Native Cross-Platform GUI Automation — A way to control the pointer, keyboard, read the screen, etc. Combine this with an LLM perhaps.. if you dare?

ObjectBox Go 1.9: A Fast, Embedded Database for Go Objects — Store objects in ObjectBox and find them again using powerful queries.

TypeScript's Compiler to Get 10x Faster, Thanks to Go — TypeScript has shaken up the JavaScript ecosystem in recent years with an increasing number of developers relying on its strong typing and added structure. TypeScript’s compiler isn’t particularly fast, though, but the TypeScript team at Microsoft is changing that by porting it to Go!

Why Reimplement TypeScript's Compiler in Go? — Many people have been asking why Microsoft is porting TypeScript’s compiler to Go rather than, say, Rust or C#. TypeScript’s architect Anders Hejlsberg delivered the definitive comment on the matter: Go fit the technical requirements and proved the best high performance language to which to port JavaScript for a variety of reasons.

Using Cursor for Large Projects — If you’ve tried using tools like Cursor to write Go code in larger projects, you’ll have almost certainly run into its limitations. Thierry has some tips for adding a bit of structure to the ghost in the machine.