Calculating P&L When a Trade Spans Multiple Sessions

What happens when an external event arrives after the process context that created it is gone — the record gets filed twice, and a FIFO matcher scoped to that context produces a confidently wrong number instead of an error.

https://seriousalchemy.com/pnl-sessions

Taking Ash Framework’s DSL on a Spin for RPC Fun

I have been lately looking into more and more Ash framework’s code and exploring the DSL package — Spark that Ash uses to write pretty much all it’s DSLs. While writing DSL in Spark eliminates many macro magic from Elixir metaprogramming, code generation using Manifest takes it to a whole new level. I wanted to write up the process I followed from writing extension, to generating code using Manifest, and sending RPC calls to a remote BEAM node to execute remote code.

https://meraj-gearhead.ca/taking-ash-frameworks-dsl-on-a-spin-for-rpc-fun-3db7393405dc

Goatmire Elixir - Last chance in a while

As vacations wind down. Your spot of joy before the winter sets in is of course Goatmire Elixir. It is high time to get tickets and travel sorted. All the information is on the website. Phenomenal speakers, legendary free workshops and with us skipping the year 2027 this is your last chance for a while to see what Goatmire is all about.

https://goatmire.com

(WIP) PON-BEAM re-architecture of the Erlang/OTP

(WIP) PON-BEAM is a complete re-architecture of the Erlang/OTP Virtual Machine (ERTS — Erlang Run-Time System) using the Notification-Oriented Paradigm (PON) https://github.com/matheuscamarques/pon_beam

Hologram v0.11: Regular Expressions, Client Stacktraces, and More

Elixir regexes now run in the browser, through a PCRE2 parser, translator and interpreter, so they return what the BEAM returns. Client errors now carry the same messages and stacktraces as errors raised on the server. Plus dynamic component and element tags, attribute and prop spread, and umbrella project support.

https://hologram.page/blog/hologram-v0-11

Security Vendor's AI Best Practices Labels Critical Elixir RCE Safe

A post about the dangers of AI generated SEO spam, especially as it relates to modern cybersecurity.

https://paraxial.io/blog/ai-spam

Running Obscura on an NVIDIA GPU with Elixir, EXLA, and Lightning AI

Loading EXLA is not proof that an Elixir workload used an NVIDIA GPU.

I documented how I validated Obscura, Nx, and EXLA on a Linux Tesla T4 through Lightning AI, including an NVSHMEM ABI mismatch, CUDA backend proof, warm inference latency, and the BEAM process’s GPU memory allocation.

https://hfiguera.github.io/obscura/blog/running-obscura-on-nvidia-exla/

Shimming Your Way Off a Dead Elixir Dependency

Two ways to retire a stuck dependency in a long-lived Elixir project: a hard replacement when the footprint is small, and a two-phase shim when it’s large. Framed with seams, characterization tests, and the strangler-fig pattern.

https://mikezornek.com/posts/2026/7/shim-off-a-dead-elixir-dependency/?utm_source=elixirstatus&utm_campaign=shim-off-a-dead-elixir-dependency

The Contract Roll State Machine in Elixir

How a production GenServer encodes a four-state machine in three struct fields, drives every transition off a handle_cast, a pattern-matched handle_info clause, and a timeout message, and refuses to resume ambiguous state after a crash rather than guess.

https://seriousalchemy.com/contract-roll

Protecting PII in Elixir Before It Reaches Logs, APIs, and LLMs

I released Obscura 0.1, an Elixir library for detecting and anonymizing PII in plain text and nested structured data.

This practical guide covers protecting application boundaries, Logger metadata, outbound API payloads, structured data, and reversible LLM pseudonymization. It also explains when deterministic detection is sufficient and when local Nx/Bumblebee model-backed recognition is useful.

https://hfiguera.github.io/obscura/blog/protecting-pii-in-elixir/

Hologram Works. Sponsor What Comes Next.

Where Hologram’s funding stands after its most productive stretch yet - four feature releases, first production apps - and why the local-first roadmap depends on company sponsors stepping in. https://hologram.page/blog/backing-hologram

Guarding Against AI Drift: My Automated Elixir Quality Checks

The full set of automated Elixir guardrails I run so AI-generated code doesn’t drift toward the median, each linked to how it’s wired in a real repo.

https://mikezornek.com/posts/2026/7/guarding-against-ai-drift/?utm_source=elixirstatus&utm_campaign=guarding-against-ai-drift

cronstrue_ex – Human-readable cron expressions in Elixir

I just published cronstrue_ex, an Elixir port of the widely used NPM package cronstrue.

It parses cron expressions and converts them into human-readable strings, bringing the same functionality from the Node.js ecosystem straight into Elixir with zero external dependencies.

Features:

• Based on NPM’s cronstrue design & test cases
• Multi-language support (:en, :es, etc.)
• Zero external dependencies

Usage example:

CronstrueEx.to_string("*/5 * * * *", locale: :en)
# => {:ok, "Every 5 minutes"}

Belay: a Postgres-backed durable job engine for Elixir (step-level retries, budgets, Oban migrator)

