
If you are discovering Fluux, it is an open-source XMPP client for teams, communities, and anyone who wants control over their communications. The iPhone and iPad version is experimental, and it is the right moment to shape it: your feedback decides what we fix first.
Beta builds can be unstable, and TestFlight builds expire after 90 days, so keep TestFlight installed to receive updates.
The widget shows your unread conversations on the home screen. The lock screen shows your unread total. Tap a row to open that conversation. Message text is never shown: the widget tells you who is waiting for you, not what they said.
We would especially like to hear whether the widget refreshes when you expect, whether the unread counts match the app, and how it behaves after a restart or a long time without opening Fluux.

The macOS widget lists your unread conversations with names, avatars, unread counts, mention markers and times. Clicking a row opens that conversation in Fluux. As on iPhone, message text is left out. If Fluux stops updating the saved list, for example because the app is no longer running, the widget marks the old list so you do not mistake it for fresh information.

On macOS, message notifications now show the sender, along with the room details for room messages, in the way other chat apps do. On iOS, room notifications show the room picture, with the room name first and the sender above the message.
Importing an OpenPGP key file now checks that your server backup matches it. You see a clear status when the backup is not confirmed, and a warning before you replace it. Rotating a key refreshes the backup and gives you a new code.
On macOS, Fluux cleans up old keychain copies without asking for access again, and keeps any copy that differs, so you never lose a secret. A keychain prompt waiting for your answer no longer blocks saving other secrets, such as your encrypted OpenPGP key.
Scrolling and reading position have kept improving since 0.18.1, and 0.18.3 continues.
Scrolling up in conversations and rooms no longer jumps or skips messages when Fluux corrects its size estimate for older messages.
You can now read back to the very start of a long conversation, past the latest 5,000 messages, without getting stuck. The message you are reading stays put when older messages finish loading, when media finishes loading, and while a conversation grows.
On macOS, reading a conversation or room also clears notifications that arrived before Fluux was last restarted.
Download Fluux Messenger for macOS, Windows, and Linux, or visit the Fluux Messenger page to explore the app and try it in your browser. iPhone and iPad testers: use the TestFlight link above.
See the full 0.18.3 release notes for the complete list of changes.
If something still feels off, tell us. Bug reports and feature requests both go to GitHub Issues.
The XMPP Standards Foundation (XSF) is excited to announce the 30th XMPP Summit taking place in Brussels, Belgium next year - just before FOSDEM 2027. The XSF invites everyone interested in development of the XMPP protocol to attend, and discuss all things XMPP - both in person and remotely!
The XMPP Summit is a two-day event for the people who write and implement XMPP extensions (XEPs). The event is not a typical conference - aside from small and short lightning talks, there are no long presentations.
If you have ever followed a thread on the standards mailing list or taken part in a discussion on the public XSF channel you should be familiar with this - just in person. The different topics are broken up by short breaks that are great for networking and getting to know other XMPP developers. Still, if you cannot participate, we will also provide an online way of joining the discussion.
Agreeing on a common strategy or even establishing a rough priority for certain features in our decentralised and interoperable technology and protocol can be hard. In-person events do a lot in getting us on the same page and if you develop XMPP software (client, server, gateway, …), we strongly encourage you to come to the summit. (In short: To get the most out of the summit you should have a background in reading (and maybe even writing) XEPs).
At the start, participants suggest topics and vote on which ones interest them, similar to an unconference. Afterwards a rough order of topics is established that will be followed in moderation with the participants. Everyone sits around one table, and active participation, in person or remote, is encouraged.
If you are simply an enthusiastic user or admin we regularly have booths at various conferences (FOSDEM, CLT, FrOSCon, …) that are a great opportunity to meet us, too. Either way, everyone is welcome to participate! Here is an impression from the summit closing from last year!
If we’ve caught your attention, we will then hopefully see you at the XMPP Summit 30 in Brussels. Read on!
Address: Philippe de Champagnestraat 23, 1000 Brussels
Room: Top floor
Cost: Free (registration required)
Hybrid participation: Yes
Map: Openstreetmap
More details will be published in the wiki page for Summit 30. Furthermore, the XSF will have its annual Summit Dinner, which is free for participating XSF members. Non-members are warmly invited to join, however at their own expense.
Please note that, although we welcome everyone to join (free of cost), you must announce your attendance beforehand. If you’re interested in attending, please make yourself known by filling out your details on the wiki page for Summit 30. To add your name, ask an XSF member to do it for you, or request a wiki account, which we’ll happily provide. Contact us using the communication channels listed below. The FOSDEM weekend is busy in Brussels, so we recommend booking accommodation early. If your plans change, please remove your name from the list.
Please also consider signing up if you plan to:
To ensure you receive all the relevant information, updates and announcements about the event, make sure that you’re signed up to the Summit mailing list and joined the Summit chatroom (Webview).
PS: You will find us also at the XMPP & Realtime Lounge at FOSDEM 2027!
Spread the word! See our communication channels in the page footer.
The XSF would like to express its sincere gratitude to its general sponsors and acknowledges that their sponsoring allows us to keep events like this an annual highlight. We also appreciate support via direct sponsoring of the event or even XSF sponsorship, so that we can keep the event open and accessible for everyone. If you are interested, please contact the XSF Board.
We are really excited to already see people signing up. Looking forward to meeting all of you!
The XMPP Standards Foundation Board

Dino and Beastie have become good friends!
From Friday 6th November to Sunday 8th November, eight XMPP community members meet for London XMPP Sprint in Greenwich.
For more information about the sprint see the wiki.
Matthew Fennell and Thilo Molitor worked on improving the Monal internals and made progress on ‘chatview’.
Daniel Gultsch implemented Oauth within Conversations with help from Matthew Wild.
Fixah worked on message style parsing within Dino.
Marvin Wißfeld worked on fixing multiple bugs within Dino’s file transfer feature, with Karel Balej helping with debugging the bugs.
Polarian worked on porting the latest version of Gajim to FreeBSD. Unfortunately being beaten by another user to submitting the patch, and worked on updating Gajim dependencies within FreeBSD. Polarian also worked on improving his build server to be able to port more XMPP software to BSD in the future.

London XMPP Sprint

We have been shipping Erlang for more than twenty years. ejabberd runs on the BEAM, and the BEAM has earned its reputation: lightweight processes, isolation, supervision, per-process garbage collection. Few runtimes have aged this well.
And yet, every time we deploy an Erlang program, we deploy two things. The program, and the virtual machine it needs to run.
For a large messaging server, that trade-off is obvious. For a command-line tool, a single-purpose service or an agent at the edge of a network, it is much harder to justify. This is where many teams pick Go. Not because goroutines are a better concurrency model than Erlang processes. Because go build gives them one file they can copy to a machine and run.
What if Erlang could do the same?
That is the question behind Nera, and its repository is now public: github.com/processone/nera. Nera v0.1.0 is out. It is a full release, and it stays experimental until 1.0. This post says exactly what that means.
Nera is an ahead-of-time compiler for Erlang, written in Rust. It parses .erl source files, lowers them to an intermediate representation, generates machine code with Cranelift, and links the result with Nera&aposs runtime into a single executable.
.erl source → parse → Nera IR → Cranelift → link with the runtime → native executable
There is no bytecode, no interpreter and no JIT. The output is a regular native program, built for one operating system and architecture like any other. The machine that runs it needs no Erlang installation, no release tooling and no erl.
Compiling Erlang to machine code is only half of the problem, though. Erlang programs expect processes, mailboxes and a scheduler. On the BEAM, the virtual machine provides them. With Nera, a runtime written in Rust takes over that part of the VM&aposs job, and it is linked into every program the compiler produces.
That runtime provides:
receive with timeouts;persistent_term, counters, atomics, and TCP sockets through gen_tcp.On top of it, Nera compiles a standard library alongside your code: lists and maps, plus subsets of gen_server, supervisor, application and proc_lib. Their sources are embedded in the compiler binary, so there is nothing else to install.
This is a part of the BEAM, not all of it. Nera does not do hot code upgrades. It does not do distributed Erlang. It has no TLS yet. It is not a drop-in replacement for the BEAM, and it is not trying to be one.
What does this look like in practice? The repository ships a classic example: two Erlang processes exchanging messages. Here it is, from source to a running native program. Every output below comes from running these commands on macOS arm64 against the public repository.
1. Build the compiler. Nera needs Rust 1.99.0, pinned in the repository, and a C linker:
git clone https://github.com/processone/nera.git
cd nera
cargo build --release --locked
This produces the compiler, target/release/nera, and the runtime library it links into every program, target/release/libnera_runtime.a.
2. Read the program. examples/ping_pong.erl spawns a second process, sends it ten pings, and waits for a pong after each one:
-module(ping_pong).
-export([start/0, pong/0]).
start() ->
Pong = spawn(ping_pong, pong, []),
ping(Pong, 10).
ping(_, 0) ->
io:format("Ping done~n");
ping(Pong, N) ->
Pong ! {ping, self()},
receive
pong ->
io:format("Ping received pong (~w remaining)~n", [N]),
ping(Pong, N - 1)
end.
pong() ->
receive
{ping, From} ->
io:format("Pong received ping~n"),
From ! pong,
pong()
end.
Nothing here is specific to Nera. It is plain Erlang: spawn, ! and receive.
3. Compile it to a native executable.
./target/release/nera build examples/ping_pong.erl -o ping_pong -e ping_pong:start
-o names the output file and -e the entry point, the function the program starts with. The compiler prints one line naming the runtime library it links, and writes ping_pong in the current folder.
4. Look at what it produced.
file ping_pong
otool -L ping_pong
ping_pong: Mach-O 64-bit executable arm64
ping_pong:
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1356.0.0)
A regular macOS executable, whose only dynamic dependency is the system library. No BEAM, no erl, no release directory next to it.
5. Run it.
./ping_pong
Pong received ping
Ping received pong (10 remaining)
Pong received ping
Ping received pong (9 remaining)
Pong received ping
Ping received pong (8 remaining)
Pong received ping
Ping received pong (7 remaining)
Pong received ping
Ping received pong (6 remaining)
Pong received ping
Ping received pong (5 remaining)
Pong received ping
Ping received pong (4 remaining)
Pong received ping
Ping received pong (3 remaining)
Pong received ping
Ping received pong (2 remaining)
Pong received ping
Ping received pong (1 remaining)
Ping done
The program exits with status 0 when start/0 returns. The same source, compiled with erlc and run on OTP 29, prints the same 21 lines.
The two processes are scheduled by Nera&aposs runtime, which starts one scheduler thread per CPU core by default. Setting NERA_SCHEDULERS=1 when you launch the program runs it on a single thread, which is handy for reproducible tests.
A compiler is only usable with the tools around it. Nera manages dependencies from hex.pm, git or a local path through a nera.toml file, and it can also build against the dependencies rebar3 has already fetched. It has a test runner (nera test), a formatter (nera fmt), and an LSP server with a VS Code extension and a JetBrains plugin, both attached to the release (the JetBrains plugin needs a commercial IDE, version 2025.3 or later). An Emacs integration is in the repository.
The checker is useful even if you never deploy a Nera binary. nera check runs the whole front end, from parsing and preprocessing to lowering and validation, without generating code. It understands standard OTP project layouts and rebar3 dependency directories, so you can point it at an existing project and get diagnostics in your editor while you keep building and deploying with the standard Erlang/OTP toolchain. (Its warnings can still differ from erlc&aposs. We want to hear about every false one.)
A ping-pong between two processes proves very little on its own. So we test Nera against real libraries.
The most complete result so far is Cowlib, the protocol library behind the Cowboy HTTP server. The repository includes a small project, examples/cowlib_demo, that fetches Cowlib 2.22.0 from hex.pm and builds it natively. With target/release on your PATH:
cd examples/cowlib_demo
nera deps get
nera build
./cowlib_demo
It makes 85 calls across all 25 Cowlib modules: cookies, dates, URIs, HTTP headers, HTTP/2 and HTTP/3 framing, HPACK and QPACK, multipart, WebSocket masking. All 85 return without an exception. Run against the same code on OTP 29, 75 output lines are byte-identical. Eight hold the same values with a different map order or an atom printed without quotes. Two differ only in byte order, because Nera orders atom keys differently from OTP; they are equal once sorted. Cowlib&aposs upstream cookie and date suites ran natively on an earlier version (2.20.0); we have not rerun them on 2.22.0.
Thoas 1.2.1, a JSON library, passes its recorded checks on Nera, including all 318 cases of JSONTestSuite. And on macOS arm64, Nera&aposs main branch passes its local gate with 2,118 Rust workspace tests and 450 Erlang tests.
Experimental is not a polite word for "almost done". Here is where Nera stands, taken from the known limits page we keep in the repository and revise with every release:
ssl module is not implemented, Nera runs single-node programs, and code cannot be reloaded at run time.one_for_one. Some ETS and binary functions are missing. After a gen_server:call times out, the late reply still arrives in the caller&aposs mailbox.In short: do not use Nera for production services yet. There is no compatibility promise between releases, and wrong results are still being found. If an output matters, compare it with the BEAM.
Let me be clear about one thing first. We are not moving ejabberd to Nera. ejabberd relies on hot code loading, distribution, Mnesia and native extensions. It belongs on the BEAM, and it stays there.
What interests us is everything around it.
Erlang&aposs ideas are worth more than any single runtime: isolated processes, message passing, supervision, and letting a failing process crash. Today, using them means accepting the BEAM&aposs deployment model. For a lot of software, that is the right deal. For a lot of other software, it is the reason Erlang was never considered in the first place.
The first demonstrator on our roadmap makes this concrete for messaging. It is an external XMPP component, connected to an existing server such as ejabberd through XEP-0114, that routes alerts with Erlang rules and runs as a native executable on a host without Erlang. The same plan adds compile-time checking of the contracts in its Erlang core. Both are planned work, not results, and the roadmap lists the gates each must pass.
Nera v0.1.0 is out. Later experimental tags will be named vX.Y.Z-experimental and published as GitHub prereleases. Next, the next milestone is Cowboy over plain HTTP, then Cowboy with TLS.
Those are milestones, not dates.
Download the archive for your platform from the v0.1.0 release page, or build from source as shown above. The ping-pong steps above are the shortest way in. From there, the walkthroughs for Erlang developers go through processes, an OTP-style server, a real JSON library and the editor tooling. Read the known limits before porting anything larger.
When Nera gives a different result from the BEAM, the most useful report is a single .erl file with the output of both. Open an issue on GitHub. Nera is released under the Apache 2.0 license.
Erlang&aposs ideas deserve to run in more places than the BEAM can reach. Nera is our bet that they can, but it is an early attempt.

