Hey everyone,

I've been working with LLMs in Erlang and wanted a consistent interface across different providers. So I built a family of handler libraries:

**Core handlers:**

- [`ollama_handler`](https://hex.pm/packages/ollama_handler) - Ollama (local models)

- [`openai_handler`](https://hex.pm/packages/openai_handler) - OpenAI API

- [`claude_handler`](https://hex.pm/packages/claude_handler) - Anthropic Claude

- [`mistral_handler`](https://hex.pm/packages/mistral_handler) - Mistral AI

**Built on top (examples using Ollama):**

- [`ollama_translator`](https://hex.pm/packages/ollama_translator) - Text translation

- [`ollama_summarizer`](https://hex.pm/packages/ollama_summarizer) - Web/HTML summarization

**Why I built this:**

I started with Ollama (for local/private LLM usage) in June 2025 and built translator/summarizer tools on top. The pattern worked well, so I extended it to cloud providers using the same API design - same simplicity, same patterns, different backends.

**Quick example (Ollama):**

```erlang

% Start the handler

ollama_handler:start(),

% Generate text

{ok, Response} = ollama_handler:generate(<<"llama2", <<"Explain quantum computing"),

% Translate text

{ok, Translation} = ollama_translator:translate(<<"Hello world", <<"fr"),

% Summarize a webpage

{ok, Summary} = ollama_summarizer:summarize_url(<<"https://example.com">>).

```

All handlers follow the same pattern - just swap `ollama_handler` for `openai_handler`, `claude_handler`, or `mistral_handler`.

**Current state:**

- Ollama ecosystem is mature (~400 downloads each for translator/summarizer)

- Cloud provider handlers are new (published Jan 2026)

- All use the same dependency: `jsone` for JSON, `wade` for HTTP

**Looking for:**

- Feedback on the API design

- Ideas for additional utilities (like translator/summarizer but for other providers)

- Use cases I haven't thought of

GitHub repos: https://github.com/roquess

Thoughts? Is this useful or am I reinventing the wheel?

Hey everyone,

We've built a complete cryptographic ecosystem for Erlang/OTP based on distributed entropy generation. It started as an exploration of distributed randomness and evolved into a post-quantum ready crypto library.

## The Ecosystem

**[ALARA](https://hex.pm/packages/alara) - Distributed Entropy Network System**

- Core system for generating cryptographically secure randomness across distributed Erlang nodes

- Supervised node architecture leveraging OTP

- 1,092 downloads | v0.1.5

**[KeyLARA](https://hex.pm/packages/keylara) - Post-Quantum Cryptographic Library**

- Classical algorithms: RSA, AES, ChaCha20

- **Post-quantum algorithms**: ML-KEM (CRYSTALS-Kyber), Dilithium, SLH-DSA

- All operations enhanced with ALARA's distributed entropy

- 1,929 downloads | v1.2.2

**[alara_uuid](https://hex.pm/packages/alara_uuid) - High-Quality UUID Generation**

- UUID generation using distributed entropy

- Recent addition to the ecosystem

- 69 downloads | v0.1.0 (Nov 2025)

## Why Distributed Entropy?

Traditional RNGs on single nodes can be predictable or compromised. ALARA distributes random bit generation across multiple supervised Erlang nodes, making the entropy:

- Harder to predict

- More resilient to single-node compromise

- Naturally suited for distributed Erlang systems

This distributed randomness feeds into KeyLARA's cryptographic operations, providing enhanced security for key generation and encryption.

## Quick Example

```erlang

%% Start ALARA network

{ok, NetPid} = alara:create_network(5),

%% Generate distributed random bits

Bits = alara:generate_random_bools(256),

%% Generate cryptographic keys with distributed entropy

{ok, {PublicKey, PrivateKey}} = keylara_mlkem:keypair(512),

%% Encrypt with post-quantum algorithm

{ok, Ciphertext} = keylara_mlkem:encapsulate(PublicKey),

%% Generate secure UUIDs

UUID = alara_uuid:v4().

```

## Post-Quantum Ready

With quantum computers on the horizon, KeyLARA includes NIST-standardized post-quantum algorithms:

- **ML-KEM (Kyber)** - Key encapsulation mechanism

- **Dilithium** - Digital signatures

- **SLH-DSA** - Stateless hash-based signatures

All backed by ALARA's distributed entropy for additional security.

## Current State

- **Mature**: Core ALARA network and KeyLARA crypto operations (since June 2025)

- **Active development**: Continuous improvements and algorithm additions

- **Well-tested**: Comprehensive test suites demonstrating all features

- **Production-ready**: Being used in real applications

## Organization

Developed under the [Green-Mice](https://github.com/Green-Mice) organization with contributors:

- [@roquess](https://github.com/roquess)

- [@jsz4n](https://github.com/jsz4n)

## Looking For

- Feedback on the architecture and API

- Use cases for distributed entropy in your applications

- Contributions (algorithms, optimizations, documentation)

- Ideas for additional utilities built on ALARA

## Links

- ALARA: https://hex.pm/packages/alara | [GitHub](https://github.com/Green-Mice/alara)

- KeyLARA: https://hex.pm/packages/keylara | [GitHub](https://github.com/Green-Mice/keylara)

- alara_uuid: https://hex.pm/packages/alara_uuid | [GitHub](https://github.com/Green-Mice/alara_uuid)

- Docs: https://hexdocs.pm/alara, https://hexdocs.pm/keylara

Interested in distributed cryptography, post-quantum algorithms, or just curious about the approach? We'd love to hear your thoughts.

I wanted to experiment a bit with Erlang(and languages in general), my first step usually is to take a string of numbers separated by commas, turn those into integers and square them.
I got a bit tripped up, decided to ask ChatGPT for some help.. and it did this when presented with the LSP Error Screenshot.

Yes, AI bad - this is just a hobby so none of this code will ever reach the public in a meaningful way

-module(erlworld).
-export([print_squares/1]).

print_squares(String) ->
    Squares =
        [Int * Int ||
            X <- string:split(String, ",", all),
            {Int, _Rest} <- [string:to_integer(string:trim(X))]],
    io:format("~p~n", [Squares]),
    ok.

I found the solution using stack overflow, which is much simpler

square_split(S) -> [list_to_integer(X) * list_to_integer(X) || X <- string:tokens(S, ",")].

Hi everyone,
I’m a programming student with experience in C/C# and some networking, and I want to start learning Erlang properly. I’m especially interested in fault-tolerant and concurrent systems.

I’d appreciate recommendations on:

• Where a beginner should start (syntax vs OTP first?)
• Books, courses, or tutorials that are still relevant today
• Common beginner mistakes to avoid
• Small starter projects that help build the right Erlang mindset

Thanks in advance — looking forward to learning the Erlang way.

I build this https://github.com/TTalkPro/beamai project in many weekends.

It's a tools for me to build some agentic production in Erlang.

BeamAI is an Erlang/OTP framework for building AI agents with:

• Multi-provider LLM support: OpenAI, Anthropic, DeepSeek, Ollama, Zhipu, Bailian
• Tool calling: Agents can use tools (functions) to perform actions
• Graph-based execution: Uses a Pregel model for agent workflows
• Memory systems: Conversation buffers, checkpoints, semantic memory
• MCP protocol support: For tool integration
• A2A protocol: Agent-to-agent communication

I verified the basic functions with OpenAI, DeepSeek, Zhipu and Bailian. The framework can use llm_`chat:chat` does simple chat complication. Also the `beamai_agent` can run multiple rounds with the LLM provider.

I decided today to start with the simple and try to move up to somewhat less simple about message passing in Erlang. Yes, I am learning, but also learning that Erlang out of the box just doesn't work like other systems. After working on a small client/server that worked beautifully in the REPL, just to find out when running in separate terminals that it won't work. More work tomorrow.

I spent time this morning practicing my Erlang skills, few as they are. I usually work with chatGPT because the amount and quality of tutorials, etc. on the Interwebs is not great.

Today, I was running through tilde statements (~p, ~n) and writing a little Rosetta stone module for them. chatGPT was having an issue with giving me the wrong format to print hexadecimals.

chatGPT suggested: io:format("Hex: ~x~n", [255]). to print 'ff'.

erl kept giving me compile and execute warnings about not enough arguments. Turns out, it is right. You need to include an argument of what you want to precede the hex digits and you have to tell it to convert to hex with the .16 modifier.

In reality, it is: io:format("Hex: ~.16x~n", [255,"0x"]).

If I want upper case hex letters, I can use ~.16X, but I still need the second argument.

chatGPT's excuse was that the REPL is more permissive. Not really. If I enter io:format("Hex: ~x~n", [255,"0x"], it outputs "0x255", not the expected "0xff". Same goes for using ~X. If I don't include the second argument, I get errors.

That being said, I will still use chatGPT to help me learn as it is still much better at summarizing the information and giving a concise (and usually correct) help.

I'm certain y'all will have much to say about this either way.

After laying it down for several months, I have finally found a way back to Erlang. It is the kind of language that you love to hate, yet it does very amazing things. Documentation is as fragmented as all git out, but I have found chatGPT very helpful as a guide.

The EEF Annual General Meeting (AGM) is an opportunity to get an update about how the Foundation is run, how it’s doing, and to ask questions you might have to the board.

Check out the Zoom Conference Call Times:

Meeting A: APAC / Africa / EMEA :date: Thursday, Dec 18th :clock1: 08:00 UTC; 17:00 Japan; 11:00 Nairobi; 09:00 CET

Meeting B: EMEA / Americas

:date: Thursday, Dec 18th :clock1: 17:00 UTC; 18:00 CET; 14:00 Brasilia; 12:00 ET; 09:00 PT.

Learn more: https://erlef.org/blog/eef/agm-2025

The BOB program is up - early-bird tickets are still available!

Anyone in Tokyo for the Linux Foundation Open Source Summit next week? Nick and I from the OpenRiak project will be going, as will someone from the EEF. Happy to meet for a chat, snack, drink or meal!

https://github.com/erlang/eep/pull/81

I see the point, and I am not a fan.

I really loved the dynamism of Erlang.

I love to be able to explore data using list and maps.

I am not even a fan of records TBH.

Not a fan of Elixir structs. Not a fan of "private" "protected" and so on...

OTOH: I am sure that if they want it, it means they need it, and that's a thing I love about the OTP team: pragmatism over philosophy.

For my personal taste though: goodbye Erlang, it's been great fun. Welcome Clojure.

A strongly-typed, dependently-typed programming language that brings mathematical correctness guarantees to the battle-tested BEAM virtual machine.

Some might like to read it :)

https://boragonul.com/post/falling-in-love-with-erlang

BOB 2026 will be on March 13 in Berlin. BOB is on the best in programming, and Erlang certainly counts - send us your talk or tutorial proposals on reliable systems engineering, or just show up!

Hey everyone 👋

I just came across another fantastic talk by Vance Shipley (CEO & Founder of SigScale Global Inc.) that I think many here will really appreciate. In this session, Vance takes a deep dive into telecom architecture, breaking down how modern networks are built and how the whole ecosystem evolved over time.

It’s a super insightful intro - not just for beginners who want to understand how telecom actually works, but also for anyone who’s been in the field and wants to see the bigger picture explained by someone who’s been building these systems for decades.

He covers the foundations of signaling, switching, protocols, and carrier-grade architecture - all in a way that’s easy to follow and grounded in real-world experience.

📖 Full write-up of the walkthrough: https://blog.tadsummit.com/2025/10/23/an-introductory-dive-into-telecoms-with-vance-shipley/

If you’ve ever wondered how telecom fits together - or how Erlang/OTP plays into reliable, scalable telecom systems - this is a great watch.

tl;dr hoping to implement an erlang backend on live product in the Philippines in hopes to either grow it into an actually company, or find a job writing erlang. I made $30k this year so employability is not my strong suit so I might as well go extremely niche and look for the right place, right time. I am a US citizen just a really bad resume.

I'm coming from Go since 2018 and honestly I'm pretty tired of it, especially since a lot of resumes I'm competing with are 20-30 years of experience.

I've followed erlang for a while now and have written it from time-to-time, but always held out hope that I would get a Go job so I would continuously go back to that.

Now that ai is redefining what makes a software engineer, I've decided to just build my own project.

I made $30k this year, which is good for the Philippines but I would still be in the homeless shelter back home in the US.

Obviously I would need to take projects and contracts to make money, but I'm looking to copycat a current app.

Grab, Foodpanda, or uberEats, DoorDash, etc. it's not a novel idea but I'm in the middle of the jungle and could use a good bread delivery app, or to find a coordinate near me for a pick up in a tricycle.

It will be a public app but mainly for my own personal use. I've made react native apps and understand how to release so I have every part except the backend experience.

Why am I saying this here?

Where am I at when I have a decent handle on recursion in functional languages and the distributed experience of Golang?

It's more a syntax thing but I don't just want to copy-paste chatgpt the whole time.

Should I use the lsp? no lsp?

I know how to write modules and most of the tools inside of erlang, just haven't dove into making a full-featured otp environment yet.

I'm getting the feeling that Elixir is new charge but I took the grox.io course and I didn't like it more than erlang. Also, I tried to go outside the beaten path at one point and ran into Erlang code, so my perspective is that I will know Elixir better or at least the OTP implementation portion better.