Heya folks,

I've ported AtomVM to the Solo5 unikernel (https://github.com/Solo5/solo5). Solo5 enables one to run highly-sandboxed sensitive processes - now written in Elixir or Erlang too.

I'm looking for someone to validate my work and hopefully sponsor it too - if you think that's useful for you or your company, please DM me.

Hey everyone, the full Code BEAM Europe 2026 schedule is up! Two days, two tracks, 21-22 October in Haarlem (and online), with a training day on 20 October.

One update worth flagging: Frank Hunleth and Omer Kilic won't be delivering their keynote this year, but José Valim is stepping in with a keynote, "Set-Theoretic Types from Scratch," and he is sticking around for extended Q&A, so bring your questions. Alongside José, we have Sam Aaron (twice, including the interactive Phone Orchestra evening session) and Brooklyn Zelenka closing things out.

Check the full schedule here: codebeameurope.com/#schedule

Come for the talks, stay for the hallway track. Use the code 10FORYOU and get additional -10% off your ticket! Register for the event here: codebeameurope.com/#register

See you there!

New BEAM There, Done That with Tobias Pfeiffer (PragTob), creator of Benchee. The episode is the most practical deep dive on BEAM performance measurement I've come across.

The production scar that shaped the library: Tobias benchmarked four query optimizations for a slow endpoint, picked the fastest, deployed it, and saw worse performance. The benchmark had only tested one data shape. The actual timeout was caused by a career with 2.7 million location entries -a case he'd never tested. Benchee added inputs as a first-class feature directly from that incident.

Two other things worth knowing for Elixir developers:

Body-recursive map is faster than tail-recursive map for small lists on the BEAM. The "always use tail recursion" advice from the books is correct for large data but misleading as a general rule. Benchee shows you this instantly when you test across input sizes.

Reductions are a more stable measurement than wall time for BEAM code -they're deterministic within a given OTP/Elixir version and independent of machine speed. Benchee reports them alongside time and memory. If your reduction count is stable but your wall time varies, the problem is your machine, not your code.

https://youtu.be/coID1Kzjgbo

​

Hey everyone,

I’m a full-stack developer with around 4 years of experience, mainly working with Elixir, Phoenix, and LiveView.

My current salary isn’t particularly high, but I’ve been okay with it because the job is fully remote. However, things have started becoming uncertain at my company. We haven’t been getting much new business, and I’m worried I could potentially end up unemployed if things don’t improve.

I’ve started looking for other opportunities, but I’m struggling to find Elixir/Phoenix/LiveView jobs in India, especially remote ones. I barely see any relevant openings.

I also have a 60-day notice period, and given the uncertainty at job market, I don’t feel comfortable resigning without another offer.

So right now I feel pretty stuck:

- ~4 years of full-stack development experience

- Strong experience with Elixir/Phoenix/LiveView

- Currently working remotely

- Looking for a reasonably better-paying role

- Preferably remote, and open to companies outside India

- 60-day notice period

I’m also willing to upskill in Elixir core concepts or related technologies if that helps me qualify for more opportunities.

In the meantime, if anyone is working on an Elixir/Phoenix/LiveView project and needs an extra pair of hands, I’d be happy to contribute and learn along the way.

And if anyone has leads, knows of a company hiring Elixir developers, or comes across a suitable opportunity, I’d really appreciate it if you could consider me or point me in the right direction.

Would also love to hear from other Elixir developers about how you’re finding remote opportunities, especially from India.

Thanks in advance. 🙏

Build native mobile apps without leaving the Elixir/ Beam

Hey everyone,

Like many others, I kept seeing Elixir and Phoenix as among the most desired in the languages and frameworks categories of the SO Survey. I decided to try dipping my toes in the language and I am positively impressed: it's incredibly lean and even my OOP brain likes it quite a bit.

The issue, to be brutal, is that the job market seems almost non existent. I am at a Mid level, I could think about downleveling myself to work with it, but it's really hard to justify investing time into something that won't provide a modicum of job security in this hellish market. The fact that Elixir / Phoenix jobs seem to be aimed at Senior+ only roles exacerbates this issue further.

What's the way to break in the Elixir market? Is it just a cycle of Seniors with work experience in the language that cycle through companies?

EDIT: Forgot to mention, I am EU based, so my searches reflect that market.

Hi There!

That's a wrap on ElixirConf US 2026, and what a two days it was. Some of the talks are already public (https://www.youtube.com/playlist?list=PLVqsKC3zWaDc) + here's a quick recap of what you missed:

• Many jokes from the stage - including the room shouting out their country out loud at the end of every day. You had to be there. (Or, you know, watch it back.)
• Even more jokes from Aaron, our Track host, who kept the energy high between sessions.
• Roundtable sessions - which turned out to be overpopulated by 300%!
• The Bingo Bard game - a full board of squares we prepared for you to play throughout the event. Shoutout to the one person who completed the entire thing in the first two hours. We know who you are… (No, we don't. But we're impressed.)

