Best of Golang — April 2026

1. 1
   Article

   Hacker News·6w

   How I run multiple $10K MRR companies on a $20/month tech stack

   A bootstrapper shares how they run multiple profitable SaaS products on a $20/month tech stack. The playbook covers using a cheap VPS (Linode/DigitalOcean) instead of AWS, Go for lean statically-compiled backends, SQLite with WAL mode instead of Postgres, local GPU inference via Ollama/VLLM for batch AI tasks, OpenRouter for frontier model access with automatic fallback, and GitHub Copilot over pricier AI IDEs. The author argues this approach gives unlimited runway and eliminates the need for VC funding.

   245

   18
2. 2
   Video

   YouTube·7w

   I need to level up my programming skills... Here's the plan

   A developer shares their personal plan to level up programming skills in the coming year. The plan includes refreshing data structures and algorithms knowledge using CLRS and YouTube resources, learning Rust using the O'Reilly book and Exercism, abandoning perfectionism to build more projects, and using AI as a supportive learning tool. RustRover is mentioned as the preferred IDE for Rust development.

   80

   6
3. 3
   Article

   Product Hunt·7w

   One command to back up every Git repo you have; and more! - git-fire

   git-fire is a new open-source CLI tool (MIT licensed, built in Go) that backs up all local Git repositories with a single command. It discovers repos, auto-commits dirty work, and pushes backup branches safely. Key features include dry-run preview, streaming pipeline, secret detection before auto-commits, no force-push, plugin support, structured logs with 250+ tests, and a Bubble Tea TUI with fire animation. It also supports an agent stop-hook use case for checkpointing AI coding sessions. A USB mode for writing backups to mounted disks is planned. The companion library git-testkit provides Go test helpers for building Git fixture repos.

   62

   2
4. 4
   Article

   Hacker News·7w

   GitHub - maaslalani/sheets: Terminal based spreadsheet tool

   Sheets is an open source terminal-based spreadsheet tool written in Go. It supports reading and writing CSV files, vim-style navigation (hjkl, gg/G, marks, jump list), cell editing, visual selection, formulas, undo/redo, and command mode. It can be used interactively as a TUI or non-interactively via CLI to read/write specific cells or ranges. Install via `go install` or pre-built binaries.

   61

   3
5. 5
   Article

   Lobsters·5w

   GitHub - xataio/xata: Open source, cloud native, Postgres platform with copy-on-write branching and scale-to-zero

   Xata has open-sourced its cloud-native Postgres platform, previously powering its managed cloud service. Built on Kubernetes using CloudNativePG and OpenEBS, it offers copy-on-write branching (enabling TB-scale Postgres copies in seconds), scale-to-zero compute, auto-scaling, high availability, PITR backups, and a serverless SQL driver over HTTP/WebSockets. Primary use cases are internal Postgres-as-a-Service platforms and ephemeral dev/preview/test environments. The platform requires a Kubernetes cluster and is not recommended for single-instance deployments. Licensed under Apache 2.0.

   60

   1
6. 6
   Article

   Hacker News·4w

   FastCGI: 30 Years Old and Still the Better Protocol for Reverse Proxies

   FastCGI, the 30-year-old protocol, is argued to be a safer alternative to HTTP for reverse proxy-to-backend communication. HTTP/1.1's ambiguous framing enables desync/request-smuggling attacks, and its lack of structural separation between trusted proxy headers and untrusted client headers creates persistent security vulnerabilities. FastCGI solves both problems: it uses explicit message framing (eliminating desync), and prefixes HTTP headers with 'HTTP_' to structurally separate them from trusted proxy parameters like REMOTE_ADDR. Popular proxies (nginx, Apache, Caddy, HAProxy) support FastCGI backends, and Go's standard library makes switching trivial. Downsides include no WebSocket support, less tooling, and potentially lower throughput due to less optimization.

   111

   5
7. 7
   Article

   Hacker News·4w

   GitHub - NV404/gova

   Gova is a declarative GUI framework for Go that lets developers build native desktop apps for macOS, Windows, and Linux from a single codebase. It uses typed struct-based components, an explicit reactive scope for state management, and real native platform integrations (NSAlert, NSOpenPanel, NSDockTile on macOS with Fyne fallbacks elsewhere). The framework produces a single static binary with no JavaScript runtime or embedded browser. It includes a CLI with hot reload, build, and run commands. Currently pre-1.0, it is built on top of Fyne as an internal dependency.

   42

   2
