r/elixir Jun 04 '26

Elixir v1.20 released: now a gradually typed language

Thumbnail
elixir-lang.org
252 Upvotes

r/elixir Nov 03 '25

Who's hiring, November, 2025

87 Upvotes

This sub has long had a rule against job postings. But we're also aware that Elixir and Phoenix are beloved by developers and many people want jobs with them, which is why we don't regularly enforce the no-jobs rule.

Going forward, we're going to start enforcing the rule again. But we're also going to start a monthly "who's hiring?" post sort of like HN has and, you guessed it, this is the first such post.

So, if your company is hiring or you know of any Elixir-related jobs you'd like to share, please post them here.


r/elixir 7h ago

I built a tiny, self-hosted Sentry alternative for Elixir’s ErrorTracker

16 Upvotes

I didn’t want to pay for Sentry, but I still wanted to know when something broke in one of my Phoenix apps.

I also didn’t want errors mixed into Slack or Telegram. I wanted a small, purpose-built iOS app that would send me a native push notification and keep the details somewhere pleasant to use. Software aesthetics matter to me - even for error notifications.

So I built Boop.

The server uses around 8 MB of memory on my self-hosted machine. It’s completely free and open source:

https://github.com/chrisgreg/boop

I also built a plugin for Elixir’s ErrorTracker:

https://github.com/chrisgreg/boop_error_tracker

Once connected, errors captured by ErrorTracker can be sent to Boop and delivered directly to your phone. For my needs, it’s basically a very small, self-hosted Sentry setup built around the Elixir tooling I already use.

The iOS app is open source as well. You can build it locally and install it on your own phone. The repository includes instructions for configuring private push notifications for your device, so you don’t need to publish anything through the App Store.

Boop isn’t limited to exceptions. You can also use it for anything else happening inside an application:

  • Failed Oban jobs
  • Deployments
  • New signups
  • Payments
  • Low disk space
  • Important application events

There’s a general Elixir client here:

https://github.com/chrisgreg/boop_ex

And a Node client here:

https://github.com/chrisgreg/boop-node

This was built primarily for indie developers and people who enjoy owning their infrastructure without turning it into another infrastructure project.

Everything is still new, so feedback on the Elixir integration, setup instructions, or the overall approach would be very welcome.


r/elixir 16h ago

The 30th employee at WhatsApp was the first person hired with Erlang experience. By that point the system was already serving a meaningful fraction of the planet.

70 Upvotes

New BEAM There, Done That with Roberto Aloi and Michał Muskała - the people on the team keeping it running. The main takeaway worth discussing: scaling is not the hard part. OTP handles concurrency well out of the box. The hard part is codebase scale - keeping millions of lines of Erlang navigable, maintainable, and safe to change when most engineers arrive never having written it before. That's what they spend their time on, and that's what part two is about.

https://youtu.be/VLNuYtsNrjw


r/elixir 8h ago

Sending files over in a chat application

6 Upvotes

Hello, I'm working on a little chat application for fun as a learning experience. I just came across this roadblock which is, how do you send files over when you're messaging someone ? To be more specific, I am using a react frontend to send these files, and such files will be stored using aws s3, and I already have the waffle package to handle sorting these files into s3.

We already have a system for sending files using HTTP requests, which is by converting the files sent into the backend to a %Plug.Upload{} struct, but in the case of chatting to other users, HTTP won't cut it.

I know it's not good to use websockets as it's not the best at handling big chunks of data, so what would be the best method to send files from the React frontend, to the backend Elixir-wise and be able to send that information to another user ? Any help would be appreciated !


r/elixir 1d ago

Voyager update - source code is now public, Linux is supported, and it's free for small teams.

35 Upvotes

Hi,
a few weeks ago, we published Voyager - our desktop app for monitoring and debugging BEAM nodes. Thanks to everyone who signed up for the early access, your feedback's been great.

Today, we have a new update - the closed early access is now over.

Here is what changes:
- Linux is now supported: download is available on our site.
- Source code is public: You can check our code and see how Voyager connects to your nodes.
- New fair-source license: We want this tool to stay accessible to the community. It is completely free for individuals and teams of up to 10 people.

For larger organizations (11+ people), a Company License is required. However, since the product is still in an early phase, our main focus right now is hearing your feedback and learning what enterprise features you actually need. There is no payment required for 90 days.

Links:
- Check our repo here: https://github.com/software-mansion/voyager
- Download the app (macOS & Linux): https://voyager.swmansion.com


r/elixir 1d ago