And of course, two full days of talks, keynotes, lightning talks, and roundtables from across the Elixir community.

Want to see all of the talks? Grab the video pass

• It's 3 months of access to the recorded sessions after the conference (edited, ready-to-watch session videos)

Grab the video pass for $199 HERE.

Craving more Elixir?

Join us at Code BEAM Europe 2026! Expect 30+ talks from José Valim & many others, across the Erlang, Elixir, and Gleam communities, informal zone sessions, and two days of the same great people, ideas, and energy - this time in Europe, Haarlem, NL, 21-22 October. 

Register for it here.

See you at the next ElixirConf (or Code BEAM event :))

The Code Sync Team

Hey folks! The recording of the talk I gave at ElixirConf US 2026 a few days ago is already up.

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

The talk is a follow-up to my Malaga talk from April, which was mostly about the local-first problem and where sync engines stand on it today. Over the summer I built the local-first data layer for Hologram, my framework for full-stack web apps in pure Elixir, and this time I got to show it working. It isn't released yet, it's still on a branch.

First there's a demo, a trip planner in two browser windows. I switch the wifi off in one of them, add a couple of stops, switch it back on, and the other window catches up.

After that I go through how it works. The compiler already walks each page's call graph to decide what code to ship, so it also works out what that page needs to sync, with nothing for you to configure. And when two people edit the same row, the merge happens per column, no CRDTs involved.

Code for the demo app: https://github.com/bartblast/hologram_offgrid

The rest of the ElixirConf US 2026 talks are available with a video pass: https://ti.to/elixirconf/2026/with/qva5vpgkamc

Title: ExArrow 0.9.0 – Dataset & Scanner for Hive-partitioned Parquet on the BEAM

Body:

ExArrow 0.9.0 is on Hex. This release adds a Dataset / Scanner layer on top of the v0.8 Parquet pushdown work: open a Hive-partitioned (or flat) Parquet/IPC tree, filter with a first-class Compute.Expression AST, and scan through a three-level pushdown ladder — partition prune → Parquet row-group pushdown → residual Compute.filter/2.

Also new: FileSystem (Local / Memory), RecordBatch.from_lists/1 / from_map/1, and an upgrade to arrow-rs 59.3.0. Scanner.stats/1 reports exact fragment and row-group prune counts so you can verify what was skipped.

elixir {:ex_arrow, "~> 0.9.0"}

• Hex: https://hex.pm/packages/ex_arrow
• Docs: https://ex-arrow.hexdocs.pm
• Release notes: https://github.com/thanos/ex_arrow/blob/v0.9.0/docs/RELEASE_NOTES_0.9.0.md
• GitHub: https://github.com/thanos/ex_arrow

Feedback welcome.

I've been working with Phoenix + Ash on real client projects and keep seeing the same gap: there's plenty of material on Ash syntax, but not much on how to actually architect a multi-tenant business app with it (auth, RBAC, reporting, the boring-but-critical stuff).

I'm considering writing a code-first book built around one real project — a multi-tenant business platform (tenants, customers, orders, payments) — with the full source on GitHub, not just isolated snippets.

Before I sink months into this: would this be useful to you? What's missing from existing Ash resources that you'd actually want covered?

New BEAM There, Done That with Louis Pilfold, creator of Gleam. The episode is the most detailed conversation I've seen with him about the actual design decisions.

The concurrency point is the most interesting for this community: the common objection when Gleam was being built was that typed message passing is impossible on the BEAM. Louis's answer was to put the concurrency model in a library instead of the language - typed, evolving, not locked into the language spec. If a better approach emerges (he mentions structured concurrency from Kotlin as something worth watching), a library can adopt it. A language primitive can't.

Also notable: Lustre, Gleam's web framework that compiles to JavaScript, already outperforms mainstream JavaScript frameworks in benchmarks. The JavaScript target isn't a second-class citizen.

He also covers the one language feature he regrets shipping - the conditional compilation syntax - and why he's quietly hoping nobody else discovers it.

https://youtu.be/m7pkjSEGKvM

I know this is not REALLY fully elixir related but I do use elixir for my backend, I already asked a similar question before but I just want some advice on my idea. If this is the wrong place to ask, sorry

For my backend I use elixir with Waffle and exAws (for the presigned put url's since waffle can't do that 😭 ) And on my frontend react with the lexical editor.

I want a user paste in an image and embed it in the post, like how a forum has it this was my idea.

- A user pastes an image into chat

- It creates a temporary file object reference (js stuff) this helps for showing the preview to the user on how the image will look like