XMPP Newsletter Banner
Welcome to the XMPP Newsletter, great to have you here again! This issue covers the month of October 2026.
The XMPP Newsletter is brought to you by the XSF Communication Team and contributors of the XMPP community.
Just like any other product or project by the XSF, the Newsletter is the result of the voluntary work of its members and contributors. If you are happy with the services and software you may be using, please consider saying thanks, donate below or help these projects!
Interested in contributing to the XSF Communication Team? Read more at the bottom.
See also the XMPP Events page.
NLnet: 47 Open Source Projects Receive NLnet Grants to Boost Digital Autonomy which also includes Gajim Audio and Video Calls. This project aims to extend Gajim’s text and rich-media messaging by implementing encrypted audio and video calls, ensuring interoperability with other XMPP clients by relying on the same standard protocols based on Jingle and WebRTC (Jingle RTP Sessions - XEP-0167, Jingle ICE-UDP Transport Method - XEP-0176, Jingle Raw UDP Transport Method XEP-0177, Jingle Message Initiation - XEP-0353).
Nspawn - Build A Tor-only XMPP Server In Containers, by DeadSwitch for The Silent Architect’s Whispers.
Una presentazione su XMPP al Linux Day 2026 from cuche.cc. [IT]
On Channel Binding, by The Prosody Team from Prosodical Thoughts.
Review blog post on the XMPP Stand/Talk at OmniOpenCon 2026 by Polarian.
XMPP Providers Support in Converse.js & More Automation! Since earlier this year Converse.js suggests an XMPP provider and allows to select one during account registration. XMPP Providers also accelerated its XMPP provider process to be listed.

Converse.js suggests an XMPP provider and allows to select one during account registration based on the data from XMPP Providers.

fluux messenger with improved conversation functions like unread messages counts as well as experimental iOS support.