8. 8
   Video

   Code to the Moon·7w

   Go for TIRED Rust Developers

   A satirical but informative comparison of Go and Rust from the perspective of a Rust developer who might be tired of the language's complexity. Covers key differences including Go's lack of a borrow checker, implicit nil handling vs Rust's Option type, simpler pointer usage for recursive types, goroutines vs async/await, built-in channels, and JSON serialization without derive macros. The author ultimately acknowledges both languages are great and the choice comes down to trade-offs.

   36
9. 9
   Article

   Hackaday·7w

   TinyGo Boldly Goes Where No Go Ever Did Go Before

   TinyGo, the Go compiler targeting microcontrollers and WebAssembly, now supports over 100 development boards including Adafruit products, ESP32s, and even the Nintendo Game Boy Advance. Garbage collection has been implemented, though it's slower than standard Go and unsupported on AVR chips or WebAssembly. Key limitations remain: no wireless connectivity support and incomplete standard library coverage. Despite these gaps, TinyGo represents meaningful progress since its 2019 debut targeting only Arduino and BBC:micro boards.

   34

   1
10. 10
    Article

    Surfing Complexity·6w

    Thoughts on the Bluesky public incident write-up

    A deep technical analysis of the April 2026 Bluesky outage, examining the cascade of failures that caused the incident. The post explains how large batch RPC calls caused goroutines to exhaust ephemeral TCP ports when connecting to memcached, how TIME_WAIT state prevented port reuse, and how this led to a memory cascade via Go runtime spawning excessive OS threads. The improvised fix involved randomly selecting from Linux's full 127.0.0.0/8 loopback range to multiply available (IP, port) pairs. Also covers the gomemcache connection pool behavior, diagnostic challenges during multi-failure incidents, and frames the failure patterns using David Woods' 'Messy 9' resilience engineering framework.

    32

    1
11. 11
    Article

    Grafana Labs·7w

    Observability in Go: Where to start and what matters most

    Engineers from Grafana Labs and Isovalent discuss practical observability strategies for Go systems. The conversation covers starting with logs and deriving metrics from them (e.g., counting panics), when to reach for distributed tracing and how context propagation works, Go's error handling tradeoffs for observability, effective use of pprof for CPU and memory profiling (including common pitfalls like profiling when the bottleneck is actually I/O wait), and how eBPF enables visibility into kernel-level behavior beyond what user-space instrumentation can provide.

    32
12. 12
    Article

    Bitfield Consulting·4w

    It's a lock: sync.Mutex in Go — Bitfield Consulting

    A beginner-friendly explanation of Go's sync.Mutex for preventing data races in concurrent programs. Using a bookstore analogy, it walks through why mutual exclusion is needed for both reads and writes, how to use Lock/Unlock, the 'lock, defer unlock' pattern, and how the Go race detector confirms a race-free result.

    34
13. 13
    Article

    Eli Bendersky·6w

    a WebAssembly Toolkit for Go

    watgo is a new open-source WebAssembly toolkit for Go, offering zero-dependency parsing, validation, encoding, and decoding of WebAssembly modules. It provides both a CLI (compatible with wasm-tools) and a Go API centered around wasmir, a semantic IR for WASM modules. The project passes the full official WebAssembly spec core test suite, achieved through a custom harness that converts WAT to binary WASM and executes it via Node.js.

    29
14. 14
    Article

    Lobsters·5w

    Emacs is my browser

    A personal account of using EWW (the built-in text-based browser in GNU/Linux) as a primary web browser inside GNU/Linux. The author explains why they moved away from modern browsers (distraction, big tech dependency) and how they configured EWW with keybindings, a self-hosted SearX search engine, and integrations for PDFs, videos, and the gopher/gemini protocols. They acknowledge limitations (no JavaScript-heavy sites, no social media, no banking) but find EWW handles 85-90% of their browsing needs.

    28
