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

. WEEKLY PICKS .

🎯 Ash Framework Stops Being Scary with Real-World Domain Modeling

AppSignal published the clearest Ash explainer yet—building AshTherapy, an AI chat service with Users, Conversations, and Messages. No hand-waving about "declarative resources." Actual code showing how domains group business logic while Phoenix handles HTTP plumbing. The key insight: Ash isn't Rails for Elixir, it's a business layer that models entities and relationships without drowning you in boilerplate. If you've been waiting for Ash to click, this is the tutorial that finally explains *why* you'd reach for it instead of raw Ecto. Check out the AshTherapy codebase on branch post-1 to see domains and resources in production context.

Read the guide

🔬 The BEAM's Memory Copy Model Explained Without the Hand-Waving

Finally—a deep dive into what actually happens between socket arrival and your GenServer's mailbox. The controversial part: Elixir *copies* message data between processes instead of passing pointers like Go or Java. Why? Process isolation means crashes can't corrupt the network stack, and per-process GC eliminates stop-the-world pauses. The exception everyone misunderstands: Reference Counted Binaries kick in at 64 bytes, so your 1GB video upload doesn't murder RAM. This isn't trivia—understanding the copy semantics is how you debug production memory issues and scale past 50k concurrent connections. The article traces packets from NIC voltage spikes through kernel ring buffers to BEAM I/O polling threads.

Read this article

📄 Kreuzberg v4 Brings Rust-Powered Document Extraction to Elixir

Kreuzberg just shipped v4 with native Elixir bindings—extracts structured data from 56+ formats (PDFs, Office docs, HTML, images) without Python dependencies. The Rust rewrite killed the GIL bottleneck and dropped Pandoc entirely. Built for RAG/LLM pipelines with OCR, semantic chunking, and embeddings baked in. MIT-licensed, production-ready with REST API and Docker images. The polyglot angle matters: your Python ML pipeline and Elixir backend can use identical extraction logic. No more "we need a Python microservice just for PDF parsing." Plug it into your Phoenix app and parse invoices, resumes, or contracts without leaving the BEAM.

Check this out

⚡ Elixir 1.20 RC Ships Full Type Inference—Guards, Maps, Function Calls

The release candidate dropped with type inference across the entire language. Elixir now infers `data.foo + data.bar` expects a map with numeric keys—no signatures required. Guards get full inference: `when is_map_key(x, :foo)` tracks that x has the :foo key, `when not is_map_key(x, :foo)` marks it as `not_set()` and catches `x.foo` bugs at compile time. Maps finally support non-atom keys with full domain tracking. This isn't gradual typing bolted on—it's inference that looks at complex guards, tuple sizes, and map operations to find bugs without forcing type annotations. The type system now implements Giuseppe Castagna's 2023 research on typing records and maps. Test it before 1.20 ships stable.

Read the announcement

Stop Waiting for Type Annotations—Elixir's Inference Already Caught Your Bugs

The Elixir community spent years debating whether static typing would ruin the language's dynamism. Turns out everyone was arguing about the wrong thing. Elixir v1.20's type inference doesn't force you to annotate anything—it just silently catches bugs you didn't know existed.

Here's what makes this different from TypeScript's gradual typing or Python's type hints: Elixir's `dynamic()` type isn't a cop-out. When you mark something as `dynamic(integer() or float())` and then try passing it to a function expecting `binary()`, you still get a compile-time warning. The type system doesn't give up just because you introduced runtime dynamism—it tracks the range of possible types and validates against them.

This is fundamentally different from `any` in other languages, which essentially tells the type checker to look the other way. The real breakthrough is inference across all language constructs without annotations. Your existing pattern matches, guards, and control flow already contain enough information for the compiler to build a complete type graph. That `User.drive/2` function? The compiler infers struct shapes, union return types, and guard constraints without a single type signature.

That `User.drive/2` function? The compiler infers struct shapes, union return types, and guard constraints without a single type signature. This isn't theoretical—it's shipping in v1.20-rc.1 right now. The contrarian take: type annotations are often a crutch for weak inference engines. Elixir proved you can have sound, gradual typing that catches real bugs without making developers write types twice—once in their heads and once for the compiler. If your type system needs annotations everywhere, it's not smart enough.

Remember:

• Elixir's `dynamic()` type tracks possible runtime types and still catches violations—unlike `any` in TypeScript/Python

• v1.20 infers types from patterns, guards, and control flow without requiring annotations

• Sound gradual typing means warnings even with dynamic types—no silent failures

• Upgrade to v1.20-rc.1 now to catch bugs your tests missed

. TIRED OF DEVOPS HEADACHES? .

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 💜