A Fast Immutable Map in Go https://lemire.me/blog/2026/03/29/a-fast-immutable-map-in-go/

Could Go be a better C? I think so! Meet Solod — a strict subset of Go that translates to C, without hidden memory allocations and with source-level interop. antonz.org/solod

This is the best product review I’ve read: samhenri.gold/blog/2026031... It doesn’t matter if you’re interested in the MacBook Neo or not; this is the kind of essay that makes you think about the potential of technology and the joys of exploration.

A great example of how the Google #golang team put thousands of lines of ultra-technical code in service of an incredibly easy-to-use and useful tool. If you ever deprecate code, you really should know about the go:inline directive!

Find out how the source-level inliner in Go 1.26 can help you with API migrations. go.dev/blog/inliner

I've spent the past couple months hand crafting a new B-tree map implementation for Go. It's fast. Faster than Rust's BTreeMap. Faster than the fastest C++ (frozenca/btree). And about 2x faster than my current Go btree (tidwall/btree).

I've just released a new version of the "sh" #golang module, including initial Zsh support in shfmt, as well as many improvements and fixes to the parser and interpreter 🎉

Finally! No more "dirty" #golang builds because you have untracked files laying around which don't affect the build at all :)

Got an idea buzzing in that brilliant gopher brain of yours? 🧠 Don’t keep it in the lab; share it with the #golang community! 🧪 #GopherCon Call for Speakers closes March 4th. Submit your proposal ➡️ sessionize.com/gophercon-20... #RoadToGopherCon

Small #golang PSA: Most of the very nice automatic code problem reports in your editor or IDE come from Staticcheck by Dominik Honnef (@honnef.co). gopls is the LSP, and it uses many of the rules from Staticcheck. Suggestion: consider sponsoring Dominik! (Well worth it in my humble opinion😅)

I'm putting the finishing touches on the Staticcheck update for #golang 1.26. You can expect a release by the end of the week.

Some pretty awesome improvements in 1.26 for compiling/testing typescript-go. With a clean build/test cache, running the full test suite used to take 3m45s, but now takes just 2m10s.

Go 1.26 is out, and the announcement says: "Over the next few weeks, follow-up blog posts will cover some of the topics in more detail. Check back later." So you can wait a few weeks OR you can read my interactive Go 1.26 tour right away: antonz.org/go-1-26

With Go 1.26, you can easily log to multiple targets (like stdout, a file, or a remote server) using just the standard library. All thanks to slog.MultiHandler, which sends log records to any number of handlers you configure.

@rog.bsky.social this sounds perfect for testing servers locally, especially with synctest 😊 github.com/golang/go/is...

This is a fun writeup of using C to implement #golang interfaces (or maybe Rust traits), complete with editable C you can run via your browser. It pairs nicely with the classic post on the Go interface implementation by @swtch.com from 16 (!) years ago: research.swtch.com/interfaces

“Floating-Point Printing and Parsing Can Be Simple And Fast” The fastest known floating-point printer and parsing algorithms - fixed-width printing, shortest-width printing, and parsing, all in 400 lines of Go. research.swtch.com/fp research.swtch.com/fp-proof

Very nice! #golang flight recorder taking off (so to speak)