Screenshot of the new Profanity messenger website describing the client purpose and technology.
Find more XMPP Clients.
Find more XMPP Servers.
Find more XMPP Libraries & Tools.
The XMPP Standards Foundation (XSF), together with our friends from the Matrix and Delta Chat communities, is organising a Decentralised Messaging devroom at FOSDEM 2027, and we are looking for speakers. Submission deadline for talks is Friday, November 20, 2026!
The XMPP Standards Foundation is calling for individuals to compose the Board of Directors and members to serve on the XMPP Council for the 2026/2027 period. If you are interested in running for the Board of Directors or the XMPP Council, please add a wiki page about your candidacy to one or both of the aforementioned sections before November 8, 2026, 00:00 UTC. Get involved in the XMPP Standards Foundation organization decisions and with the specifications we publish. Note: XMPP Council members must be elected members of the XSF; however, there is no such restriction for the Board of Directors.
Being an elected member of the XMPP Standards Foundation signals a commitment to open standards and professional engagement in / with the XMPP community. Here, your membership helps position the XSF as a healthy organization, which in itself is valuable. It also grants voting rights on technical and administrative matters within the XSF. The application is a light-weight and free of cost process and you can use your membership to get more involved more easily, too. If you are interested in joining the XMPP Standards Foundation as a member, please apply to our 4th quarterly call for members admission before November 29, 2026, 00:00 UTC.
The XMPP Standards Foundation develops extensions to XMPP in its XEP series in addition to XMPP RFCs. Developers and other standards experts from around the world collaborate on these extensions, developing new specifications for emerging practices, and refining existing ways of doing things. Proposed by anybody, the particularly successful ones end up as Final or Active - depending on their type - while others are carefully archived as Deferred. This life cycle is described in XEP-0001, which contains the formal and canonical definitions for the types, states, and processes. Read more about the standards process. Communication around Standards and Extensions happens in the Standards Mailing List (online archive).
The XEP development process starts by writing up an idea and submitting it to the XMPP Editor. Within two weeks, the Council decides whether to accept this proposal as an Experimental XEP.
If an experimental XEP is not updated for more than twelve months, it will be moved off Experimental to Deferred. If there is another update, it will put the XEP back onto Experimental.
<replace/> element (jcb)Last calls are issued once everyone seems satisfied with the current XEP status. After the Council decides whether the XEP seems ready, the XMPP Editor issues a Last Call for comments. The feedback gathered during the Last Call can help improve the XEP before returning it to the Council for advancement to Stable.
Please share the news on other networks:
Also check out our RSS Feed!
Looking for job offers or want to hire a professional consultant for your XMPP project? Visit our XMPP job board.
This is a community effort, and we would like to thank translators for their contributions. Volunteers and more languages are welcome! Translations of the XMPP Newsletter will be released here (with some delay). Consider to donate to the individuals that spend their time creating this edition:
Contributors:
Translations:
This XMPP Newsletter is produced collaboratively by the XMPP community. Each month’s newsletter issue is drafted in this simple pad. At the end of each month, the pad’s content is merged into the XSF GitHub repository. We are always happy to welcome contributors. Do not hesitate to join the discussion in our XSF Communications Team group chat (MUC) and thereby help us sustain this as a community effort. You have a project and want to spread the news? Please consider sharing your news or events here, and promote it to a large audience.
Tasks we do on a regular basis:
For this newsletter either log in here and unsubscribe or simply send an email to newsletter-leave@xmpp.org. (If you have not previously logged in, you may need to set up an account with the appropriate email address.)
This newsletter is published under CC BY-SA license.
Here comes Kaidan 0.17.0! This release allows to report spam and retract messages. In addition, it automatically reconnects based on your internet connection. As always, it includes several smaller improvements and fixes.
Most of the work has been funded by NLnet via NGI Zero Commons Fund with public money provided by the European Commission.
Spam and abusive messages can be reported now. You can either report the sender or specific messages. The sender is automatically blocked in either case. The spam or abuse is reported to your XMPP provider. Your XMPP Provider is allowed to forward the report to the sender’s XMPP provider or external services such as blocklist providers.
That way, a community-based spam protection can evolve. You flag spam for other people and their reports protect you from receiving spam.
To report a sender of spam or abusive messages, you can do that via the details dialog.
To report a specific message, there is a context menu entry for it.
Once you pressed the context menu entry, a dialog is opened to send the report.
Since Kaidan 0.10 it is capable of removing messages locally (i.e., from your device). It is now also able to retract own messages resulting in removing them globally (i.e., from your device and all devices that received it).
You can even retract a message while not being connected. Kaidan retracts the message automatically once you are connected again. To keep it simple, removing a message globally is the default and performed via the context menu entry Remove. If that is not possible, e.g., because the message is too old, it can still be removed locally via the context menu entry Remove from Kaidan.
Note: If you retract a message, Kaidan instructs all of your and your contacts’ devices to remove that message too. A device receiving such a request can deny or simply not support it. Thus, it is possible that a message you retracted is not removed from all devices that received the request.
In Kaidan, you can enable or disable accounts. If an account is disabled, it stays offline. If it is enabled, it automatically tries to connect to your XMPP provider. In case of connection problems, Kaidan displays an error message. But it was not able to automatically try to reconnect after recovering from them.
The user had to manually disable and enable the account again. Kaidan is now able to detect the connection’s status and reconnect on its own once the connection is reestablished. You do not need to take care of being connected anymore. Instead, you can focus on chatting! In combination with Kaidan’s support for composing messages while being offline, messages are sent in the background as soon as you are connected again.
There are several other improvements. Have a look at the following changelog for more details.
Features:
Bugfixes:
Notes:
Or install Kaidan for your distribution:
Due to a family health emergency, the OpMeet that has been moved to the 31st October needs to be cancelled. OpMeet will hopefully return in early 2027.
Apologies to anyone who was planning on attending, and for those who put their ideas forward, this was unavoidable.
OpMeet are online meetups/conferences targeted at XMPP Operators.
With the latest update to the popular Conversations app, which requires “channel binding” by default, lots of people are encountering channel binding for the first time. This post aims to answer questions for both Prosody operators and users.
Channel binding is a security feature which helps to keep your connection secure. We’ll dig into exactly what it is, how it is used, and what (if anything) you need to do.
When you establish connections on the internet today, they will almost certainly be using TLS (on the web, TLS connections are referred to as HTTPS). It is well known that TLS provides encryption, but there is no point in encrypting your bytes if you are sending them to an attacker, e.g. someone who can intercept or divert your internet traffic. TLS therefore provides something else - authentication, or the ability to cryptographically prove who you are communicating with - using certificates.
Anyone can create a certificate that claims they are anybody. You can trivially
use the openssl command-line tool to create a certificate for microsoft.com
or google.com. But nobody would trust your certificate - you have to have it
signed by a recognised Certificate Authority. The most well-known CA is
Let’s Encrypt, but there are many more. Operating systems and browsers ship a
list of trusted certificate authorities, and software automatically trusts
certificates that have been signed by one of these CAs.
However, this arrangement has suffered numerous problems. Any trusted CA can issue a certificate for any domain, and in the past, they have. By utilizing Chrome’s pinning and telemetry, Google discovered multiple cases of CAs issuing certificates for domains without permission. This led them to develop Certificate Transparency, a system of public logs that (these days) every CA trusted by browsers is required to submit every single issued certificate to, leading to transparency and accountability.
Browsers have now started requiring every certificate to include a proof that it has been submitted to a Certificate Transparency log. This is known as a Signed Certificate Timestamp (SCT).
SCTs solve the problem of CAs silently misissuing certificates - via CT logs every certificate can now be tracked and audited. CAs found to have incorrectly issued certificates can be investigated and potentially distrusted by browsers and operating systems.
But the CT/SCT solution isn’t perfect. It provides a record after the attack has already happened, and this record can assist with remediation. But it does not prevent the attack in the first place.
It also does not protect against:
A case of a compromised CA happened just a couple of weeks ago. The eMudhra CA incident found that this CA’s keys were extremely weak and guessable, meaning anyone could generate a certificate that looked like it was officially signed by eMudhra. Although CT helped to determine the impact after the compromise was discovered, during the period between the discovery of the weak keys and the CA being distrusted by systems, anyone could forge a valid-looking certificate, submit it to CT logs, and obtain SCTs for the forged certificates. The attack was not prevented by CTs/SCTs, they only made things auditable after the compromise became known.
In another kind of incident in 2023, a public XMPP server was found to have had its TLS connections intercepted. Because the intercepting machine had access to the legitimate server’s traffic, it was also able to intercept the “challenge” requests from Let’s Encrypt, and obtain a valid certificate. This certificate was published in CT logs, while the attack lasted for months.
From the perspective of Let’s Encrypt, this was not a misissued certificate.
They performed the expected checks before issuing the certificate.
Unfortunately the victim domain did not have a CAA record with a pinned
accounturi. This was a mechanism introduced in 2019 to prevent
this kind of attack.
However, even with CAA records, it is not that hard to imagine situations where a CA could be tricked or compelled into issuing certificates.
Another mechanism - you guessed it, channel binding - would have made both these attacks immediately detectable by XMPP clients.
Enough of the problems. What can we do? Well, XMPP has for some time supported a technique known as channel binding. This is actually part of the authentication layer - the layer that verifies your password/token - and all it does is cryptographically “bind” that authentication to the encrypted data channel (your TLS connection).
To work, channel binding requires a few things:
In a non-mutual authentication mechanism, the client might send the password to the server and the server says “Correct password! You’re now authenticated.” But with mutual authentication, the client submits proof that it has the password/token, and the server also returns a proof that it has the password/token (or a hash of it) to the client. This allows the client to ensure it is logging in to the legitimate server.
Client Attacker Server
(MITM)
| | |
| == TLS connection A ==> | === TLS connection B ===> |
| attacker's valid cert | attacker poses as client |
| | |
|-- password proof ------->|-- relayed as-is ---------->| proof OK
|<---------- server proof -|<----------- relayed as-is -|
| | |
Logged in! Attacker sees and can modify Logged in!
everything in both directions
SCRAM is a widely used authentication mechanism which supports mutual authentication and channel binding (SCRAM “PLUS”), and allows the client and the server to store a hashed version of the credentials.
Channel binding extends mutual authentication to include unique per-connection data from the TLS layer. This means that the entity you are authenticating with must now also be the entity that is decrypting your TLS connection. If you have a malicious machine in the middle, decrypting the client’s TLS and then encrypting it again and sending it onwards to the real server, this would now be detected - because the client’s connection to the MITM is not the same connection as the one between the MITM and the server.
Client Attacker Server
(MITM)
| | |
| == TLS connection A ==> | === TLS connection B ===> |
| | |
|-- proof bound to A ----->|-- relayed as-is ---------->| I'm on B, but
| | | this proof is
| | | for A: REJECT
| |<----------------- failure -|
| | |
The attacker can't generate a correct proof for connection B
because it needs knowledge of the password. For the same reason,
it also can't fake a proof from the server and trick the client
into believing that authentication succeeded.
Channel binding seems rather magical. It doesn’t depend on the CA ecosystem at all, and works with any certificate, including self-signed. It doesn’t matter if the CA has been compromised - if your mutual authentication with channel binding passes, your connection is being handled by the same server that you are authenticating to.
It prevents a range of attacks, and is relatively simple from an operational perspective. However, for it to be an effective defence, the client must not simply try authentication without channel binding when channel binding fails. Otherwise an attacker can just make channel binding fail, and when the client tries again without channel binding, the attack will succeed. This is known as a downgrade attack.
Channel binding is actually already enabled in Prosody out of the box, there is nothing specific you need to do to enable it. The requirements are simply:
authentication = "internal_hashed" and network_backend = "epoll" (the libevent backend also works in latest 13.0.x)But this doesn’t mean that it is available in every deployment. As discussed above, channel binding provides proof that the server authenticating you is the same server your TLS connection is being handled by. Channel binding cannot work if:
In both these cases, channel binding breaks because the situation is similar to a MITM attack. Something is decrypting your TLS connection before the authentication. Channel binding is trying to ensure that your authentication server is also your encryption server.
For the TLS offloading case, there is a version of channel binding which can work by providing
a hash of the certificate. This will then be compared with the hash of the certificate that the
client sees. It has weaker security guarantees, but it allows things to work even if
Prosody is not terminating the TLS connection. If you have such a setup, set tls_server_end_point_hash
in your configuration to the hash of your DER-encoded certificate, and note that this needs
to be updated every time your certificate changes (which, with modern CAs, can be rather frequently).
If you’re having problems with channel binding and you’re not sure why, enable
debug logs (or use prosodyctl shell watch log) - it’s likely that the debug
logs will tell you whether channel binding is available, and if not, why not.
Some external services can work in theory. Authentication providers which are compatible with channel binding are those which can provide to Prosody either:
If your authentication provider is receiving either a plain or hashed password from Prosody, and making its own decision about whether the authentication was successful, your authentication provider is very likely to be incompatible with channel binding.
If your server doesn’t support channel binding, it’s not the end of the world.
The new Conversations requirement for channel binding can be turned off in the security settings of the app, and you only need to do this once. Even with the setting disabled, Conversations will still use channel binding when a server supports it. For other servers you will still benefit from standard TLS, just make sure you have taken other precautions such as adding CAA records for your domain.
Channel binding is great, but it’s not going to save you from every kind of attack (nothing will). You should still do things like add CAA records and use DNSSEC.
Channel binding has the following weaknesses:
Channel binding is a powerful tool for ensuring connection security. It’s generally automatically enabled for most people, if your server is up to date and has the recommended configuration.
If not, just disable the requirement in Conversations. Your connections will still be encrypted!
As a bit of background, I have been to a few XMPP stands organised by others, at FOSDEM and FrOSCon, seeing their strengths and where I felt they were weaker. This was my first attempt at organising a stand, and to my surprise it was more successful than I could have ever dreamed of.
We had a large proportion of the conference come over and chat, not just take stickers, and leaflets like many other stands at other conferences, but full on in-depth discussions, which inevitably led to the XMPP stand becoming a hackerspace of sorts, the organisers suggesting we pull more tables over to the end so that people could hack at the end of the stand and not block the main stand.
We also trialled some new ideas, which I haven’t seen at any other stands so far. I will also cover the ideas which are common at every stand.

OmniOpenCon 2026 Devices stand
Like every stand, we had stickers. This in my opinion doesn’t really help too much with getting people interested in XMPP, most people end up throwing stickers into a box at home. This doesn’t mean they are a waste of time, people who are passionate about XMPP love to be able to decorate their devices with stickers, which then helps with making XMPP more mainstream and familiar.
para designed new leaflets for the conference, these were more popular than the stickers for newcomers, because it explained exactly what XMPP is, and on the back explained how to try XMPP, even the organisers of the conference were taking a look at the leaflets, and could potentially play with XMPP in the future.
Leaflets are also ridiculously cheap to print (compared to stickers) making them much more disposable, allowing you to spread XMPP to more people for less.
The device demos we picked were to target the most platforms possible, so that anyone who came over to the stand could see the interop between different clients and devices. We had an iPhone with Monal IM, two Androids with Conversations and Cheogram and a Linux laptop with Gajim (which would also run on Windows as well).
As with all conferences, the device demos were popular, and people like playing with them. However they are much more of a “woah cool” rather than a method of getting people onto XMPP.

