Elixir Wizards

Today, the Elixir Wizards wrap up Season 14 “Enter the Elixirverse.” Dan, Charles, and Sundi look back at some common themes: Elixir plays well with others, bridges easily to access languages and tools, and remains a powerful technology for data flow, concurrency, and developer experience. We revisit the popular topics of the year, from types and tooling to AI orchestration and reproducible dev environments, and share what we’re excited to explore next.
 
We also invite your questions and takeaways to help shape future seasons and conference conversations. Season 14 doubles as a handy primer for anyone curious about how Elixir integrates across the stack.
 
Key topics discussed in this episode:
 
* Lessons from a season of interoperability
* Set-theoretic types and what new compiler warnings unlock
* AI in practice: LLM orchestration, fallbacks, and real-world use
* SDUI and GraphQL patterns for shipping UI across web/iOS/Android
* Dataframes in Elixir with Explorer for analytics workflows
* Python interoperability (ErlPort, PythonX) and when to reach for it
* Reproducible dev environments with Nix and friends
* Performance paths: Rustler and Zig for native extensions
* Bluetooth & Nerves: Blue Heron and hardware integrations
* DevEx upgrades: LiveView, build pipelines, and standard project setup
* Observability and ops: Prometheus/Grafana and sensible deployments
* Community feedback, conferences, and what’s on deck for next season
 
Links mentioned in this episode:
Cars.com
S14E06 SDUI at Scale with Elixir https://youtu.be/nloRcgngTk?si=g4Zd4N1s56Ronrtw
https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html
https://wordpress.com/
https://elixir-lang.org/
S14E01 Zigler: Zig NIFs for Elixir https://youtu.be/hSAvWxh26TU?si=d55tVuZbNw0KCfT
https://ziglang.org/
https://hexdocs.pm/zigler/Zig.html
https://github.com/blue-heron/blueheron
https://github.com/elixir-explorer/explorer
S14E08 Nix for Elixir Apps https://youtu.be/yymUcgy4OAk?si=BRgTlc2VK5bsIhIf
https://nixos.org/
https://nix.dev/
S14E07 Set Theoretic Types in Elixir https://youtu.be/qMmEnXcHxL4?si=Ux2lebiwEp3mc0e
S14E10 Python in Elixir Apps https://youtu.be/SpVLrrWkRqE?si=ld3oQVXVlWHpo7eV
https://www.python.org/
https://hexdocs.pm/pythonx/
https://github.com/Pyrlang/Pyrlang
https://github.com/erlport/erlport
S14E03 LangChain: LLM Integration for Elixir https://youtu.be/OwFaljL3Ptc?si=A0sDs2dzJ0UoE2PY
https://github.com/brainlid/langchain
S14E04 Nx & Machine Learning in Elixir https://youtu.be/Ju64kAMLlkw?si=zdVnkBTTLHvIZNBm
S14E05 Rustler: Bridging Elixir and Rust https://youtu.be/2RBw7B9OfwE?si=aRVYOyxxW8fTmoRA
https://github.com/rusterlium/rustler
Season 3: Working with Elixir https://youtube.com/playlist?list=PLTDLmInI9YaDbhMRpGuYpboVNbp1Fl9PD&si=hbe7qt4gRUfrMtpj
S14E11 Vibe Coding the LoopedIn Crochet App https://youtu.be/DX0SjmPE92g?si=zCBPjS1huRDIeVeP
Season 5: Adopting Elixir 
YouTubeLaunchisode and Outlaws Takeover with Chris Keathley, Amos King, and Anna Neyzberg
S13E01 Igniter: Elixir Code Generation https://youtu.be/WM9iQlQSF_g?si=e0CAiML2qC2SxmdL
Season 8: Elixir in a Polyglot Environment https://youtube.com/playlist?list=PLTDLmInI9YaAPlvMd-RDp6LWFjI67wOGN&si=YCI7WLA8qozD57iw
!! We Want to Hear Your Thoughts *!!*
Have questions, comments, or topics you'd like us to discuss on the podcast?
Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

