Go 1.27 ships goroutine leak profiler, faster JSON and post-quantum crypto

<h2>What shipped in Go 1.27</h2>
<p>Go 1.27 dropped on August 19, 2026. Most of the changes are the kind that matter in production rather than in benchmarks — here’s what’s actually worth paying attention to.</p>
<h3>Goroutine leak profiler is now stable</h3>
<p>The goroutine leak profiler, which was experimental in 1.26, is now generally available in <code>runtime/pprof</code>. It’s exposed at <code>/debug/pprof/goroutineleak</code>. The old experiment flag from 1.26 is gone — if you were using it, update your code.</p>
<p>This is the one I’d prioritize. Goroutine leaks are genuinely annoying to diagnose in production, and having a dedicated profiling endpoint for them is a lot cleaner than trying to infer leaks from raw goroutine counts.</p>
<h3>JSON gets faster (with some caveats)</h3>
<p><code>encoding/json</code> is now backed by <code>encoding/json/v2</code> internally, while keeping v1-compatible behavior. The practical result: unmarshalling is significantly faster. Marshalling typed struct slices, though, is actually slower in some cases — benchmarks from the community confirm this tradeoff is real, so it’s worth testing your specific workload before assuming a win.</p>
<p>There’s also a separate <code>encoding/json/v2</code> package available if you want stricter defaults: it rejects invalid UTF-8 and duplicate keys, which v1 silently accepted. Whether that’s a feature or a breaking change depends entirely on what your inputs look like.</p>
<h3>Smaller allocations</h3>
<p>Size-specialized memory allocation cuts some sub-80-byte allocations by up to 30%. In allocation-heavy programs, expect roughly a 1% overall gain. The cost is about 60KB of binary size, which is a reasonable trade for most services.</p>
<h3>Other changes worth knowing</h3>
<ul>
<li>Goroutine labels now appear in tracebacks, which makes debugging significantly less painful</li>
<li><code>go tool trace</code> now only listens on localhost by default — a small but sensible security change</li>
<li>HTTP/1 response bodies are drained on close, fixing a class of connection reuse bugs</li>
<li><code>crypto/mldsa</code> adds post-quantum ML-DSA signature support</li>
<li>SIMD support is still experimental behind <code>GOEXPERIMENT=simd</code></li>
</ul>
<hr>
<h2>Swiss Table maps and the mapsplitgroup experiment</h2>
<p>Separate from the release itself, there’s been good writing this week on Go’s Swiss Table map implementation — the data structure that replaced the old hash map internals. If you want to understand why map operations got faster in recent Go versions, it’s worth reading. There’s also a new <code>mapsplitgroup</code> experiment in progress, though it’s early days.</p>
<hr>
<h2>TinyGo 0.42: panic recovery and UEFI boot</h2>
<p>TinyGo 0.42 is out with two notable additions: working panic recovery (finally), and an early UEFI boot target. That second one is what the Go Weekly headline is gesturing at — TinyGo can now target UEFI, meaning Go code can run before the operating system loads. It’s early and experimental, but it’s a genuinely interesting direction for embedded and firmware use cases. TinyGo 0.42 also adds Go 1.27 support.</p>
<hr>
<h2>Library releases</h2>
<ul>
<li><strong>AWS Lambda for Go 1.55</strong></li>
<li><strong>GoReleaser 2.18</strong></li>
<li><strong>quic-go 0.62</strong></li>
<li><strong>Miniredis 2.39</strong></li>
</ul>


Go 1.27 shipped August 19, 2026 with a now-stable goroutine leak profiler exposed at /debug/pprof/goroutineleak, replacing the 1.26 experimental flag. encoding/json is now backed internally by encoding/json/v2, making unmarshalling notably faster while some struct-slice marshalling gets slower; a separate stricter encoding/json/v2 package rejects invalid UTF-8 and duplicate keys. Size-specialized allocation cuts sub-80-byte allocations by up to 30% for roughly 1% overall gains at the cost of about 60KB binary size. Other changes include goroutine labels in tracebacks, go tool trace binding to localhost only by default, HTTP/1 response body draining on close, and post-quantum crypto/mldsa support. Separately, TinyGo 0.42 adds working panic recovery, an experimental UEFI boot target letting Go run before the OS loads, and Go 1.27 support. Library releases include AWS Lambda for Go 1.55, GoReleaser 2.18, quic-go 0.62, and Miniredis 2.39.

TinyGo 0.42 adds recoverable panics, Puya PY32 support and LLVM 22