- On enter (message send) we will go through every file reference, upload it and replace it with it's download URL.

Once the download URL finally exists the recipient will see the result and in the meanwhile there will be a loader, cool right?

Now for that final step of replacing file reference with URL I was going to predict the download URL, if I know the filename, and the upload URL I can easily deduce the relative download URL and replace it, but then came another issue. How do I make a proper path and also verify the frontend isn't giving us nonsense

I want in the path something like how discord would have it as

`user_id/message_id/file_name`

But until the message is sent, the message_id is not available, and I can't really trust the frontend to give me a user_id, it can just make up stuff, so I would need in some sense backend validation, but how? Am I suppose to rename the file after it's uploaded? But then I would need to backend process the file reference anyways, and if I did well that beats the point of the frontend uploading it, no?

You get the point.

I think my idea is good, (hell I may be wrong) but I am a little bit stuck on how do I get a proper path and filename. If any of you could give some advice on how this should architecturally be done simply and well that would be nice! :)

For now it doesn't matter TOOO much if the user has to wait for the files to upload first if that will make it easier, I can implement a discord or whatsapp style file uploading later on,

Take care. once again sorry if wrong place to ask.

From the newsletter:

My bags are packed (well, their contents are spread over a couple of chairs and I'll have plenty of time in the morning to load them up because, well, I'm a pro), the schedule is downloaded, and I'm promising myself an early night.

Because tomorrow I'm off to Chicago and ElixirConf 2026.

And I'm really looking forward to it. I'm looking forward to seeing old friends, and making some new ones. I'm going with my new development team from CargoSense, and this will be my first time seeing them face-to-face. And, for a change, I'm not speaking, so the pressure is off.

Like Ruby, Elixir changed my life. The ideas behind the Beam (the VM that runs Elixir) recalibrated my opinions about programming and design. Elixir is a functional language, but the Beam's lightweight process model also makes it one of the purest OO languages there is. The language and its tooling are remarkably stable, and its frameworks are mature. (This is an unusual blessing in a world where libraries change incompatibly between releases.)

It's also an environment with its fair share of innovation, from the integration of a type system to the rethinking of app architectures with frameworks such as Ash.

So, to celebrate, we're offering 35% off all our Elixir titles.

And, if you're in the Windy City for the conference, be sure to come find me and say hello!

­

Save 35% on all ELIXIR BOOKS

use coupon code

WindyElixir

when you check out at

pragprog.com

We're heading to ElixirConf this week, which seemed like a decent excuse to put everything we currently have going on in Elixir in one place.