In this episode of Elixir Wizards, host Sundi Myint chats with SmartLogic engineers and fellow Wizards Dan Ivovich and Charles Suggs about the practical tooling that surrounds Elixir in a consultancy setting. We dig into how standardized dev environments, sensible scaffolding, and clear observability help teams ship quickly across many client projects without turning every app into a snowflake. Join us for a grounded tour of what’s working for us today (and what we’ve retired), plus how we evaluate new tech (including AI) through a pragmatic, Elixir-first lens.
Key topics discussed in this episode:
Standardizing across projects: why consistent environments matter in consultancy work
Nix (and flakes) for reproducible dev setups and faster onboarding
Igniter to scaffold common patterns (auth, config, workflows) without boilerplate drift
Deployment approaches: OTP releases, runtime config, and Ansible playbooks
Frontend pipeline evolution: from Brunch/Webpack to esbuild + Tailwind
Observability in practice: Prometheus metrics and Grafana dashboards
Handling time-series and sensor data
When Explorer can be the database
Picking the right tool: Elixir where it shines, integrations where it counts
Using AI with intention: code exploration, prototypes, and guardrails for IP/security
Keeping quality high across multiple codebases: tests, telemetry, and sensible conventions
Reducing context-switching costs with shared patterns and playbooks
Links mentioned:
http://smartlogic.io
https://nix.dev/
https://github.com/ash-project/igniter
Elixir Wizards S13E01 Igniter with Zach Daniel https://youtu.be/WM9iQlQSFg
https://github.com/elixir-explorer/explorer
Elixir Wizards S14E09 Explorer with Chris Grainger https://youtu.be/OqJDsCF0El0
Elixir Wizards S14E08 Nix with Norbert (Nobbz) Melzer https://youtu.be/yymUcgy4OAk
https://jqlang.org/
https://github.com/BurntSushi/ripgrep
https://github.com/resources/articles/devops/ci-cd
https://prometheus.io/
https://capistranorb.com/
https://ansible.com/ 
https://hexdocs.pm/phoenix/releases.html
https://brunch.io/
https://webpack.js.org/loaders/css-loader/
https://tailwindcss.com/
https://sass-lang.com/dart-sass/
https://grafana.com/
https://pragprog.com/titles/passweather/build-a-weather-station-with-elixir-and-nerves/
https://www.datadoghq.com/
https://sqlite.org/
Elixir Wizards S14E06 SDUI at Cars.com with Zack Kayser https://youtu.be/nloRcgngTk
https://github.com/features/copilot
https://openai.com/codex/
https://www.anthropic.com/claude-code
YouTube Video: Vibe Coding TEDCO's RFP https://youtu.be/i1ncgXZJHZs
Blog: https://smartlogic.io/blog/how-i-used-ai-to-vibe-code-a-website-called-for-in-tedco-rfp/
Blog: https://smartlogic.io/blog/from-vibe-to-viable-turning-ai-built-prototypes-into-market-ready-mvps/
https://www.thriftbooks.com/w/eragon-by-christopher-paolini/246801
https://tidewave.ai/
!! We Want to Hear Your Thoughts *!!*
Have questions, comments, or topics you'd like us to discuss in our season recap episode?
Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

Today, co-founders Kimberly Erni and Pei Pei Wang join the Elixir Wizards to discuss their crochet app, LoopedIn. Recognizing a gap in the market for a more user-friendly and interactive crochet pattern experience, they're building an app that makes following patterns easier and more enjoyable for crocheters of all skill levels.
They're building features such as step-by-step guidance, video tutorials, and the ability to upload and convert PDF patterns into an interactive format. Kimberly explains how she's leveraging AI tools to vibe code in Elixir and LiveView.
They highlight the challenges and successes they encountered while creating a Progressive Web App (PWA) that integrates AI-powered features. They also discuss their user research and testing process, which involved gathering feedback from the crochet community to prioritize features and improve the app's UX.
Kimberly and Pei Pei share their thoughts on the potential of AI in the tech industry and how it has assisted them in the development and iteration process. They emphasize the importance of understanding the code generated by AI and the need for proper testing and verification. They offer advice to others looking to create passion projects, stressing the value of finding a partner with complementary skills and shared enthusiasm for the project.
Topics discussed in this episode:
Discovering a niche: why crochet patterns need a digital makeover
Core LoopedIn features: interactive steps, video help, PDF conversion
Building a PWA with Elixir & Phoenix LiveView for cross-platform reach
Offline support and caching strategies for on-the-go crafting
AI-driven pattern parsing: benefits and pitfalls of generated code
User research: gathering feedback from beginner to expert crocheters
Agile iterations: testing, prioritizing features, and shipping quickly
Balancing “vibe coding” with quality assurance and proper test coverage
Partnership dynamics: complementary skills and shared passion
Monetization approaches for a niche, community-driven app
Roadmap highlights: expanded social features, advanced AI tooling, and more
Lessons learned: documentation gaps, performance tuning, and UX trade-offs
Advice for side projects: start small, validate with users, and iterate
Links mentioned:
Amigurumis
https://www.amigurumi.com/
https://pragmaticstudio.com/phoenix-liveview
https://grox.io/about-product/liveview
Creating a Local First LiveView App https://www.youtube.com/watch?v=kcafwf14SDo
https://capacitorjs.com/docs
https://flutter.dev/
https://passion.place/
https://cursor.com/
https://claude.ai/
https://nerves-project.org/
https://crochetapp.web.app/
https://www.figma.com/
Little Red Book App https://www.xiaohongshu.com/ 
!! Try the LoopedIn app here 👉 https://looped-in.gigalixirapp.com *!!*
Add it to your phone like an app:
Open the link in Safari
Tap the Share button (square with arrow)
Tap Add to Home Screen
Tap Add
Then you can open it like a regular app! 🎉 Leave a comment if you try it!
!! We Want to Hear Your Thoughts *!!*
Have questions, comments, or topics you'd like us to discuss in our season recap episode?
Share your thoughts with us here: https://forms.gle/Vm7mcYRFDgsqqpDC9