A good way to keep up with the Go project is this starter pack from @mvdan.cc (long-time #golang contributor). Two other good ways to keep up are subscribing to the Go proposal review meeting GitHub issue: go.dev/issue/33502 and the Go compiler & runtime meeting notes issue: go.dev/issue/43930

New blog post, with a perhaps mildly unpopular opinion: jayconrod.com/posts/133/in...

Related #golang PSA: Gophers often mistakenly put a -u in 'go get -u foo', when they would have been better off with just 'go get foo'. 'go get foo' says to upgrade foo itself. It's shorthand for 'go get foo@upgrade' 'go get -u foo' says to *also* upgrade all the direct and indirect deps of foo.

30 Years of Programming at 44 Years Old blainsmith.com/articles/30-... #Programming #Birthday

Tailscale, AT protocol, #golang, holding hands running through a field

Go did this best in my opinion. The "time" package's API is a work of art: want the current time? ```go time.Now() ``` want time since an operation? ```go t := time.Now() elapsed := t.Sub(start) ``` Need a ticker every 5 seconds? ```go timer := time.NewTimer(5 * time.Second) <-timer.C ```

New #golang Reed-Solomon release. Contains new progressive field decoding and some significant speedups. Check it out: github.com/klauspost/re...

Seeing an influx of people starting out their adventures building in the atmosphere or asking how to, so here’s my statusphere demo app built in #golang as reference. tangled.org/willdot.net/...

So the second most imported 3rd-party dependency is Google's own UUID package. I wonder what it would take to convince the Go team to add it to stdlib. Also, I don't think x/crypto and x/net should be here at all. Both are imported by stdlib itself, so they're basically included in every project.

“Pulling a New Proof from Knuth's Fixed-Point Printer” Happy 88th Birthday to Don Knuth! And thanks again to @robpike.io for Ivy. research.swtch.com/fp-knuth

Go 1.26 will be huge for the ecosystem thanks to massive improvements in the garbage collector: > Benchmark results vary, but we expect somewhere between a 10—40% reduction in garbage collection overhead in real-world programs that heavily use the garbage collector. Exciting!! go.dev/doc/go1.26

Coming in at number 5 with over 93,000+ dependents, cobra is more than just a Go library: it's a core par of the breathing ecosystem. It's been a pleasure shepherding this library for the better part of 5 years. To the whole Go community, thank you!!! blog.thibaut-rousseau.com/blog/the-mos...

I don't have a large collection, but it is timeless. #Books

Feels like writing assembly minus the part where you typo on letter and create an Remote-Code-Execution vulnerability. Really exciting stuff to play with !

Hi @mcy.gay, looking over Go SIMD proposal, I'm reminded you expressed some interest in giving it a quick whirl once it was merged. I'm curious if you've had a chance to try a hello world or port some code or whatever? (and fyi, there's been some tweaks since go1.26rc1, so tip is probably better)

Right now, and the next few months, is a very good time to talk about that organization, since an "experiment" is technically still up for change. The argument *for* archsimd is that long term, it will all be build-tag gated, a smaller number of Go programmers will be using low level simd

Go 1.26 brings the long-awaited vectorized operations (SIMD) in the simd/archsimd package. Since it's hard to create a portable high-level API, the Go team decided to start with a low-level, architecture-specific one and support only amd64 for now.

I have written self-tests for the Python test generator and added tests to the Go tests. Folks, I can confirm we got all the edge cases! 💥 🥳 Thank you so much to everyone who contributed to the > 8,500(!) cores. I would like to credit you, so either reply or DM me your name/handle, if you'd like.

Go 1.26 received a somewhat under-the-radar language change: recursive type constraints in generics. Previously, type constraints couldn't directly or indirectly refer to type parameters. ↓

My GopherCon talk was just posted!

Hi @antonz.org, good question! Something like 'make([]byte, 0, 33)' does indeed create a slice with a capacity of exactly 33, as your example shows. However, the underlying allocated heap object actually is larger. Quick playground example that hacks things to print the heap object size:

Hey @thepudds.bsky.social! Thanks for io.ReadAll in Go 1.26 :) Why did you choose to use append-make instead of just make for the final slice? Using append-make sets the slice capacity to the next size class, which seems to go against the idea of having a "perfectly-sized slice", doesn't it?

This is an excellent interactive overview of upcoming #golang 1.26 changes put together by @antonz.org 🚀 (And @antonz.org -- I appreciate the shoutout there about you enjoying reading my CLs! Now that I know at least one other person might read them, I'll try not to let you down in the future 😅)

Go 1.26 is coming soon, and the official release notes are pretty dry. So I prepared an interactive version with lots of examples. Read on and see! antonz.org/go-1-26

Profiling Request Latency with Critical Path Analysis, @felixge.de @ GopherCon 2025 www.youtube.com/watch?v=BayZ...

My GopherCon lightning talk on the Lua interpreter I built for zb is now up! #golang youtu.be/BVLgLZ6_ZHo

What's new in gopls 21: go.dev/gopls/releas... Please try it out: $ go install golang.org/x/tools/gopls@latest

This was a fun conversation. Thanks to ACM Bytecast for having me on. learning.acm.org/bytecast/ep7...

“Go’s Sweet 16” by Austin Clements, for the Go team — https://go.dev/blog/16years #golang

I'm proud to officially announce CUE Labs! I co-founded CUE Labs with @myitcv.io to build a Configuration Control Plane, solving config chaos with CUE. Our work also provides the stewardship for the @cuelang.org open source project. Read our launch post: cue.dev/blog/announc...

So excited to finally share what we've been building at CUE Labs! Proud to be on this mission with @mpvl.io, @myitcv.io, @rog.bsky.social, @hylomorphism.bsky.social, and @dominikdm.bsky.social.

For some added fun, also see go.dev/cl/715362, wherein I discover that VPCOMPRESSQ is horrifically slow on AMD Zen 4, but only with a memory destination. And thanks to @lemire.bsky.social for writing about this, which made this much faster to track down!