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.)