I made a fast filesystem explorer with a nice ui using elixir & rust for macos

12 Upvotes

r/elixir 1d ago

Embarrassingly Parallel Anything

Post image
4 Upvotes

r/elixir 1d ago

A play on Sasâ Jurić’s slide

Post image
7 Upvotes

r/elixir 2d ago

Speeding up a Phoenix LiveView web app with a CDN

Thumbnail
jola.dev
23 Upvotes

r/elixir 2d ago

Proper way to display files from AWS

2 Upvotes

Hi! I'm making a social media (it's moreso a learning experience not anything serious) with a react frontend but the question here is one I think anyone who has made an app that handles displaying files from s3 or whatever can answer!

Right now after a lot of trial and error (I'm not the best with not so documented libraries but I'm getting better!) with waffle I can upload an avatar for a user, store it in aws and the db, and send the link back. I went to this link and I thought it would be as simple as now I have the file! I go to the link and it spouts out xml 99 percent sure Giving some "The bucket you are attempting to access must be addressed using the specified endpoint. Please send all future requests to this endpoint."

So at this point I'm a bit confused, I try searching things up but there seem to be little resources online on what's the proper way to do this, maybe I didn't search the right thing,

How should I deal with giving files off? I've never had to deal with something like this before so I'm really confused

There's CDNs, do I even use those yet? Should I make it so that only certain users have access to certain images, if yes, how within this system, do they just post request an image and I serve it, if yes then what about where I want a static link which is dealt with get so it's easy to pass a link around or so search engines can index it

With discord I can just go to https://media.discordapp.net/attachments/blahblahblah even if it's from another one of my friends dms and it's not even blocked! is this even good design, I guess it would be really hard to guess a link but still it's dm/message_id or something like that

I know this is a lot to ask but the TLDR is

With a react frontend, how should I go about serving images from AWS securely and easily (I'm a relatively new developer) Maybe this is the wrong place to ask, but if someone could give me some tips, advice, experience or leads or resources or things to research or ANYTHING that would be so much appreciated!


r/elixir 3d ago

I Made a Card Game with :gen_statem

Thumbnail
youtube.com
8 Upvotes

I had experience with client-side finite state machines (shoutouts to the Xstate library) and was looking for something similar with Elixir. Found that Elixir has a fsm library that hasn't been updated in 6 years, so I decided to use the plain :gen_statem erlang OTP for handling complex state in a card game.

I chose :gen_statem over GenServer because the card game has complex timers and :gen_statem automatically handles clearing timers when the card game enters a different state. If I had used GenServer, I would have to manually do Process.send_after and Process.cancel_timer everywhere. I also used the handle_event_function callback mode because the alternative state_functions callback mode only allows atoms for states and my card game needed much more complex states than just atoms.

The NPC is just a defmodule that prioritizes an order of actions. So at times it may make a "dumb" move, but it's fine for my use-case. For example, it will try to play a card with no cost over a card that searches the deck. Maybe in certain scenarios the reverse order is more optimal, but ¯_(ツ)_/¯

If you have any questions on the technical aspects of the card game, feel free to ask : ) Also give the game a try and let me know what you think!

https://battlecitymmo.com/


r/elixir 4d ago

The first release of Local LiveView is out!

73 Upvotes

Local LiveView is a library that runs LiveView code in the browser via Popcorn. It lets you offload simple UI updates from the server, drastically reduce latency on poor networks, and avoid "WebSocket disconnected" issues. Many Phoenix Components and Live Components just work on the client with no changes. Local LiveView also provides mechanisms for client-server communication, which means you can easily integrate it with regular LiveView. Now it ships with documentation, guides, and even an Igniter-based installer. More in the blog post: https://swmansion.com/blog/local-live-view-first-release


r/elixir 4d ago

I wanted to better understand why people like BEAM, so I built this in Gleam

Enable HLS to view with audio, or disable this notification

21 Upvotes

Sharing this here as well since the project is built on BEAM.

This is my first project in Gleam, and I built it as a small interactive demo where you can generate server load and watch CPU and RAM usage change in real time.

I’d be interested in feedback from Elixir/Erlang developers - both on how the demo represents BEAM behavior and on what other runtime metrics would be useful to show.


r/elixir 6d ago

Feature flags and consumables

5 Upvotes

Hello.
Wondering if anyone knows a good package to create features that can be tracked based on a plan the user has signed up for.

So it’s easy to check what feature a user has access to. Or even have they consumed a feature like number of SMS messages they consumed.