<p>TinyGo 0.42 is out, and it closes a few gaps that have been open for a while.</p>
<h2>Recover finally works</h2>
<p>The headline feature is that runtime panics are now recoverable via <code>defer</code> and <code>recover</code>. Nil pointer dereferences, divide by zero, out-of-range slice and map access, channel panics - all of these can now be caught, including on Windows and riscv64. This brings TinyGo meaningfully closer to mainline Go behavior and removes a class of workarounds that embedded developers had to build around.</p>
<h2>Puya PY32 support</h2>
<p>The release adds support for Puya’s PY32 line of 32-bit Arm microcontrollers - 87 individual chip configurations across 40 device-definition families, covering both Cortex-M0+ and Cortex-M4 cores. The range goes from tiny 8 KB flash / 2 KB SRAM parts up to 512 KB flash / 144 KB SRAM devices.</p>
<p>The port includes startup code, generated register definitions via the py32-svd repository, linker scripts, and machine-API support for GPIO, UART, clocks, and timers. ADC, I2C, SPI, and PWM don’t have portable drivers yet.</p>
<p>Two EmbedFire development boards get dedicated TinyGo targets: the PY32F030 and PY32F002B, both available on AliExpress for under $2. They come with pin aliases for LEDs, keys, and UART, and can be flashed with a single <code>tinygo</code> command via pyOCD.</p>
<p>The port was built by contributor Pavel Burgr, partly to support BleRiot - a low-power radio protocol for IoT nodes that report sensor values to a lightweight Registry service. AT32 MCU support is reportedly next.</p>
<h2>Other changes</h2>
<ul>
<li><strong>Go 1.27 support</strong> added</li>
<li><strong>LLVM 22</strong> is now the default build toolchain, with LLVM 19 and 20 still supported</li>
<li><strong>Minimal UEFI target</strong> introduced, letting Go programs run as pre-boot applications</li>
<li><strong>ESP32</strong> gains interrupt support, ADC, WiFi, and Bluetooth</li>
<li><strong>STM32</strong> adds new chip and board targets</li>
<li><strong>USB handling</strong> improved across several boards</li>
</ul>


TinyGo 0.42 adds recoverable runtime panics via defer/recover across platforms including Windows and riscv64, closing a long-standing gap with mainline Go behavior. The release also adds support for Puya PY32 32-bit Arm microcontrollers (87 chip configurations, both Cortex-M0+ and Cortex-M4 cores) with startup code, register definitions, and GPIO/UART/clock/timer support, plus two EmbedFire dev boards priced under $2. Additional updates include Go 1.27 support, LLVM 22 as the new default toolchain (with 19/20 still supported), a minimal UEFI target, and ESP32/STM32/USB improvements.

OpenTelemetry Go Logs API and SDK reach release candidate status

OpenTelemetry Go v1.47.0-rc.1 promotes the Logs API and SDK from beta (v0.22.0) to release candidate status, the final step before v1 stability guarantees. The RC covers go.opentelemetry.io/otel/log and go.opentelemetry.io/otel/sdk/log, while log exporters and logtest remain experimental. New Logger, GetLoggerProvider, and SetLoggerProvider functions land in the root otel package, deprecating the equivalent APIs in otel/log/global. The team is asking developers to test direct API use, bridges, custom processors/exporters, high-volume workloads, and shutdown behavior, and will wait at least 14 days after publication before stabilizing, restarting that window if another RC is needed.

Go 1.27 adds generic methods to the language