In this episode, Elixir Wizard Charles Suggs sits down with Victor Björklund to map out the landscape of Python integration in Elixir applications. From HTTP APIs and external services to embedded runtimes like ErlPort, PythonX, and the Venomous library, we evaluate each approach’s impact on performance, coupling, and developer experience. Victor draws on real-world examples like Scrapy-based web scraping and the Swedish BankID authentication to illustrate best practices for error handling, process pooling, and effective telemetry across the BEAM boundary.
We also tackle the practical side of deployment: packaging Python dependencies in Mix releases, mocking Python calls in tests, and deploying multi-language apps with confidence. Wrapping up, Victor shares his wishlist for even tighter interop (think multiple Python interpreter instances per VM) and offers low-risk entry points, like automating monthly reports, for teams ready to explore the power of Python’s ecosystem within Elixir.
Key topics discussed in this episode:
Integration methods: HTTP APIs, ports, ErlPort, PythonX, Venomous
Performance vs. coupling trade-offs across interop patterns
Managing the Global Interpreter Lock (GIL) with process pools
Leveraging mature Python libraries (Scrapy, BankID, etc.)
Error handling strategies across BEAM↔Python boundaries
Testing mixed-language systems: mocks and integration tests
Packaging and deploying Python alongside Elixir releases
Monitoring and telemetry for multi-language pipelines
Functional programming advantages in Elixir workflows
Tool selection guidance by project requirements
Future possibilities: multiple Python interpreters in one VM
Community resources for Python–Elixir interop help
Links mentioned:
jawdropping.io
https://cplusplus.com/
https://www.python.org/
https://react.dev/
https://nodejs.org/en
https://erlport.org/
https://hexdocs.pm/pythonx/Pythonx.html
https://pyrlang.github.io/Pyrlang/
Python GIL (Global Interpreter Lock): https://realpython.com/python-gil/
https://github.com/devinus/poolboy
https://hexdocs.pm/venomous/Venomous.html
Try-catch https://syntaxdb.com/ref/python/try-catch
https://www.scrapy.org/
https://www.bankid.com/en/
https://www.phoenixframework.org/
https://www.tzeyiing.com/posts/using-a-hunky-poolboy-to-manage-your-python-erlport-processes-in-elixir/
https://medium.com/stuart-engineering/how-we-use-python-within-elixir-486eb4d266f9
https://x.com/bjorklundvictor
https://victorbjorklund.com/
https://www.linkedin.com/in/victorbjorklund/
[email protected]

In this episode of Elixir Wizards, Charles Suggs sits down with Chris Grainger, co-founder and CTO of Amplified and creator of the Explorer library. Chris explains how Explorer brings the familiar data-frame workflows of R’s dplyr and Python’s pandas into the Elixir world. We explore (pun intended!) how Explorer integrates with Ecto, Nx, and LiveView to build end-to-end data pipelines without leaving the BEAM, and how features like lazy evaluation and distributed frames let you tackle large datasets.
Whether you’re generating reports or driving interactive charts in LiveView, Explorer makes tabular data accessible to every Elixir developer. We wrap up by looking ahead to SQL-style backends, ADBC connectivity, and other features on the Explorer roadmap.
Key topics discussed in this episode:
dplyr- and pandas-inspired data manipulation in Elixir
Polars integration via Rust NIFs for blazing performance
Immutable data frames and BEAM-friendly concurrency
Lazy evaluation to work with arbitrarily large tables
Distributed data-frame support for multi-node processing
Seamless integration with Ecto schemas and queries
Zero-copy interoperability between Explorer and Nx tensors
Apache Arrow and ADBC protocols for cross-language I/O
Exploring SQL-style backends for remote query execution
Building interactive dashboards and charts in LiveView
Consolidating ETL workflows into a single Elixir API
Streaming data pipelines for memory-efficient processing
Tidy data principles and behavior-based API design
Real-world use cases: report generation, patent analysis, and more
Future roadmap: new backends, query optimizations, and community plugins
Links mentioned:
https://hexdocs.pm/explorer/Explorer.html
https://www.amplified.ai/
https://www.r-project.org/
https://vita.had.co.nz/papers/tidy-data.pdf
https://www.tidyverse.org/
https://www.python.org/
https://dplyr.tidyverse.org/
https://go.dev/
https://hexdocs.pm/nx/Nx.html
https://github.com/pola-rs/polars
https://github.com/rusterlium/rustler
https://www.rust-lang.org/
https://www.postgresql.org/
https://hexdocs.pm/ecto/Ecto.html
https://www.elastic.co/elasticsearch
https://arrow.apache.org/
Chris Grainger & Chris McCord Keynote ElixirConf 2024: https://youtu.be/4qoHPh0obv0
https://dbplyr.tidyverse.org/
https://spark.posit.co/
https://hexdocs.pm/pythonx/Pythonx.html
https://hexdocs.pm/vegalite/VegaLite.html
10 Minutes to Explorer: https://hexdocs.pm/explorer/exploringexplorer.html
https://github.com/elixir-nx/scholar
https://scikit-learn.org/stable/
https://github.com/cigrainger
https://erlef.org/slack-invite/erlef
https://bsky.app/profile/cigrainger.bsky.social
https://github.com/cigrainger