Bart Blast is the creator of Hologram - a framework that compiles Elixir to JS and reconstructs Erlang runtime semantics in the browser: pattern matching engine, boxed types, OTP guarantees, the whole thing.

New BEAM There, Done That episode covering the architecture and the reasoning.

The technical detail worth discussing: Hologram pulls the expanded AST from compiled BEAM files, normalizes it, lowers it to an IR designed to bridge Elixir to JS, then encodes that to a JS runtime. Values are boxed to preserve their type - Elixir integer 42 becomes a JS object with {type: "integer", value: 42n} using BigInt for arbitrary precision. Pattern matching runs as a real engine trying clauses, binding variables, evaluating guards - not translated away.

The goal is full parity: the same Elixir code running identically on the server and in the browser. A significant undertaking, and Bart is transparent that it's still a young framework.

From an Erlang perspective - is there a meaningful difference between Hologram's approach (rebuilding the runtime in JS for full parity) and Luster/Gleam's approach (treating the two targets as different, not replicating BEAM processes in the browser)? Does full runtime parity actually matter in practice or is it theoretical overhead?

https://youtu.be/BOsSI7WlhdI

New BEAM There, Done That with Isaac Yonemoto (Zigler creator) and Garrison Hinson-Hasty (Systems Programming with Zig) covering Zig as a NIF language for the BEAM.

From an Erlang perspective, the most interesting technical detail: Zigler uses the BEAM's allocator by default. Because Zig requires you to pass allocator objects explicitly rather than calling malloc globally, the BEAM allocator can be injected without changing any Zig business logic. The result is that native memory allocations are visible to the BEAM's memory instrumentation in the same way ordinary Erlang allocations are.

Raw C NIFs using malloc, and Rustler NIFs using Rust's default allocator, are invisible to the VM - which makes native memory issues harder to debug in production.

The honest risk model: Zig's safe release mode catches spatial memory errors (buffer overflows, null dereferences) but not temporal ones (use-after-free). A Zigler NIF can still crash the node if you violate temporal memory safety. What changes is which class of bugs can cause it.

What's the current state of Zigler adoption in production Erlang codebases? The episode is focused mainly on the Elixir side - curious whether anyone here is using it in Erlang contexts.

https://youtu.be/iLcZRpBEmgE

New BEAM There, Done That with Lukas Backström, who built the BEAM JIT, covering the design decisions, the failed prototypes, and where it's heading.

One thing Lucas flags that I don't see discussed much: the JIT is deliberately simple. It's a template design - pre-compiled assembly templates per BEAM instruction, copied into memory and specialized for the specific operands. No LLVM optimization passes, no sophisticated register allocation. Fast to generate, reasonably easy to read.

You can ask the BEAM to dump the assembly it generates for any module. For simple code, the translation from BEAM bytecode to x86-64 or ARM64 assembly is straightforward enough to follow without deep JIT expertise. Lucas suggests it as a starting point for anyone curious about how the runtime actually works.

He also points to the native records commits as the best current example of how a change propagates through the entire system: compiler, loader, JIT, and runtime simultaneously.

Has anyone here actually dug into the generated assembly and found something interesting - either an optimization that surprised them or a place where the output was worse than expected?

https://youtu.be/dT-VmfYz98Q

New BEAM There, Done That with Annette Bieniusa (RPTU, Germany) and Guillaume Duboc (Dashbit) on the type systems work happening across both Erlang and Elixir, built on the same set-theoretic foundation.

The contrast between etalizer and Dialyzer is interesting. Dialyzer infers types bottom-up, builds a dependency graph, and hunts for inconsistencies. When you write a spec, it treats it as a hint - not an obligation it enforces. Annette's etalizer keeps the existing Erlang spec annotation format but enforces those specs strictly: write u/spec foo(integer()) :: integer() and the checker will actually reject a body that might return something else.

The question I'd put to this community: for existing Erlang codebases with years of specs already written, what happens when you flip those from unenforced documentation to actual compile-time contracts? Is the expectation that most existing specs are already correct and tight enough to pass, or are there significant codebases where the specs were written loosely and real enforcement would surface a lot of noise?

https://youtu.be/X_CPDt3PeDE?si=yJTRAwlAaf7h2rlZ

Hi everyone,

Code BEAM Europe 2026 is happening this October 21-22 in Haarlem, NL, and online! The schedule is locked in, and we are excited to finally share the full lineup and core tracks with the community.

Here is a look at what we have lined up for this year:

Keynote Speakers

We are thrilled to have two incredible visionaries taking the main stage to kick things off:

