As of Erlang R15B, the full set of version string tags is:
[64-bit]
The BEAM emulator is built to make full use of a 64-bit CPU.
[64-bit halfword]
Added as an experimental feature in R14 and considered stable as of R14B02, it means the emulator is built to support a 64-bit CPU, but that it uses "halfwords" (32-bit values) to address almost every class of memory managed by the emulator. The main exceptions are the biggest bulk users of RAM, ETS tables and off-heap binaries. This makes the emulator faster while still being able to address more than 4 GB of RAM at a time.
The halfword emulator is currently incompatible with the HiPE feature. This limitation may be removed in the future.
Enable this with the --enable-halfword-emulator option to the configure script.
[async-threads:0]
This refers to the number of blocking system calls that can be
running at once in the background. The default is 0, which means that
any system call can block an Erlang emulator thread. You can enable the
thread pool by passing the emulator an argument greater than 0 with the +A option. Beware that at least one test
showed that it has a negligible performance advantage. That is probably
why it defaults to 0. You should only enable this feature if testing
shows that it helps your particular workload.
[debug-compiled]
The emulator was built such that it can be run under a native debugger.
[hipe]
The emulator was compiled with the HiPE feature enabled, which is an on-the-fly native code compiler for Erlang. It only works on the most popular CPU types that Erlang supports, and it doesn't work with all configurations even on those CPUs, which is why it's optional.
[hybrid-heap]
Appears if you passed --enable-hybrid-heap to the configure
script. It affects how the emulator deals with data shared among
multiple processes. The hybrid heap is more complex to manage, but
avoids multiple copies of shared data, which can be a net advantage when
your program has lots of shared data.
[incremental GC]
Appears if the hybrid heap option is enabled and you have also uncommented the #define INCREMENTAL line in erts/emulator/beam/erl_vm.h. Apparently an experimental feature.
[kernel-poll:false]
The Erlang emulator code knows several different ways to ask the OS's
network stack which of a set of file descriptors and sockets are
available for I/O. The only one that works pretty much everywhere is the
old BSD select() call which is relatively slow due to its
design, and has other scalability issues besides. So, most systems have
one or more faster and more scalable replacements — e.g., kqueue, epoll(), etc. — but none of them is supported everywhere. When the emulator startup message says false here, it can mean either that kernel polling isn't available or that it is but you did not pass +K true to erl.
[lock-checking]
Appears if you passed --enable-lock-check to the configure script.
[lock-counting]
Appears if you passed --enable-lock-counter to the configure script.
[no-c-stack-objects]
This can only appear if you have built the BEAM emulator in a nonstandard way, defining two constants in a way that can only happen if you have hacked the Erlang source code. It says the new 64-bit halfword heap code isn't being used, but heap allocations are being done at least partly the way the halfword heap code works. My guess is that this configuration is only intended for use in development to isolate two bits of behavior from each other to make them easier to test and debug.
[purify-compiled]
The emulator was compiled with Purify support.
[rq:2]
Means 2 run queues, a new feature as of R13, allowing Erlang to make better use of multi-core machines. The first SMP-capable versions of Erlang had multiple schedulers (e.g. [smp:2]) but a single shared run queue, which limited scalability.
[smp:2:2]
The [smp:2] tag changed to this format in Erlang R13, meaning 2 schedulers, both of which are online. If you say "erl +S1", it says [smp:1:1] instead. You can take schedulers offline at runtime with erlang:system_flag(schedulers_online, N), where N can be anything between 1 and the number of cores detected, inclusive.
[source]
It means some third party (maybe you, maybe your OS distro's package mantainer, maybe your sysadmin) built Erlang from source. The alternative is downloading an official binary version from Erlang.org.
[type-assertions]
Appears when you uncomment the ET_DEBUG line in erts/emulator/beam/erl_term.h, enabling runtime checking of all type-specific data accesses. Not enabled by default because it slows down the emulator.
[valgrind-compiled]
Appears when you build on a platform with Valgrind installed, and the configure script finds valgrind.h.
(This list comes from erts/emulator/beam/erl_bif_info.c in the Erlang OTP source tree.)
