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

ActiveMemory v0.7 — query in-memory data by attributes, not just keys (now with TTL + crash resilience)

ActiveMemory is a typed, attribute-queryable in-memory store for ETS and Mnesia. Where a key/value cache answers “what’s the value for this key?”, ActiveMemory answers the questions a cache can’t:

SessionStore.select(%{user_id: user_id, active?: true})
StaffStore.select(match(:role == "admin" and :last_login < cutoff))
TokenStore.withdraw(%{value: submitted_token})  # atomic take-once: exactly one caller wins

You define a Table with named attributes and get typed structs queryable by any combination of fields — no cache keys to design, no match specs to hand-write. v0.7 adds the safety rails for real workloads:

• TTL / record expiry — expired records are never returned, and a background sweep reclaims the memory. Ideal for one-time tokens, 2FA codes, and magic links.
• Crash resilience — an ETS heir process preserves your table when a Store crashes; the restarted Store reclaims it with data intact. Zero config.
• Atomic withdraw/1 — fetch-and-delete as a single atomic operation (:ets.select_delete/2 / Mnesia transaction).
• ActiveRepo — manage many tables (mixing ETS and Mnesia) from one supervised process. Named so it won’t collide with your Ecto.Repo.

Hex: https://hex.pm/packages/active_memory Docs: https://hexdocs.pm/active_memory GitHub: https://github.com/SullysMustyRuby/active_memory

Feedback and contributions welcome!

API Management Console - runtime route toggling for Phoenix apps

I’ve published my first Hex package — API Management Console, a Phoenix LiveView library for toggling API routes on/off in real time without redeploying. Disabled routes return 403 at the Plug level, and everything’s logged in an audit trail.

The idea came from thinking about how to limit blast radius on some public endpoints at work — disable fast, then fix properly, instead of scrambling to redeploy under pressure. This is also my first real step into open source, so bug reports and feedback very welcome.

GitHub: https://github.com/rizwan-khalid-1/api-management-console

Hex: https://hex.pm/packages/api_management_console

Where Messages Flow

When people think BEAM, they think WhatsApp-scale messaging, Discord-style concurrency, and systems that stay up while the world pokes at them. When people think secure chat, they think Signal or Matrix. Signal is excellent, but self-hosting your own server is not really part of the deal. Matrix is.

Meet River: a Matrix homeserver written in Elixir, built on the same runtime instincts that made the BEAM a natural home for real-time messaging in the first place. It is an attempt to pair Matrix’s open, federated, self-hostable model with Elixir’s strengths: massive concurrency, supervision, fault tolerance, and a web stack that already understands live, distributed systems.

There’s also a super power for building companion apps, web front ends or bridges, using native rpc’s over a cluster instead of http/json calls.

Source: git.sr.ht/~sbr/river

Beam those tunes

Coda brings the power of Elixir and the BEAM to your tunes.

It’s a self-hosted music server built on Phoenix LiveView: concurrent, fault-tolerant, and comfortable juggling playback, library scans, metadata enrichment, podcasts, audiobooks, device output, and background jobs at the same time. Your local library gets a clean web UI, listening stats, MusicBrainz enrichment, and playback across local audio, AirPlay2, Snapcast, and UPnP devices. It also supports room correction with impulse files and multi-room audio, so Coda can fit into more serious listening setups instead of just being another library browser.

Install as a self-contained Burrito binary with a sqlite db, or build from src and hook it up to postgres.

Want to rock your own thing? The bits that make Coda great are on hex https://hex.pm/packages/airplay and https://hex.pm/packages/snapcast

Check it out https://coda.8by3.com/

Ash Framework in 11 minutes

Model your domain, derive the rest. In this video, you’ll learn how Ash lets you define resources, actions, policies, relationships, and data layer once, then reuse them across code interfaces, Phoenix forms, JSON:API, GraphQL, TypeScript, and AI tools.

Watch here: https://www.youtube.com/watch?v=dDP1I2d3CB4

Hologram v0.10: Events, Middleware, and More

A real event system comes to Hologram - v0.10 is out! You can now handle keyboard, scroll, resize, click-outside and scroll-edge events, bind handlers to the window and document, and debounce or throttle the noisy ones, all checked at compile time. To show it off, I rebuilt Space Invaders in pure Elixir, running in the browser with no game engine. There’s also a new server-side middleware layer, and comprehensions and try/rescue now work client-side. More here: https://hologram.page/blog/hologram-v0-10

Modernizing realtime-js and Logflare for Supabase

