Observability in applications comes with instrumentation overhead, which can impact performance and resource consumption. A benchmark of OpenTelemetry in a Go application revealed a CPU usage increase of about 35% and some additional memory usage, while still maintaining stable throughput. For teams prioritizing incident resolution, the tradeoff for detailed observability is often justified, though eBPF-based instrumentation offers a lighter alternative for monitoring without significant resource costs.

Wildcat is a high-performance embedded key-value database written in Go, featuring modern design principles such as LSM tree architecture and MVCC for efficient read and write operations. It supports ACID transactions, offers configurable durability levels, and provides comprehensive iteration capabilities, making it suitable for applications requiring immediate consistency and durability. Users can join a community for support and access resources for development and benchmarking.

hyperpb is a new high-performance Protobuf library for Go, designed to leverage optimizations from UPB while addressing the challenges of Go's C FFI. It features a dynamic, runtime-based parser that outperforms existing Go Protobuf parsers in benchmarks. The library aims to provide an efficient and flexible solution for handling Protobuf messages in Go applications.

Dolt, the version-controlled SQL database, tested Go's experimental Green Tea garbage collector but found no significant performance improvements. Despite the new collector's intention to enhance cache locality and throughput, real-world tests showed minimal differences in latency and throughput compared to the classic garbage collector. Consequently, Dolt will not enable Green Tea for production builds.

Since adopting Go in 2016, American Express has gained valuable insights into its performance, efficiency, and scalability. Key learnings include improved dependency management with Go Modules, the challenges of concurrency, the importance of training for idiomatic Go, the establishment of standardized frameworks, and fostering an internal community to enhance collaboration and innovation.

Telemetry Harbor transitioned its data ingest pipeline from Python to Go to enhance performance and scalability. The move was driven by the need for improved concurrency and lower latency in processing large volumes of data. This rewrite aims to better meet the growing demands of their services and improve overall efficiency.

Software engineers frequently use diffs to represent changes in code, yet many existing libraries fall short of meeting diverse needs. The author shares insights from creating a new Go library to improve diff functionality while addressing issues such as readability, performance, and support for non-text inputs.

Go 1.25, released in August 2025, focuses on enhancements to the toolchain, runtime, and libraries while maintaining compatibility with previous versions. Key updates include new runtime features for GOMAXPROCS, an experimental garbage collector, and improved debugging tools, alongside several changes in the Go command and standard library. The release also introduces new analyzers for the vet command and updates to the compiler and linker for better performance and debugging support.

Doltgres, a version-controlled SQL database, faced a performance regression due to the inclusion of system tables in its pg_catalog. The author utilized Go's pprof tool to visualize performance differences between code branches, ultimately identifying and fixing a bug that was causing unnecessary overhead in fetching table names. This fix not only resolved the slowdown but also improved overall performance benchmarks.

Observability in applications introduces instrumentation overhead that can impact performance, particularly when using OpenTelemetry with Go. A benchmark comparing a Go HTTP server's performance with and without OpenTelemetry revealed a notable increase in CPU and memory usage, but maintained stable throughput. The choice of observability method should balance the need for detailed tracing against resource costs, with eBPF-based instrumentation offering a more lightweight alternative for high-load environments.

Turso has rewritten significant portions of their API using Go to enhance performance and maintainability. This transition aims to leverage Go's efficiency and concurrency features, ultimately improving the overall experience for developers and users alike. The blog post details the motivations behind this decision and the expected benefits.

hyperpb is a new high-performance Protobuf library for Go that implements many optimizations from UPB while addressing the unique challenges of Go's runtime. It leverages a dynamic table-driven parsing approach to improve performance and reduce instruction cache issues associated with traditional Protobuf parsers. The library's API allows for efficient message handling and compilation, making it faster than existing Go Protobuf solutions.

The article explores the inefficiencies in Go related to handling io.Reader interfaces, particularly when decoding images with libraries like libavif and libheif. It discusses the challenges of type inspection and the need for optimization to avoid unnecessary data copying, ultimately leading to a workaround that allows for efficient byte extraction. The author critiques the design of Go's standard library concerning structural typing and the hidden requirements for certain functionalities.

After two years of using serverless technology on Cloudflare Workers, the Unkey team transitioned to stateful Go servers to improve API performance and reduce latency by six times. This shift simplified their architecture, enabled self-hosting, and removed the complexities associated with serverless limitations, ultimately enhancing developer experience and operational efficiency.

The article discusses the implementation of Swiss Tables in the Go programming language, highlighting their efficiency in handling various data structures. It emphasizes the advantages of using this approach for organizing and accessing data quickly in software engineering practices. Additionally, it covers practical examples and performance comparisons with traditional methods.

The article explains the use and implications of the `//go:nosplit` directive in Go programming, which allows functions to skip stack overflow checks for performance reasons. While it can enhance speed, using this directive poses risks such as potential stack overflows, undefined behavior, and complications with asynchronous preemption, leading to hard-to-diagnose bugs. Caution is advised when employing `nosplit` functions in high-performance applications.

Understanding software performance often requires profiling to determine where code execution time is spent. Go offers built-in profiling tools and the article explains how to use flame graphs to visualize profiling data, helping developers identify performance bottlenecks effectively.

The article discusses how memory maps (mmap) can significantly enhance file access performance in Go applications, achieving up to 25 times faster access compared to traditional methods. It explains the mechanics of memory mapping, the performance benefits it provides for read operations, and the limitations regarding write operations. The author also shares insights from implementing mmap in real-world applications, highlighting its effectiveness in improving performance.