<p>Go 1.27 shipped on August 19 with a handful of changes worth knowing about. Here’s a rundown of the most significant ones.</p>
<h2>Generic methods</h2>
<p>The headline feature is generic methods. Before 1.27, if you wanted a method that operated on a type parameter beyond the receiver’s own, you had to reach for a package-level function. Something like <code>MapList(list, fn)</code> instead of <code>list.Map(fn)</code>. It worked, but it felt like a workaround.</p>
<p>Now concrete methods can declare their own type parameters directly:</p>
<pre><code class="language-go"><span class="hljs-function"><span class="hljs-keyword">func</span> <span class="hljs-params">(l *List[E])</span></span> Map[R any](fn <span class="hljs-function"><span class="hljs-keyword">func</span><span class="hljs-params">(E)</span></span> R) *List[R] { ... }
</code></pre>
<p>This makes code more chainable and keeps related logic closer together. The Go team’s write-up walks through the before/after in detail.</p>
<p>One thing that won’t change: generic interface methods. The reason is a real constraint, not a temporary limitation. Go generates specialized code per type argument at compile time. When an interface method call crosses a package boundary, the compiler has no way to know in advance which type arguments it’ll need to generate code for. So interface methods stay monomorphic.</p>
<h2>Goroutine leak profiling</h2>
<p>Go 1.27 adds a goroutine leak profiler to <code>runtime/pprof</code> and <code>net/http/pprof</code>, available at <code>/debug/pprof/goroutineleak</code>. No experiment flags needed.</p>
<p>The regular goroutine profile shows you all goroutines. This one specifically identifies goroutines that are <em>permanently</em> blocked — stuck on channel sends/receives or sync primitives like <code>Mutex</code>, <code>RWMutex</code>, <code>WaitGroup</code>, and <code>Cond</code> — with very few false positives.</p>
<p>The implementation adapts the garbage collector’s mark-and-sweep algorithm to trace liveness through goroutine references. If a goroutine is blocked waiting on something that nothing else will ever unblock, it shows up here.</p>
<p>Common patterns it catches:</p>
<ul>
<li>Unbuffered channel sends where the receiver returned early</li>
<li>Double sends to a channel with only one receiver</li>
<li>Missing mutex unlocks</li>
<li><code>range</code> over a channel that never gets closed</li>
<li>Mutual blocking between channels and mutexes</li>
</ul>
<p>Real-world examples from CockroachDB, etcd, Kubernetes, and Moby are covered in the detailed write-up on the profiler.</p>
<p>A few limitations to know: it can’t detect goroutines blocked on file or network I/O (those aren’t tracked the same way), there’s some non-determinism, and there’s an O(n²) worst case in daisy-chain blocking scenarios.</p>
<h2>JSON v2 is now stable</h2>
<p>The <code>encoding/json/v2</code> package moves out of experimental status in 1.27. It has stricter defaults and better interoperability, and comes with a thin v1 wrapper for backward compatibility. Joe Tsai from the Go team discussed the migration story at the release party — the short version is that you can adopt it incrementally.</p>
<h2>Other language changes</h2>
<p><strong>Struct literal field selectors</strong> now support any valid field selector for initializing nested or embedded struct fields. Previously you had to initialize embedded structs separately in some cases.</p>
<p><strong>Function type inference</strong> is expanded to work across all assignment contexts, not just a subset.</p>
<h2>Standard library additions</h2>
<ul>
<li>A <code>uuid</code> package joins the standard library</li>
<li>Post-quantum cryptography support via ML-DSA</li>
<li>Unicode 17</li>
</ul>
<h2>Tooling and performance</h2>
<p><code>go doc</code> now supports <code>package@version</code> queries, so you can look up docs for a specific version without changing your module.</p>
<p><code>go mod tidy</code> automatically consolidates <code>require</code> blocks.</p>
<p>Four new <code>go fix</code> modernizers are included, and gopls is getting an upcoming CLI and interactive LSP refactoring support.</p>
<p>On the performance side, size-specialized memory allocation cuts small object allocation costs by up to 30%. This is a runtime change that requires no code changes to benefit from.</p>
<h2>In the ecosystem</h2>
<p>A few notable library releases around the same time: Goldmark 2.0 (first breaking release in seven years, adds generics and a cleaner parser/renderer split), Bubble Tea 2.0.9, Bubbles 2.2, and goquery 1.13.0. There’s also an experimental <code>simd</code> and <code>archsimd</code> package that reportedly speeds up ChaCha20 encryption by 7.5x without hand-written assembly, though that’s still in early stages.</p>


Go 1.27, released August 19, introduces generic methods, allowing concrete types to declare their own type parameters on methods rather than requiring package-level generic functions. Generic interface methods remain disallowed due to compiler specialization constraints. Other language updates include expanded struct literal keys, broader function type inference across assignment contexts, four new go fix modernizers, go doc support for package@version queries, automatic require block consolidation in go mod tidy, up to 30% cheaper small object allocation, and general availability of the goroutine leak profile.

Grafana Labs open-sources AI SDK for Go with multi-provider LLM and agent support

Grafana Labs has open sourced the Grafana AI SDK for Go, a shared foundation built internally to stop teams from reinventing provider clients, streaming abstractions, and error handling for every new LLM experiment. It provides common interfaces for calling models, streaming responses, executing tools, generating structured output, and running multi-step agents, and it speaks the Vercel AI SDK's UI message stream protocol so a Go backend can stream directly to React hooks like useChat, useCompletion, and useObject. It currently supports Anthropic, Amazon Bedrock, OpenAI's Responses API, and OpenAI-compatible APIs, with provider integrations split into separate Go modules. The SDK is explicitly modeled on Vercel's AI SDK, tracks a public compatibility baseline against pinned upstream versions, and ships with Agent Observability middleware, structured logging, and Prometheus metrics support. Grafana frames it as a young, evolving project and invites the Go and open source community to contribute providers, middleware, and feedback.

Go 1.27 ships generic methods, UUID package, JSON v2 default and post-quantum signatures

