HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
golang
go
Go2014–2026
golang / go

go

The Go programming language

1,181Distinct people
1,944Mentions
14Explicit recommenders
139.9KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

The Go programming language

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

> To convert the Stream.Reader to an std.Io.Reader, we need to call its interface() method. To get a std.io.Writer from an Stream.Writer, we need the address of its &interface…

j1elo used a recommendation phrase. 14 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 12:56:33 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year1,944 dated mentions

Observed mentions: 2014-12-08 08:41:45 UTC to 2026-10-22 10:17:39 UTC.

0501001502002014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 16 mentions; 1 submissions, 15 comments20142015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 80 mentions; 17 submissions, 63 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 135 mentions; 18 submissions, 117 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 164 mentions; 20 submissions, 144 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 174 mentions; 26 submissions, 148 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 196 mentions; 30 submissions, 166 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 159 mentions; 21 submissions, 138 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 184 mentions; 34 submissions, 150 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 220 mentions; 45 submissions, 175 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 221 mentions; 27 submissions, 194 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 163 mentions; 13 submissions, 150 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 167 mentions; 24 submissions, 143 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 65 mentions; 15 submissions, 50 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC16115
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC801763
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC13518117
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC16420144
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC17426148
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC19630166
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC15921138
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC18434150
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC22045175
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC22127194
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC16313150
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC16724143
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC651550

From the project README

An excerpt from the repository, fetched Nov 12, 2026.

Read the project’s introduction
The Go Programming Language Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. Gopher image by Renee French, licensed under Creative Commons 4.0 Attribution license. Our canonical Git repository is located at https://go.googlesource.com/go. There is a mirror of the repository at https://github.com/golang/go. Unless otherwise noted, the Go source files are distributed under the BSD-style license found in the LICENSE file. Download and Install Binary Distributions Official binary distributions are available at https://go.dev/dl/. After downloading a binary release, visit https://go.dev/doc/install for installation instructions. Install From Source If a binary distribution is not available for your combination of operating system and architecture, visit https://go.dev/doc/install/source for source installation instructions. Contributing Go is the work of thousands of contributors. We appreciate your help! To contribute, please read the contribution guidelines at https://go.dev/doc/contribute. Note that the Go project uses the issue tracker for bug reports and proposals only. See https://go.dev/wiki/Questions for a list of places to ask questions about the Go language.
Read the full README on GitHub

What Hacker News says

