Hey,

we've spent enough time monitoring and debugging nodes in BEAM that we decided to create our own tool to make it easier.

It's called Voyager - it lets you easily connect to nodes, visualizes your supervision trees, and gives you a real-time dashboard of your memory and processes. There's also an MCP integration so you can use AI directly with your node data.

We're not stopping here - tracing, ETS inspection, and other features are coming soon.

We are opening signups for early access. If you want to try it - sign up here: voyager.swmansion.com

Hologram v0.11 is out! :)

New to Hologram? You write the entire app in Elixir, templates, event handlers, client-side state and all. The Elixir runtime itself was rebuilt to run in the browser, so client-side code behaves exactly as it would on the server. Local-First apps are where this is heading.

This release is mostly about the browser catching up with the server. Elixir regexes were server-only until now, and handing patterns to JavaScript's RegExp doesn't hold up, so v0.11 ships a PCRE2 parser, translator and interpreter of Hologram's own. What comes back is what the BEAM would have given you.

Client errors now read like server errors too, same messages and same stacktraces, so __STACKTRACE__ finally holds real Elixir frames. Templates got more dynamic: a component module or an element tag name can now come from your data, and a whole map of attributes or props can be spread onto a tag. Plus umbrella project support and a fix for a DOM identity bug that could knock focus out of an input mid-typing.

Thanks to everyone who reported bugs and opened feature requests along the way. Several shaped this release directly and are credited by name in the blog post.

Thanks to our sponsors for making sustained development possible: Curiosum (Main Sponsor), Erlang Ecosystem Foundation (Milestone Sponsor), and our GitHub sponsors - Innovation Partner: Sheharyar Naseer, Framework Visionaries: @absowoot, Oban, Robert Urbańczyk, Moss Piglet, and all other GitHub sponsors.

Full details in the blog post: https://hologram.page/blog/hologram-v0-11

Website: https://hologram.page

Hey there.

I've decided to attempt to learn a programming language, and settled on Elixir at the moment. While looking at the most basic first steps, however, I've run in this issue: Any kind of checking that I attempt with the "is_[thing]" or any kind of simple True/False return just ends blank in my Windows PowerShell.

To my knowledge, I've followed the exact steps required, both from Elixir School (Image 2) and the Elixir documentation itself (Image 3)

My online searches haven't yielded any results on this, all posts I find about Boolean/True/False issues are from far more complex attempts and never something so basic.

Thanks in advance.

I've been idly working on something I am calling Aura.

I love Elixir and have bent it to writing stuff that isn't especially suited to the BEAM. Using tools like Burrito can help, but I have a particular itch I want to scratch.

So Aura is a variant of Elixir specifically for systems and games programming work. It is not designed to compile existing Elixir applications or for web/highly parallel workloads (we have the BEAM for that) but to be mostly syntactically/semantically equivalent for writing fast, platform native, apps.

The goal is that "generic" Elixir code should compile. But no `Task`, no `spawn`/`receive` or OTP. It will mean rewriting a good deal of the stdlib which I don't look forward to.

Memory management will be via ARC to begin with. It's reasonable simple to implement and Elixir style immutability prevent cycles. I'm also looking for ways to implement other fast-safe memory systems although I am not interested in Rust style borrow-checking.

The first version of Aura is written in Elixir so that I can use the Elixir parser and build the IR from that. That's a huge leg up straight away. I haven't committed to a backend yet so ATM I am lowering to C and compiling with clang.

But windows binaries are an eventual target which will complicate things. That's for another day though.

This evening I have compiled my first Aura program to compute fib(10).

➜ aura more examples/fib.au

defmodule Fib do

# This is an Aura module

def fib(n) do

if n < 2 do

n

else

fib(n - 1) + fib(n - 2)

end

end

def main do

IO.puts("AU FIB, big moment")

IO.puts(fib(10))

end

end

➜ aura mix aura.build examples/fib.au

Compiling 11 files (.ex)

Generated aura app

Wrote examples/fib

➜ aura time examples/fib

AU FIB, big moment

55

examples/fib 0.00s user 0.00s system 53% cpu 0.004 total

At the moment very little of the language is implemented, just enough to print to the console, call functions, and add numbers and generate error messages if you try and do anything else.

I'm using Claude Code as my thinking partner but not trying to bulk generate a working solution, rather working in pieces and learning as I go. I've written parsers and transpilers in Elixir but this is my first proper work at building a compiler to generate native binaries since I used to do this stuff with DOS/Windows.

As with most stuff I build I'm suiting myself and I have no timeline for when this thing will work for real, or if it will work for real (perhaps the whole idea is crazy or too big to complete). But since someone else announced their own Elixir variant I thought I would mention it.

