Atmo Beta-4 is here, and it's a big step towards our goals of making WebAssembly a useful, reliable, and scalable cloud technology. This release is all about making it easier to build applications by working with more languages, more systems, and most importantly, more of your data.
This release brings a few tentpole new abilities: Go and Grain language support, Database capabilities, Kafka/Redpanda support, and a little sprinkling of major performance improvements. While you read this, don't forget that we're also constantly improving the quality of the codebase, and new features often require refactors that make Atmo easier to contribute to and maintain. We've been extremely pleased to see the size of our community growing at a rapid pace, with more new members and specifically new code contributors in the past 2 months than ever before. If you're interested in the future of cloud computing or learning more about WebAssembly, come join us!
Getting down to the good stuff, let's talk about language support. Until this point, the Suborbital ecosystem has supported Rust, AssemblyScript, and Swift. This release brings two new languages to the mix: Go (via the TinyGo toolchain) and Grain, a WebAssembly-native language. Both of these languages are now in 'preview', meaning we'd love for you to try them out, build some applications with them, give us your feedback, and help make using them a really great experience. As Go developers ourselves, we're really excited to be able to deploy Go Runnables in our Atmo applications! Grain gets us really excited because it asks the question 'what would a language built FOR WebAssembly look like?' and comes up with some really great answers. Get started with these new languages using Atmo Beta-4 and Subo Beta-2.1 (which now has binaries available on the releases page!).
Now for the part that I'm personally most excited about, which is support for databases in Atmo. You can now connect your MySQL and PostgreSQL databases to Atmo, and build entire end-to-end systems with its WebAssembly goodness. Database support is also in preview with this release, and only supports Rust Runnables for now. We plan to add more databases (SQLite and MongoDB?) and more languages in the near future. We've been looking forward to this day because it makes Databases a native part of the Suborbital ecosystem, and it does so in a cool, novel way.
To connect your database to Atmo, you'll add it as a
connection in your
Directive.yaml, like we introduced for Redis and NATS in Beta-3. Atmo handles ALL of the details of that connection for you at runtime, so you don't need to worry about any database-specific or connection-related logic. Atmo just makes it happen. New in this release is the
Queries.yaml file, which is where you define all of the SQL queries that your Runnables may need to execute. Your Runnables are not allowed to execute arbitrary queries (for good reason), and so we declaratively define exactly which queries they're allowed to run.
At runtime, your Runnables can execute any of the queries in
Queries.yaml, and they can include variables to be inserted dynamically (using MySQL's
? syntax or Postgres'
$1 syntax). Atmo creates prepared statements automatically, safely executing the queries using the values provided by your code. This is an incredibly safe way to enable database access, because it means that your application code never knows any connection secrets, can't access the database connection directly, and is protected against any malicious activity by the WebAssembly sandbox.
Now that you've got access to your data, it's time to connect with the rest of your system. We introduced NATS support in Beta-3, and several of you asked for us to support Kafka and Redpanda as well. Beta-4 brings exactly that, allowing you to define a
kafka connection in your Directive, settting it up as a stream source for your handlers. You can now build entire distributed async systems using just Atmo. Its declarative format makes it really simple to 'choreograph' your message-based systems using powerful WebAssembly functions in a really scalable way. Atmo can hook on to Kafka topics, execute your handler for every message in the stream, and then write results back out onto another topic for further processing (maybe by Atmo yet again!). This is a super ergonomic way to build distributed systems, and we can't wait to see what you'll build with it.
Finally, we have a big set of performance improvements in this release. As you may know, Atmo is powered by our Reactr WebAssembly scheduler, and so it gets a performance boost any time Reactr does. Not only did Reactr Beta-13 gain a huge performance boost from some internal refactoring and some changes to Wasm memory management, Atmo itself also improved its performance by reducing the number of JSON encode/decode events by more than half over the course of a request, meaning that it can now handle significantly more load with far less overhead. This is by far the fastest and most scalable release of Atmo yet.
I'll close out this one by saying that we're making some pretty big announcements this week, and if you're interested in hearing about those, I suggest you follow us on Twitter and subscribe to our Newsletter (down below).
I'm pretty proud of what the team has built for these awesome releases. Stay safe, and give Atmo a try!