Supabase maintained a heavily diverged fork of Phoenix.js under realtime-js (~20M weekly downloads). We moved it back to canonical Phoenix.js, then took Logflare’s ingestion-rule matching from linear scans to a tree-based engine and swapped BigQuery onto the gRPC Streaming API. Full write-up: https://swmansion.com/case-studies/supabase/

Stop mounting your LiveView twice

Every LiveView mounts twice — once for the dead render, once when the socket connects.

Everyone reaches for connected?(socket), but it doesn’t stop the double mount; it just hides it.

What that quietly costs you, and how to actually mount once:
https://elixirdrops.net/d/9mrw2kg3

Thinking Elixir 309: The Final Episode

Episode 309 of Thinking Elixir. This is it. The final episode of Thinking Elixir after six incredible years of weekly episodes! We send things off in style with a packed news segment covering Phoenix LiveView 1.2’s new colocated CSS powered by the @scope at-rule, the retirement of the long-standing Earmark Markdown library and why you should migrate to MDEx, a major Sagents v0.8.0 release bringing durable interrupts, and structured extraction, PostgreSQL 19’s exciting new features including graph queries and partition management, SpaceX’s jaw-dropping $60 billion acquisition of Cursor, and more! Then we share a special tribute song for you, the audience, and give a shoutout to our original co-host Cade Ward and to longtime sponsors Fly.io and Paraxial. Finally, David shares his new role on the Erlang Ecosystem Foundation board, and Mark talks about what’s next for Sagents and his exciting new AI-native startup. Thank you for six wonderful years. We’re so glad you were here along the way and now for the final episode!

https://www.youtube.com/watch?v=p5FWCNUex84

Tick-to-Trade in Elixir: A GenServer handle_info Pipeline

A full walk through the handle_info chain inside one GenServer — PubSub-fed candle messages, two near-identical clauses that do different jobs, a behaviour-dispatched handoff, and an Oban offload to keep the mailbox draining faster than messages arrive.

https://seriousalchemy.com/tick-to-trade

CDPEx: drive Chrome from Elixir over CDP — no ChromeDriver, no zombie processes

CDPEx is a Chrome DevTools Protocol client for Elixir. It drives a real Chrome directly over CDP, with no ChromeDriver, Selenium, or WebDriver layer in between.

You launch a Chrome (or connect to one that’s already running, local or remote), drive the page, and the OS process is reaped for you on teardown, so there are no orphaned Chrome processes left behind.

What it does:

• with_page/3 that guarantees teardown when you’re done
• Real, trusted input: clicks and keystrokes dispatched as genuine user gestures, not synthetic events
• Connect to a remote or already-running Chrome over ws(s)://, not just a local launch
• Navigation, evaluate, screenshots, and PDF rendering
• Network observation, including waiting for the network to go idle
• Proxy support with authentication
• :telemetry instrumentation and an optional warm browser pool

It runs in production today as the only browser engine behind a concert-listing app, rendering JS-heavy and Cloudflare-gated pages (a real browser running real JS, no stealth tricks).

Hex: https://hex.pm/packages/cdp_ex

Repo and docs: https://github.com/patrols/cdp_ex

It’s pre-1.0, so the API may still change, but it’s been stable under daily load. Feedback welcome.

LiveView JS commands playlist in dual audio (🇧🇷,🇺🇸)

I’ve been posting videos teaching about JS commands frequently on my YouTube channel and so far there’s 3 out and more to come.

https://www.youtube.com/playlist?list=PLQIum1rzJJv261U6WZNlnuYiqHs0rdWef

Thinking Elixir 308: Elixir Goes Gradually Typed

Episode 308 of Thinking Elixir. Elixir v1.20 has officially landed, marking a huge milestone as the language is now officially a gradually typed language, type checking every single line of code without requiring developer annotations, and even prompting some developers to drop Dialyzer entirely. HexDocs is rolling out per-package subdomains for improved browser security isolation, the Erlang Ecosystem Foundation has launched an Ecosystem Registry to help answer “who uses this?” for Erlang, Elixir, and Gleam companies, and the Lua library for Elixir is approaching its v1.0 release with a brand new pure-Elixir Lua 5.3 VM. On the security front, a sophisticated self-replicating worm called Miasma compromised 73 Microsoft GitHub repos by exploiting legitimate OIDC tokens and valid SLSA provenance, even weaponizing AI coding tools like Claude Code and Cursor, raising fresh questions about supply chain safety and whether Hex might benefit from a cooldown mechanism like the one Ruby just shipped, and more!

https://www.youtube.com/watch?v=mlSq6kN3GjI

BeamWeaver - LangChain/LangGraph-style agents and workflows for Elixir

BeamWeaver: AI agents and durable LLM workflows for Elixir

