Introducing AshStudio: A VS Code Extension for the Ash Framework
AshStudio is a Visual Studio Code extension purpose-built for Ash Framework projects. With AshStudio, you get a better experience for building Elixir applications with Ash.
🚀 Key Features
Intuitive Section Navigation: Jump between top-level sections of your Ash resources with Ctrl+Shift+P, breadcrumbs, and a custom sidebar. The extension parses your codebase, so navigation is always context-aware and lightning fast.
Jump-to-Definition: Ctrl+Click navigation to actions, aggegates, attributes, calculations, and resource definitions.
Mermaid Diagram Generation and Viewing with CodeLens: Instantly visualize relationships and resource diagrams right in your editor. CodeLens annotations provide one-click access to diagrams, making it easier to understand and communicate your architecture.
Available in both the Microsoft store and OpenVSX. Check out the github repo for more.
Elixir Hub: An adoption & engineering entry point to the ecosystem
Speaking to many members of the Elixir community including developers as well as technical and business decision-makers, we’ve identified that the Elixir ecosystem needs a curated and showcase of business adoption in digital products.
That’s why we’ve created the Elixir Hub, showcasing adopters, knowledge resources and other valuable Elixir-related information.
Visit the Elixir Hub here: https://curiosum.com/sl/jwko5i56
Thinking Elixir 264: Hot Reload In Dev and QA Bottlenecks
Episode 264 of Thinking Elixir. News includes Phoenix v1.8 shipping with an AGENTS markdown file for new apps to enhance coding agent experiences, Popcorn bringing Elixir to the browser through WebAssembly with no installation required, LiveVue v0.6.0 with 90% payload size reduction through JSON Patch operations, an awesome LiveView development tip for hot-reloading code changes while preserving LiveView state, MDEx v0.8 adding decorators support for enhanced code block styling, Hologram v0.5.0 delivering major performance improvements with milliseconds to microseconds execution times, ElixirConf US 2025 tickets available with our discount code, and a discussion about how AI-generated code is creating new bottlenecks in QA and code review processes, and more!
Understanding Stack Traces in Elixir
Let’s explore the fundamentals of stack traces in Elixir, how to read and interpret them, and some best practices for debugging and error handling: https://blog.appsignal.com/2025/08/05/understanding-stack-traces-in-elixir.html
Free security audits for Elixir open source projects
learn more: https://www.erlang-solutions.com/blog/supporting-the-beam-community-with-free-ci-cd-security-audits/
What the Free CI/CD Audits Offer
Erlang Solutions’ free CI/CD security audits for open source projects are powered by SAFE (Security Audit for Erlang/Elixir), a dedicated solution built to detect vulnerabilities in Erlang and Elixir code that could leave systems exposed to cyber attacks.
The CI/CD version of SAFE integrates directly into your development pipeline (e.g. GitHub Actions, CircleCI, Jenkins), enabling you to scan for vulnerabilities automatically every time code is committed or updated. This helps projects:
Detect issues early, before they reach production Maintain a more secure and resilient codebase Improve visibility of risks within day-to-day workflows Results are delivered quickly– typically within a few minutes. For larger codebases, it may take up to 20–30 minutes. The feedback is designed to be clear, actionable, and minimally disruptive.
parrot_platform - Putting the “T” Back In OTP
Parrot Platform is a real-time communication platform built the Elixir way. Parrot Platform provides Elixir libraries and OTP behaviours implementing the SIP (Session Initiation Protocol) stack and leveraging Membrane multimedia libraries for media streaming.
🔥 CodeBEAM Europe 2025 speakers!
@bitcrowd - LLM logits processing, Coby Benveniste - AI with gen_statem, Dan Janowski - Champion the BEAM, Daniel Gorin - New debugger, Daniil Popov - Olympics broadcasts, Dániel Horpácsi & Péter Bereczky - Formal methods
ElixirConf US- Keynote announcement - Josh Price
Don’t miss the #ElixirConf US keynote by @joshprice - founder of @Alembic, polyglot dev & tooling enthusiast. He’s sharing lessons from years of building ambitious software with smart teams & better processes. https://elixirconf.com/participants/josh-price/
ElixirConf US- Keynote announcement - Josh Price
Don’t miss the #ElixirConf US keynote by @joshprice - founder of @Alembic, polyglot dev & tooling enthusiast. He’s sharing lessons from years of building ambitious software with smart teams & better processes. https://elixirconf.com/participants/josh-price/
100+ plants, billions of daily messages, 50+ applications
Schaeffler built a global NATS mesh that just works Schaeffler’s Max Arndt and Jean-Noel Moyne from Synadia spill the secrets at MQSummit 2025 https://mqsummit.com/talks/nats-on-edge/
Elixir and Gleam in top 3 most admired languages!
According to SO Developer Survey 2025: Elixir again on the podium https://survey.stackoverflow.co/2025/technology/#admired-and-desired
TantivyEx: search engine library NIF
TantivyEx provides a complete NIF wrapper to Tantivy, Rust full-text search library. Build powerful search applications with support for all Tantivy field types, custom tokenizers, schema introspection, and advanced indexing features.
Online Elixir Meetup Aug 4 - What's Next for Elixir Security
Monday, August 4, 6pm MDT the online Denver Elixir Meetup is happening! Join for a talk by Holden Oullette, “What’s Next for Elixir Security”
Holden currently works for Netflix (not Paraxial.io, despite the similarities in appearance with Michael some have noted) and maintains the open source Sobelow security scanner for Elixir. Hope to see you there!
https://www.meetup.com/denver-erlang-elixir/events/310256108
A Practical Look at SAFE and Security in the BEAM Ecosystem
How do you make sure security holds up in real-world BEAM projects? Jonatan Männchen (CISO at the Erlang Ecosystem Foundation) spoke with Erlang Solutions about using the Security Audit for Erlang/Elixir (SAFE) to review an OIDC client library.
Part 1 – [SAFE and OIDCC] How the audit process worked, what was found, and how it improved the code. https://www.erlang-solutions.com/webinars/safe-and-oidcc/
Part 2 – [Security and the BEAM Ecosystem] Covers CVEs, common risks, and how the EEF is supporting better security across the ecosystem. https://www.erlang-solutions.com/webinars/security-and-the-beam-ecosystem/
Short, practical, and one to add to your listening if you’re working with Erlang, Elixir, or anything BEAM-based.
Thinking Elixir 263: BEAM Scales from Nano to BBC Big
Episode 263 of Thinking Elixir. News includes the BEAM runtime fitting into just 16MB for the GRiSP Nano prototype, the BBC using Elixir to serve most of their web and mobile traffic, GenStage’s pull-based design delivering 50% performance improvements, a new PDF data extraction library that leverages Python through PythonX, AppSignal’s guide to deploying Phoenix with Kamal, an Elixir School lesson on embedding Lua in applications, Peter Solnica’s new inflection library for word transformations, Fly.io announcing Docker Compose compatibility for multi-container deployments, and the full ElixirConf 2025 agenda going live with discount tickets available, and more!
Learn to untangle your data layer & build admin tools that almost write themselves.
Don’t miss Stephanie Lane’s talk as she takes us on a visual journey through Elixir’s config layers! Save your spot. https://elixirconf.com/talks/elixir-s-configuration-layers-a-visual-journey/
Instrumenting HTTP server by making requests without curl
https://ievgenpyrogov.com/requests-without-curl/
Tracing execution of entire HTTP requests in Elixir can be tricky because of the inherent nature of the short-lived processes handling them. Is there a way to simulate the HTTP request, while allowing room for the set up any instrumentation?
In this blog post I show how to do it without modifying application code.
Integrating Generative AI into Elixir-based applications by using the Jido agentic framework
In this case study, we showcase how Elixir unlocks a fundamentally better architecture for building autonomous AI agents. Most agentic AI frameworks today are built in Python—and they buckle under the pressure of concurrency, crash recovery, and distributed deployments. We took a different path.
First-class gRPC Streams in Elixir
First-Class gRPC Streams in Elixir: A new composable API
For a long time, the Elixir community has lacked a truly idiomatic way to handle gRPC streaming. While unary RPCs have always been well-supported in the elixir-grpc library, stream handling felt incomplete — too low-level and too imperative for a language that thrives on functional and reactive principles.
This gap was finally addressed in issue #270, which led to a major improvement: first-class support for gRPC streams using a functional and declarative API that fits seamlessly into the Elixir ecosystem.
🚀 This new API is available starting from
elixir-grpc
version 0.10.0 — with the latest release being 0.10.2.
It’s worth highlighting the irony: while Elixir is inherently concurrent and reactive — thanks to the BEAM and its actor-based model — its gRPC streaming capabilities lagged behind those found in other ecosystems.
Languages like Java (via Project Reactor or RxJava), Kotlin (with coroutines and Flows), and JavaScript (using RxJS or async iterators) have long embraced reactive paradigms for working with gRPC streams. These models allowed developers to work with streams as composable, functional data flows.
Until recently, Elixir developers lacked similar expressive power. The new API introduced in version 0.10.0
finally brings that same level of expressiveness and control to the Elixir world — and in a way that feels natural, pure, and declarative.
A Functional API for Streaming
The new streaming API is designed around stream composition and functional data flows, relying on GRPC.Stream
to model and process streaming inputs and outputs. This new abstraction enables a developer experience that feels intuitive, powerful, and aligned with some Elixir’s design principles.
Here’s an example of the new API in action:
defmodule HelloworldStreams.Server do
@moduledoc false
use GRPC.Server, service: Stream.EchoServer.Service
alias HelloworldStreams.Utils.Transformer
alias GRPC.Stream, as: GRPCStream
alias Stream.HelloRequest
alias Stream.HelloReply
@spec say_unary_hello(HelloRequest.t(), GRPC.Server.Stream.t()) :: any()
def say_unary_hello(request, _materializer) do
GRPCStream.unary(request)
|> GRPCStream.ask(Transformer)
|> GRPCStream.map(fn %HelloReply{} = reply ->
%HelloReply{message: "[Reply] #{reply.message}"}
end)
|> GRPCStream.run()
end
@spec say_server_hello(HelloRequest.t(), GRPC.Server.Stream.t()) :: any()
def say_server_hello(request, materializer) do
create_output_stream(request)
|> GRPCStream.from()
|> GRPCStream.run_with(materializer)
end
defp create_output_stream(msg) do
Stream.repeatedly(fn ->
index = :rand.uniform(10)
%HelloReply{message: "[#{index}] I'm the Server for #{msg.name}"}
end)
|> Stream.take(10)
|> Enum.to_list()
end
@spec say_bid_stream_hello(Enumerable.t(), GRPC.Server.Stream.t()) :: any()
def say_bid_stream_hello(request, materializer) do
output_stream =
Stream.repeatedly(fn ->
index = :rand.uniform(10)
%HelloReply{message: "[#{index}] I'm the Server ;)"}
end)
GRPCStream.from(request, join_with: output_stream)
|> GRPCStream.map(fn
%HelloRequest{} = hello ->
%HelloReply{message: "Welcome #{hello.name}"}
output_item ->
output_item
end)
|> GRPCStream.run_with(materializer)
end
end
As seen in the example above, composing different stages in the streaming pipeline is straightforward. Each step in the transformation can be expressed clearly, making the overall flow easier to follow and reason about.
To support this, the GRPC.Stream
module offers a set of functions designed to operate directly on the stream, such as map
, filter
, flat_map
, partition
, reduce
, uniq
and so on. These utilities provide the flexibility needed to build expressive and efficient streaming logic while maintaining clarity and composability throughout the pipeline.
Conclusion
The introduction of a first-class streaming API represents a meaningful step forward for the Elixir gRPC ecosystem. It provides a more consistent and idiomatic way to implement streaming services using well-established functional constructs.
This new approach makes it easier to model real-time interactions, handle bi-directional communication, and process data streams using composable and readable code.
Further details and examples can be found in the official elixir-grpc repository and hex.
The Alchemy of Security
. @mattludwigs, Sr. Software Engineer at @River, brings nearly a decade of Elixir experience to #ElixirConfUS!
In “The Alchemy of Security”, he’ll share practical techniques for crafting secure Elixir apps from Phoenix to Nerves. https://elixirconf.com/talks/the-alchemy-of-security-crafting-secure-applications-in-elixir/