OmniOpenCon 2026 Devices Close-up
Edward designed two example diagrams showing at a high level how servers federate, and users message across different servers. This also was invaluable in my talk to describing how the XMPP protocol functioned. These diagrams made it far easier to explain to people who were less tech-savvy how XMPP is beneficial to them, and why it would suit their use case.
On top of this, para had rendered an A3 image of the XMPP operators graph, as this is so big and hard to render on the web that under conference conditions it’s hard to have it on hand. Having it printed on paper allowed us to use it as a high level overview of how many servers (which publish themselves) are federating within the network, with the protocol diagrams being a “slice” of that network.

OmniOpenCon 2026 Diagram Stand
I have not yet seen this as at any stand personally. I have seen the use of a demo MUC hosting on hardware at the conference, but not an actual public MUC with a QR code for people to join as they walked past the stand.
This was probably the most successful part of the stand, those who already used XMPP or had dabbled in it came past and joined the MUC and were chatting throughout the conference, and even days later theres been regular activity after the conference. This has allowed people to make new connections, which is something XMPP has always struggled with providing due to the limited number of communities outside of XMPP development.
We printed the XMPP URI off as a QR code stuck it in the middle of the stand.
We had two operators (other than myself) who were at the stand. We had already decided in advance to try to break the cycle of people coming over, speaking and then forgetting about XMPP, that we would hand out invite links along with the leaflets they could collect, so they could easily install the app on their phone at the stand, and scan a QR code, make a username and then immediately join the MUC.
This had some success, some people still decided to use random providers as is their freedom to, but we also saw a few people sign up via the invite links.
The invite links were printed off and then cut up into sticker-sized QR codes which people could take away with them.
Unfortunately, due to a mistake, half way through the day the invite link was invalidated, and all the invite links distributed in the morning had to be discarded. For this reason, we can not draw a definite conclusion whether this method of onboarding is actually successful or not. Better luck next time.
Unfortunately, I was given the last talk slot before the closing notes. This meant a lot of people had already left by the time my talk was up, and I don’t feel like it properly reached the audience I intended. The talk was focused at sparking interest in XMPP, rather than a deep dive into some topic within XMPP. However the majority of the audience already used XMPP.
Nevertheless, it was a fun talk, and at the bare minimum I got to thank everyone who had been involved in making the stand possible.
The stand was definitely the highlight fo the conference, it drew many more people towards it, and was far better at onboarding and getting new people interested in XMPP.
You can see the slides here.
Most talks are just people standing at the front speaking about something for the allotted time, however we instead handed out XMPP leaflets, and invite links to everyone who attended. This provided them with the information to go away after the talk and look into it more if they were interested.
Due to the few people who attended the talk, I can’t say if this would be effective if scaled, but 1-2 people who attended my talk and got the leaflet ended up making an account and messaging me after the conference, so at the limited scale I had, it was successful.
As a bit of background, I have been to a few XMPP stands organised by others, at FOSDEM and FrOSCon, seeing their strengths and where I felt they were weaker. This was my first attempt at organising a stand, and to my surprise it was more successful than I could have ever dreamed of.
We had a large proportion of the conference come over and chat, not just take stickers, and leaflets like many other stands at other conferences, but full on in-depth discussions, which inevitably led to the XMPP stand becoming a hackerspace of sorts, the organisers suggesting we pull more tables over to the end so that people could hack at the end of the stand and not block the main stand.
We also trialled some new ideas, which I haven’t seen at any other stands so far. I will also cover the ideas which are common at every stand.

OmniOpenCon 2026 Devices stand
Like every stand, we had stickers. This in my opinion doesn’t really help too much with getting people interested in XMPP, most people end up throwing stickers into a box at home. This doesn’t mean they are a waste of time, people who are passionate about XMPP love to be able to decorate their devices with stickers, which then helps with making XMPP more mainstream and familiar.
para designed new leaflets for the conference, these were more popular than the stickers for newcomers, because it explained exactly what XMPP is, and on the back explained how to try XMPP, even the organisers of the conference were taking a look at the leaflets, and could potentially play with XMPP in the future.
Leaflets are also ridiculously cheap to print (compared to stickers) making them much more disposable, allowing you to spread XMPP to more people for less.
The device demos we picked were to target the most platforms possible, so that anyone who came over to the stand could see the interop between different clients and devices. We had an iPhone with Monal IM, two Androids with Conversations and Cheogram and a Linux laptop with Gajim (which would also run on Windows as well).
As with all conferences, the device demos were popular, and people like playing with them. However they are much more of a “woah cool” rather than a method of getting people onto XMPP.

OmniOpenCon 2026 Devices Close-up
Edward designed two example diagrams showing at a high level how servers federate, and users message across different servers. This also was invaluable in my talk to describing how the XMPP protocol functioned. These diagrams made it far easier to explain to people who were less tech-savvy how XMPP is beneficial to them, and why it would suit their use case.
On top of this, para had rendered an A3 image of the XMPP operators graph, as this is so big and hard to render on the web that under conference conditions it’s hard to have it on hand. Having it printed on paper allowed us to use it as a high level overview of how many servers (which publish themselves) are federating within the network, with the protocol diagrams being a “slice” of that network.

