I genuinely like the project. The interface is clean, fast, and consistent. Unlike ecosystems such as npm, package authors don’t need to explicitly publish documentation anywhere—if your module is available through the Go module ecosystem, it’s already indexed.

The documentation is …

Read more

Sponsored by CodeRabbit — but this is a real PR, on a real codebase, with real findings. I’m going to show you exactly what the tool caught, what it got wrong, and whether the “AI reviews your PR” pitch holds up when the PR is 218 files and minus‑74,096 lines.

Read more

One reason is that we don’t use Go at my current company. We mostly use TypeScript, about which I still have mixed feelings, but to be fair, it works pretty well for us nevertheless. So I won’t blame TypeScript much here.

I still maintain a few Go projects, so I write at least some am…

Read more

Cline is an open-source AI coding agent focused on real software work. Most developers first encounter Cline as an assistant in the editor or terminal, but Cline is broader than a single interface.

It has both a CLI and an SDK:

• The CLI is for running agent workflows directly from the terminal

• The SDK is for embedding the same agent runtime inside your own scripts, products, CI jobs, and internal tools

That distinction matters. In the Cline SDK launch post, the team explains that the original product started inside the VS Code extension, and over time the runtime became harder to separate from the IDE around it. The SDK is the answer to that problem: the agent runtime is treated as a shared service rather than an implementation detail hidden inside one app.

That is also why the SDK is more interesting than a thin API wrapper, the same runtime now powers Cline across the CLI and IDE surfaces, while staying open for other teams to embed in their own products. The low-level agent loop stays reusable, and the stateful runtime around it becomes more durable, portable, and product-agnostic.

Read more

Most databases persist data to disk, but the underlying files are usually opaque: binary blobs, internal formats, encrypted pages. You cannot just open a file, edit a few lines, and expect the database state to change.

But using the filesystem itself as the source of truth can be surprisingly powerful.

For my personal blog, I use Hugo. Articles are just Markdown files in a Git repository. In a way, that already behaves like a tiny database: posts have authors, tags, metadata, version history, collaboration via Git.

$ tree

├── about.md
├── an-ode-to-logging.md
├── benchmark-grpc-protobuf-vs-http-json.md
├── books-2025.md
├── building-slack-bot-with-go.md
├── centrally-collecting-events-in-go-microservices.md
├── concurrency-data-race.md

It is simple and ergonomic.

But once the number of files grows, searching, indexing, querying, and connecting data becomes painful. Filesystems are not databases.

So the obvious question is:

Read more

In a single-player game, state is easy. There’s one player, one save file, and as long as you don’t corrupt the file, you’re fine.

In a live multiplayer game, state is the hardest problem you’ll have. Two players can act on the same target at the same time. A scheduled job (a build, a launder, a raid) needs to resolve at exactly the right moment regardless of who’s online. A player can come back after three days and expect their progress to be where they left it, plus whatever happened in the world while they were gone.

You can’t naively keep this in memory. You can’t lazily flush to disk on logout. You need a real persistence story, and you need it to handle concurrent access without melting.

Here’s the architecture I landed on.

Read more

Introduction

Every game has a core loop. In a shooter it's: see → aim → shoot → reload. In an idle game it’s: click → earn → upgrade. The loop is the heartbeat of the design: the smaller it is and the better it feels, the more the rest of the game can hang off it.

For a browser-based multiplayer game, the core loop is harder than it looks. Browsers are not a great real-time runtime. Players come and go. Tabs sleep. WebSocket disconnect on Wi-Fi handovers. You cannot rely on every player being online at the same time, and you definitely cannot rely on a 60Hz tick.

So you have two choices: pretend the browser is a real-time engine and fight it, or accept that your loop is fundamentally async and design around that.

I went with the second option. Here is what I learned.

Read more

It’s also remarkably extensible. You can write plugins in TypeScript, apply custom themes, build tools and web apps around it, and even extend it with Skills. The community around it is growing fast — check out awesome-opencode or opencode.cafe if you want to explore what people are building.

What I recently discovered, though, is that Opencode has a Go SDK (not to be confused with Opencode Go), and that’s what inspired this whole project. Let’s see what we can build with it.

