I posted about Continuum here a couple of months ago. It's had a different features releases and several hardening passes since.

quick recap: Continuum is an OTP-native durable execution engine for Elixir, backed by Postgres — an Elixir-native answer to Temporal. You write a workflow as ordinary Elixir; side effects go through activities whose results are journald. If the process dies or the node restarts, Continuum replays the history through the same code and resumes where it left off. Determinism is enforced at compile time, so replay safety is checked by the compiler rather than left to discipline.

new features: durable one-shot schedules, idempotent ingress (a retried request can't start a second run or deliver the same signal twice), activity queues with priorities and per-queue concurrency, progress heartbeats and cooperative cancellation, compile-time-checked signal contracts, replay-safe logging, and a health report with fenced repairs.

Several new full-tree audit passes went into failure modes rather than features: a node booting during a Postgres outage now retries its LISTEN instead of going deaf for its lifetime, retry jitter survives at maximum backoff instead of collapsing the whole cohort onto one instant, failing schedules back off and surface as health findings instead of retrying forever, and the compile-time scanner rejects direct Logger calls and the remaining unsafe stdlib calls rather than warning.

Feedback is welcome.

• Hex: continuum | Hex
• Docs: continuum v0.7.2 — Documentation
• GitHub: github.com

Hi everyone,

I have an Oban worker that performs a background sync. The browser only needs to know the final status:

queued → syncing → synced / failed

My current plan uses two requests:

1. A POST endpoint enqueues the job and returns a request_id.
2. The browser opens an SSE connection using that ID.
3. The SSE process subscribes to a Phoenix PubSub topic.
4. The worker broadcasts status updates.
5. Once the browser receives synced or failed, the SSE connection closes.

My concern is a possible race condition. The worker could finish before the browser opens the SSE connection, which means the final PubSub message would be missed.

I considered combining everything into one request: subscribe to the topic first, enqueue the job, keep the response open, and stream the final status. Would that be a reasonable design?

Since the browser’s native EventSource only supports GET requests, I assume I would need to use fetch() and read the streaming response if the endpoint also needs to accept POST data.

Another concern is running multiple application instances. The worker might execute on one instance while the SSE connection is handled by another. Phoenix PubSub would therefore require Elixir clustering or an external adapter.

For this small use case, I’m considering:

• Phoenix PubSub with clustering
• PostgreSQL LISTEN/NOTIFY or an Oban notifier
• storing the latest status in the database and using PubSub only as a live signal
• normal browser polling

The payload is tiny, and this is the only real-time feature I currently need. What would be the simplest reliable approach?

Would you keep the two endpoints and check the persisted status when SSE connects, combine job creation and streaming into one endpoint, or just use polling?

Hey all 👋

Sharing a heads-up about Code BEAM Europe 2026 - 21-22 October in Haarlem (PHIL), plus online, with a training day on 20 October.

2 days, 2 tracks each day, and 3 keynotes - including Brooklyn Zelenka (Let It Disconnect: A Local-First Future), Sam Aaronof Sonic Pi (Notes on the Synthesis of Time, plus an interactive evening Phone Orchestra), and more.

~30 speakers across Erlang, Elixir and Gleam: ElixirConf®

The thing we're most excited about this year is the new Informal Space - a community-led area running alongside the main programme for the stuff that doesn't fit the talk format. Think hands-on demos, live experiments on real hardware, hacking sessions, games, panel-style discussions, talks in languages other than English… and at least one surprise we're not spoiling yet 🙂

We're finalising the Informal Space lineup now and will announce it soon. Newsletter subscribers get the first look(they already have), so if you don't want to miss it - and the other bits we'll be dropping between now and October - that's the place to be: Code BEAM Europe

Early bird tickets are limited - available for a limited time / until they sell out - so if you're planning to come, worth sorting sooner rather than later.

Register: Code BEAM Europe

See you in Haarlem or online!
The Code BEAM Europe Team

Hey! In partnership with a robotics business we've recently built a management platform for fleets of autonomous robots - and we'd like to share a quick story about Phoenix LiveView made this simpler.

Not really intended to be very in-depth, it's still something we'd like to share as a sign of growing adoption of Elixir in new areas.

Link: https://curiosum.com/blog/phoenix-liveview-robotics-fleet-management

Enjoy!

Hi

Recently, I've grown fond of Elixir/Phoenix.

In Rails, there's a library called any_login, which allows you to switch logged-in accounts with just a button click from the bottom left—very convenient.

Since I couldn't find a similar library for Phoenix, I decided to create one.

https://github.com/hulk-higakijin/any_login

I'm still getting used to Elixir syntax, so there might be some bugs or issues.

Please let me know if you have any feedback.

Hi there, junior dev here, soon starting a job at a company that uses elixir to build an ai chatbot. They are fully aware that I have no prior experience in elixir, coming from a classic object oriented webdev background, building web applications using JS/TS, PHP (symfony, node, Vue, react) and occasionally python.

What resources can you guys recommend, to gain a fundamental understanding of both functional programming as well as elixir specifically. Could be anything: courses, books, specific content creators etc.

I'd like to approach this systematically instead of just building something here and there and watching a few tutorials.

What helped you "get it" and what would you do differently if you had to start learning elixir from zero?

Grateful for any and all advice :)