OmniOpenCon 2026 Diagram Stand
I have not yet seen this as at any stand personally. I have seen the use of a demo MUC hosting on hardware at the conference, but not an actual public MUC with a QR code for people to join as they walked past the stand.
This was probably the most successful part of the stand, those who already used XMPP or had dabbled in it came past and joined the MUC and were chatting throughout the conference, and even days later theres been regular activity after the conference. This has allowed people to make new connections, which is something XMPP has always struggled with providing due to the limited number of communities outside of XMPP development.
We printed the XMPP URI off as a QR code stuck it in the middle of the stand.
We had two operators (other than myself) who were at the stand. We had already decided in advance to try to break the cycle of people coming over, speaking and then forgetting about XMPP, that we would hand out invite links along with the leaflets they could collect, so they could easily install the app on their phone at the stand, and scan a QR code, make a username and then immediately join the MUC.
This had some success, some people still decided to use random providers as is their freedom to, but we also saw a few people sign up via the invite links.
The invite links were printed off and then cut up into sticker-sized QR codes which people could take away with them.
Unfortunately, due to a mistake, half way through the day the invite link was invalidated, and all the invite links distributed in the morning had to be discarded. For this reason, we can not draw a definite conclusion whether this method of onboarding is actually successful or not. Better luck next time.
Unfortunately, I was given the last talk slot before the closing notes. This meant a lot of people had already left by the time my talk was up, and I don’t feel like it properly reached the audience I intended. The talk was focused at sparking interest in XMPP, rather than a deep dive into some topic within XMPP. However the majority of the audience already used XMPP.
Nevertheless, it was a fun talk, and at the bare minimum I got to thank everyone who had been involved in making the stand possible.
The stand was definitely the highlight fo the conference, it drew many more people towards it, and was far better at onboarding and getting new people interested in XMPP.
You can see the slides here.
Most talks are just people standing at the front speaking about something for the allotted time, however we instead handed out XMPP leaflets, and invite links to everyone who attended. This provided them with the information to go away after the talk and look into it more if they were interested.
Due to the few people who attended the talk, I can’t say if this would be effective if scaled, but 1-2 people who attended my talk and got the leaflet ended up making an account and messaging me after the conference, so at the limited scale I had, it was successful.
The XMPP Standards Foundation (XSF), together with our friends from the Matrix and Delta Chat communities, is organising a Decentralised Messaging devroom at FOSDEM, and we are looking for speakers!
Focused on federated and self-hostable chat, this devroom brings our ecosystems together to tackle shared challenges. Although our architectures look pretty different under the hood, we face many of the same hurdles. We want to get together to share operational and implementation experiences, discuss shared technical challenges, and look at practical ways our networks can cooperate.
Our own communities have plenty of material to share, and we are also deliberately reaching beyond them to invite contributors working on chat across other federated and decentralised ecosystems (such as AT Protocol and ActivityPub), as well as developers building reusable components like moderation tools.
Talks that others can learn from are preferred, and marketing talks will be rejected.
FOSDEM is an annual conference about free and open source software. It takes place at the ULB Solbosch Campus, Brussels, Belgium on 30 & 31 January 2027. See https://fosdem.org/.
Please distribute this CFP as widely as possible to interested parties!
We welcome technical presentations, demos, and experience reports on topics including:
We ask for a short talk abstract, a proposed duration, and a brief speaker biography. Links to your code repositories, project websites, or prior talks are also appreciated.
Submissions must be made through Pretalx (https://fosdem.org/submit) no later than Friday, November 20, 2026.
The suggested duration for a regular talk is 25 minutes (20 minutes presentation + 5 minutes Q&A). If the best format for your project or idea is a 5-to-10-minute lightning talk, we will happily accommodate lightning sessions as well. Talks are streamed and published under CC-BY, and the FOSDEM Code of Conduct applies.
Depending on the volume and variety of submissions, we may contact you to adapt your talk length to fit the final room schedule.
A programme committee with at least one reviewer from each organising community reviews all submissions jointly. Talks will be selected based on technical interest, relevance, and overall project diversity across the schedule.
If you would like to help to keep things running smoothly on the day, we’d be grateful for a few extra hands! Please get in touch via decentralised-messaging-devroom-manager at fosdem.org
On behalf of the Decentralised Messaging devroom managers, The XSF Summits, Conferences, and Meetups Team (SCAM) Daniel & Guus
along with our co-managers Andy, Holger, Matthew, and Saul
Earlier this year another XMPP app has added XMPP Providers support to its onboarding. Converse.js suggests an XMPP provider and allows to select one during account registration. That web app is hosted by many XMPP operators to provide their users a decent web experience. We are very happy about this development and further distribution. Using XMPP Providers will enhance the onboarding experience for many people.

Screenshot of XMPP Providers support in Converse.js.
To continue enabling true federation and reduce manual work, the creation of merge requests to add new providers has been automated. One simply needs to follow the steps to add a missing provider. Once an issue has been created, our bot, will create a merge request including an initial check to update the provider’s properties. Considering the growing demand of providers that want to be listed, the new automation (as you may have recognised already) will accelerate the whole process from the first request to the final inclusion. Furthermore, it allows us to focus on developing more features.
Thanks to everyone for being patient with us! It is great to see so many old XMPP services still being run and new ones constantly being established. Moreover, many thanks to the XMPP apps for supporting this service as well as using it for their onboarding. That is the best way of using XMPP Providers!
For a good user experience, apps integrating XMPP Providers are as important as the providers themselves. If you are an XMPP developer, please consider adding XMPP Providers support to your app. If you are an operator of a public XMPP service, add your service to the list.
You can also consider to run your own XMPP server and become a public provider. With our automated XMPP server setup, you can operate a fully-featured XMPP server with minimal effort.
Feel free to reach out to us if you have any questions! If you like to support XMPP Providers, please consider making a donation. Follow us and spread the word!
XMPP Providers Logo
The recent eMudhra Intermediate CA Compromise is a security threat for ejabberd if you use s2s, modules that make outgoing HTTPS requests, or TLS connections to MQTT brokers (mod_mqtt_bridge).
To check if your ejabberd is vulnerable, you can use the following code snippet (works on ejabberd 19.08 and later).
Open the debug console with:
ejabberdctl debug
Paste the following code into the debug console (the indented version of this code is available at the end of this post):
(fun() -> Host = "dv-g3b-emudhra.we-have-a-problem.com", Fail = fun(Err) -> {"unable to connect to test server", Err} end, case gen_tcp:connect(Host, 443, [binary, {active, false}]) of {ok, Sock} -> case fast_tls:tcp_to_tls(Sock, [connect, {cafile, ejabberd_option:ca_file()}]) of {ok, TSock} -> _ = fast_tls:send(TSock, list_to_binary("HEAD / HTTP/1.0\r\nHost: " ++ Host ++ "\r\n\r\n")), case fast_tls:recv(TSock, 0, 10000) of {ok, _} -> case fast_tls:get_peer_certificate(TSock) of {ok, Cert} -> FT = case fast_tls:get_cert_verify_string(fast_tls:get_verify_result(TSock), Cert) of <<"ok">> -> "vulnerable"; _ -> "ok" end, HT = case list_to_integer(erlang:system_info(otp_release)) >= 26 of true -> case httpc:request("https://" ++ Host) of {ok, _} -> "vulnerable"; _ -> "ok" end; false -> "not verified (OTP < 26)" end, "fast_tls status: " ++ FT ++ ", ssl status: " ++ HT; E4 -> Fail(E4) end; E3 -> Fail(E3) end; E2 -> Fail(E2) end; E1 -> Fail(E1) end end)().
Exit the console with Ctrl-C twice.
It returns "fast_tls status: ok, ssl status: ok" if you are not vulnerable. If either status is vulnerable, please read on.
If you are running ejabberd with the official Docker image, you can update to 26.09.1 to fix the problem. It just removes the problematic certificates from the OS; it still runs ejabberd 26.09. Pull ghcr.io/processone/ejabberd:26.09.1 and recreate your container.
To fix it manually without restarting ejabberd, you can follow this procedure (requires Erlang/OTP 25+; on older versions, restart ejabberd).
First, update the CA bundle on your OS by upgrading the ca-certificates package:
# Debian / Ubuntu
apt update && apt install --only-upgrade ca-certificates
# RHEL / Rocky / Alma / Fedora
dnf update ca-certificates
# Alpine
apk upgrade ca-certificates
If your distribution has not shipped an updated package yet, you can distrust the certificates manually: see update-ca-certificates(8) on Debian/Ubuntu, or Using shared system certificates on RHEL-based systems.
Once the OS bundle is updated, paste the following into the debug console to reload it:
public_key:cacerts_clear(), public_key:cacerts_load(), ejabberd_admin:reload_config().
Exit the console with Ctrl-C twice.
Finally, re-run the check above to verify that you are not vulnerable anymore.
If you are still vulnerable, your ejabberd may be using CA certs from a specific location. You can use the following functions in the debug console to check where to update your certs (ca_file shows the CA file actually in use; if s2s_cafile is undefined, s2s uses ca_file).
ejabberd_option:ca_file().
ejabberd_option:s2s_cafile().
If you are using some s2s CA cert per vhost, pass it as a parameter, for example:
ejabberd_option:s2s_cafile(<<"example.com">>).
Here is the check above, indented for readability:
(fun() ->
Host = "dv-g3b-emudhra.we-have-a-problem.com",
Fail = fun(Err) -> {"unable to connect to test server", Err} end,
case gen_tcp:connect(Host, 443, [binary, {active, false}]) of
{ok, Sock} ->
case fast_tls:tcp_to_tls(Sock, [connect, {cafile, ejabberd_option:ca_file()}]) of
{ok, TSock} ->
_ = fast_tls:send(TSock, list_to_binary("HEAD / HTTP/1.0\r\nHost: " ++ Host ++ "\r\n\r\n")),
case fast_tls:recv(TSock, 0, 10000) of
{ok, _} ->
case fast_tls:get_peer_certificate(TSock) of
{ok, Cert} ->
FT = case fast_tls:get_cert_verify_string(fast_tls:get_verify_result(TSock), Cert) of
<<"ok">> -> "vulnerable";
_ -> "ok"
end,
HT = case list_to_integer(erlang:system_info(otp_release)) >= 26 of
true ->
case httpc:request("https://" ++ Host) of
{ok, _} -> "vulnerable";
_ -> "ok"
end;
false ->
"not verified (OTP < 26)"
end,
"fast_tls status: " ++ FT ++ ", ssl status: " ++ HT;
E4 -> Fail(E4)
end;
E3 -> Fail(E3)
end;
E2 -> Fail(E2)
end;
E1 -> Fail(E1)
end
end)().

If you are discovering Fluux, it is an open-source XMPP client for teams, communities, and anyone who wants control over their communications. This release keeps the focus on making those conversations easier to follow.
Long conversations open more smoothly, including those with large blocks of text. Catching up on archived history is faster when thousands of messages are already loaded, and busy rooms no longer stall or crash during bursts of messages and presence updates.
History is easier to navigate, too. When a conversation contains several gaps, Fluux can show and fill each one separately. Search&aposs “Go to message” now reaches and highlights results far back in both direct chats and rooms.
The view stays steadier while you read. Reopening a room with short multi-line messages no longer makes it jump. The last message stays visible above the typing indicator and composer, and the scroll-to-bottom button appears as soon as you move away from the latest messages.
Unread badges now recover correctly after a reconnect and catch-up. A room read through to its latest message clears its badge. A read position from another device that Fluux cannot yet place no longer blocks unread counts.
The “New messages” divider now counts the messages actually below it, rather than repeating the unread total on the scroll-to-bottom badge. Joined room avatars show unread message counts, while mentions keep their own badge.
Messages from ignored room members no longer add to unread or mention badges. Messages you send from another device under a different room nickname are recognized as yours, without an extra notification or unread count.

On macOS, you can share links, documents, and images to Fluux from another app&aposs system Share menu. Fluux opens so you can choose the conversation and send the content.
Whispers to a room member can now include attachments. Before you send, Fluux explains that the file is stored on the server and that the recipient keeps a copy. When the server provides a retention period, Fluux shows that too.
Desktop file handling also gets a practical fix: attaching or opening files with non-Latin names works again.
Version 0.18.0 introduces experimental native iOS support, with push notifications, system sharing, native file transfers, and OpenPGP encryption.
Photos shared from another app open in Fluux ready to send. Large photos are reduced before sharing, with the option to send the original when it fits the server&aposs limit.
Notifications can show contact and room avatars, and OpenPGP message previews can be decrypted on the device. Those previews start enabled for accounts with OpenPGP enabled and a usable key; you can turn them off for each account in Notifications settings. The app switcher hides your conversations behind a blurred cover.
On iOS 16 or later, Siri and Shortcuts can open an existing conversation or room, or check the unread count shown on the app icon.
This support is experimental.
Subscribe to the ProcessOne newsletter to hear when TestFlight testing opens.
For wide windows, Accessibility settings now offer “Limit conversation width”, with a slider to choose a centered reading column. Small windows continue to use the full width. Presence indicators also use more distinct shapes: Away is an orange rounded square, and Do Not Disturb is a red ring.
OpenPGP conversations work better alongside Gajim, including encrypted edits, replies, receipts, and read markers. Deleted messages stay deleted after a restart and archive sync, rather than returning to the conversation or search.
On Linux desktops using XEmbed trays, closing the window keeps Fluux running in the tray. Reopening Fluux keeps your conversations on screen while it reconnects, instead of briefly showing the login form.
Download Fluux Messenger for macOS, Windows, and Linux, or visit the Fluux Messenger page to explore the app and try it in your browser.
See the full 0.18.0 release notes for the complete list of changes.
If something still feels off, tell us. Bug reports and feature requests both go to GitHub Issues.
“AI is not my area.” That was my answer when a friend suggested I give a talk about agentic workflows. I used that phrase a lot at the beginning of the year; I was pretty skeptical about the whole thing.
But the idea stuck. I started reading about what makes agentic systems hard to build, expecting to find something wild and exotic to dig into. What I found instead was a list of problems that sounded pretty familiar:
None of that was new to me. If you work with Elixir, Erlang, and the BEAM, it’s probably not new to you either.
A few months later, I was on stage at ElixirConf US giving the talk “Exploring OTP Patterns for Agentic Workflows”. This series is based on that talk, but it goes deeper into the topics I couldn’t fully cover on stage.
The goal is to help you better understand agentic systems from the perspective of a BEAM developer. Not because OTP is an AI framework, nor because AI concepts map one-to-one to elements of the BEAM ecosystem, but because many of the engineering challenges these systems present are problems the BEAM community has been solving for decades.
So the question is simple:
What do I already know that can help me understand agentic workflows?
In this chapter, we start with the first item on the list: state.
The example we’ll use throughout this chapter starts with a familiar situation: an endpoint that returns an error instead of the user’s data, and us leaning on an AI agent to debug and fix it.
GET /users/:id Hey Claude: The GET /users/:id endpoint is returning a 500 error for a valid ID. It should return the user object. Fix it.
Notice that the prompt describes what I want, not how to get there.
The agent takes this prompt as its goal. It has a codebase to investigate and a set of tools to do so. Let’s say it starts by inspecting the router and then the controller. What it does next depends on what it finds along the way.
One distinction matters for everything that follows. The model at the center of the agent, a large language model (LLM), doesn’t open files or interact directly with the system. It participates in deciding what should happen next, but it’s the tools that do the work, and their results become part of the context the model sees when it makes its next decision.
At a high level, we can represent it like this:

For this series, that’s our working definition of an agentic workflow: a workflow in which the model decides the path as it progresses, based on the context and on what it observes.
What interests us is everything behind that loop that makes it work as a system:
We already know how to reason about those problems, and that’s what this series explores.
After a few iterations, the agent has gathered information: the controller function behind the endpoint, the tests, the relevant spots in the codebase. If every iteration had to start from scratch, it would never make any progress.
But from the model’s perspective, each invocation starts with only the context it’s given. The model itself doesn’t carry anything over from one invocation to the next.
That means the system around it must preserve information about the execution: the goal, what has already happened, what work is still pending, how many steps it has taken, and so on.
In other words, the workflow has state.
Before we continue, let’s define another concept we’ve already mentioned and will need throughout this series: context.
When the model needs to decide what to do next, it needs information about what has happened so far. Maybe the failing test output, the relevant function, the original goal, and the result of the last tool call. The model receives that information as context.
The two are related, but they’re not the same thing. One way to see it:
The system has state. The model receives context derived from that state.
The state usually contains more than the model needs for a particular decision. Step counts and pending work may matter to the system without needing to be exposed to the model. And the model can only take in a limited amount of context per invocation (what’s known as its context window), so even the relevant information may need to be selected, summarized, or trimmed.
What the model sees depends on the decision we’re asking it to make. This brings us to the first interesting question of the chapter.
The answer is the essential building block of the BEAM world: a process.
A process owns its state. No other process can reach into its memory and change it; anyone who wants to interact with it has to send it a message. For a workflow, that suggests one process per execution: it starts when a goal comes in, holds the state for that run, and exits when the run is over.
But the process doesn’t just hold a value. It has to react to messages that arrive on their own schedule: a tool result, a timeout, a request to cancel.
A GenServer gives us exactly that. But be careful: the GenServer isn’t the AI agent. It’s just the process we’ll use to own and coordinate one execution of the workflow.
A naming note: agent in this series always means an AI agent, never Elixir’s Agent module. That module wouldn’t be enough here anyway: it’s a simple abstraction around state, built to hold a value, not to react to messages as they arrive.
Before writing the process, let’s look at what it has to hold. Go back to our broken endpoint. The agent has already read the router, and the model’s next decision was to do two things at once: read the controller and run the tests. Neither has come back yet. At that moment, the state of the run looks like this:
%BlogOtp.Workflow{ goal: "The GET /users/:id endpoint is returning a 500 error...", model: BlogOtp.Model.Scripted, history: [ {{:read_file, %{path: "lib/my_app_web/router.ex"}}, ~s(get "/users/:id", UserController, :show)} ], pending: %{ #Reference<...> => {:read_file, %{path: "lib/my_app_web/controllers/user_controller.ex"}}, #Reference<...> => {:run_tests, %{path: "test/my_app_web/controllers/user_controller_test.exs"}} }, steps: 3, max_steps: 10 }
Each field maps to something we’ve already talked about:
goal is the prompt we gave the agent.model is the module that makes the decisions. In this chapter it’s a scripted stand-in for an LLM, so it doesn’t need anything extra to run.history is what has happened so far: each tool call paired with its result.pending is the work requested but not answered yet. Each request gets a unique reference, so when a result arrives, we know which one it answers.steps counts the tool calls requested so far, and max_steps lets the system stop a run that goes on too long.Only goal and history end up in the context. The rest exists for the system; the model never sees it.
Here’s the process that owns that state:
defmodule BlogOtp.Workflow do use GenServer, restart: :transient require Logger defstruct [:goal, :model, history: [], pending: %{}, steps: 0, max_steps: 10] def start_link(opts), do: GenServer.start_link(__MODULE__, opts) @impl true def init(opts) do state = %__MODULE__{ goal: Keyword.fetch!(opts, :goal), model: Keyword.get(opts, :model, BlogOtp.Model.Scripted), max_steps: Keyword.get(opts, :max_steps, 10) } {:ok, state, {:continue, :next_step}} end @impl true def handle_continue(:next_step, state), do: next_step(state) @impl true def handle_info({:tool_result, ref, result}, state) when is_map_key(state.pending, ref) do {call, pending} = Map.pop(state.pending, ref) state = %{ state | pending: pending, history: [{call, result} | state.history] } next_step(state) end # A result we aren't waiting for: a duplicate, or a late arrival def handle_info({:tool_result, _ref, _result}, state), do: {:noreply, state} # Still waiting on results: keep waiting defp next_step(%{pending: pending} = state) when map_size(pending) > 0, do: {:noreply, state} # The system decides when to stop, not only the model defp next_step(%{steps: steps, max_steps: max} = state) when steps >= max, do: finish({:stopped, :max_steps}, state) defp next_step(state) do # Chapter 1 shortcut: the owner calls the model itself case state.model.decide(build_context(state)) do {:tools, calls} -> {:noreply, request(calls, state)} {:done, answer} -> finish({:done, answer}, state) end end # Nobody executes these yet: each call waits in `pending` for its result defp request(calls, state) do Enum.reduce(calls, state, fn call, state -> %{state | pending: Map.put(state.pending, make_ref(), call), steps: state.steps + 1} end) end defp finish(outcome, state) do Logger.info("Workflow finished: #{inspect(outcome)}") {:stop, :normal, state} end # What the model gets to see, in its simplest form def build_context(state) do [{:goal, state.goal} | Enum.reverse(state.history)] end end
The loop lives in next_step/1, which works like this:
pending, or a final answer, which ends the process normally.And restart: :transient tells a supervisor to restart the process only if it terminates abnormally: a run that finishes with :normal stays finished.
Two things are deliberately missing in this chapter. First, nobody executes the tools yet: requests sit in pending until someone sends back a {:tool_result, ref, result} message. Second, the owner calls the model directly, even though a model call is slow. Both are problems we’ll come back to.
The code also shows the state/context distinction from the previous section. pending, steps and max_steps exist for the system; the model never sees them. And the context is the output of build_context/1, a plain function over the state, so we can test what the model will see without calling a model.
The code also gives us serialized access to the state.
Look at pending in the example above. Suppose the controller’s contents and the test output come back at almost the same time. They arrive as messages, and the process handles them one at a time. Each handle_info/2 runs to completion against a consistent state before the next message is processed. There are no locks; nothing else can change the state in the meantime, and the context for the next model call is never built from a half-applied update.
The first result is simply recorded: pending still holds the other request, so next_step/1 keeps waiting. Only when the second result arrives does the model get to decide, with both observations in its context.
But that same property has a cost.
A GenServer handles one message at a time, and the work in this loop is slow: a model call can take seconds, while a test suite can take much longer. If the process did that work itself, it couldn’t handle anything in the meantime. Messages would pile up in its mailbox: a result, a timeout, a request to cancel, all waiting their turn.
And that’s exactly what our chapter 1 shortcut does with the model call. It works here because our scripted model answers instantly; a real one wouldn’t.
So owning the state and doing the work pull in opposite directions.
The owner process needs to stay available, so the work has to happen somewhere else. That’s why nobody executes the tools yet: the owner shouldn’t be the one doing it. We’ll come back to that.
First, there’s a more urgent question: everything above lives in memory.
“Let it crash” works because a supervisor can start a new process in a known good state. But for a GenServer, that known good state is whatever init/1 builds. For a workflow, that means starting from the beginning, which is exactly what we don’t want.
Think about our endpoint. By the time the process crashes, the model may have already made several decisions: it read the router, read the controller, ran the tests, maybe even edited the controller. Starting over means repeating all of that, paying for it again in time and in model calls. And some of that work, like editing a file, may not be something we want to do twice.
The process can own the workflow state while it’s running, but that doesn’t mean process memory has to be the only place where that state lives.
We need enough durable information to reconstruct the workflow.
One way to do that is to record its progress as an append-only log. The goal is the first entry. Each tool call the model decides on becomes another, as does each tool result. As the workflow progresses, we only ever add these entries to the end.
For our endpoint, the log might look like this when the process crashes:
{:goal, "The GET /users/:id endpoint is returning a 500 error..."}
{:decision, 1, {:read_file, %{path: "lib/my_app_web/router.ex"}}}
{:result, 1, ~s(get "/users/:id", UserController, :show)}
{:decision, 2, {:read_file, %{path: "lib/my_app_web/controllers/user_controller.ex"}}}
{:decision, 3, {:run_tests, %{path: "test/my_app_web/controllers/user_controller_test.exs"}}}
{:result, 2, ~s[def show(conn, %{"id" => id}) do ... json(conn, user) ...]}
Everything the process knew is there: the goal, every decision, every result that came back. Even the request that’s still waiting for its answer.
If that log becomes the source from which we reconstruct the workflow state, we’re using the same core idea as event sourcing.
Let’s put that idea into code. Three things change: the workflow gets an id that survives the process, each tool call gets a step id the workflow assigns, and every state change goes through a single function.
defstruct [:id, :goal, :model, history: [], pending: %{}, steps: 0, max_steps: 10] # Only updates the state: no work, no model calls, no messages defp apply_step({:goal, goal}, state), do: %{state | goal: goal} defp apply_step({:decision, step_id, call}, state) do %{state | pending: Map.put(state.pending, step_id, call), steps: state.steps + 1} end defp apply_step({:result, step_id, result}, state) do {call, pending} = Map.pop(state.pending, step_id) %{state | pending: pending, history: [{call, result} | state.history]} end
Each clause handles one kind of entry from the log. apply_step/2 never starts work, calls a model, or sends a message. That restriction will matter in a moment.
The owner is still the only one that writes:
@impl true def handle_info({:tool_result, step_id, result}, state) when is_map_key(state.pending, step_id) do state = record({:result, step_id, result}, state) next_step(state) end # Each call becomes a decision in the log, with a step id the workflow assigns defp request(calls, state) do Enum.reduce(calls, state, fn call, state -> record({:decision, state.steps + 1, call}, state) end) end # Persist first, then apply defp record(entry, state) do :ok = BlogOtp.Log.append(state.id, entry) apply_step(entry, state) end
Notice two things.
The first is step_id, which replaces the reference from the previous version. A reference created with make_ref/0 only identifies something within the running node, and the process waiting for it may be gone after a crash. A step id is just a number the workflow assigns when it records the decision, and it means the same thing to any process that reads the log.
The second is the order inside record/2. We write to the log first, then apply the entry to the in-memory state. If the process dies between those two lines, the log is ahead of memory, and memory is the part we know how to rebuild. The other way around, the process could act on a step that no restart would ever see. And if the append fails, the process crashes before acting on anything.
The same rule applies to decisions: they’re recorded before anyone starts the work. In this chapter nobody executes the tools yet, but when someone does, the decision will already be in the log.
This puts a durable write on the owner’s critical path. That’s intentional: we don’t want the workflow to act on a transition it couldn’t recover after a crash.
In this chapter, BlogOtp.Log keeps its entries in an ETS table owned by its own process. It survives a workflow crash, but not a node restart. A real implementation would write to disk or a database; the contract, append first and read in order, stays the same.
Starting a run now means creating its log first:
def start(goal, opts \\ []) do id = new_id() :ok = BlogOtp.Log.append(id, {:goal, goal}) DynamicSupervisor.start_child( BlogOtp.WorkflowSupervisor, {__MODULE__, Keyword.put(opts, :id, id)} ) end def start_link(opts) do GenServer.start_link(__MODULE__, opts, name: via(Keyword.fetch!(opts, :id))) end defp via(id), do: {:via, Registry, {BlogOtp.WorkflowRegistry, id}}
The goal is written before the owner exists; from then on, the owner is the only writer. Registering the process under the workflow id in a Registry with unique keys turns “only one writer” from an intention into a guarantee: a key points to at most one process, and a second attempt to start an owner for the same run would get {:error, {:already_started, pid}}.
Look at what the process is started with: the id, not the goal. When a supervisor restarts a child, it calls the same start function, with the same arguments, from the child’s specification. The id is all a new process needs to find out everything else.
@impl true def init(opts) do state = %__MODULE__{ id: Keyword.fetch!(opts, :id), model: Keyword.get(opts, :model, BlogOtp.Model.Scripted), max_steps: Keyword.get(opts, :max_steps, 10) } {:ok, state, {:continue, :rebuild}} end @impl true def handle_continue(:rebuild, state) do state = state.id |> BlogOtp.Log.read() |> Enum.reduce(state, &apply_step/2) next_step(state) end
When init/1 returns {:continue, :rebuild}, OTP runs handle_continue/2 before the process receives any other message, so no result can be handled while the state is still being rebuilt.
The same apply_step/2 that updates the workflow while it runs also rebuilds it after a crash. Now we can see why it had to be free of side effects: replaying the log must not run the tests again. And a new run isn’t a special case either: it’s a log with a single entry, the goal. The fold produces a state with nothing pending, and next_step/1 asks the model for its first decision.
The state is a fold over the log.
This changes what a restart means. The new process doesn’t need to remember what the old one knew. It only needs to rebuild enough of the workflow to continue from a known point. But careful!
Fold the log from our crash, and pending holds exactly one entry: step 3.
Run the tests
There’s no result for it. So next_step/1 sees something pending and waits, for a result that may never come.
We know the decision was recorded. But did the work actually run? Maybe the request was never sent. Maybe the tests were still running when the process crashed. Maybe they finished, and the result was lost before it could be recorded.
For a test suite, running it again is harmless. But imagine our agent’s last step had been:
Open a pull request
Now repeating it means a duplicate pull request. And some actions are even more delicate than that, like inserting a row into a database that must never exist twice, or charging a customer. Those are the ones where we have to be really careful.
Restarting the process gives us back the ability to continue the workflow. It doesn’t tell us whether to run an external action again.
Restart and retry are two different problems.
That leaves two questions open: where the work actually happens while the owner stays available, and what to do with a step whose outcome we don’t know. The first question is where the next chapter picks up. The second one will have to wait until we talk about failure recovery.
The complete code repository for this series will be shared in Chapter 2.
Want to learn more about agentic workflows and OTP? Get in touch with our ESL team.
The post Exploring OTP Patterns for Agentic Workflows appeared first on Erlang Solutions.
It’s that time of the year when the annual Biketober and Coffeeneuring challenges are on! This year I’m not planning on any serious miles or any particular goals for Biketober, but as always I plan on completing the Coffeeneuring challenge, and will document it here as well as on the fediverse at social.coop.
As always, I’ll start my week on Monday (per Rule 4, “As long as you define it as seven consecutive days, you can start your week any day.”), so “Week One” will be a short one since the challenge started with “Early Bird Friday” (Rule 2).
Since last year I’ve started a Smyrna based group ride that aims to be a short ride (30-45 minutes, normally 5-7 miles depending on who shows up with longer rides if we’re all experienced riders) aimed at getting new riders on bikes, so for the first week I decided to pair up my Coffeeneuring ride and the group ride and went to Cafe Lucia. Unfortunately, I think I’ll haver to stop going to this location. It’s been one of my favorite coffee spots for a while, but lately it’s taken to only playing christian praise music, which I find somewhat offensive both as music and in the sense that a coffee shop should be more welcoming and not force its owner or employees beliefs on everyone else. Believe what you want, but in a public community space there’s no reason to assume everyone else will want to hear about it.
The ride itself, however, was great. Between it being a rainy day, one of the regulars being sick, and several of the others being at the Atlanta Pride Parade, we only had three folks for the day, none of whom were new so we decided to do a slightly longer ride (~9.1 miles), ending at a local beer establishment—though I did not count the beer place per rule 4, “Only one coffee location per day counts toward official completion”.
2026-10-11 Smyrna Group Ride
A GPX track for the ride can be downloaded from the Internet Archive.
I took advantage of our weekly Smyrna Group Ride to try and get a few of our other regulars Coffeneuring, so today we stopped at Rev Coffee mid-route. Their beans are a bit expensive for what you get, but the coffee is pretty solid. It was just chilly enough to need a jacket when we started, and it was windy enough to slow us down in a few places, so the coffee was a welcome break.
2026-10-18 Smyrna Group Ride
A GPX track is available from the Internet Archive.
We took a slightly longer ride than our normal beginner-friendly route this week and took the Mountain to River trail up to Cool Beans Coffee in Marietta, GA. We also stopped by th enearby “Tuesday” coffee, but just to take a quick photo, next time we’ll have to try their coffee.
The directory for this week with more photos and a GPX trace can be found here.
Thank goodness for the Smyrna Group Ride, since that seems to be the only way I can get myself out Coffeeneuring this year! This week we did one of our regular loops that I like to call the “War Crimes” loop since it goes past Dobbins Air-Force Base / a Lockheed Martin facility. Along the way we stopped at Ruby’s Sourdough Pizza / Ruby’s Coffee & Cream for a quick coffee/ice-cream/pizza depending on who was feeling what.
As always, a GPX trace is available for the route.
Security teams are good at finding problems. The difficult part is finding the right problems across a growing codebase, a changing application and the connections between them. A scanner can flag a known pattern quickly. A skilled tester can follow a complicated line of enquiry. Neither has unlimited time, and there will always be a question nobody thought to ask.
Could AI agents take on more of that investigative work? I think the answer is yes, provided we are precise about what “find” means. Agents can produce leads, test assumptions and uncover issues that established checks have missed. A security vulnerability, though, has to survive examination in the context of the real system.
That distinction matters more as agents become available to both defenders and attackers. A familiar weakness can become more relevant when agents have the time to find it, test it and follow where it leads. Defenders have a good reason to look again at parts of their systems that were too laborious to examine thoroughly.
Think about the code paths that work perfectly well in normal use but behave differently with a surprising input or an unusual amount of data. Fuzzing (testing software with unexpected or malformed inputs) helps explore these cases; agents can then read the surrounding code, try a more specific hypothesis and keep working through leads that would consume too much of an engineer’s day if checked one by one.
Some issues only become apparent when you understand how the application is used. A finding may look harmless in isolation until you establish who controls the input, which permissions are involved or what the application is meant to prevent. Agents can explore a sequence of actions and check how the application responds at each step, which may reveal a problem that would be hard to spot from an isolated code warning.
There is also the possibility that one weakness opens the way to another. A low-priority issue could expose useful information; a forgotten endpoint might give access to a service assumed to be isolated. Agents can follow a discovery into the next step, although its account of that path still needs to be checked. The full route through a system may matter more than the severity of any one weakness in it.
I would be careful about grouping all of this under one claim that “AI finds what traditional testing misses”. Code analysis tools, fuzzing tools, formal verification and agents conducting a permitted penetration test are doing different jobs. Their findings have different levels of evidence. Formal verification is also starting to gain traction, with code agents proving useful for generating the specifications it requires. The useful question is where agents give the team another line of enquiry and how that enquiry will be validated.
We have seen one version of this in our own work. Lukas Backström, a senior developer at Erlang Solutions and a member of the Ericsson Erlang/OTP core development team, built a custom workflow using Claude Code to examine the Erlang/OTP repository for security vulnerabilities, bugs and performance issues.
This codebase already receives human review, regular automated functional and performance testing, and vulnerability scanning. Even so, agents surfaced cases where expensive encoding or decoding could be performed on untrusted data that was very large or unbounded, creating a possible denial-of-service risk. The operation itself was not mysterious. Finding the relevant combination of input and behaviour across a large repository was the challenge.
Our published case study reports approximately 20 previously unknown, potentially severe security vulnerabilities, alongside around 400 critical or high findings and roughly 4,000 findings overall, most of them low-severity bugs. These are reported findings from the investigation, not a claim that thousands of confirmed security vulnerabilities were waiting to be fixed. And, this is one of the world’s most thoroughly tested code bases.
The project gives us evidence for a particular point: agents helped investigate parts of an extensively tested codebase that would have been difficult to cover manually. It does not prove that agents will outperform every scanner or security team. The details of the task and the review process made the result useful.
Lukas gave agents a verification mode, including access to a Docker container to check findings and rank their severity and confidence. He also found that a fresh context and a focused second look at an issue helped expose false positives. That separate work took substantial compute, and the agents still sometimes returned a high-confidence finding that was wrong. It could also mistake a bug for a security issue because it misunderstood the threat model.
An engineer has to ask whether an attacker can reach the relevant code, what input they control, what limits exist elsewhere and what happens in a real deployment. A persuasive explanation from an agent is a reason to investigate, not evidence that every assumption is true.
There is a second challenge once agents start finding more faults. Most teams do not need a larger pile of unverified tickets. They need to know which findings are real and which ones deserve attention first. Every result takes time to assess, and asking agents to assess it again can add to the compute cost. Finding more vulnerabilities only helps if the team has enough context to act on what matters.
The investigative agents must also be secure in its own right. It may read code, retrieve documents and run tools, so its permissions and execution environment deserve scrutiny. Untrusted material could contain instructions intended to redirect its behaviour. The team needs to decide what the agents can access and do before giving it sensitive systems to examine.
I would treat an agentic investigation as an experiment with a clear question, rather than asking agents to “find everything” and judging success by the length of its report:
So, can agentic AI find security vulnerabilities other tests miss? Yes, it can uncover leads that existing checks have not surfaced, particularly when an issue takes sustained investigation to find. Our Erlang/OTP work showed that in a codebase with established reviews, automated tests and vulnerability scanning. It was not a test-by-test comparison, so we cannot say which individual check missed each issue.
Finding a lead is only part of the answer. An experienced engineer still needs to establish whether it is a genuine security vulnerability and what should be fixed. The opportunity is to investigate more of the questions a team has never had the time to pursue, then give those findings the scrutiny they deserve.
The post Can Agentic AI Find the Security Vulnerabilities Other Tests Miss? appeared first on Erlang Solutions.

XMPP Newsletter Banner
Welcome to the XMPP Newsletter, great to have you here again! This issue covers the month of September 2026.
The XMPP Newsletter is brought to you by the XSF Communication Team and contributors of the XMPP community.
Just like any other product or project by the XSF, the Newsletter is the result of the voluntary work of its members and contributors. If you are happy with the services and software you may be using, please consider saying thanks or help these projects!
Interested in contributing to the XSF Communication Team? Read more at the bottom.
See also the XMPP Events page.
Being an elected member of the XMPP Standards Foundation signals a commitment to open standards and professional engagement in / with the XMPP community. Here, your membership helps position the XSF as a healthy organization, which in itself is valuable. It also grants voting rights on technical and administrative matters within the XSF. The application is a light-weight and free of cost process and you can use your membership to get more involved more easily, too. If you are interested in joining the XMPP Standards Foundation as a member, please apply to our 4th quarterly call for members admission before November 29, 2026, 00:00 UTC.
The XMPP Standards Foundation is calling for individuals to compose the Board of Directors and members to serve on the XMPP Council for the 2026/2027 period. If you are interested in running for the Board of Directors or the XMPP Council, please add a wiki page about your candidacy to one or both of the aforementioned sections before November 8, 2026, 00:00 UTC. Get involved in the XMPP Standards Foundation organization decisions and with the specifications the XSF publish. Note: XMPP Council members must be elected members of the XSF; however, there is no such restriction for the Board of Directors.
The XMPP Standards Foundation develops extensions to XMPP in its XEP series in addition to XMPP RFCs. Developers and other standards experts from around the world collaborate on these extensions, developing new specifications for emerging practices, and refining existing ways of doing things. Proposed by anybody, the particularly successful ones end up as Final or Active - depending on their type - while others are carefully archived as Deferred. This life cycle is described in XEP-0001, which contains the formal and canonical definitions for the types, states, and processes. Read more about the standards process. Communication around Standards and Extensions happens in the Standards Mailing List (online archive).
The XEP development process starts by writing up an idea and submitting it to the XMPP Editor. Within two weeks, the Council decides whether to accept this proposal as an Experimental XEP.
If an experimental XEP is not updated for more than twelve months, it will be moved off Experimental to Deferred. If there is another update, it will put the XEP back onto Experimental.
Last calls are issued once everyone seems satisfied with the current XEP status. After the Council decides whether the XEP seems ready, the XMPP Editor issues a Last Call for comments. The feedback gathered during the Last Call can help improve the XEP before returning it to the Council for advancement to Stable.
Please share the news on other networks:
Also check out our RSS Feed!
Looking for job offers or want to hire a professional consultant for your XMPP project? Visit our XMPP job board.
This is a community effort, and we would like to thank translators for their contributions. Volunteers and more languages are welcome! Translations of the XMPP Newsletter will be released here (with some delay):
Contributors:
Translations:
This XMPP Newsletter is produced collaboratively by the XMPP community. Each month’s newsletter issue is drafted in this simple pad. At the end of each month, the pad’s content is merged into the XSF GitHub repository. We are always happy to welcome contributors. Do not hesitate to join the discussion in our XSF Communications Team group chat (MUC) and thereby help us sustain this as a community effort. You have a project and want to spread the news? Please consider sharing your news or events here, and promote it to a large audience.
Tasks we do on a regular basis:
For this newsletter either log in here and unsubscribe or simply send an email to newsletter-leave@xmpp.org. (If you have not previously logged in, you may need to set up an account with the appropriate email address.)
This newsletter is published under CC BY-SA license.

Contents:
This release contains fixes for those security issues:
There was a reference-ordering problem in the fast_xml generator, it generated XML encoders that could reorder child elements in a different order from the one declared in the codec specification. From now, the order is the one declared in the codec specification. See details in https://github.com/processone/fast_xml/pull/53
Additionally there was an incorrect sasl2_continue declaration order in the xmpp erlang library: it declared "additional-data, text, tasks". Now it follows the ordering defined in XEP-0388 schema: "additional-data, tasks, text". See details in https://github.com/processone/xmpp/pull/112
New toplevel option captcha_pow adds a SHA-256 hashcash challenge as described in XEP-0158 in the CAPTCHA form, alongside the image challenge or on its own.
Unlike the image challenge, this does not require setting the option captcha_cmd.
This option is used only by mod_register when registering a new account using In-Band Registration, not in MUC rooms or in mod_register_web. It is disabled by default.
It is well known how to grant administrative privileges to an account: by adding that account to an acl called admin:
acl:
admin:
user: admin1@localhost
The default ejabberd configuration uses this admin ACL in many places:
announce access rule used by mod_announceconfigure access rule used by mod_configure and WebAdminapi_permissions entries used to execute API commands in WebAdmin, mod_adhoc_api, mod_http_api, ...shaper_rulesaccess_admin option in mod_mucConsequently, that admin account can administer all of ejabberd: all the global features, all the modules, in all the vhosts... For now let&aposs call it a "global admin".
If you have several vhosts, you can allow specific accounts to administer only specific vhosts. Let&aposs call them "vhost-admins". In this example admin1@localhost can execute commands on all vhosts. Additionally, localhost has a vhost-admin, second has two vhosts-admins, and third has a vhost-admin:
hosts:
- localhost
- second
- third
acl:
admin:
user: admin1@localhost
append_host_config:
localhost:
acl:
aclhostadmin:
- user: hostadmin@localhost
second:
acl:
aclhostadmin:
- user: hostadmin@second
- user: hostadmin@third
third:
acl:
aclhostadmin:
- user: hostadmin@second
api_permissions:
"vhost http access":
from: mod_http_api
who:
access:
allow:
- acl: admin
allow:
- acl: aclhostadmin
what: "*"
Example call of a vhost command by a vhost-admin:
$ curl --basic --user hostadmin@third:somepass -k \
&aposhttps://localhost:5443/api/status_num_host?host=second&status=dnd&apos
7
If a vhost-admin tries to execute an API command directed to a vhost he does not administer, or a global command (that has no host argument, and affects all ejabberd), they are rejected:
$ curl --basic --user hostadmin@third:somepass -k \
&aposhttps://localhost:5443/api/status_num_host?host=third&status=dnd&apos
{"code":32,
"message":"AccessRules: Account does not have the right to perform the operation.",
"status":"error"}
$ curl --basic --user hostadmin@third:somepass -k \
&aposhttps://localhost:5443/api/stats?name=registeredusers&apos
{"code":32,
"message":"AccessRules: Account does not have the right to perform the operation.",
"status":"error"}
force value to auth_external_user_exists_check option*_to_atomejabberd_cluster:*call operate only on known nodesacl:load_tab()ejabberd_systemd: Prefer matching over length/1mod_auth_fast: Make sure that fast tokens can be used only with method that they were created formod_invites: don&apost apply overuse limit if max_invites is infinity (#4615)mod_invites: don&apost crash in get_invite_by_invitee_t if reset_token present (#4620)mod_invites: now that Conversations is for free we remove Yaxim (#4621)mod_mix: Make access_create rule be applied when creating channelmod_mqtt: Add lower limits for pre-auth packetsmod_muc_room: Fix handling of hats request with missing xdatamod_muc_rtbl: Accept also plain account and domain JIDsmod_muc_rtbl: Fix handling of remote ban servers (#4622)mod_register: After changing password disallow password change on currently authenticated sessionsdb_serialize to mod_privacy and mod_pubsubrename_column op to ejabbrd_sql_schema update routinesrename_column compatible with older mysql versionsejabberd_sql_schema: Escape all column/table namesmod_roster serializer with info about approved fieldmake-binaries: Bump Elixir to 1.19.6make-binaries: Bump Erlang/OTP version to 28.5.0.7make-binaries: Bump Expat version to 2.8.5make-binaries: Bump JPEG version to 10make-binaries: Bump OpenSSL 3.6.4make-binaries: Bump PNG version to 1.6.58make-binaries: Bump SQLite version to 3530400make-binaries: Bump WebP version to 1.6.0Dockerfile: Workaround to get image with amd64 (#4598)https://github.com/processone/ejabberd/compare/26.07...26.09
We would like to thank for the security reports provided by:
the contributions to the source code by:
fast_xml and xmpp XML child orderingand the translation by:
And also to all the people contributing in the ejabberd chatroom, issue tracker...
Customers of the ejabberd Business Edition, in addition to all those bugfixes, also get the following changes:
mod_applepush service (to change sandbox connection endpoint)When using multihost schema:
ALTER TABLE push_gate CHANGE COLUMN user username text NOT NULL;
CREATE INDEX i_push_gate_username_server_host USING BTREE ON `push_gate`(username(191), server_host(191));
Otherwise:
ALTER TABLE push_gate RENAME COLUMN user TO username;
CREATE INDEX i_push_gate_username USING BTREE ON `push_gate`(username(191));
When using multihost schema:
ALTER TABLE push_gate RENAME COLUMN "user" TO "username";
CREATE INDEX i_push_gate_token_server_host ON "push_gate" USING btree ("username", "server_host");
Otherwise:
ALTER TABLE push_gate RENAME COLUMN "user" TO "username";
CREATE INDEX i_push_gate_token ON "push_gate" USING btree ("username");
As usual, the release is tagged in the Git source code repository on GitHub.
The source package and installers are available in ejabberd Downloads page. To check the *.asc signature files, see How to verify ProcessOne downloads integrity.
For convenience, there are alternative download locations like the ejabberd DEB/RPM Packages Repository and the GitHub Release / Tags.
The ecs container image is available in docker.io/ejabberd/ecs and ghcr.io/processone/ecs. The alternative ejabberd container image is available in ghcr.io/processone/ejabberd.
If you consider that you&aposve found a bug, please search or fill a bug report on GitHub Issues.