The Problem: Catching dumb mistakes before commit

I’m the type of developer who absolutely hates typos in code and stray debug print statements — and also the type who produces them constantly. Regular formatters and linters don’t always catch these things, and let’s be honest: other code reviewers aren’t exactly trustworthy either. Nobody really reads the code anymore.

There are tools like CodeRabbit, GitHub Copilot, and Graphite that can review your pull requests after the fact. But what if I want to run similar checks before committing my code? And what if I want those checks to be configurable?

The idea: run an AI-powered code review as a pre-commit hook, using a coding agent that’s already aware of the codebase.

Since I use Opencode daily, let’s build it with that.

Read more

I was hoping that I could try the latest version 3, but it’s not yet released. But that shouldn’t be a problem as v2 is more than enough to create a lightweight desktop app.

Short recap of how Wails works, I won’t Go into the details, you can check it yourself:

A Wails application is a standard Go application, with a webkit frontend. It is possible to bind Go methods to the frontend, and these will appear as JavaScript methods that can be called, just as if they were local JavaScript methods.

Read more

Intro

Building services that sit on top of a Postgres replication slot and continuously stream data into Elasticsearch is a great way to get low‑latency search without hammering your primary database with ad‑hoc queries. But as soon as traffic ramps up, these services become a stress test for Go’s memory allocator, garbage collector, and JSON stack.

This post walks through optimizations applied to a real-world service that:

• Connects to a Postgres replication slot

• Transforms and enriches the change events

• Uses Elasticsearch’s bulk indexer to index and delete documents

The constraints: the service cannot stop reading from the replication slot for long (or Postgres disk will grow), and it cannot buffer unbounded data in memory (or Go’s heap will). The goal is to keep latency and memory stable under sustained high volume.

Read more

• It isn’t the most character efficient or human-readable.

• UUID v1/v2 is impractical in many environments, as it requires access to a unique, stable MAC address.

• UUID v3/v5 requires a unique seed.

• UUID v4 provides no other information than true randomness, which can lead to database fragmentation in data structures like B-trees, ultimately hurting write performance.

Introducing the ULID Identifier

Few projects I worked on used the ULID (Universally Unique Lexicographically Sortable Identifier), and I really enjoyed working with it, and would love to share this experience with you. Specifically for Go programs using Postgres database. But the same applies to other languages or databases too.

You can find the full spec here - github.com/ulid/spec

ulid() // 01ARZ3NDEKTSV4RRFFQ69G5FAV

Read more

However, I wanted to do something in Go, so I started with Conway’s Game of Life. There are various options from C bindings to OpenGL and SDL2 to full game engines such as Ebitengine. I went with raylib-go as it was a good mixture of low-level and abstracted programming.

In this tutorial, we’ll use Go and raylib-go to create Conway’s Game of Life, a simulation where simple rules create endless patterns. By the end, you’ll have gliders drifting, pulsars pulsing, and even a glider gun firing across your screen.

The Game of Life

Conway’s Game of Life is a cellular automaton created by John Conway. It is a zero-player game which evolves. Each generation is built on the previous generation using a set of simple rules.

The game requires no players as you start it off, and it starts to evolve without intervention. It is Turing Complete and can simulate a wide variety of different patterns and Turing Machines.

It starts with an initial game start, then it uses the following rules to determine which cell lives or dies:

1. Any live cell with fewer than 2 live neighbours dies, as if by underpopulation.

2. Any live cell with 2 or 3 live neighbours lives on to the next generation.

3. Any live cell with more than 3 live neighbours dies, as if by overpopulation.

4. Any dead cell with exactly 3 live neighbours becomes a live cell, as if by reproduction.

Each generation or frame in the context of our game will use these rules to determine the next state.

Demo

In this tutorial, we will be creating a simple cellular automation in Go using raylib-go. It will start with a state we define, and allow us to modify the state to see different evolutions.

Read more

The challenge in event-driven systems

In modern, event-driven architectures, services often communicate asynchronously using a message broker. A typical flow looks like this: a service receives a request, updates its own database, and then publishes an event to notify other services about the change. Or these two actions happen in parallel.

