Rustler VS Akka

For performance intensive tasks, you could rely on Rust NIFs, there is this great project: https://github.com/rusterlium/rustler

My last project with Elixir was using Elixir merely as an orchestrator of static binaries (developed in golang) which were talking in JSON via stdin/stdout.

From the moment we discovered Tauri, we really felt like this was the perfect fit. The API is really solid, the configuration files are minimal and easy to understand, and the usage of Rust makes it way easier to add new functionalities and think about interesting ways of interoperating with Elixir via the Rustler library.

Elixir/Rust is the new Python/C++, and Rustler makes the communicating between the 2 languages super easy: https://github.com/rusterlium/rustler

Rustler is so awesome for this. Write Elixir NIFs in Rust? Yes, please!

But really, I would suggest thinking about what you want to build before "how" or "with which tool" - one of the signs of a person becoming a good engineer is having an array of tools at their disposal and being able to choose a correct tool for the correct task. Rust also excels in integrating with other languages - with JS via WebAssembly (a bit of self-promotion, for example), with Elixir via Rustler, with Python via PyO3 and PyOxidizer, etc. So you absolutely can start writing a frontend app with JS, or a distributed system with Elixir, or a data processing/ML app with Python and use Rust to speed up critical parts of those. Or, in reverse, you can start with Rust & add new capabilities to whatever you're building, that being a frontend, a resilient chat interface, or an ML model.

I created a elixir (wrapper) library to generate password hashes. Other Elixir libraries use a C NIF to generate password hashes. This libary uses a Rust NIF (using Rustler) and the Rust libraries the generate the different hashes. Additionally this library uses RustlerPrecompiled so you don't need to have a Rust compiler installed to use this library. It supports argon2, scrypt, brypt and pbkdf2.

> I guess, why not use Rust entirely instead of as a FFI into Elixir or other backend language?

Because Rust brings none of the benefits of the BEAM ecosystem to the table.

I was an early Elixir adopter, not working currently as an Elixir developer, but I have deployed one of the largest Elixir applications for a private company in my country.

I know it has limits, but the language itself is only a small part of the whole.

Take ML, Jose Valim and Sean Moriarity have studied the problem, made a plan to tackle it and started solving it piece by piece [1] in a tightly integrated manner, it feels natural, as if Elixir always had those capabilities in a way that no other language does and to put the icing on the cake the community released Livebook [2] to interactively explore code and use the new tools in the simplest way possible, something that Python notebooks only dream of being capable of, after a decade of progress

That's not to say that Elixir is superior as a language, but that the ecosystem is flourishing and the community is able to extract the 100% of the benefits from the tools and create new marvellously crafted ones, that push the limits forward every time, in such a simple manner, that it looks like magic.

And going back to Rust, you can write Rust if you need speed or for whatever reason you feel it's the right tool for the job, it's totally integrated [3][4], again in a way that many other languages can only dream of, and it's in fact the reason I've learned Rust in the first place.

The opposite is not true, if you write Rust, you write Rust, and that's it. You can't take advantage of the many features the BEAM offers, OTP, hot code reloading, full inspection of running systems, distribution, scalability, fault tolerance, soft real time etc. etc. etc.

But of course if you don't see any advantage in them, it means you probably don't need them (one other option is that you still don't know you want them :] ). In that case Rust is as good as any other language, but for a backend, even though I gently despise it, Java (or Kotlin) might be a better option.

[1] https://github.com/elixir-nx/nx https://github.com/elixir-nx/axon

[2] https://livebook.dev/

[3] https://github.com/rusterlium/rustler

[4] https://dashbit.co/blog/rustler-precompiled

unfortunately as of the time of this writing, rustler does not support generic type intefaces so I guess this is impossible?

One thing that drew me to Rust was actually Elixir/Erlang calling out to it for certain specialized needs. Within Elixir/Erlang you get best of breed concurrency but exiting the BEAM to run other code is unsafe. Calling out to Rust, however, comes with great safety guarantees.

Managing concurrency outside of Rust and then calling Rust for the more focused and specialized work is a good combination IMO.

https://github.com/rusterlium/rustler

Kotlin also has a construct for asynchronous collections/streams. Kotlin's version of AsyncSequence is called a Flow. Just as Swift's AsyncSequence builds upon prior experience with RxSwift and Combine, Kotlin's Flow APIs build upon earlier stream/collection APIs in the JVM ecosystem: Java's RxJava, Java8 Streams, Project Reactor, and Scala's Akka.

First-class distributed and multicore computing. Swift has first-class “actors” and “distributed” methods. Unison, Erlang, and Elixir are built with distributed being one of the #1 concerns. Though first-class is not super common and I don't really expect it to be because usually libraries are enough (e.g. Scala has Akka and is used WIDELY for distributed); whereas something like linear types and typed effects, you can't emulate in a library.

Akka is a library that implements the actor model for JVM languages. Mainly in Scala, but you can use it in Java too, and maybe others. It doesn't feel as ergonomic as Elixir, but if Elixir is too "out there" for the decision makers in your case, this might be a friendlier alternative.

Kalix builds on the lessons we have learned from more than a decade of building Akka (leveraging the actor model) and our experience helping large (and small) enterprises move to the cloud and use it in the most time, cost, and resource-efficient way possible.

Note Akka, the Java & friends framework, is working with the actor model and have as main inspiration Erlang to mimic some features of the BEAM on top of the JVM.

Looking back at real dates, I started learning the language (Scala) back in 2008 because it was something new and trendy that interested me. I started spending some serious time with it in 2009 (helping out other newcomers and making small contributions to various projects), and then in 2010 became a core contributor to the Akka project (you can find me a little ways down this list: https://github.com/akka/akka/graphs/contributors). For the most part I worked on the features I wanted to, but worked on other things if a user asked nicely. Akka became very popular in the early 2010s, so all of a sudden I had highly sought after skills. Got hired by a London based company and moved myself and my family from Canada over here. But even today, that exposure I got 10 years ago still helps me to land new contracts.

In the open source world, Akka, the most popular actor system library in the JVM ecosystem, that’s heavily used in tonnes of open source projects, recently went from “free and open source” to “paid/proprietary and source available.” https://github.com/akka/akka/pull/31561

Same strategy - the pricing is insanely high (for a library), and the project is effectively dead now, but it’ll take some larger enterprises awhile to move away from.

Lightbend, the company owning Akka, recently shared a blog post signed by the CEO announcing a license change from Apache 2.0 to Business Source License 1.1, a proprietary license. You can already find it in this PR, merged a couple days ago.

Akka 2.6 is on the open source Apache license, that is unchanged (its not possible for Lightbend to change an existing license). Its only the new Akka 2.7 which has the BSL license, so as long as you don't upgrade you are fine. See https://github.com/akka/akka/pull/31561.