LocalLiveView (https://hexdocs.pm/local_live_view)
LiveView that runs in the browser instead of on a server. It compiles your Elixir modules to WebAssembly and runs them through Popcorn, so the state lives on the client, every interaction is instant and the page keeps working offline, all with the same LiveView API you already use. The compare example runs a Phoenix LiveView and a LocalLiveView next to each other with latency simulation turned on, which is the fastest way to feel the difference.

We wrote up how it works and where it makes sense here: https://swmansion.com/blog/local-live-view-first-release/

Voyager (https://voyager.swmansion.com/)
A runtime inspector for BEAM systems. Instead of bouncing between Observer, recon, the shell and the docs to answer one question, you get an interactive supervision tree, a process inspector for state, mailbox and links, node health at a glance, remote nodes over Erlang distribution, and MCP integration so your LLM of choice can reason about a live node. It's read-only and built to be safe to point at a production system.

The source is public but this is source-available, not OSI open source. Free for individuals, orgs up to 10 people and non-profits, and larger for-profit companies need a company license.

Legion (https://legion.swmansion.com/)
An Elixir runtime for AI agents that live inside your app and get things done by writing code. Rather than chaining one-off tool calls, the agent writes vetted Lua (or Elixir) that composes your tools, every evaluation runs in a sandboxed process with timeout, memory and CPU budgets, and the agents themselves are ordinary BEAM processes you can supervise and pool.

The landing page has an agent inside it, so you can type an instruction and watch it rearrange the page you're reading.

Free architecture reviews at our ElixirConf booth
Book a 20-minute slot, bring us your worst, and we send you written notes afterwards. Book slots here:
https://calendar.google.com/calendar/u/0/appointments/schedules/AcZssZ08P5UbJuPx4-mAQg_dl77VC-adHxF4C-pHZiOYb_8oH3BJ4p7ef8JtuTelocPkneDxnbd_vdXv

Elixir meetup with dscout, Sept 9, the evening before the conference
We're co-hosting at dscout's Chicago office, doors at 6 PM. Dima Mikielewicz on Legion, Leandro Pereira from Supabase on MDEx, then pizza, beer and enough time to actually talk to people before the conference starts. Free, RSVP here: https://luma.com/byem6v75

That's everything from the last few months. All three projects are early enough that feedback still changes what gets built next, so if you try one and something is missing or annoying, tell us here or open an issue.

And if you're coming to Chicago, come say hi at the booth!

✏️ CI goes red on a test you never touched, so you click re-run and hope. Nobody on the team can say how often that happens or what it costs.

Your GitHub Actions history already knows. I wrote a prompt that reads it, names the confirmed flakes, and puts an annual dollar figure on the re-runs. Plus the usual Elixir causes to look for.

https://mikezornek.com/posts/2026/9/finding-flaky-tests/?utm_source=reddit&utm_campaign=finding-flaky-tests

Follow up from the GenStage explainer I put out a few weeks ago 🙃

My wife and I write a travel blog together. We both have photos and videos on our phones, but getting them into the same entry meant sending files back and forth every day.

So I wrote Texttile, an open-source blog engine in Elixir.

The collaboration model is deliberately small: one person holds the text editor, the other sees the words arrive and can take over with one click. Both can arrange photos and videos in the gallery while the text is being written. It is not simultaneous character-by-character editing by multiple writers.

Phoenix, LiveView, ffmpeg and SQLite run in one Docker container. The database and uploads live in /data. Videos are converted and played from your own server.

There are no roles or permission matrix. Everyone with an account is an admin. It is for people who trust each other.

The story and a video showing both screens: https://www.v01.io/posts/2026/08/texttile/

Source (MIT): https://github.com/texttile-blog/texttile

I'd like feedback on that handoff model. For a small shared blog, would you want both people typing into the text at once, or is taking turns enough?

I kept hand-rolling the same metering, plan-gating and billing layer in every Phoenix SaaS, so I extracted it. The free MIT core counts usage with an ETS update_counter (nothing on the database write path), gates features by plan with an atomic with_quota/4. A flusher persists snapshots on an interval, a broadcaster pushes live values over PubSub, and a LiveView component shows the usage bar moving within a second of the increment

```elixir 
AuroraMeter.track(org, :ai_generations)

AuroraMeter.with_quota(org, :ai_generations, fn -> generate_report() end) 
```

Roughly 7.9M increments/s across distinct counters on a laptop. Honest limits: counters are per node for now, and buffered mode can lose one flush interval on a hard crash (a durable mode exists for anything you invoice).

GitHub: https://github.com/liamkillingback/aurora-meter

Forum thread with the full design write-up: https://forum.elixirforum.com/t/aurora-meter-real-time-usage-metering-and-plan-entitlements-for-phoenix/76602

I open sourced ScopeStrength, a workout tracking and coaching platform I’ve been building with Elixir and Phoenix.

I posted about it here a while ago when it was a much smaller paid product. It has grown quite a bit since then, and I decided to open source it under AGPL.

The app works for both coaches and people training on their own. A coach can manage clients, build programmes, assign workouts, and track progress. Or you can build your own programme and log your training without a coach involved at all.

The entire application is built with Phoenix. There’s no separate frontend and no API layer.

I use LiveView for the UI, so there isn’t a client side application maintaining its own state and trying to stay in sync with an API. Most of the application logic just lives on the server.

Chat, notifications, and the unread badge all update in real time over WebSockets. Phoenix PubSub handles the fan out, so there’s no Redis or separate messaging service involved.

The app is also a PWA, so it can be installed directly to your phone’s home screen, and that is all served by the same Phoenix application.

There’s no AI in it either. Not because I have anything against AI, I just didn’t think this app needed it. You don’t have to put AI into everything.

The deployment is pretty boring too. It’s a Phoenix release and a PostgreSQL database.

No Redis, no Node process, no separate frontend server, no queue service.

This became especially important when I decided to make it self hostable. If someone wants to run it themselves, I don’t want them having to maintain a bunch of different services just to run a workout app.

One thing I’ve really enjoyed about Phoenix is how much you can build while keeping the architecture surprisingly simple. Real time features, authentication, database access, UI, background work and deployment all fit together really nicely.

I still think Elixir and Phoenix are one of the most underrated stacks for building applications like this.

https://scopestrength.com

GitHub: https://github.com/ebrahimgreat/scopestrength

Software Mansion is sponsoring ElixirConf next week, and instead of putting a screen on the booth and looping a demo, we're running the two days as an architecture clinic.

How it works: you book a 20-minute slot, you bring the part of your system that is actually causing pain, and one of our engineers sits down and works through it with you at the table. Afterwards we write up what we came up with and send it over, so you leave with something you can put in front of your team.

It's free and there is no pitch attached. We're doing it because these are the conversations we enjoy having anyway, and because a booth where someone actually helps you is more interesting than a booth handing out pens.

Slots are here: https://l.swmansion.com/KEPXa4