221 sources
In some cases you can use the block system in Go templates, but it is extremely sad. I actually made a proposal for an extension to Go templates that would make the “component” workflow a little easier[1], and used it on my site before switching to LuaX, but at the end of the day I don’t like switching languages and I don’t like recompiling my site while I’m writing. Go templates are fundamentally not what I wanted. [1] https://github.com/golang/go/issues/54748
In LuaX: A Lua Dialect with JSX
What a strange article. Goroutines definitely do have their downsides, they aren't hard to find either, but nothing he talks about here is actually a downside of goroutines. Also for some reason almost every reference he has is from 2016. > Further, goroutines' lack of their stack ancestry means they can't natively give out the nice stacktraces found in other languages, though there are a lot of workarounds, to be sure. I wish he was more speific here, what's "nice" about stacktraces in other languages that is lacked by Go? I really don't get it, it seems to me that they are the same, maybe I'm missing something. There's even a mechanism to record goroutine ancestry [1] but it's from 2018, past this article's knowledge cutoff date maybe? > Because of this stack disconnection of parents and children, it really becomes impossible to have ex
Read the rest
ceptions But panics use the exact same mechanism as exceptions? They are not used in the same way as exceptions but it isn't because of any technical limitation of goroutines, it's mostly about what's idiomatic in the language. His whole example about a panic causing a resource leak, as far as I can tell the difference is that in java an uncaught exception will only close its thread while in go the whole program crashes. You can definitely argue for both behavior as being better (IMO it really depends on the application), but it doesn't have anything to do with how goroutines are implemented. > This highlights a key difference between cooperative scheduling and OS-level scheduling: OS-level threads can be stopped at any time, while cooperatively scheduled coroutines cannot Goroutines are actually scheduled preemptively since 2020 [2], again this is probably beyond the knowledge cutoff date of the article. This isn't surfaced to the user however, you still can't stop a goroutine at an arbitrary point. But it doesn't have anything to do with the way goroutines are implemented, it's because it is a design decision to not allow users to do that. [1] https://github.com/golang/go/issues/22289 [2] https://go.dev/doc/go1.14
In The Downsides of Go's Goroutines
Not only that. It seems that with all the millions they have, Slack devs were unable to implement the most basic bracket balancing in the link parser. Try to send a link with a title including square brackets, and contemplate the disaster that gets interpreted from it: [Unmarshal(data []byte, v any)](https://github.com/golang/go/blob/go1.21.0/src/encoding/json/decode.go#L97) (spoiler: it just thinks that the link title is "Unmarshal(data [" and somehow inserts links into the rest of the words.)
In Show HN: Heynote – A dedicated scratchpad for developers
> A MITM attacker can arbitrarily delete messages from a connection before the secure channel is established, as sequence numbers are only validated once the channel is established and arbitrary messages are allowed during the handshake, allowing them to manipulate the sequence numbers. Depending on the cipher being used, once the secure channel is established, the attacker can then use the manipulated sequence numbers to delete messages sent immediately after the channel is established. (https://github.com/golang/go/issues/64784) OpenSSH also has released an update: https://seclists.org/oss-sec/2023/q4/291
In Vulnerability in golang.org/x/crypto/ssh
Someone made a benchmark of serialization libraries in go [1], and I was surprised to see gobs is one of the slowest ones, specially for decoding. I suspect part of the reason is that the API doesn't not allow reusing decoders [2]. From my explorations it seems like both JSON [3], message-pack [4] and CBOR [5] are better alternatives. By the way, in Go there are a like a million JSON encoders because a lot of things in the std library are not really coded for maximum performance but more for easy of usage, it seems. Perhaps this is the right balance for certain things (ex: the http library, see [6]). There are also a bunch of libraries that allow you to modify a JSON file "in place", without having to fully deserialize into structs (ex: GJSON/SJSON [7] [8]). This sounds very convenient and more efficient that fully de/serializing if we ju
Read the rest
In Gobs of data (2011)
I can't recommend enough Zitadel and its OIDC library. Code is very well-writen and informative. Highly encourage everyone jump into source code and explore how IntrospectionResponse struct work with all related code around https://github.com/zitadel/oidc/blob/main/pkg/oidc/introspec... // IntrospectionResponse implements RFC 7662, section 2.2 and // OpenID Connect Core 1.0, section 5.1 (UserInfo). // https://www.rfc-editor.org/rfc/rfc7662.html#section-2.2. // https://openid.net/specs/openid-connect-core-1_0.html#Standa.... type IntrospectionResponse struct { Active Scope ClientID TokenType ... exp iat nbf sub Audience ... aud ... JWTID ... Claims map[string]any } If you want to explore the difference between identity providers, click through https://github.com/nextauthjs/next-auth/tree/main/packages/c... Azure is the most
Read the rest
insane ... and it's a lot of fun to compare them all against each other. Next go though PKCE (Proof Key for Code Exchange) and look how code_challenge, code_verifier works or at least see interfaces . Ory Fosite is a great alternative too https://github.com/ory/fosite Support PKCE #59835 in x/oauth2 https://github.com/golang/go/issues/59835 Scott Brady's content is great for undetstanding the topic SPA Identity and Access Control with OpenID Connect https://www.youtube.com/watch?v=rP3St0GU_Bk OAuth is Not Authentication https://www.scottbrady91.com/oauth/oauth-is-not-authenticati... SPA is a landmine .. OAuth 2 0 and OpenID Connect for Single Page Applications Philippe De Ryck https://www.youtube.com/watch?v=XoBtUn4XczU The deeper you go into the topic the more you will discover. It's an ultimate "rabbit hole" - web, native, SPA flows, PKCE, JWT, session storage, custome middleware for your favorite flavor of backend framework, etc
In Easy to use OpenID Connect client and server library written for Go
I looked at the Go implementation of this in "tagged pointers" [0] The amount of data that can be used for the tag is architecture-dependant, and the routine discards any tag bits that don't fit into the tagged pointer without telling the caller. To me, this seems ridiculous - why not just use a struct with a tag and a pointer, and not run the risk of your tag being destroyed without you knowing because the architecture can't fit that many bits? But the Go folks are smart, and must be doing this for a reason. Can anyone explain the thinking here? [0] https://github.com/golang/go/blob/master/src/runtime/tagptr_...
In Storing data in pointers
> Your game looks great, congrats on your progress! I especially enjoyed how the zoom works when you're leaving/arrive planets, and the unique propulsion system (also, the anchor made me giggle!). Thank you. Feedbacks are very much appreciated. There is still a long was until an eventual release, but it's very fun to work on it. > I tend to not need many, so I'd be curious if you can recall any structure in particular which you couldn't find? No biggie if not. I had trouble finding basic structures like sets or linked lists, as much as more specific ones like R-tree, M-tree, KD-tree quad-tree or specific kinds of tries. When quickly searching on Google, there are pretty much always some results, but when looking at the details it's not that great. Most of the packages have some kind of flaw that was a deal-breaker for me. Most common ones
Read the rest
are: - The package is something developed by one guy 4 years ago, and has pretty much no stars and is abandoned - The structure is somehow backed by the native `map`, meaning that it has the same randomized iteration order - There is some kind of logic to try to handle multi-threading, mixed-up with the data structure's logic. Often with mutexes/locks, thus killing the performance. My game is pretty much only mono-thread, and I just need something simple and that does not care about synchronization. - The structure is not generic, but only uses `interface{}` - The structure lacks tests or have unreadable code made of 1-letter variables > I'm not a game dev, but I've seen some larger games such as https://github.com/divVerent/aaaaxy/tree/main/internal (if you haven't played it before—do it!) which seems to be able to place everything into separate packages without issue, so perhaps there's something to gleam from their architecture? Thanks for the reference. After looking at it, is seems to me that they are creating really tiny packages made of one or two files. I don't want my codebase to end-up with thousands of 1-file packages, it does not seem very maintainable. I want to keep having packages with clearly defined purposes and domains. > Hash map iteration shouldn't be sorted in _any_ language (here's Rust, for example https://play.rust-lang.org/?version=stable&mode=debug&editio... (Python makes it _appear_ as if dicts are sorted hash maps, but that's only because it doesn't only use a hash table, but a vector as well (same as you'd have to do in Go))), otherwise it would cause both portability and security (https://github.com/golang/go/issues/2630) issues. You should probably be using a b-tree if you aren't willing to sort it yourself. I think that you didn't understand my message (or I didn't explain clearly enough). I do not need the items to be sorted, I need the iteration order to be consistent. Let's say that I insert A, B and C in a map, then want to iterate on it. I will get an unspecified order, maybe ABC, maybe CBA, maybe BAC, which does not matter to me. However, in any language, this order will be consistent across all future iterations unless the data is changed. This is a natural property of any data structure. So if I got CBA in the first loop, I will also get CBA in the second and third loops. In golang this is not the case because they actively inserted a random order. It means that even if the data does not change, I may get CBA in the first iteration, but BAC in the second, then ABC... Which created a ton of issues for me. > If you don't care about unloading https://github.com/pkujhd/goloader > > Go actually has one of the best WASM runtimes https://github.com/tetratelabs/wazero > > It also has a bunch of libraries for embedding scripting languages https://awesome-go.com/embeddable-scripting-languages, with Tengo _probably_ being the quickest https://github.com/d5/tengo Yes, I noticed those packages recently. The problem is that there is little data about how reliable and maintainable goloader is going to be on the long term. As I care about performance and security, I don't want a scripting language, but WASM seems to be a very promising possibility. I have made benchmarks with 2~3 WASM engines in Go, and so far I am not completely convinced about the quality and performance of the available APIs. Also, when compiling Golang to WASM, the native compiler is still abysmally bad and does not have full support for imports, so Tinygo is a must-have. Anyway, modding is still a long term idea at this point, so hopefully the ecosystem will get more mature within a couple of years.
In Making games in Go for absolute beginners
> I am the developer of Astral Divide, which is entirely written in Go: https://store.steampowered.com/app/2597060/Astral_Divide/ Your game looks great, congrats on your progress! I especially enjoyed how the zoom works when you're leaving/arrive planets, and the unique propulsion system (also, the anchor made me giggle!). > lack of data structure packages I tend to not need many, so I'd be curious if you can recall any structure in particular which you couldn't find? No biggie if not. > package structure not suited for games I'm not a game dev, but I've seen some larger games such as https://github.com/divVerent/aaaaxy/tree/main/internal (if you haven't played it before—do it!) which seems to be able to place everything into separate packages without issue, so perhaps there's something to gleam from their architecture? > maps are random
Read the rest
when iterated Hash map iteration shouldn't be sorted in _any_ language (here's Rust, for example https://play.rust-lang.org/?version=stable&mode=debug&editio... (Python makes it _appear_ as if dicts are sorted hash maps, but that's only because it doesn't only use a hash table, but a vector as well (same as you'd have to do in Go))), otherwise it would cause both portability and security (https://github.com/golang/go/issues/2630) issues. You should probably be using a b-tree if you aren't willing to sort it yourself. > modding options If you don't care about unloading https://github.com/pkujhd/goloader Go actually has one of the best WASM runtimes https://github.com/tetratelabs/wazero It also has a bunch of libraries for embedding scripting languages https://awesome-go.com/embeddable-scripting-languages, with Tengo _probably_ being the quickest https://github.com/d5/tengo I'd _highly_ recommend Ebitengine in the future, as not only have there been multiple brilliant games using it, but it also has Switch/Android/iOS support, and you can find help with any issue whatsoever in their Discord. People have even built 3D games with it, and Hajime is an absolute beast of a developer.
In Making games in Go for absolute beginners
> C Doesn't Want to Fix It Or: C knows that it doesn't need fixing. How often do I need to `setenv()` anything? The answer is "Never" in the vast majority of programs, because ENVVRS are usually read rather than set, so this issue is nonexistent for them. For the vast majority of the small amount of programs that actually need to use `setenv()`, the answer is: "Maybe once or twice during the entire lifetime of the process, and then only at the very start, probably even before running any threads", meaning this issue is nonexistent for them as well. So, is there a potential issue with thread safetey? Yes. Does it matter given where and under what circumstances it occurs? Not really. > such as Go's os.Setenv (Go issue) Here is the link to the "issue": https://github.com/golang/go/issues/63567 What kind of actual real life production code wo
Read the rest
uld continuously set envvars while simutaneously calling a function that tries to read the environment? Yes, this is a footgun. But even the issues author acknowledges, in the issue thread: Realistically: this is a pretty rare problem, and documenting it is probably a fine solution. This is probably going to cost someone else a couple of days of debugging every couple of years > It has wasted thousands of hours of people's time, either debugging the problems, or debating what to do about it. Source?
In Setenv Is Not Thread Safe and C Doesn't Want to Fix It

Showing the 15 most recent of 221 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.