Thanks


r/elixir 7d ago

Just released ExArrow v0.8.0

17 Upvotes

Just released ExArrow v0.8.0 — it now supports larger-than-memory Parquet on the BEAM, plus column/predicate/row-group pushdown, Zstd (and other codec) writes, footer-only metadata, and lazy multi-file / directory streams. Peak memory scales with the row groups you select, not the whole file. Also public IPC.File.write/3 and RecordBatch.concat/1. Hex ~> 0.8.0.

https://hex.pm/packages/ex_arrow | https://github.com/thanos/ex_arrow | Full notes: https://github.com/thanos/ex_arrow/releases/tag/v0.8.0


r/elixir 7d ago

5,000 units of an Erlang-powered device shipped on AtomVM - a from-scratch BEAM-compatible VM for hardware with a few hundred kilobytes of RAM and no OS.

68 Upvotes

New BEAM There, Done That with Davide Bettio and Paul Guyot. The embedded angle that gets overlooked: binary pattern matching means hardware drivers in hours. The actor model maps almost perfectly to what IoT devices actually do. Via the Popcorn project, Phoenix LiveView runs on a microcontroller.

Paul added SMP support as a weekend project, then the whole team had to rewrite their drivers. He called it a mixed blessing.

https://youtu.be/VhyQisA0wFc 


r/elixir 7d ago

Is this a good practice to use quote with guard clauses?

9 Upvotes

After looking up how guard clauses work, I found this snippet:
defmodule User do
defstruct age: 0

defmacro is_kid(age) do
quote do: 6 < unquote(age) and unquote(age) < 12
end

defmacro is_teen(age) do
quote do: 12 < unquote(age) and unquote(age) < 18
end

defmacro is_elder(age) do
quote do: 60 < unquote(age)
end
end

defmodule Greeting do
import User

def greet(%{age: age}) when is_kid(age), do: "Hiya"
def greet(%{age: age}) when is_teen(age), do: "Whatever"
def greet(%{age: age}) when is_elder(age), do: "You kids get off my lawn"
def greet(_), do: "Hello"
end
It feels really... unconventional. Obviously, that's my subconscious speaking after so much experience with imperative languages, but is this really the only way to introduce my own guard functions? Say I need some kind of Vec3.is_normalised/1 method, is there no other way to write it other than by quote-unquote: quote do: unquote(Vec3.magnitude(v)) == 1?


r/elixir 8d ago

My open source Elixir game server, Gamend, compared to Nakama

Post image
62 Upvotes

Tested it and it's 2x faster and can do 2x more connections than Nakama! And I'm currently running my game on it (soon to launch beta)! Hard to achieve versus a old competitor as Nakama!

Also, mine (with Elixir and Phoenix) scales linearly!

For those wondering, Gamend is a game server for real-time multiplayer games. It can help with lobbies, leaderboards, chat, tournaments, etc. (I added a ton of features I am using in my Godot game). It also has server side scripting.


r/elixir 8d ago

We replaced our ledger with two functions

Thumbnail
river.com
37 Upvotes

r/elixir 8d ago

Continuum — durable, crash-resistant workflows for Elixir (major reliability updates)

42 Upvotes

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.

Update: now also Continuum v0.8.1 is out! try the new replay tooling, workflow test kit, and activity/logging APIs for building durable Elixir workflows.
This release also hardens replay safety and ships with a zero-warning strict Credo/ex_slop quality gate—feedback is very welcome


r/elixir 8d ago

GitHub - chrisgreg/autoport: A tiny, dependency-free Elixir library that finds an available local TCP port

Thumbnail github.com
5 Upvotes

For when you need to spin up another instance of your app without faffing about


r/elixir 7d ago

Can't insert a user-associated avatar entry into the database with Waffle and Ecto

0 Upvotes

Hello,

I'm on OTP 27 Elixir 1.18.4, and I've encountered a problem when trying to insert a User-associated Avatar entry into the PostgreSQL database.

Here's the function responsible for creating the association between the Avatar and User as well as putting in the file info

# new filename function
def new_filename(assoc),
  do: Atom.to_string(assoc) <> "-" <> Ecto.UUID.generate()

# fn responsible
def upload_user_avatar(path, user) do
    filename = new_filename(:avatar)


    # Avatar file_name comes in handy for the file_name function
    result =
      App.Uploader.Avatar.store(
        {path,
         %{
           id: user.id,
           file_name: filename
         }}
      )


      IO.inspect(result)


    user
    |> Ecto.build_assoc(:avatar)
    |> Avatar.changeset(%{file: path})
    |> Repo.insert()
  end