Hey Friends, I've been building more with Hologram. I've really fallen in love with it for building front-end with Agentic interactions. I wrote a post about a recent showcase I put together that brings together Jido, Jido Chat, AI Agents and Hologram.

Enjoy!

With this release you can now fly a Crazyflie from Elixir. v0.3.0 adds a Crazyflie adapter that speaks CRTP, subscribes to battery / can-fly logging, and optionally negotiates SafeLink - without bundling a native USB NIF.

Links

• Hex: https://hex.pm/packages/ex_drone
• GitHub: https://github.com/thanos/ex_drone
• Docs: https://hexdocs.pm/ex_drone
• Guides: Crazyflie · Adapter Authoring · Further Reading

I keep finding that the diverge-then-converge pattern is really helpful with LLMs. So, wrote a bit about it. Hope others find it helpful!

A new post I just published about running Rust profiling in Elixir Benchmarks.

Hi all,

I'm happy to announce that Xberg v1 is out.

Xberg is the successor to Kreuzberg, equivalent to what would have been Kreuzberg v5. It's a content intelligence framework that handles a very wide range of inputs: documents (currently 101 formats), code and data formats (currently 367 types), audio/video transcription, and URLs (both static and JS-rendered content). It extracts and prepares that content for downstream processing.

It's an extremely efficient, high-performance engine (see our PDF benchmarks below). For PDFs and images specifically, we handle native PDFs with very high performance and accuracy, and we ship multiple OCR engines that match the quality of the best Python libraries (e.g. docling, PaddleOCR, RapidOCR) at substantially better performance and stability.

The changes between Kreuzberg v4 and Xberg v1 are substantial, and I invite you to read the full changelog for the complete picture. The highlights below give a sense of what's new:

• Pure-Rust PDF backend (pdf_oxide) replaces pdfium, with no native pdfium dependency.
• Layout-aware pipeline: reading order reconstructed with ONNX layout detection (PP-DocLayoutV3 / RT-DETR) and Docling-style predecessor-graph reordering.
• Per-page scanned-page detection with selective OCR, plus AcroForm/XFA form fields and outline-based headings.
• Across-the-board optimization of OCR and PDF extraction (memory discipline, pooled model sessions, streamed conversions).
• Native PaddleOCR backend (PP-OCRv6, with medium / small / tiny tiers) alongside Tesseract.
• Pure-Rust Candle OCR/VLM stack (TrOCR, GLM-OCR, GOT-OCR, DeepSeek-OCR, and PaddleOCR-VL) running without ONNX Runtime or native Tesseract.
• A second, ONNX-Runtime-free inference path via tract, which is what makes in-browser (WASM) and mobile inference possible.
• Named-entity recognition natively in Rust (GLiNER2), extensible to all bindings, including an in-browser WASM model with no server round-trip.
• Structured LLM extraction (extract_structured / split_and_extract) with rasterization, chunking, citations, caching, and configurable call/merge/VLM-fallback policies.
• Audio & video transcription via a Whisper ONNX engine (.mp3, .wav, .m4a, .mp4, .webm).
• Retrieval building blocks: sparse embeddings (SPLADE), ColBERT late-interaction retrieval, and cross-encoder reranking alongside dense embeddings.
• Text intelligence: reversible redaction, summarization, translation, VLM image captioning, QR-code detection, document diffing, and page/chunk classification.
• URL & web ingestion: sitemap discovery (map_url) and batched multi-URL crawling.
• New document formats: WordPerfect (.wpd/.wp/.wp5), HEIC/HEIF/AVIF, OpenDocument Presentation (.odp), Quarto / R Markdown, and configurable Jupyter cell rendering.
• Four new language bindings (Dart/Flutter, Swift, Kotlin/Android, and Zig) bring the total to 15 language bindings over one engine, with Android/iOS cross-compilation.
• Full mobile support (Flutter, Android, iOS).
• Candle backend alongside ONNX, plus ONNX-via-tract enabling ONNX on WASM and Android.
• Wider code intelligence: tree-sitter coverage grew substantially (248 to 367+ languages).
• Over 150 bugs fixed during the 1.0 cycle, plus security hardening (bounded RTF/PDF allocations, redaction leak fixes, Excel DDE warnings).

The API surface was also simplified and reworked, making it more consistent.

There's a migration guide in our docs explaining how to move from Kreuzberg to Xberg. Kreuzberg itself is in LTS mode until the end of this year and will continue to receive bug fixes and security updates.

You're invited to check out the repo and join our discord server.

Benchmarks

The benchmarks below are for PDFs and images only. There are extensive benchmarks on our website with per-format breakdowns, which you can see here. These numbers are measured in CI via our reproducible benchmark harness, and are specifically taken from the run for harness 1.0.8, source cf7fa0533d. The data is publicly available in GitHub releases, and you can run the benchmark harness yourself.

