BEAM is the abstract register machine that executes Erlang instructions; ERTS is the larger Erlang Runtime System around it. That distinction matters: processes, ports and ETS tables are runtime concepts, not features modeled directly by BEAM. In current OTP documentation, code can run through a traditional interpreter or, on supported builds, BeamAsm’s load-time JIT.
What is the BEAM virtual machine?
BEAM is the abstract machine for Erlang code. As Erlang/OTP developer John Högberg puts it, “BEAM is a register machine, where all instructions operate on named registers.” Its instructions describe operations on registers, calls, branches and other execution steps.
ERTS, the Erlang Runtime System, supplies the broader environment in which BEAM code runs. The distinction is more than terminology: the official BEAM primer says the machine itself has no notion of processes, ports or ETS tables. Those belong to the runtime surrounding the instruction set.
How does the BEAM VM work?
From Erlang source to loaded code
The Erlang compiler turns source modules into object code, commonly stored in .beam files. ERTS loads modules through its code-loading machinery. The suffix reflects the name of the abstract machine that executes the compiled instructions; it does not mean that a file is already native machine code.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
During the OTP build, the beam_makeops script uses instruction definitions to generate source used by the compiler and runtime. The documentation distinguishes external generic instructions, internal generic instructions and specific instructions. Generic instructions provide a more general representation; when code is loaded, the loader maps them to specific instructions suited to the runtime implementation. The interpreter and BeamAsm JIT have separate implementation paths. See the official beam_makeops documentation for the instruction-generation details.
Registers, arguments and results
BEAM uses two register groups with different roles. X registers hold temporary values and are used to pass function arguments and return results. Y registers belong to stack frames and hold values that need to remain available across calls.
Rank #2
Arguments are placed from left to right beginning at {x,0}; a function’s result is returned in {x,0}. The machine’s register model gives instructions a concrete way to refer to values without making those values synonymous with operating-system registers or Erlang processes.
Following a compiled instruction sequence
To inspect compiler output, compile a module with erlc -S; this emits an assembly listing alongside the usual compiled output. A simple list-processing function’s listing can be read as a sequence: test a value’s type or shape, branch to a failure label if the test fails, call a function on the success path, and return its result. The primer’s sum_tail example walks through this style of test, branch, call and return. The listing is useful for understanding instruction flow, but it is not a promise that every source construct compiles to the same sequence in every OTP release or execution engine.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWhat is the difference between the interpreter and BeamAsm?
Both are ways for ERTS to execute loaded BEAM code; they differ in how instructions are implemented. In the traditional path, the runtime interprets BEAM instructions. In the BeamAsm path, documented for OTP 29.1.1, instructions are converted to native code at load time on supported x86-64 and aarch64 builds.
| Execution path | How loaded code is executed | Support and memory context |
|---|---|---|
| Traditional interpreter | The runtime executes instructions through the interpreter implementation. | The OTP 29.1.1 BeamAsm reference compares BeamAsm code memory against interpreter code memory; it does not give a universal whole-node memory figure. |
| BeamAsm JIT | BEAM instructions are converted to native code at load time. | OTP 29.1.1 documentation names x86-64 and aarch64. It reports about 10% more loaded code memory than the interpreter, a code-memory comparison rather than total process or node memory. |
These are version- and build-dependent implementation details, not a guarantee that every installation uses BeamAsm. Consult the OTP 29.1.1 BeamAsm reference for current documented support and configuration information. It describes load-time conversion and little optimization across instruction boundaries; BeamAsm should not be confused with a continuously profiling, profile-guided optimizing JIT.
Does BeamAsm make Erlang programs faster?
The fact that instructions become native code is not enough to establish a speedup for a particular application. Results depend on the workload, OTP version, architecture, build configuration and runtime settings. The cited OTP documentation does not establish one performance gain that applies to all programs, so compare representative workloads on the systems that matter to you.
For a meaningful comparison, record the OTP release, processor architecture, build and runtime flags, workload, and measurement method. Keep the same conditions when comparing execution paths; otherwise a difference cannot reliably be attributed to the JIT.
Recommended Free Tools
Inspecting JIT execution with Linux perf
The BeamAsm guide documents a Linux perf workflow for examining generated native code. It covers enabling JIT profiling support, then collecting and reviewing data with perf record and perf report. Call-graph collection and transitions between Erlang and C code have caveats, so a profile may not present a complete or effortless picture of execution. Use the official profiling guidance for the relevant runtime options and limitations.
How does Erlang code loading affect running processes?
Erlang/OTP supports module-level code replacement rather than requiring every process to stop for a new module version. Current and old code can coexist, and a process may still be executing old code while new code is available. A fully qualified call can move execution to the current version.
This is not unlimited version retention: the system handles current and old code, and an additional version requires the old version to be purged. The precise behavior and operational implications are described in the OTP 27.3.4.18 code-loading documentation.
Are Erlang processes operating-system processes?
No. Erlang processes are lightweight runtime entities, not one operating-system process apiece. The process guide describes them as lightweight relative to OS threads or processes. Its OTP 29.1.1 example reports 327 words for a newly spawned Erlang process, including 233 words for the initial heap area. Those numbers describe the guide’s example and runtime context; they are not a universal per-process cost or a substitute for measuring a particular application. See Processes in the Erlang System Documentation v29.1.1.
Quick Recap
What to keep in mind when reading about BEAM
- BEAM and ERTS are not interchangeable: BEAM is the instruction-executing abstract machine; ERTS is the surrounding runtime.
- Execution details vary by implementation: the loader and runtime can transform generic instructions into specific ones, with separate interpreter and JIT paths.
- Release and build matter: BeamAsm architecture support and configuration should be checked against the OTP documentation for the version in use.
- Measure the application, not the label: neither native conversion nor a documented code-memory comparison proves an application-wide speed or memory outcome.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
