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!

If you have an interest in understanding garbage collection better, or in how Go's new GC works under-the-hood, I highly recommend reading @michael.express's thorough guide through Go's current and Green Tea GC.