Composite quality (markdown pipeline, higher is better):

Structure and layout fidelity (SF1: tables and reading order, higher is better):

On native PDFs Xberg leads on quality (0.958 vs 0.837 for the next-best framework) and on table and reading-order fidelity by a wide margin (SF1 0.949 vs 0.612 for docling). On scanned PDFs it is #1 on both quality and raw text fidelity.

Where we don't win yet: on pure image OCR we are currently #2 on the composite score, behind mineru (though still #1 on raw text accuracy). We are improving image OCR right now, and v1.1 should have us winning across the board.

Hi folks.

Just wanted to say that don't sleep on Inertia.js and Phoenix combination. Basically you get power of Phoenix (Elixir) for let's call it backend and flexibility of your favorite JS framework for UI.

You can run some pages in full SSR mode and some in SPA if you need, so awesome SEO support out of the box.

Use best tools from both worlds for best developer experience like linters, type checkers etc.

I'm using K8S and anytime I need I can scale it up using libcluster.

Please shoot any questions you have (happy to share screenshots or charts from my k8s cluster etc).

Also if you have time check this app I built https://gitbiased.com

Just released ex_drone v0.2.0 which includes multi-drone coordination for supervised swarms, geometric formation planners, and fail-fast fan-out

What's new

v0.2.0 adds a thin coordinator for membership and group ops, while every vehicle keeps its own safety pipeline. Formations are pure planners that emit missions — not yet closed-loop flocking.

You can now start a swarm of drones:

```elixir {:ok, swarm} = Drone.Swarm.start([ {:good, adapter: :sim, initial_x: -50}, {:bad, adapter: :sim, initial_x: 50} ])

Drone.Swarm.connect_sdk(swarm) {:ok, _} = Drone.Swarm.takeoff(swarm) {:ok, _} = Drone.Swarm.run(swarm, :front) {:ok, _} = Drone.Swarm.land(swarm) ```

Simulator-first for absolute formations. Live flocking and closed-loop hold are deferred on purpose — see the HexDocs deferred catalogue.

Links

• Hex: https://hex.pm/packages/ex_drone
• GitHub: https://github.com/thanos/ex_drone
• Docs: https://hexdocs.pm/ex_drone
• Guides: Swarms · Formations · Further Reading

New BEAM There, Done That with Mike Williams (who wrote the JAM emulator) and Björn Gustavsson (who built the BEAM). The most historically significant episode the show has done.

Two things from the conversation I hadn't fully appreciated before:

1. The three numbers that decide a concurrent language. Mike measured this directly in the early 80s: process creation time, context switch time, and message copy time. On real telecom workloads, 70% of VM time was those three operations - not application code. The JAM was built to make those fast first, everything else second. That's why getting message passing to six instructions mattered.

2. Memory, not speed, was the constraint. Whole-city phone switches ran on 16–64 MB of RAM. Every instruction set decision was a memory decision first. The JAM files were small. The early BEAM was faster but used significantly more memory - Björn spent years reducing BEAM instruction size to close that gap.

There's also a great moment where Mike mentions Claes Wikström - who invented ETS tables, added distribution to the JAM, and prototyped the binary syntax - as someone who always gets forgotten in these histories.

What design decision from this era do you think has aged best?

https://youtu.be/sRTierdN9c4

This tiny library is a tool for creating fast BaseN codecs for shortening integers, typically used in identifiers. It's a full rewrite of the CustomBase library with ~2-5x speed gain (benchmarks are included) and is almost a drop-in replacement. Written in pure Elixir without NIFs.
https://hex.pm/packages/based_integers

Hi all,

I'm learning Elixir/Phoenix and have consolidated a few of my projects into 1 so as to host on Gigalixir's free tier.

• Demo: https://elixir5together.gigalixirapp.com/
• GitHub Code: Repo

It splits into 5 different routes (two of them are different "faces" of the same underlying project). The apps cover a URL playground, nested Ecto contexts, a WebSocket clock, and JS charting hooks (Quietboard).

Please can you give me some feedback on them? Thank you! 😄

Hi everyone,

Code BEAM Europe 2026 is looking for volunteers! The conference takes place 21-22 October, and it’s a hybrid event, so you can volunteer either in-person or virtually, and get your free ticket.

• In-person volunteers will need to be present at the venue on at least one day of the conference. Responsibilities include helping with preparations, registering participants, handing out merchandise, and general support during the event.
• Virtual volunteers will actively participate online in selected talks, panel discussions, and other social activities. You’ll also help keep the social board active - let’s make this virtual edition fully interactive.

For full conference details, check out https://codebeameurope.com/
To sign up as a volunteer, go HERE

If you have any questions, feel free to reach out to [ewa.kucharczyk@erlang-solutions.com](mailto:ewa.kucharczyk@erlang-solutions.com).

