Already existed when it was first merged: https://github.com/erlang/otp/commit/fefb5d039e87ff7137e78b3...
Atomics were introduced a while before `counters`, maybe you remember a custom implementation on top of that?
In Counting Fast in Erlang with:counters and:atomicserlang
otp
Erlang2009–2026
erlang / otp
otp
Erlang/OTP
73Distinct people
93Mentions
1Explicit recommenders
12.4KGitHub stars
What to know before exploring
What it is
Erlang/OTP
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
It has built-in maps now! (like dicts or hashes in other languages). http://www.swi-prolog.org/pldoc/man?section=maps That is exciting. I'd want to play with it again. I like…
rdtsc used a recommendation phrase. One indexed comment matches. 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
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM 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 year93 dated mentions
Observed mentions: 2009-11-25 17:20:26 UTC to 2026-05-11 21:10:48 UTC.
* 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
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2009 | 2009-01-01 00:00:00 UTC | 2010-01-01 00:00:00 UTC | 1 | 1 | 0 |
| 2010 | 2010-01-01 00:00:00 UTC | 2011-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2011 | 2011-01-01 00:00:00 UTC | 2012-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 2 | 2 | 0 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 9 | 0 | 9 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 13 | 2 | 11 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 11 | 3 | 8 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 5 | 2 | 3 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 9 | 0 | 9 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 16 | 5 | 11 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 3 | 1 | 2 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 5 | 0 | 5 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 8 | 1 | 7 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 4 | 1 | 3 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Erlang/OTP
Erlang is a programming language and runtime system for building massively scalable soft real-time systems with requirements on high availability.
OTP is a set of Erlang libraries, which consists of the Erlang runtime system, a number of ready-to-use components mainly written in Erlang, and a set of design principles for Erlang programs. Learn more about Erlang and OTP.
Learn how to program in Erlang.
Examples
There are several examples on the website to help you get started. The below example defines a function world/0 that prints "Hello, world" in the Erlang shell:
-module(hello).
-export([world/0]).
world() -> io:format("Hello, world\n").
Save the file as hello.erl and run erl to enter the Erlang shell to compile the module.
Erlang/OTP 24 [erts-12.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit]
Eshell V12.2 (abort with ^G)
1> c(hello).
{ok,hello}
2> hello:world().
Hello, world
ok
Learn more about the Erlang syntax of modules, functions and expressions on Erlang.org.
Installation
Binary Distributions
Erlang/OTP is available as pre-built binary packages by most OS package managers.
apt-get install erlang
Compiling from source
To compile Erlang from source, run the following commands. The complete building and installation instructions can be found here.
git clone https://github.com/erlang/otp.git
cd otp
Checkout the branch or tag of your choice
git checkout maint-27 # current latest stable version
Configure, build and install
./configure
make
make install
Alternatively, you can use Kerl, a script that lets you easily build Erlang with a few commands.
Bug Reports
Please visit our GitHub Issues page for reporting bugs. The instructions for submitting bugs reports can be found here.
Security Disclosure
Please do not report security vulnerabilities through public channels, like
GitHub issues, discussions, or pull requests.
Please disclose the security issues following our SECURITY guidelines.
Contributing
We are grateful to the community for contributing bug fixes and improvements. Read below to learn how you can take part in improving Erlang/OTP. We appreciate your help!
Contribution Guide
Read our contribution guide to learn about our development process, how to propose fixes and improvements, and how to test your changes to Erlang/OTP before submitting a pull request.
Help Wanted
We have a list of Help Wanted bugs that we would appreciate external help from the community. This is a great place to get involved.
Awesome-Erlang
You can find more projects, tools and articles related to Erlang/OTP on the awesome-erlang list. Add your project there.
License
Erlang/OTP is released under the Apache License 2.0.
For any license inquiry, please send an email to opensource@ericsson.com
%CopyrightBegin%
SPDX-License-Identifier: Apache-2.0
Copyright Ericsson AB 2010-2025. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
%CopyrightEnd%
Read the full README on GitHubWhat Hacker News says
93 sources>IMO the nice thing about Erlang and Elixir is their foundation of representing data is rock solid. Because data is fully immutable, you get a lot of nice things "for free" (no shared state, reliable serialisation, etc). [...]
>In contrast with languages like C++ and Java where things are shakey from the ground up.
Yes, immutable does provide some guarantees for "free" to prevent some types of bugs but offering it also has "costs". It's a tradeoff.
Mutating in place is useful for highest performance. E.g. C/C++, assembler language "MOV" instruction, etc. That's why performance critical loops in high-speed stock trading, video games, machine learning backpropagation, etc all depend on mutating variables in place.
That is a good justification for why Erlang BEAM itself is written in C Language with loops that mutate variables everywhere.
Read the rest
E.g.: https://github.com/erlang/otp/blob/master/erts/emulator/beam...
There's no need to re-write BEAM in an immutable language.
Mutable data helps performance but it also has "costs" with unwanted bugs from data races in multi-threaded programs, etc. Mutable design has tradeoffs like immutable has tradeoffs.
One can "optimize" immutable data structures to reduce the performance penalty with behind-the-scenes data-sharing, etc. (Oft-cited book: https://www.amazon.com/Purely-Functional-Data-Structures-Oka...)
But those optimizations will still not match the absolute highest ceiling of performance with C/C++/asm mutation if the fastest speed with the least amount of cpu is what you need.
Have you deployed critical systems where human lives depend on?
"BEAM crashes with segmentation fault #7683" - https://github.com/erlang/otp/issues/7683
You dont use NIFs ?
"A native function that crashes will crash the whole VM." -
https://www.erlang.org/doc/apps/erts/erl_nif.html
"Who Supervises The Supervisors?"
- https://learnyousomeerlang.com/supervisors
In LLMs and Elixir: Windfall or Deathblow?If I interpret the patch correctly the issue seems to be that you could just ask for a channel and do a request_exec before authenticating. The regression test is:
{send, hello},
{send, ssh_msg_kexinit},
{match, #ssh_msg_kexinit{_='_'}, receive_msg},
{send, SshMsgChannelOpen},
{send, SshMsgChannelRequest},
{match, disconnect(), receive_msg}
https://github.com/erlang/otp/commit/6eef04130afc8b0ccb63c9a...
edit: Ah, found by the people at RUB, they do a lot of research in verifying protocol implementations iirc.
In Unauthenticated Remote Code Execution in Erlang/OTP SSHUnauthenticated Remote Code Execution in Erlang/OTP SSH
8 points · Open discussionThe example you've given here does not work the way you think it does. I would agree however that the mechanics of closure environments is simpler in Erlang due to the fact that values are immutable, as opposed to closures in other languages where mutability must be accounted for.
I would also note that, for the example you've given, the compiler _could_ constant-fold the whole thing away, but for the sake of argument, let's assume that `Val` is an argument to the current function in which `SumFun` is defined, and so the compiler cannot reason about the actual value that was bound.
The closure will be constructed at the point it is captured, using the `make_fun` BIF, with a given number of free var slots (in this case, 1 for the capture of `Val`). `Val` is written to the slot in the closure environment at this time as well. See the implem
Read the rest
entation of the BIF [here](https://github.com/erlang/otp/blob/6cefa05a2a977864150908feb...) if you are curious.
At runtime, when the closure is executed, the underlying function receives the closure environment, from which it loads any free vars. In my own Erlang compiler, the closure environment was given via pointer, as the first argument to the function, and then instructions were emitted to load free variables relative to that pointer. I believe BEAM does the same thing, but it may differ in the specific details, but conceptually that is how it works.
The compiler obviously must generate a new free function definition for closures with free variables (hence the name of the function you see in the interactive shell, or in debug output). The captured MFA of the closure is this generated function. The runtime distinguishes between the two types of closures (function captures vs actual closures) based on the metadata of the func value itself.
Like I mentioned near the top, it's worth bearing in mind that the compiler can also do quite a bit of simplification and optimization during compilation to BEAM - so there may be cases where you end up with a function capture instead of a closure, because the compiler was able to remove the need for the free variable in cases like your example, but I can't recall what erlc specifically does and does not do in that regard.
Unfortunately, servers are usually configured without X forwarding enabled. And the functionality I am describing already exists for terminal-based programs, it's been reimplemented multiple times — see e.g. [0][1], it's just implemented with horrible hackery (by manually driving terminal, processing raw input and counting how much lines of text the terminal screen is probably displaying right now).
I just want to, e.g. write a simple Python program that has
for line in streaming_response.lines():
print(line)
in one thread, and
while True:
cmd = input('> ').strip()
if cmd == 'q':
break
if cmd == 'stop':
requests.post(...)
...
in another, and be able to input my commands without the echo of my input being teared up by the output. Erlang's shell can do that. Readlin
Read the rest
e can be used to do that, but Python's bindings don't export the needed functions. Swapping out the sys.stdout/sys.stdin with my custom interceptors to do this manually... barely works, slow, ugly as hell and complicated.
[0] https://github.com/thejoshwolfe/consoline
[1] https://github.com/erlang/otp/blob/90a48ae2bff26d5df67ceaa7e...
Tuples can be up to 16,777,215 elements,
so quite substantial applications.
https://www.erlang.org/doc/system/system_limits
There is also some hope that future versions
of the Erlang compiler will allow mutable O(1)
update of tuple elements through setelement
(code inside a process is - almost - guaranteed
not to have shared references).
Safe destructive update of tuples has been implemented
in the compiler and runtime system. This allows the VM to
update tuples in-place when it is safe to do so, thus
improving performance by doing less copying but also by
producing less garbage.
https://github.com/erlang/otp/releases?q=27&expanded=true
It should be possible to add Elixir syntactic sugar to make this more concise and natural.
In Elixir GotchasAsk HN: Elixir LSP doesn't work on VSCode and Neovim. Any solutions?
I have tried installing Elixir+Erlang through Homebrew (as instructed by the official Elixir website): https://elixir-lang.org/install.html#macos
I also tried uninstalling them and installing through ASDF and I made sure that they both had the same version (27) as mentioned in this article: https://elixir-ko.github.io/install.html
This Issue mentions that Elixir may be incompatible with the most recent OpenSSL versions, but I don't want to downgrade OpenSSL: https://github.com/erlang/otp/issues/4577#issuecomment-925962048. Also: https://elixirforum.com/t/elixirls-cannot-connect-to-server-in-vscode/55345/8
I also did every tip mentioned on the Github page of the Elixir LSP: https://github.com/elixir-lsp/elixir-ls?tab=readme-ov-file#troubleshooting
Several hours later, I still can't use the Elixir LSP in VSCode. This is the error I keep get
Read the rest
ting:
```
Client ElixirLS - elx: connection to server is erroring. Header must provide a Content-Length property. {"{\"jsonrpc\"":"\"2.0\",\"method\":\"window/logMessage\",\"params\":{\"message\":\"Running in /Users/<me>/Downloads/LLM/elx\",\"type\":3}}Content-Length: 130"} Shutting down server.
```
And
```
Client ElixirLS - elx: connection to server is erroring. Header must provide a Content-Length property. {"{\"jsonrpc\"":"\"2.0\",\"method\":\"window/logMessage\",\"params\":{\"message\":\"Started ElixirLS v0.21.3\",\"type\":3}}Content-Length: 121"} Shutting down server.
```
And
```
Client ElixirLS - elx: connection to server is erroring. Header must provide a Content-Length property. {"\u001b[6 qcontent-length":"103"} Shutting down server.
```
This isn't supposed to be like this, and a search on Google shows many people have this problem. I like Elixir and BEAM, but the tooling is not comparable to Rust, Haskell, Go, etc.
Even with Python (which has one of the worst toolings), all I need to do before using the language is:
1. Install Python through Homebrew or a binary.
2. Install the plugin on VSCode.
3. Profit.
Cool, they've added support for long message queue monitoring: https://github.com/erlang/otp/pull/7651
In Erlang/OTP 27.0 ReleaseThere are more benchmarks and quite a bit more detail here: https://github.com/erlang/otp/pull/8111
In The Optimizations in Erlang/OTP 27Even some BIFs and NIFs (BIF are mostly just an built-in NIFs) can yield [1]
and choose to reschedule themselves later. But inside the C code it is voluntary, of course. An example of this can be seen when running hash functions [2].
Another interesting idea is that a NIF which may not reschedule themselves with yield, can still signal the scheduler that they are consuming so many "reductions" if they did some lengthy work. So if, say, they run for 10 msec, they might want to bump the reduction counter a bit: enif_consume_timeslice. Otherwise a tight recursive loop calling the same NIF could still effectively block the VM.
[1] https://www.erlang.org/doc/man/erl_nif#enif_schedule_nif
[2] https://github.com/erlang/otp/blob/ab7b354c37dac92704faac455...
[3] https://www.erlang.org/doc/man/erl_nif#enif_consume_timeslic...
In Scheduling Internals> I think the idea was that Elixir was going to be a boon to Erlang and other languages in there over time but I think it's demonstrably pretty useless as a BEAM citizen except for some of the patches they've submitted
Not sure whose idea it was but I would say this is a very inaccurate take. Of course, we have taken much more from Erlang than given (that's expected from hosted languages), but I personally sit on more than 100 PRs to Erlang/OTP. I made binary matching several times faster by using SIMD. I improved the compiler performance (including Erlang programs) by (conservatively) 10-20%. I contributed compiler optimizations to reduce memory allocation. There is a now faster sets implementation which I contributed. Erlang/OTP 26 ships with faster map lookups for atom keys based on a pull request I submitted. The new logger system in
Read the rest
Erlang takes ideas from Elixir logger. The utf-8 string handling in Erlang is based wholesale on Elixir’s (and extended for lists). And this is in no way a comprehensive listing [1].
And this is not counting everyone else in the Elixir community who contributed and those who are now actively working on Erlang tooling and were on-boarded to the ecosystem via Elixir. The Erlang ecosystem now has a package manager [2], used extensively by both languages, rebar3 and Mix, all implemented and powered by Elixir.
And then there are efforts like the Erlang Ecosystem Foundation, which is made of developers and sponsored by companies working with both languages, and it delivers important projects around observability, documentation, and more. For example, you can find several Erlang projects now using ExDoc for documentation, such as Recon [3].
That’s my take. What are your demonstrations that we are pretty useless for the BEAM ecosystem?
1: https://github.com/erlang/otp/pulls?q=is%3Apr+author%3Ajosev...
2: https://hex.pm/
3: https://hexdocs.pm/recon
The BEAM VM (Erlang/Elixir) recently optimized a related procedure as well https://github.com/erlang/otp/pull/7426
In Packing a string of digits into an integer quicklyShowing the 15 most recent of 93 sources. Enable JavaScript to search and browse every indexed mention.