Welcome to GigaElixir Gazette, your 5-minute digest of Elixir ecosystem news that actually matters.

This week, we dig into a Redis-compatible cache that embeds in your BEAM node, JavaScript running natively inside the BEAM, and formal verification you can write without learning TLA+ syntax.

Every Phoenix app ends up with the same stack: database, cache layer, app. Three things to deploy, three things to monitor, three things to hope stay connected. FerricStore collapses the cache into your BEAM node. Add it as a dependency, call FerricStore.set("key", "value"), and your data hits disk through Raft consensus and Bitcask append-only logs with fsync. When you get OK back, the write is durable. Not eventually. Not if the AOF rewrite finishes. On disk, right now.

The architecture is clean. Writes go through Raft (using the same ra library RabbitMQ runs on), then to a Rust NIF storage engine. Reads hit ETS first for microsecond responses, fall back to disk for cold data. The Rust NIF handles low-level I/O with pure stateless functions - no Mutex, no dirty schedulers, proper consume_timeslice yielding. You get 50+ Redis commands, RESP3 protocol support, probabilistic data structures (Bloom filters, HyperLogLog, T-Digest), and vector search built in.

The embedded mode is the real story. No connection pool. No "what happens when Redis is down." One deployment, one thing to monitor. For standalone use, docker run -p 6379:6379 and connect with redis-cli.

Check the hex package

A research project just dropped that runs JavaScript natively inside the BEAM VM with OTP supervision, native DOM access, and a built-in TypeScript toolchain. Quickbeam is not a port or a bridge - it is a JavaScript runtime that lives under BEAM supervision trees. Crashed JS process? Supervisor restarts it. The companion Volt asset pipeline integrates directly with Elixir projects.

This is not Hologram compiling Elixir to JS or Node interop through ports. Quickbeam embeds an actual JavaScript engine supervised by OTP. The implications for polyglot teams are significant - JavaScript developers can write frontend logic that runs on the same runtime as their Elixir backend, with the same fault tolerance guarantees. Whether that is a good idea is a separate conversation entirely.

Watch the episode

The elixir-lang/expert repository tagged v0.1.0 - the first stable release of Elixir's official Language Server Protocol implementation. After six release candidates, the LSP handles umbrella apps without spawning duplicate engines, fixes Windows startup issues, prevents recursive alias generation for nested modules, and ships performance improvements by loading the module store after build.

This matters because LSP quality directly affects developer retention. Every "go to definition" failure and every missed autocompletion is friction that pushes developers toward languages with better tooling. Expert v0.1.0 is Elixir saying the tooling gap is closing - with official backing, not community goodwill alone.

See the release

Matthew Sinclair's Part 3 of "Building GPT from Scratch in Elixir" implements the full self-attention mechanism. Query-key-value projections, scaled dot-product attention, multi-head parallelism, and KV caching - all in pure Elixir with Value nodes from the autograd engine built in Part 1.

The implementation makes transformer internals explicit in ways Python frameworks hide. Each attention head slices the embedding with Math.slice, computes dot products against cached keys, applies softmax, and produces weighted sums of values. The KV cache uses prepend-then-reverse - standard functional pattern, O(1) prepend, one reverse per attention computation. The MLP block is five operations in a pipeline with a residual connection. Elixir's pipe operator makes the data flow readable in a way that PyTorch's method chaining obscures.

Read the deep dive

Every LiveView developer has hit this: user fills a complex form, WebSocket disconnects, state vanishes. URL parameters handle simple cases but fall apart with nested data. Database persistence is overkill for ephemeral UI state. LiveStash fills the gap with two strategies - ETS adapter keeps state server-side with minimal overhead, browser memory adapter offloads state to the client so it survives full server redeploys.

The distributed systems angle is what makes this interesting. Server-side state persistence across reconnects means handling node failures, rebalancing, and the fundamental tension between consistency and availability for UI state. The blog post from Software Mansion details the technical implementation and the tradeoffs between their two adapter strategies. If you have ever debated where LiveView state should live during a deploy, this library picked a side and shipped it.

Read the announcement

TLX lets you write TLA+/PlusCal formal specifications in Elixir syntax and verify them with TLC, the TLA+ model checker. Define variables, actions with guards and transitions, invariants, and temporal properties using a Spark DSL. TLX emits valid TLA+ that TLC exhaustively explores - every reachable state checked for race conditions, deadlocks, invariant violations, and liveness failures. The kind of bugs that testing and code review miss because they require specific interleavings of concurrent operations.

The tooling is where this gets practical. mix tlx.simulate runs a random walk in pure Elixir without needing Java. mix tlx.check invokes the real TLC model checker and formats counterexample traces. mix tlx.gen.from_state_machine generates a spec skeleton from an existing GenStateMachine module - so you can verify code you already wrote, not just greenfield designs. The author built this because TLA+ syntax was the barrier to formal verification, not the concepts. Amazon, Microsoft, and MongoDB use TLA+ to find distributed systems bugs. Now Elixir developers can too, without leaving their language.

Remember for formal verification:

Explore TLX on Hex

Deploy your next Elixir app hassle-free with Gigalixir and focus more on coding, less on ops.

We're specifically designed to support all the features that make Elixir special, so you can keep building amazing things without becoming a DevOps expert.

See you next week,

Michael

P.S. Forward this to a friend who loves Elixir as much as you do 💜