Here's the problem: what happens if the database commit succeeds, but the subsequent call to the message broker fails? Maybe the broker is temporarily down, or there's a network glitch. Or what if the database is not available at that time? Or what if the program somehow crashes?

You end up in an inconsistent state. Your local database has the new data, but the rest of the system never gets the notification. This is a serious issue because the database operation and the message publishing are not atomic - they don't succeed or fail as a single, indivisible unit.

Read more

I don’t know about you, but I love code reviews.

The power of code reviews

There are different ways to conduct a code review (mailing lists, pull/merge requests, even the code printouts), but they all serve the same main purposes.

• 🐛 Help catch bugs early, which can save time and resources later in the development cycle.

• ✅ Help maintain high code quality and adhere to the code standards, performance considerations, etc.

• 💬 Code reviews can improve team communication. They create a platform for discussing design decisions and coding standards. This dialogue can lead to better solutions and a more cohesive team.

• 📚 Promote knowledge sharing among team members. When developers review each other's code, they learn different approaches and techniques, which can enhance their skills.

Read more

What are Redis Streams ?

A Redis stream acts as an append-only log where each new entry is assigned a unique, time-based ID. Unlike traditional logs, Redis Streams support random access in O(1) time and enable complex consumption patterns, such as consumer groups for distributed processing. This makes them suitable for scenarios where you need to record, syndicate, and process events in real time.

Key characteristics:

• Append-only: Once data is written, it cannot be modified.

• Immutable entries: Each entry is a set of key-value pairs with a unique ID.

• Real-time syndication: Multiple consumers can process events as they arrive.

• Trimming and retention: Streams can be trimmed to prevent unbounded growth.

Read more

For example, there is a circumflex TUI that lets you read Hacker News from your Terminal.

clx

Read more

In modern CI/CD pipelines, supporting multiple architectures for Docker image builds, specifically amd64 and arm64, is crucial. This ensures compatibility for your team, whether they're on Apple silicon or Intel machines, and aligns with your production infrastructure.

If you don’t have access to Github Runners or Machines in your CI/CD with both architectures, you might be using emulation, like QEMU and it can be quite slow to build an arm64 image on an amd64 machine.

That’s why you can optimize your builds and use cache to make it faster.

This article details a robust 3-step workflow for achieving efficient multiplatform builds and covers best practices for frontend (FE) projects where static assets should be built only once for amd64.

Read more

In this article we will dive into the standard itself to make sure we understand how JWT works. We will also implement a secure Go server that can issue JWTs and verify them. And finally we will review some best practices for securely using JWTs.

Use Cases

The most common use case for JWT is authorization. Once the user is logged in, each subsequent request will include the JWT, allowing the user to access routes, services, and resources that are permitted with that token. Usually sent in a header, for example “Authorization”.

Read more

Introduction

Change Data Capture (CDC) enables real-time tracking of database changes, critical for event-driven systems, analytics pipelines, and synchronizing microservices. This guide walks through implementing PostgreSQL CDC in Go using native logical replication and the pgx driver.

1. Understanding PostgreSQL CDC

PostgreSQL provides CDC via logical replication, which decodes changes from the write-ahead log (WAL) into consumable events (inserts/updates/deletes). Key concepts:

• Replication Slots: Persistent channels for streaming changes.

• Publications: Define which tables to monitor.

• Logical Decoding Plugins: Convert WAL entries to readable formats (e.g., pgoutput, wal2json).

2. Prerequisites

a) PostgreSQL configured for replication

# postgresql.conf  
wal_level = logical  
max_replication_slots = 5

In GCP with cloudSQL, you have to enable some flags:

cloudsql.logical_decoding = on 

b) Replication user

CREATE ROLE repl_user WITH LOGIN REPLICATION PASSWORD 'password';  
GRANT SELECT ON ALL TABLES IN SCHEMA public TO repl_user;

Read more

Errors are values

I've been using Go for probably 8 years, and it's been my go-to language for most of the projects. I think we can all agree that Go can be verbose sometimes, which attracts some people (like me) but also is a hot topic often. Specifically when it comes to error handling, when the big portion of your codebase might be pure error handling.

What's beautiful in Go about error handling is that errors are values, this simplifies passing them around, modifying them as you want, because as Rob Pike said:

Read more