TypeScript creator explains why Go beat Rust for the 10x compiler rewrite

Anders Hejlsberg, creator of TypeScript and C#, discusses the technical decisions behind porting the TypeScript compiler from JavaScript to Go for a claimed 10x performance improvement. He explains why Go was chosen over Rust (garbage collection, shared-memory concurrency, and difficulty handling circular data structures with Rust's borrow checker), why they opted to port rather than rewrite from scratch to preserve backwards compatibility, and how LLMs played a smaller-than-expected role due to timing (the project started two years ago when LLMs were less capable). He also shares views on why JavaScript remains popular, why TypeScript became the most-used language on GitHub, and why he believes AI favors incumbent languages with large training data over new ones, making it unlikely AI will replace software engineers or make JavaScript obsolete.

Go 1.27 ships with generic methods, post-quantum crypto and encoding/json/v2

<p>Go 1.27 shipped this week, and the release notes are genuinely impressive. But the most interesting thing isn’t what’s in the release — it’s the argument it’s already started.</p>
<p><strong>What landed</strong></p>
<p>The headline features: generic methods (methods can now declare their own type parameters, not just inherit the receiver’s), smarter type inference across assignment contexts, and struct literals that accept nested field selectors as keys. Runtime gets a size-specialized allocator for objects under 80 bytes, cutting small-object allocation costs by up to 30% — roughly 1% overall speedup with zero code changes. Standard library adds a native UUID package, <code>encoding/json/v2</code> (stricter defaults, old <code>encoding/json</code> now runs on top of it for free perf gains), post-quantum ML-DSA signatures in <code>crypto/mldsa</code>, and experimental SIMD support via a portable vector package plus a lower-level <code>arch/simd</code> for per-instruction control.</p>
<p>The SIMD story is already getting real-world validation. One engineer implemented SIMD-accelerated ChaCha20 encryption using the new packages and hit a 7.5x speedup over stdlib on AMD EPYC Zen5 with AVX512 — slightly faster than an equivalent Rust implementation. That’s not a benchmark toy; that’s the kind of number that makes people pay attention.</p>
<p><strong>The fight</strong></p>
<p>Here’s where it gets interesting. ThePrimeagen and VictoriaMetrics founder Aliaksandr Valialkin are pushing back on the generics expansion, arguing it chips away at the thing that made Go worth using in the first place: you could read anyone’s Go code and understand it immediately. More abstraction means more cognitive overhead, and Go’s whole pitch was that it didn’t do that to you.</p>
<p>The counter-argument — and this is the part that’s going to keep coming up — is that Google engineers are framing readability as <em>more</em> important now, not less, precisely because AI is writing more of the code. When agents generate the implementation and humans mainly review it, simpler and more explicit beats clever and abstract. Generic methods cut repetitive boilerplate, which sounds like a win, but whether that makes AI-generated Go easier or harder to audit is genuinely unclear.</p>
<p>JetBrains already updated GoLand 2026.2 to support the new syntax on day one, and they’ve updated their Modern Go Code Guidelines repo so AI agents generate 1.27-idiomatic code. Which is either reassuring or exactly the thing the readability crowd is worried about, depending on where you sit.</p>


Go 1.27 arrived with generic methods, nested-field struct literal keys, broader function type inference, size-specialized allocation cutting small-object costs by up to 30%, a GA goroutine-leak profiler, encoding/json/v2, crypto/mldsa, a native uuid package, and an in-memory fake network for httptest. But the real buzz is the experimental SIMD support (still gated behind GOEXPERIMENT=simd): a portable simd package and a lower-level archsimd package with AVX512, Arm Neon, and WebAssembly 128-bit support. One developer implemented SIMD-accelerated ChaCha20 encryption and measured up to 7.5x speedup over the stdlib implementation on an AMD EPYC Zen5/AVX512 machine, edging out an equivalent Rust implementation. The portable simd package couldn't handle ChaCha20's platform-specific rotation instructions, forcing a drop to the low-level archsimd package; gaps remain, including no SIMD arrays and some missing instructions.

Uber open-sources SubmitQueue, a speculative merge queue for large monorepos

Uber has open-sourced SubmitQueue, a high-performance speculative merge queue written in Go, designed to keep trunk branches consistently green at scale. Instead of validating changes sequentially, it speculatively rebases and validates multiple changes in parallel against predicted future HEAD states. When validations pass, changes land automatically; when they fail, SubmitQueue isolates the offending change and retries the rest without human intervention. It targets large monorepos and fast-moving teams dealing with concurrent changes and build instability. The repository includes a Gateway, Orchestrator, and MySQL backend, runnable locally via Docker Compose.