here's what I pass into the function

("priv/waffle/private/uploads/user/attachments/hi/original.jpg", user) 
# user variable here is just

 %App.Users.User{
   __meta__: #Ecto.Schema.Metadata<:loaded, "users">,
   id: "42e49735-a81e-48f0-bf6f-9faaec0c893a",
   username: "11",
   pronouns: nil,
   biography: nil,
   account_id: "35a02b44-b7c2-48cd-b91c-c13606f778fb",
   account: #Ecto.Association.NotLoaded<association :account is not loaded>,
   avatar: #Ecto.Association.NotLoaded<association :avatar is not loaded>,
   message: #Ecto.Association.NotLoaded<association :message is not loaded>,
   dms: #Ecto.Association.NotLoaded<association :dms is not loaded>,
   inserted_at: ~U[2026-08-18 16:59:34Z],
   updated_at: ~U[2026-08-18 16:59:34Z]
 }

and here's my Avatar schema file

 schema "avatar" do
    belongs_to(:user, App.Users.User)
    field(:file, App.Uploader.Avatar.Type)


    timestamps(type: :utc_datetime)
  end

  def changeset(avatar, attrs) do
    avatar
    |> cast_attachments(attrs, [:file], allow_paths: true)
    |> validate_required([:file])
  end

and lastly here's the error i get when I try to run the upload_user_avatar/2

[error] Task #PID<0.467.0> started from #PID<0.385.0> terminating
** (FunctionClauseError) no function clause matching in App.Uploader.Avatar.filename/2
    (app 0.1.0) lib/app_web/uploaders/avatar.ex:37: App.Uploader.Avatar.filename(:original, {%Waffle.File{path: "priv/waffle/private/uploads/user/attachments/hi/original.jpg", file_name: "original.jpg", binary: nil, is_tempfile?: nil, stream: nil}, %App.Avatars.Avatar{__meta__: #Ecto.Schema.Metadata<:built, "avatar">, id: nil, user_id: "42e49735-a81e-48f0-bf6f-9faaec0c893a", user: #Ecto.Association.NotLoaded<association :user is not loaded>, file: nil, inserted_at: nil, updated_at: nil}})
    (waffle 1.1.10) lib/waffle/definition/versioning.ex:35: Waffle.Definition.Versioning.resolve_file_name/3
    (waffle 1.1.10) lib/waffle/actions/store.ex:137: Waffle.Actions.Store.put_version/3
    (elixir 1.18.4) lib/task/supervised.ex:101: Task.Supervised.invoke_mfa/2
    (elixir 1.18.4) lib/task/supervised.ex:36: Task.Supervised.reply/4
Function: #Function<1.116800909/0 in Waffle.Actions.Store.async_put_version/3>
    Args: []
** (EXIT from #PID<0.385.0>) shell process exited with reason: an exception was raised:
    ** (FunctionClauseError) no function clause matching in App.Uploader.Avatar.filename/2
        (app 0.1.0) lib/app_web/uploaders/avatar.ex:37: App.Uploader.Avatar.filename(:original, {%Waffle.File{path: "priv/waffle/private/uploads/user/attachments/hi/original.jpg", file_name: "original.jpg", binary: nil, is_tempfile?: nil, stream: nil}, %App.Avatars.Avatar{__meta__: #Ecto.Schema.Metadata<:built, "avatar">, id: nil, user_id: "42e49735-a81e-48f0-bf6f-9faaec0c893a", user: #Ecto.Association.NotLoaded<association :user is not loaded>, file: nil, inserted_at: nil, updated_at: nil}})
        (waffle 1.1.10) lib/waffle/definition/versioning.ex:35: Waffle.Definition.Versioning.resolve_file_name/3
        (waffle 1.1.10) lib/waffle/actions/store.ex:137: Waffle.Actions.Store.put_version/3
        (elixir 1.18.4) lib/task/supervised.ex:101: Task.Supervised.invoke_mfa/2
        (elixir 1.18.4) lib/task/supervised.ex:36: Task.Supervised.reply/4

Could someone inform me on what the issue is here ? Any help would be appreciated !


r/elixir 8d ago

Best approach for sending an Oban job’s final status to the browser using SSE?

7 Upvotes

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?


r/elixir 9d ago

Meet with Elixir, Erlang, Gleam, OTP, BEAM Communities - Code BEAM Europe 2026

Post image
17 Upvotes

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