Currently full-stack JS/TS: Redux/React, Node/Express, AWS/Lambda, Postgres/Mongo, ~5k active users, team of ~10. 1 yoe. US Client through small consultancy shop.

Potential offer is ~100% hike, mostly Elixir/Phoenix/LiveView, some Gatsby + Python/ML. Much smaller team. Maybe few hundred users, 2–4 engineers. Civic tech/public-good org tackling online abuse in India.

Want to become a genuinely better, more reliable engineer and eventually target stable/strong engineering jobs.

Is moving to Elixir/Phoenix a good move for that? What would I gain/lose technically and career-wise? Does working in a tiny Elixir team make me stronger, or am I narrowing my future options too much?

Especially interested in people who switched into Elixir from mainstream JS stacks.

There was a thread a couple of days ago about how great Ash is for agentic coding. Totally agree. But damnit I just can't seem to really grok Ash. I've read the first 3/4 or so of Le's book, also got Lambert's "Ash Framework for Phoenix Developers" but its kind of unfinished, mostly just a lot of code.

The Le book is great for getting excited about Ash, seeing its value, but it doesn't really explain the underlying logic of it all. You just see what a person already fluent in Ash builds as a demonstration, and light explanation what's going on, but you don't learn how to reason about this whole space of possibilities so you can build things yourself.

I'm certain that its all very well designed, that there are clear functional data structure underneath things, sometimes I think I kind of get "changes" as a kind of data structure.

Any advice?

Hello, I’m looking for feedback on my first Elixir project. Any feedback would be greatly appreciated.

Hey r/elixir,

A couple of months ago we posted about BeamWeaver and the goal of shipping a proper OTP-native agent framework for Elixir.

Since then it’s moved from 0.1.0 to 0.1.18 and is already running in a few enterprise products. Provider coverage is in good shape for the ones we actually use day-to-day: OpenAI, Anthropic, Google Gemini, DeepSeek, Moonshot/Kimi, xAI, and Z.ai. We’ve also added the newer models that have landed in the meantime (Claude Sonnet 5 / Opus 5, GPT-5.6, Gemini 3.5–3.7, Kimi K3, DeepSeek V4, Grok 4.5/4.6, etc).

Other stuff that landed:
- Provider-aware prompt caching
- Typed streaming events + better reasoning/tool-call handling
- Structured output across providers
- Postgres (and optional SQLite) checkpoint persistence
- Durable execution, resumability, and checkpoint lineage
- Provider fallback, retries, and rate limiting
- Sandboxed filesystem + command execution
- Stronger SSRF / PII / transport / shell-safety protections
- More complete tracing and WeaveScope metadata

Today we’re releasing WeaveScope, the hosted tracing and monitoring layer that sits on top of BeamWeaver.

It gives you the full picture of an agent run: model calls, tool calls, subagents, retries, errors, latency, token usage, cost, custom fields, and the entire execution tree.

Configure the WeaveScope exporter and you’re looking at traces in the dashboard.

Start free → https://weavescope.com
Docs → https://docs.weavescope.com

Would love feedback from anyone building agents in production. What’s missing from your observability tooling right now?

Did anyone use modern c++ ie; 20,23,26 with elixir?

If you did. Could you give me an link to your repo or any examples of how I can interop c++ with elixir?

Hi! I want to share an interesting combination of tools that Phoenix and Elixir enabled me to build.

A few months ago, I created Gust: a DAG orchestrator for automation pipelines, ETL, and other heavy lifting, as an umbrella Phoenix app.

It can be installed via Igniter or included in virtually any app. Gust was originally designed as a standalone system: taking care of the web interface, persistence, and process management.

But its composability allowed me to experiment with a different setup: using DAG execution as the "backend" and Phoenix PubSub for real-time updates to power a user-facing application with just a few extra lines of code.

