Wrote about how to safely run a globally unique process in an Elixir cluster, and a scary story from the past!

Learn about `:global` for registering unique processes in a cluster, and where using it can go horribly wrong. Or at least, a little bit wrong. And how to avoid weird edge cases. This was a lot of fun and nostalgic to write, hope you enjoy it

I have spent the past 2 weeks experimenting with the idea of adapting the tiling model used by window managers like TUIOS or BSPWM. The experiment became Jigsaw.

Jigsaw represents the layout as a binary tree. The tree is then fed to a Phoenix component that will handle rendering the panes recursively using flexbox.

The layout is separated from phoenix deliberately in order to allow changes down the road where we want the tree to track dimensions of panes and other enhancements. A pane on the phoenix component should not care what is inside it. It can contain plain HTML or another liveview component.

For Example:

<JigsawComponents.Components.layout jigsaw_layout={@layout} >
  <:pane id="terminal">
    <!-- phoenix component that can be rendered in a slot -->
  </:pane>

  <:pane id="stats">
    <!-- phoenix component that can be rendered in a slot -->
  </:pane>
</JigsawComponents.Components.layout>

The current v0.1.0 is deliberately experimental and subject to a lot of breaking changes. I am currently building the demo application which I shall link when it is live.

Hexdocs: https://jigsaw.hexdocs.pm/

Github: GitHub - W3NDO/jigsaw: POC of a liveview tiling manager · GitHub

Happy to hear your feedback on architecture and API, and perhaps what you would build with such a library.

Also any mistakes and anti-patterns in the code are entirely my own lol.

Hi everyone! We (Software Mansion) are co-hosting an Elixir meetup with dscout at their Chicago office on Wednesday 9 September, the evening before ElixirConf kicks off. Doors at 6 PM, a few talks, then pizza and beer and hanging around talking to people.

Two talks confirmed so far:

• Dima Mikielewicz on Legion

• Leandro

  Pereira

• from Supabase on MDEx

We have one slot left and would rather give it to someone from the community than fill it ourselves. If you have something Elixir-related you've been wanting to talk about, let us know here: https://forms.gle/GNnzRXRwgdmeuggs5
It doesn't need to be polished, and a first-time talk is completely fine.

It's free, but places are limited by the size of the office, so RSVP here if you're coming: https://luma.com/byem6v75

Hello.

This is my first fully functional product written in Elixir. I built it for myself, for monitoring jobs in my other projects, but I've decided to make it available for everyone.

It's cron job monitoring - job calls a url when it finishes, and if the call doesn't come on time app sends an alert. Each monitor is just a GenServer sitting on a timer. No polling the DB to find what is late.

It's free up to 20 monitors. You can test it and tell me what you think.

Feel free to leave comments, I'll appreciate your feedback.

Link to website: https://didit.run

Just a reminder for anyone still on the fence: early bird pricing for Code BEAM Europe closes on 8 September at 23:59 CEST. This is the last chance to get your ticket 20% cheaper before prices go up.

21-22 October in Haarlem + a full online option if you cannot make the trip. Two days of Erlang, Elixir and Gleam, real production stories, and demos from people building the tools we all use.

If you have been meaning to book, now is the time.

Register here: codebeameurope.com/#register

We hope to see you there!
The Code Sync Team

I have an elixir app running in production, and with some recent changes (mostly library updates due to CVEs) it's started leaking memory, which is resulting in pods restarting.

I think I know what the cause might be, but just wondering if there are any techniques for debugging this that I'm not aware of.

We're now just 10 days out from ElixirConf US 2026, and we wanted to give the forum a proper heads-up, with a little thank-you discount attached.

📅 Dates: September 10–11, 2026
📍 Where: Chicago, IL (and streamed live everywhere)

Two days of production war stories and real scaling challenges, deep dives into Phoenix, LiveView, OTP, Nerves & Nx, keynotes including "Set-Theoretic Types from Scratch" with José Valim, and hallway-track conversations with the people who maintain the libraries you actually ship on. Meeting the community in person is the part you can't stream - grab an in-person ticket while they last.

Not in the area? No problem. The virtual pass gets you every talk streamed live, the conference app, live Q&A, and early access to the recordings. Same content, from wherever you are.

See you in Chicago - or on the stream! 🔥
The ElixirConf US Team

An educational side project in Elixir, Phoenix, and Tauri. I share what I learned while wiring Automerge into the BEAM, including how I surfaced edit and delete conflicts for users.

I'm very new to the language and I'm very confused on some things. Coming from imperative langs, I'd assume that modifying tuples is very fast since they're basically just vectors. Unfortunately, they're also immutable like every other data structure in the whole language. So, if I want to make, say, a Canvas data type that holds all my pixels in a 2d data structure, is there literally no way to make it even if a little more efficient than just making a new one every single time I update a pixel? Even if I made it a 1d data structure, is Elixir just the wrong tool here?

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.

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

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 !

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

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!

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/

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

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.

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

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