We’ve been building LLM features in Elixir and kept running into the same problem: the available Elixir libraries were useful, but still fairly simple, and there was almost no observability for agentic systems.

So we either had to keep Python microservices around for LLM workflows, or accept much less tooling on the Elixir side. We wanted to stop doing that.

BeamWeaver is our attempt to bring the best ideas from LangChain, LangGraph, and Deep Agents into Elixir, with an OTP-native design:

• agents and tool calling
• graph workflows
• checkpoints and resumable execution
• memory stores
• retries, fallbacks, interrupts, and human review
• typed streaming events
• provider adapters for OpenAI, Anthropic, Google Gemini, xAI, and Moonshot/Kimi
• fake/replay models for deterministic tests

We’re also building observability on top of it through WeaveScope, which we’ll release very soon.

The goal is to give Elixir teams the full harness needed to build advanced agentic systems without pushing the hard parts into Python services.

Documentation: weavescope.gitbook.io/beam_weaver

Hex: beam_weaver

GitHub: GitHub

Example of Person CRUD application built with Erlang/OTP

Person CRUD application built with Erlang/OTP, Mnesia, and a Ports & Adapters (Hexagonal) architecture.

https://github.com/Erlang-Brasil/person_mnesia_crud

Thinking Elixir 307: Trust Nothing, Sort Everything

Episode 307 of Thinking Elixir. Mark shares a bittersweet housekeeping update — the Thinking Elixir Podcast is winding down, with the final episode airing June 23rd, 2026, closing the book on over six years of weekly shows. On the news front, Ecto 3.14 lands with long-awaited UUIDv7 support (time-sortable UUIDs for better index performance) along with a host of other improvements, Oban Pro adds a “human approval” workflow step that lets jobs pause mid-execution and resume on a signal without holding a database connection open, Hologram v0.9 arrives with a new Realtime feature enabling pure-Elixir WebSocket push from server to browser, Dashbit shares a behind-the-scenes look at how they designed Git integration in Tidewave Web across three developer personas, and the NSA drops new Zero Trust Implementation Guidelines that pair nicely with the Erlang Ecosystem Foundation’s own security hardening document, and more!

https://www.youtube.com/watch?v=anxr5QsqPOc

p1meter.dev - a LiveView powered virtual P1 smart meter simulator

I’ve been working on p1meter.dev (GitHub), a small Phoenix LiveView project that provides a virtual smart meter P1 port for development and testing.

The idea is simple: if you are building software around Dutch or Belgian smart meters, home energy dashboards, DSMR parsing, P1 integrations, or TCP-based meter readers, you often need realistic telegram data. But having a physical smart meter, P1 cable, adapter, or test setup nearby is not always convenient.

p1meter.dev simulates a live DSMR 5.0 smart meter and streams telegrams over raw TCP.

You can try the live TCP stream with:

nc p1meter.dev 8080

The web interface shows a live preview of the simulated smart meter data, while the TCP endpoint emits the same kind of telegram stream that a P1 reader would receive.

The project itself is built with Phoenix LiveView. The simulated telegrams are generated using my dsmr package, which handles DSMR telegram data structures and formatting.

It is mainly useful for:

• testing DSMR/P1 parsers without a real meter nearby
• developing energy monitoring tools
• experimenting with TCP-based P1 readers
• demos, examples, and documentation
• reproducing parser or integration issues with predictable input

The project is still intentionally small, but I’d like to keep improving it. Some things I’m considering:

• more realistic usage patterns throughout the day
• configurable meters or scenarios
• support for more edge cases in telegram data
• examples for consuming the stream from Elixir and other ecosystems

Feedback, ideas, bug reports, and contributions are very welcome.

Website: https://p1meter.dev Related DSMR package: https://github.com/mijnverbruik/dsmr Repo: https://github.com/mijnverbruik/p1meter.dev

Fine tuning classification in Elixir

I fine-tuned a GPT-2 model for ham/spam SMS classification in Elixir.
This post follows chapter 6 of Sebastian Raschka’s Build a Large Language Model From Scratch, but instead of Python/PyTorch, I implemented the training pipeline in Elixir with Nx.
For me, the most interesting part is not only that GPT-2 can be fine-tuned for classification, but that Elixir is becoming a serious environment for machine learning experiments.

https://karlosmid.com/2026/06/fine-tuning-for-classification/

Your context module has 30 query functions. It needs five

I wrote about a pattern for trimming oversized Elixir context modules down to a smaller, clearer API. The goal is to make queries easier to find, easier to reason about, and harder to misuse without losing the flexibility you need in a real codebase.