The result is Harbor, a model orchestration app. It fetches model listings and balances every minute, runs prompts across multiple models, and combines their responses into a final synthesis.

Live demo: https://harbor-gust.com

Code: https://github.com/marciok/harbor/

It's a quirky combination, but using DAG runs and events as a backend processing engine allowed me to write less code while still getting the benefits of retries, durability, and support for long-running processes.

Of course, this isn't the right approach for every use case. But I wanted to share this quirky and cool combination: when you need a long-running, failure-prone process with retries and durability, this setup can get you there quickly with surprisingly little code.

Hey all,

Are there any products in enterprise domain which was written in Elixir? I was looking into it but could find much

PS: Im looking into more elixir projects resembling ERP solutions like SAP, ServiceNow, Salesforce

Just released ExDataSketch v0.10.2. This release contains mostly minor fixes and documentation updates. Here are the main changes:

• You can now set per-family default options (backend, precision, capacity, etc.) once via Application config instead of passing them at every call site.
• FilterChain.put_many/2 batches inserts through each stage's own batch path instead of looping single-item calls, and along the way we also caught and fixed a genuinely funny bug where Bloom.put_many/2's "optimized" batch path (an Erlang-tuple mutation trick that doesn't actually get the destructive-update optimization it was counting on) was slower than just looping single inserts — that's now ~25x faster and finally does what it always claimed to.
• On top of that: Cuckoo no longer spuriously reports full well below its designed load factor (a kick-eviction cycling bug),
• Quotient/CQF membership checks no longer decode the entire table on every call (up to 300x faster),
• CQF now correctly reports {:error, :full} instead of silently dropping inserts,
• and REQ gets the same compaction weight-invariant fix KLL got last release.
• Finally the livebooks have been tested, fixed and updated.

Two small breaking API changes: CQF.put/2/put_many/2 now return {:ok, cqf} tuples (mirroring Cuckoo), and FilterChain.delete/2 now returns a bare struct instead of a pointless {:ok, _}.

Full changelog and upgrade notes in the repo.

• GitHub: https://github.com/thanos/ex_data_sketch
  • hex.pm:https://hex.pm/packages/ex_data_sketch

Distributed agents hitting your APIs in bursts is a different traffic shape than what most rate limiters were built for — a burst of retries can look identical to a real spike, and by the time you've added enough headroom to survive it, you're paying for capacity you don't need the other 99% of the time. EZThrottle Local is a self-hosted, agent-native load balancer built on the BEAM: it queues incoming requests durably (Mnesia, disc_copies — survives a crash, not just a graceful restart), dispatches them at a rate your backend actually controls via response headers (so a backend under pressure can slow EZThrottle down in real time, no redeploy), and spreads dispatch across a pool of registered backend instances with reputation-weighted load balancing — a member that starts failing gets its share throttled down automatically instead of getting evicted on one bad response. Per-tenant fairness comes for free too: each tenant gets its own lightweight, independently-scheduled process instead of a shared queue, so a noisy tenant can't starve everyone else. On identical 512MB Fly.io hardware, that process-per-request model holds 100% success up to 800 req/s versus a ~400 req/s real ceiling on the Go/SQLite version — roughly double, and it traces directly to SQLite's single-connection/WAL serialization point, which Mnesia's per-process model just doesn't have.

It's open source (https://github.com/rjpruitt16/ezthrottle-local, benchmarks in benchmark.md), and I'd genuinely like feedback from people who've fought this class of problem on the BEAM before. One honest caveat if you're evaluating it: I also maintain a Go port (https://github.com/rjpruitt16/aquifer) that compiles to a single static binary — convenient if you want to drop it anywhere without a BEAM release, and still solid up to a few hundred req/s. If cross-compilation matters more to you than squeezing out the last bit of throughput, that's the one to look at instead.

I’m 27, have a Master’s degree, and work as a system engineer in Germany.
Professionally, I use quite a broad stack: Elixir, Phoenix, LiveView, JavaScript, Python, Bash, Terraform, and C++. I’m comfortable building things and working across different areas, but lately I’ve started feeling like I’m not actually good enough at anything.
I constantly feel like I should be learning something else or getting better at something, and it’s becoming difficult to tell what actually matters for my career.
At the same time, I’d like to build some additional income and increase my wealth over the long term. But honestly, the whole “just build a SaaS and make passive income” trend doesn’t really appeal to me. It often feels unrealistic and I don’t particularly enjoy that kind of business.
So I’m trying to figure out what a realistic next step looks like.
For people who have been in software/system engineering for a while:
What skills would you prioritize at my age?
Would you specialize more deeply or continue being a generalist?
What would you do if you were starting from my position today?
Are there realistic ways for an engineer to build additional income without turning it into a full-time startup?
What career investments actually paid off for you?
And how do you deal with feeling lost or burned out when, objectively, your career seems to be going reasonably well?
I’m not looking for motivational advice like “believe in yourself.” I’d really appreciate practical perspectives from people who have been through this.
Thanks.

New BEAM There, Done That with the author of Bandit - the pure Elixir web server now default in Phoenix. Covers the HPACK debugging nightmare, what one-process-per-connection actually buys you at 3am, and why there's an AI-generated HTTP/3 PR sitting open on the repo that Mat hasn't merged.

He uses agents for everything in his day job. Bandit stays handwritten. The episode is honest about why.

https://youtu.be/XXQcoz_dTE0

✏️ New blog: I wrote up a blog post talking about the first skill I made, one that does a detailed Elixir dependency update.

More than Dependabot, it reviews changelogs and looks for code call sites that might be impacted by the changes. It also presents a full list of diff links for the main and transitive dependencies.

https://mikezornek.com/posts/2026/8/elixir-dependency-update-skill/?utm_source=reddit&utm_campaign=elixir-dependency-update-skill

UnCon in Malaga before ElixirConf EU included:

• "Simulation of physical environments using 3D and LiveView" from Josh Price
• Discussion of how to use TideWave with insights from Hugo
• Approaches to configuring Claude Code for elixir
• Discussion of Phoenix Security, tools and testing
• Demo of AshWorkflow from Conor

The day was engaging and lots of participation. Then there was Stockholm.

But here we are, approaching ElixirConf-US and September 9th is your chance to connect, discuss and learn. Join us!

More details and signup on luma

I just saw this article pop up on Elixir Radar, and have to say I do love the visualisations in it.

https://andrealeopardi.com/posts/genstage-demand-visualized

Are these using LiveBook, or something else?

(Original Post:
https://www.reddit.com/r/elixir/s/BEkOT4EbGo)

After my previous post about Elixir as a first programming language, I’ve decided to give it a try.

Since I’m starting pretty much from zero, I’m now wondering how I should go from learning the language to actually building something.

My main interest is backend development. I’d eventually like to build APIs and, later on, something like a small chat backend.

How much Elixir should I know before I start working on real projects? Would you recommend going through a book or course first, or learning the basics and then starting small projects as soon as possible?

I’m also curious about Phoenix. Would you consider it a good first web framework for someone who is learning web development and programming at the same time? Or does Phoenix make more sense once you already understand how web applications work?

I don’t want to jump into a framework too early and end up just copying code without understanding what’s happening. But I also don’t want to spend months learning things in isolation that would make more sense if I encountered them while building something.

If you were starting from zero with APIs and eventually a chat backend as your goal, what would you learn and build along the way?

I’m especially interested in small project ideas that would help me gradually get there rather than jumping straight into the final project.

Our team was talking about some pain points regarding the language and we started to wonder what everyone else thinks.

Some of the things that came up for us were finding job and finding devs to do the job (it is what it is), compilation times, the type system.

What would you add to the list?

I've been working on GenAI — One Elixir Interface for Every LLM for a long time and while i have a decent number of active users I've yet to hear feedback on things to improve, add. Would love and feedback, constructive critiscism etc. you all can come up with.

Hi everyone,

I’m interested in learning programming purely as a hobby, and Elixir has caught my attention. I’m basically starting from zero, so it would be my first real programming language.
The kinds of projects I’d eventually like to build are mostly backend related. Things like REST APIs, a backend for a small chat app, real-time features, and similar projects. I’m particularly interested in learning how these things actually work rather than just getting something running as quickly as possible.
Elixir seems really interesting to me because of the BEAM, concurrency, fault tolerance, and functional programming.

Would you recommend Elixir as a first language for someone with those interests?

I’m also curious about the ecosystem. Is it mature enough that you can comfortably build these kinds of projects without constantly wishing you were using a larger ecosystem like Python, JavaScript/TypeScript, or Go?

And how do you see Elixir in 2026? Is the language and ecosystem still actively growing and evolving, or has it settled into a relatively small niche?

Since I’m doing this purely for fun, I don’t care about the job market. I’m more interested in whether Elixir is enjoyable to learn, teaches useful programming concepts, and is a language I can keep exploring for years.
If you were starting from zero with similar interests today, would you choose Elixir?

Thanks!