15. 15
    Article

    Hacker News·7w

    pgit: I Imported the Linux Kernel into PostgreSQL

    pgit, a Git-like CLI that stores repository history in PostgreSQL using delta compression, successfully imported the entire Linux kernel history: 1,428,882 commits, 24.4 million file versions, and 20 years of development in 2 hours on a Hetzner dedicated server. The resulting 6.6 GB PostgreSQL database (2.7 GB actual data) enables SQL queries across the full history in seconds. Analysis reveals: 38,506 unique authors with 25:1 contributor-to-committer ratio, 90% of commits touching 5 or fewer files, Intel i915 and Btrfs as the most tightly coupled subsystems, David S. Miller merging 7.9% of all commits, Intel leading corporate contributions, and quirky findings like 7 f-bombs in commit messages (from 2 people), 665 bug fixes pointing to the initial git import commit, and bcachefs taking 13 years to merge into mainline.

    23
16. 16
    Article

    Hacker News·6w

    I Made a Terminal Pager

    A developer details building a reusable viewport component in Go for navigating large text in terminal UIs (TUIs), then using it to create 'lore', a personal terminal pager. The post covers how terminal pagers work, the $PAGER environment variable, ANSI escape codes, Unicode handling complexities (graphemes, code point widths), and the architecture of the viewport component including search/filter, item selection, and wrapping. The viewport is built on the Bubble Tea framework and is also used in the author's Kubernetes log viewer 'kl'.

    21
17. 17
    Article

    Golang Weekly·4w

    Golang Weekly Issue 598: April 24, 2026

    Issue 598 of Golang Weekly covers several Go-focused articles: building a minimal container from scratch using Linux namespaces, a deep dive into the Go runtime's network poller (covering epoll/kqueue/IOCP and goroutine parking), a comparison of Go and Rust startup times, a production-grade Raft implementation designed to fail, and real-time goroutine tracing with eBPF.

    19
18. 18
    Article

    Golang Weekly·5w

    Golang Weekly Issue 597: April 17, 2026

    Golang Weekly Issue 597 curates several Go-focused articles and tools: a deep dive into the Go compiler internals to implement a conditional expression syntax; watgo, a zero-dependency pure Go WebAssembly toolkit for parsing WAT and creating WASM binaries; a guide on error translation in layered Go services using domain sentinels; and gontainer, a reflection-based dependency injection container from NVIDIA with no external dependencies.

    19

    1
19. 19
    Article

    freeCodeCamp·5w

    How to Create Dynamic Emails in Go with React Email

    A step-by-step guide to building dynamic email templates using React Email and Go. Covers creating a React Email template with Go template annotations, exporting it to HTML, parsing it with Go's html/template package using custom delimiters to avoid conflicts with React's curly braces, and rendering the result via a simple HTTP server. Also includes an optional section on sending emails with go-mail and previewing them locally using MailHog via Docker Compose.

    20
20. 20
    Article

    Collections·4w

    TypeScript 7.0 beta: the Go rewrite is here

    TypeScript 7.0 beta is available, featuring a compiler rewritten in Go. The native rewrite delivers roughly 10x faster build times over TypeScript 6.0 by eliminating V8 startup overhead and enabling shared-memory parallelism for parsing, type-checking, and emitting. Two new flags, `--checkers` and `--builders`, control parallel workers. Type-checking semantics remain identical to 6.0. Breaking changes include removal of `target: es5`, `moduleResolution: node`, AMD/UMD/SystemJS, and `baseUrl`, with strict mode now on by default. The programmatic API is deferred to 7.1, meaning build tool integrations must wait. Bloomberg, Vercel, and VoidZero are reportedly already running it in production. Stable release is expected within two months.

    19

    1
21. 21
    Article

    Wawandco·4w

    Blog: How to Hire Go Developers: Staff Augmentation vs. Dedicated Teams vs. Outsourcing

    Hiring senior Go developers is difficult due to a widening supply-demand gap. Three external talent models exist: staff augmentation (developers join your team, you manage everything), dedicated teams (self-sufficient unit for long-term product work), and project outsourcing (hand off a fixed scope entirely). Each model differs across project duration, scope stability, management burden, speed, cost predictability, and knowledge retention. Staff augmentation suits short-term bandwidth needs with an existing team; dedicated teams suit long-term product development with compounding institutional knowledge; outsourcing suits discrete, well-specified deliverables. A screening checklist for Go developers covers goroutines, channels, context, modules, gRPC, testing, and observability tooling. The post concludes with a call to action from Wawandco, a Go staffing firm.

    41