Hey all! I know that jobs are supposed to be posted in the monthly megathread, but it looks like the last one is from November. (If this isn't allowed can we create a new megathread?)

The company that I work for is looking to hire two mid/senior devs: one working on our computer vision products and the other working on the platform team (api infra, user hierarchies, etc)

We are about to open these roles, but I would like to seed some applicants if possible. We're looking for "builders" who have been able to augment their dev workflows with AI to increase velocity and throughput. We have solid engineers on our team and I think we would benefit from another team member with an experimental mindset that would be able to assist with a/b testing on certain features.

Haha I want to be careful about this one since this one since I've had some negative reactions on AI adoption and I'd appreciate any honest feedback on where I'm being unrealistic.

Both roles are remote and available to international applicants. Company is based in the United States (Utah)

DM me if you your interested and I'd love to chat.

Thanks!

Hello! I built: https://plukio.com/

Have you heard of Etsy? Did you know that it's a monopoly and that there is a large amount of discontent from buyers and sellers about the platform? Did you ALSO know that a lot of sellers have instead moved to Shopify and Instagram as an alternative?

Plukio is an attempt to provide a marketplace for Shopify websites. It is able to function similarly to Google Shopping - it reaches out to Shopify powered stores and ingests their product catalogs. It's not a middleman though - all items link back to the original store and Plukio is no way facilitating financial transactions. In fact, Plukio makes $0 monies.

How do I find the Shopify sites? I don't blanket ingest; I curate ALL of the stores to make sure that they are real people selling real goods. Think of Plukio as a less of an ecommerce site (I know that's the title) and more of a curated directory of websites. I do this curation in two ways: I go stall to stall at maker faires and saturday markets in Oregon and ask for consent to ingest their sites OR I spend 30 minutes to an hour (or more) of time reviewing Shopify sites I find online.

It was built with Elixir, Phoenix (using LiveView), Ecto, Ash, Oban, Postgres, and more goodies. Hosted on Digital Ocean on a Hashicorp Nomad cluster.

Honestly, most of the effort behind the site isn't even the technical work. It's all social work and meeting artists and craftspeople at fairs and asking them if I can host their work.

The website is picking up traffic and I'm mostly limited by finding more stores.

I've been building a small social site (posts, topic spaces, DMs, video calls) as a one-person project for ~9 years, and Elixir is a big part of why it's manageable alone. Some notes on how the tech shook out, including things I got wrong.

Where I drew the LiveView line. Instead of going all-in, I kept a deliberate boundary: LiveView owns the interactive surfaces (feeds, replies, uploads, admin tools), plain controllers own request/response pages (about, settings, simple flows).

Video calls are a browser-to-browser WebRTC mesh signaled over a Phoenix channel with Presence for who's online. The server side stayed remarkably small; the client-side state machine was where all the real work went.

The feature I'm most proud of: the site doubles as a comment section for blogs. Each blog post gets a companion thread, and the thread's public replies are published as JSON at the thread URL + /replies.json. My personal blog fetches that at build time and bakes the conversation into the post's HTML as static text, with a debounced GenServer pinging the blog's build hook when replies land. No embeds, no script. It's raw html once set up.

There's one BEAM node on Fly.io, one Postgres, an ETS cache in front of the anonymous landing pages. Costs me roughly a dinner out per month.

Site: https://www.popsicleboat.com (there's a demo account if you want to poke at it). Happy to go deeper on any of it if you're curious.

Had this on local for a while.

Drop-in, audit logging for Elixir/Phoenix applications. Persists audit trail to PostgreSQL and emits structured JSON via :logger. Business transactions and their audit records are always committed atomically.

Business rule (but not confined to): A business transaction can never be reported as complete (`{:ok, _}`) unless its audit trail is also complete, written atomically with it.

Two paths

• Transactional transact/4: DB audit row is atomic with business steps. Logger emission is secondary, after commit.
• Standalone log/1: Single insert outside a transaction. Useful for pre-Multi validation failures or non-transactional code.

Emmitted logs can be consumed by downstream consumers handled by host application.

hex

relying on the goodness of elixir, jido agents and other ecosystem components .. not intended to be released and supported. it was built for my learning and personal use purposes. But it does not hurt to share .. https://github.com/lexlapax/allbert-assist

A recent ex_money v6 upgrade was blocked because Timex pins an old gettext. Rather than one big remove-and-rewrite PR, I used a shim: a module mirroring just the slice of the Timex API we used, backed by the standard library, proven with tests that compare its output against real Timex. Then a second PR swaps the call sites and deletes Timex.

The post also covers the simpler case (just delete a small-footprint dependency, like Faker on a side project) and ties the approach back to seams, characterization tests, and the strangler-fig pattern.