We build fast, honest Go tools in the open: networking, storage, runtimes and developer tooling. Your next commit belongs here.
- Repositories
- 105
- GitHub stars
- 718
- Articles
- 46
- Languages
- 23
Join in three steps
No sign-up. Everything happens on GitHub.
Pick a project
Find a repository that matches what you love to build, from relays to databases.
GoOpen an issue or PR
Report a bug, propose an idea or send a fix. Small pull requests are welcome.
GoWrite for the blog
Share what you learned. Every post is translated into 20+ languages automatically.
GoProjects looking for you
Our most starred repositories. Pick one and say hi.
Publishes localhost services to the agentic web through self-hostable, trustless relays.
Independent bitcoin full node in Rust
sites/artifacts alternative
Human and machine friendly speedy open source coding harness. Our defaults. Your agent. dal is a minimal, pluggable coding agent; dalgona adds opinionated batteries. Make either yours with Starlark plugins, written by you or your agent.
Randflake ID: a distributed, uniform, unpredictable, unique random ID generator.
Golang implementation of an x402 payment facilitator
From the blog
Deep dives written by GoSuda members.
Running Docker, docker build, and docker compose Without Root or User Namespaces
How to securely run a complete Docker Engine (dockerd, BuildKit, overlayfs, and docker compose) inside an isolated gVisor user-space sandbox as an unprivileged user when root, sudo, unshare(CLONE_NEWUSER), mount(2), and /dev/fuse are blocked.
gvx: Running Linux Containers, Docker, and Kubernetes in One Unprivileged Process
Technical overview of gvx, a security-hardened, cross-platform container runtime and Go SDK built on the gVisor user-space kernel that safely runs Linux containers, Docker-in-Docker, and multi-node HA Kubernetes in a single unprivileged process across Windows, macOS, and Linux.
Fast Isolated Docker Environments for AI Agent RL Rollouts with gvx
How to securely run hundreds of parallel, strongly isolated unprivileged Docker and Kubernetes environments for SWE-bench and coding agent reinforcement learning rollouts with 100-millisecond copy-on-write ext4lite volume resets.
Running Docker-in-Docker Inside gVisor and Nested Sandboxes with gvx
Why installing docker.io or nesting runsc inside a gVisor container fails across modprobe, iptables-nft, overlay2, cgroups, and seccomp EBUSY, and how gvx securely runs nested docker:dind inside an isolated user-space kernel without --privileged.
Rethinking the Git Monorepo: A CAS-Native Architecture for Humans and Coding Agents
How to build a zero-daemon, CAS-native monorepo on standard Git using parentless trunk snapshots, isolated workspace references, in-memory merge trees, hierarchical OWNERS, and O(delta) mirror synchronization.
gosuda.org/zstd: Drop-In DataDog/zstd Compression with Zero CGO and Crash Isolation
CGO_ENABLED=0 Go Zstandard library running upstream C libzstd 1.5.7 in a shared-memory worker with a DataDog/zstd-compatible API, reusable contexts, and bulk batching.
gosuda.org/sqlite3: CGO_ENABLED=0 database/sql Driver Over Shared-Memory IPC
Drop-in database/sql SQLite 3.54.1 driver for Go with CGO_ENABLED=0, HQQ shared-memory worker isolation, 64 KiB batch row prefetching, and SLSA-attested binaries.
HQQ: Isolating C Libraries from Go Over Cache-Line Shared Memory
Zero-cgo IPC runtime, IDL compiler (hqq-bindgen), and verified process supervisor that execute native C11 libraries in isolated worker processes over shared-memory rings.
Schottky: Zero-Allocation, Order-Preserving Byte-Key Encoding for Go
Zero-allocation Go library that encodes composite tuples into memcmp-ordered byte keys with independent ASC/DESC sorting, NULL placement tags, and prefix-scan bounds.
Portalite: A Lightweight Portal Go SDK with Multi-Relay Binding and Standard net.Listener Support
A lightweight Portal client and CLI that implements the standard Go net.Listener interface and supports simultaneous binding across multiple relays, end-to-end encryption (E2EE), and automatic session recovery.
Go 1.27, or How I Learned to Stop Worrying and Love Generic Methods
Generic methods, encoding/json/v2, a standard uuid package, and a goroutine leak detector that actually works. A tour of Go 1.27 with examples that were all actually run.
Analysis of AMD64 Assembly Code Generation and Branch Instructions for Go Conditional Statements (if)
This article compares the process by which the Go compiler translates if-else conditional statements into AMD64 machine-level branch instructions such as CMPQ, JGE, and JMP with the branch code generation results of the C compiler (-O2).
Runtime Architecture of Managed Languages and Analysis of Go Binary AMD64 Assembly
This paper compares the execution models of managed and unmanaged languages and, through AMD64 assembly extracted with go tool objdump, analyzes the stack check and runtime function call structure of Go binaries.
AI-Native Development Methodology: Bidirectional Context Circulation Beyond Tool Utilization
This paper compares the structural limitations of AI-dependent development and simple tool-utilization stages, and defines an AI-native development process that accumulates design intent and organizational context in both directions.
Portal Tunnel: Expose Localhost Services Over Decentralized Public Relays
Expose local HTTP services to the public internet with a single curl command over multi-relay, permissionless Portal tunnels without accounts or binary installation.
Shannon's Channel Capacity Limit and the Architecture of AI-Based Semantic Communication
This text reviews the physical channel capacity limit of the Shannon-Hartley theorem and addresses semantic communication, which compresses transmitted data in units of meaning rather than bits through a shared knowledge base and semantic encoder/decoder.
Portal: An End-to-End Encrypted Open Relay for Forwarding Local Services to External Networks
This document describes the Portal architecture, which exposes a local server to the external internet through an end-to-end encrypted (E2EE) open relay network, without requiring a public IP address or cloud infrastructure configuration.
Direct Linux System Calls in Pure Go with syscall.Syscall and unsafe.Pointer
Invoking Linux kernel system calls such as SYS_SYSINFO directly from pure Go using ABI-aligned structs, unsafe.Pointer, and the standard syscall package without cgo.
Any is not Any, but Any is Any
This document provides a detailed analysis of Go's `any` type and its internal `EFace` structure, and explains dynamic type handling methods utilizing the `reflect` package as well as type assertions and type switches.
Structure of the FIPS 140-2 and FIPS 140-3 Implementations in the Go Standard Cryptographic Library
This document analyzes the limitations of integrating external C OpenSSL providers and covers, from BoringCrypto (FIPS 140-2) through the native Go standard crypto package's FIPS 140-3 mode, Fail-Fast validation, Hedged ECDSA, and the DRBG structure.
Vibrant Bitmap
From the concept of bitmap indexes in databases to the operating principles of Roaring Bitmap and its use in Go. This work explores bitmap optimization for the efficient processing of large-scale datasets.
Politics and Computers
Politics and computer science, two fields that seem different yet share surprising similarities, examine how they can address social problems and how developers may become the new legislators.
How Goroutines Work in Go: 2KB Growable Stacks and the M:N GMP Scheduler
This explains the difference between concurrency and parallelism, the 2KB initial growable stack of goroutines, user-level context switching, GOMAXPROCS, and the GMP (Goroutine-Machine-Processor) runtime scheduling model.
Database Servers and Embedded Databases: A Comparison of Architecture and I/O Characteristics
This paper compares independent process-based RDBMSs with in-process embedded databases such as SQLite, RocksDB, BadgerDB, and PebbleDB from the perspectives of NVMe SSD I/O latency, MSA data isolation, and deployment architecture.
Embedded NATS Server Configuration and In-Process Communication Architecture in Go Applications
This document covers how to configure and run a NATS broker (nats-server/v2) embedded within a Go process, as well as in-memory communication based on InProcessConn and the design of consumer-defined interfaces.
Go Interfaces and Struct Embedding: Differences from Class Inheritance and Composition-Based Design
This document compares the structural typing of Go interfaces with class inheritance in Java/C++, and explains the Composition pattern using struct embedding and method delegation through code examples.
Five Design Characteristics of the Go Language from the Perspective of Systems and Backend Engineering
This document summarizes the design philosophy of Go, focusing on fast native compilation and execution performance, a standard library that operates without frameworks (net/http, database/sql), the M:N goroutine scheduler, and the guarantee of backward compatibility.
A cup of green tea's leisure that the Go runtime will take away, GreenTea GC
Go's new GreenTea GC improves performance by enhancing GC efficiency for small objects based on memory spans. We examine the problems of the existing GC and the benefits of the GreenTea GC.
Reducing Response Latency in Go HTTP File Uploads: Implementing an Asynchronous Worker Queue Based on Channels
This structure separates temporary file reception and the Incus container transfer operations in the net/http file upload handler into a buffered channel and a goroutine worker pool, thereby reducing endpoint response latency.
Analysis of Behavioral Changes in Go 1.25 encoding/json/v2 and the v1 Compatibility Layer
This article compares case-sensitive matching, changes in the semantics of omitempty and omitzero, serialization of nil slices and maps, and the related options of encoding/json/v2, introduced as a experimental feature in Go 1.25 (goexperiment.jsonv2).
Go Compile-Time Variable Injection: Using go build -ldflags -X
This document explains how to inject Go string variable values at compile time without an external .env file, by using the go build -ldflags "-X" linker flag and specifying the package symbol path.
Handling HTTP Errors with Less Hassle + RFC7807
Is error handling in your Go API a hassle? Try handling errors more simply and clearly with RFC 7807.
Comparing Language Design in LLM Code Generation Environments: Abstraction Costs and Go's Explicitness
Object-oriented polymorphism, syntactic sugar, and complex module trees are analyzed as factors that increase the contextual inference cost of LLMs, and the discussion addresses why Go, with its explicit control flow and simple syntax, is advantageous for AI code generation.
Cilium Story: The Remarkable Improvement in Network Stability Brought About by a Small Code Change
Learn in detail how a small code change in the Cilium project dramatically improved the stability of LRU-based NAT connection management.
Getting a Little Familiar with MCP Host
This article is intended to help readers understand Anthropic's MCP protocol and the MCP host (mcphost) implemented in Go.
Running a Scalable Go Server with .NET Aspire
How to Run Go Servers Scalably with .NET Aspire: A Configuration Example for Horizontal Scaling and Automation Using the YARP Reverse Proxy.
Experiences Using MLDSA and MLKEM in the Go Language
This article explains how to use the post-quantum cryptographic algorithms MLDSA and MLKEM in the Go language, and provides the characteristics of each algorithm along with code examples.
Go 1.24 Release Overview: Swiss Table Maps, ML-KEM, os.Root, and testing/synctest
Technical overview of Go 1.24: Swiss Table built-in maps, crypto/mlkem (FIPS 203), TLS Encrypted Client Hello, runtime.AddCleanup, os.Root, and testing/synctest.
Randflake ID: Distributed 64-Bit Unique ID Generation with Sparx64 Block Cipher
Distributed 64-bit unique ID generator combining a 30-bit timestamp, 17-bit node ID, 17-bit local counter, and the Sparx64 ARX block cipher for unguessable IDs.
Improving Responsiveness with Redis Client-Side Caching
Improving API Responsiveness Using Redis Server-Assisted Client-Side Caching
Implementing a Multi-File Listbox-Based Image Viewer with Go and Tcl/Tk 9.0
This implementation adds Tcl listbox command bindings and virtual event handlers to modernc.org/tk9.0 to create a GUI image viewer capable of opening multiple image files, switching selections, and deleting list items.
Implementing a CGo-free Go Tcl/Tk GUI (modernc.org/tk9.0): Widget Packing and Image Rendering
Implements window creation, button and menu bar widget packing, and SVG/PNG/ICO image rendering in Go using the cross-platform library modernc.org/tk9.0, which has no CGo dependencies.
Go and the OpenAPI Ecosystem
This article introduces libraries and strategies that can be used for developing OpenAPI-based APIs in the Go language.
Go Concurrency Starter Pack
This article introduces various tools and techniques for managing concurrency in Go, including goroutines, channels, and mutexes.
Why Go Chose Explicit Error Returns and panic-recover Over try-catch Exception Throwing
This section examines the limitations of try-catch structures, which pass exception-handling responsibility up the call stack, and explains Go's design of explicit error handling at the call site, with panic and recover reserved solely for unrecoverable states.
Building AI Service Infrastructure in Go: Concurrency and API Integration
How Go handles foundation model API orchestration, concurrent network I/O, streaming pipelines, and cloud-native service deployment.