Belay runs background jobs as sequences of memoized steps. When a job retries, it reads the finished steps back from the journal and continues from the first one that did not complete, so a crash halfway through does not repeat earlier work or the API calls it already paid for.

It also handles per-job spend budgets, human-in-the-loop waits, workflow DAGs, and a built-in dashboard, with Postgrex, Jason, and telemetry as the only dependencies (no Ecto or Redis). If you are on Oban, workers convert with small changes and mix belay.migrate_oban moves your pending jobs. Apache-2.0, currently at 1.0.0-rc.

https://github.com/b-erdem/belay

Monolith juice that looks like Lambda and tastes like fast booting machines

https://youtu.be/9RHnHABTnYc

Presentation I did in July 3rd at Python Norte 2026.

I took the opportunity to talk about how we scaled our main monolith at https://fly.io using Fly.io primitives itself and how process groups can help scaling different parts of the same app both horizontally and vertically as demands can be different. I’ve also plugged in a bit on how to have predictable charges each month so you dont go bankrupt.

Hologram: The Journey to Local-First Elixir in the Browser (ElixirConf EU 2026 talk)

Bart Blast’s ElixirConf EU 2026 talk. A year of Hologram in review, then a deep dive into local-first Elixir in the browser - what the term means, why CRDTs guarantee convergence but not invariants, and the structural advantages Elixir has for building a sync layer that JS-first stacks can’t copy. https://www.youtube.com/watch?v=qqpNovT7cys

Comcent CE — open-source voice/contact-center platform on Elixir/OTP

Comcent CE is an open-source, self-hostable voice/contact-center platform built on Elixir/OTP. The actor model shaped the whole design: a call queue manager is just a process whose sole job is managing that queue, so you reason about the system the way you’d reason about people doing the work. Elixir’s clustering gives each queue a cluster-wide singleton manager — exactly one per queue across the whole cluster, restarted elsewhere if a node dies — so it scales out without changing the mental model. Phoenix for the APIs and real-time layer, FreeSWITCH for media/SIP (driven over mod_httapi + ESL), with full call timelines, dual-channel recording, diarized transcripts, AI summaries, and IETF vCon support. GitHub: https://github.com/comcent-io/comcent-ce · Walkthrough: https://youtu.be/Cm4JDB95vpI

Distributed Elixir with ESP32s and AtomVM

I had a few spare ESP32s lying around and the great folks at AtomVM added dist_erl, so I had to see how far I could push it. I made a cluster of 7 esp32s to find primes using a distributed work queue. The result is a completely unreliable cluster, but some interesting learnings regarding memory usage, reliability and distributed compute.

The repo contains the source code for the application and the housing for the 3d printed housing.

https://github.com/m1dnight/nano-cluster

Hyper - distributed Firecracker microVM orchestrator written in Elixir

Hey everyone! One of the problems I ran into is that a large part of the VM-provider ecosystem is currently paid closed-source SAAS products with varying degrees of reliability. I wanted an OSS distributed microVM orchestrator and I couldn’t find one.

Hyper is a distributed FirecrackerVM orchestrator written in Elixir (BEAM), with gRPC support for non-BEAM clients. Hyper is:

• Distributed – it’s designed to run across a cluster of bare metal machines, and will automatically connect to other Hyper nodes.
• Fast – it builds COW layers to enable fast, localized COW forking. Cold boots happen within 1s. Filesystem forks take ~50ms. Forked VMs are colocated to take the fast path as much as possible.
• Interactive – like all Elixir applications, if you can connect to the cluster, you can spawn, manage, monitor and interact with VMs live in an iex REPL. Or, you can use the gRPC interface if your system isn’t on the BEAM.
• Yours – although I developed this primarily for Harmont (which is paid), Hyper is an MIT-licensed project and will remain such.
• Self-contained – all we need is a side-car Postgres instance.
• Configurable – colocation, vmlinux options, etc. can all be customized.
• Secure – everything runs on the BEAM; a single setuid Rust helper performs the few operations that need root, keeping the privileged surface small.

Fair warning: the software is still in active testing and I expect a couple more features to be added soon:

• Automatic cloud provisioning – when you run out of headroom in your cluster, you should be able to fall back to Latitude/GCP/AWS to provision more compute.
• More testing – I am currently integrating Hyper into harmont.dev and will likely run into some issues. Fuzzing is part of the roadmap.
• Better docs – I spent some time working on the docs, but they’re definitely not total nor ideal.

Very open to feedback, critique, and/or contributions. Please open any issues on Github, or feel free to DM/email me. It’s available at https://github.com/harmont-dev/hyper

PS. A couple people asked how this differs from firecracker-containerd and Kata containers. Both of those projects are runtimes for managing VMs on a single node. A fair mental model for Hyper is an amalgam of firecracker-containerd and k8s.

The Potions blog: Exploring LiveView 1.2

With LiveView 1.2 you can move a surprising amount of client-side code back into Elixir. I refactored a trivia game to show how: server-composed JS commands, colocated CSS, and colocated hooks.

Screencast + full walkthrough: https://potions.io/blog/colocating-liveview-js-css-and-hooks