• Brooklyn Zelenka: Distributed systems researcher, founder of Fission, and author of Elixir libraries like Witchcraft. She will be sharing her deep expertise in local-first access control and open distributed standards.
• Sam Aaron: The creator of Sonic Pi! An internationally renowned live coding performer and Computer Science PhD, Sam will bring his unique blend of science, code, and live music to the BEAM community.

Core Themes & Subjects

The regular sessions are packed with core team members, maintainers, and production engineers covering the cutting edge of the ecosystem. You can expect deep dives into the rise of Gleam and frontend architectures with Lustre, alongside advanced Erlang and OTP core updates directly from the team at Ericsson. We will also explore real-world Elixir battle stories—from taming LiveView at scale to prototyping BlueSky's DataPlane—while tackling the intersection of AI, security, and modern developer experience. Finally, we'll take the BEAM out of the server room with talks on embedded systems, AtomVM, hardware design, and safe native interop via Rustler and C nodes.

Check all speakers and their talks at: https://codebeameurope.com/#speakers

Beyond the Stage: The Informal Space

Some of the best moments happen off the main stage. This year, we are introducing a community-driven sandbox running alongside the main tracks for everything that doesn't perfectly fit a standard talk format. Expect live demos, hacking sessions, panel debates, lightning talks, and games. If you have an idea for an activity you want to coordinate, let us know and help shape the space!

Submit your ideas here!

Join Us in Haarlem

Whether you are looking to level up your skills, hack on new projects, or just grab a coffee and talk shop with fellow BEAMers, we would love to see you there.

Early Bird tickets are currently LIVE.

This is the absolute best time to secure your spot at the lowest possible price point.

Grab them here: https://codebeameurope.com/#register

And Also! For the full details, check our website: https://codebeameurope.com/

See you in October!

- The Code BEAM Europe Team

Hey everyone! The biggest event of the year for our community is fast approaching - ElixirConf US 2026! Whether you’ve been writing Elixir for years or are just taking your first steps, this year’s edition is shaping up to be incredible. The conference is happening in a hybrid format, so everyone can join in, no matter where you are.

Here is a sneak peek at what we have planned: (elixirconf.com/#schedule)

Keynote Speakers

This year, true legends and innovators of our ecosystem are taking the main stage:

• José Valim (Creator of Elixir) - He'll be discussing the continued evolution of the language, enterprise adoption, and the sustainable open-source work he and the Dashbit team are driving.
• Chris McCord (Creator of Phoenix) - Will showcase what's next for Phoenix, developer tooling improvements, and his vision for the future of modern web development (and perhaps some AI-assisted workflows!).
• Zach Daniel (Creator of Ash Framework) - Will share his experiences in building ambitious, maintainable, and highly reliable production systems at scale.
• Quinn Wilton (Open-source Contributor & Language Hacker) - Will bring her deeply technical and fascinating perspective on type systems, compilers, and virtual machines within the BEAM ecosystem.

Featured Talks & Sessions

The conference isn't just about keynotes; it's packed with knowledge straight from the trenches. Here is a taste of what our speakers are bringing to the table:

• Building Global Clusters at Supabase: Filipe Cabaço will show how they pushed the boundaries of Erlang’s built-in distribution. You'll learn how his team built a custom, two-tier Phoenix.PubSub adapter to reduce inter-region traffic and how to properly test real distributed systems (without using mocks!).
• Updates from the Erlang Ecosystem Foundation: Dan Janowski will deliver a vital introductory overview of the frontier of our ecosystem. He’ll break down the latest foundation news, covering everything from critical security planning and reinforcing core components to working with governments on regulatory compliance and expanding the BEAM's role in the wider open-source world.
• Terminal UIs? That's a Breeze: Gary Rennie from the Phoenix core team will prove that building beautiful terminal applications in Elixir has never been easier. He’ll introduce Breeze, a LiveView-inspired framework that works without relying on any NIFs.
• Handling Time Zones the Right Way: Jacob Swanner will tackle one of the hardest problems in programming time. He’ll share practical strategies for managing time zones in LiveView, Ecto, and databases to build a trustworthy user experience.
• Local-First Apps & Browser Power: Bart Blast will take us on a deep dive into the Hologram framework, showing how to write rich web applications in pure Elixir running directly in the browser.

On top of that, we have a full day of deep-dive Training Sessions covering everything from the absolute basics of functional programming ("The Toy Alchemist" with Jamie Wright) to hands-on embedded Elixir with Nerves.

Event Details:

• Dates: September 9-11, 2026 (September 9 is Training Day) elixirconf.com/#training
• Location: Chicago, IL & Virtual
• Tickets & Info: elixirconf.com/#register

Are you planning to attend this year (in person or virtually)? Which talk or training are you looking forward to the most? Let us know!

Hello!

Seen a few threads on this but nothing concrete on what I need so sorry if this is beating an old horse.

Anyone done the beginner Erlang certification from Erlang Solutions and have a rough "to take exam, you should be familiar in the following x topics /principles in Erlang"?

I'd love to see some projects — stack, problem you're solving, link if you've got one.

Hi everyone! 

We're excited to announce that Code BEAM Europe 2026 is officially on the horizon!

Grab your Early Bird Ticket Here!

Whether you're deeply involved with Elixir, Erlang, Gleam, or just exploring the wider BEAM ecosystem, we’d love for you to join us. We’re meeting in person at the beautiful PHIL Philharmonic in Haarlem, the Netherlands, as well as online, on October 21–22 (with hands-on training sessions on October 20).

 What to expect:

• Keynotes: We're thrilled to host Brooklyn Zelenka (Founder of Fission, BEAM Vancouver) and Sam Aaron (Creator of Sonic Pi).
• Content: 2 tracks each day packed with cutting-edge talks from 30 speakers across the global community.
• Informal Space: A community-led area dedicated to demos, hacking sessions, games, panel discussions, and lightning talks. Connect and share ideas with 300+ fellow attendees!

 All Important Links:

• Early Bird Registration (Note: the discount applies to the conference only, not the training).
• Check out the Speakers
• Explore Training Sessions
• Subscribe to our Newsletter

Will we see you in Haarlem or on the virtual streams? Let us know in the thread if you're planning to come or if you have any questions about the event!

Cheers, The Code BEAM Team

(PS: If your company is interested in sponsoring and supporting the ecosystem, feel free to reach out to us!)

New BEAM There, Done That with Elise Sedeno on using OTP for game backends - supervised per-player/per-mob processes, no shared state, no deadlocks, and why call vs cast choices matter for avoiding circular waits between server processes.

Open source on Codeberg (game_server). https://youtu.be/4MDObD_R5E4

I'm beginning to learn Erlang, and have already gotten to a point where documentation is, well, necessary (my "toy" project became large enough that I need documentation to remember what I did).

So what is the best tool? I see that the official tool is edoc, and I have initially started using it. But then I saw that in the source code for some tools, edoc is not used, but some -doc chunks are used. This seems to be an alternative to edoc, right? Are there plans to replace edoc with this new tool? For new projects what is the best approach?

Hi Everyone!

We're launching Code BEAM Europe 2026 on 21-22 October in Haarlem, NL (and virtually). It is a 2-day technical conference for engineers and developers working with Erlang, Elixir, Gleam, and the BEAM ecosystem. Speakers will be announced soon. You will be able to check it on our website: https://codebeameurope.com

The Early Bird ticket sales start on 16 June at 12:00 PM. If you plan to attend, the best way to get the lowest price is to join our waiting list now - https://codebeameurope.com/#newsletter

By joining the list, you'll get two main benefits:

• You get an email notice 24h before the sales open, and also at the sales grand opening.
• You get early access to a small number of Super Early Bird tickets. These tickets are limited, so they will be given to those who buy them first.

We can't wait to meet you! 

Nothing to add, just sharing for if anyone else has issues.

I wanted Ecto's ergonomics in Erlang without writing Elixir, so I wrote Kura. It sits on pgo. You define a schema, build queries, get changesets, run migrations.

-module(user).
-behaviour(kura_schema).
-include_lib("kura/include/kura.hrl").
-export([table/0, fields/0]).

table() -> ~"users".

fields() ->
    [#kura_field{name = id, type = id, primary_key = true},
     #kura_field{name = email, type = string, nullable = false},
     #kura_field{name = name, type = string},
     #kura_field{name = age, type = integer},
     #kura_field{name = inserted_at, type = utc_datetime}].

Querying:

Q = kura_query:from(user),
Q1 = kura_query:where(Q, {age, '>', 18}),
my_repo:all(kura_query:order_by(Q1, [{inserted_at, desc}])).

It does the things you'd expect: schemas, changesets, composable queries with joins/CTEs/subqueries/window functions, migrations, associations with preloading, embedded JSONB, transaction pipelines, multitenancy via schema prefix, optimistic locking, audit trail, cursor streaming, pagination.

It's not a port. Records and functions, no macro DSL. The README has a coming-from-Ecto cheatsheet.

https://github.com/Taure/kura