radu's blog

A practical guide to WebAssembly memory

Mon, 11 Jan 2021 00:00:00 +0000

Memory in WebAssembly is one of the topics that creates confusion for newcomers, particularly for those with experience in languages with memory management features like garbage collection, such as JavaScript, Go, or Java. In this article we explore using memory in WebAssembly in various scenarios - passing JavaScript arrays to Rust and AssemblyScript modules, checking for some basic memory leaks using Valgrind, or exchanging strings between runtimes and modules using Wasmtime.

From (C)Go to Rust: A practical guide to building shared and static libraries, linking, and FFI

Sun, 12 Jan 2020 00:00:00 +0000

In this article we will explore how to build shared and static libraries in Go, and import them in Rust.

Raspberry Pi SpinKube livestream

Tue, 09 Apr 2024 00:00:00 +0000

I recently built a 5-node Raspberry Pi cluster running Wasm workloads using the new SpinKube project.

This week, I joined Fermyon’s weekly live stream together with Sohan to talk about how I configured the cluster and to demonstrate running Spin applications on Kubernetes.

You can follow along this gist to set up your own cluster, and stay tuned for a full write-up on this setup.

Trying something new

Sun, 07 Apr 2024 00:00:00 +0000

I’ve been writing on this blog since 2016. I’ve written about .NET, WebSockets, debugging microservices on Kubernetes, or about WebAssembly memory.

I rarely have the time to write lengthy blog posts anymore, and social media seems to be the worst place to have a conversation these days; so I stopped posting almost entirely.

I’m trying to change that with a new notes section of my blog where I’m trying to write more by sharing something in-between a tweet and a fully fledged blog post. I might write about personal projects and experiments around Wasm, Spin, distributed systems, dotfiles and fonts, interesting conference talks, or bike rides.

Introducing Fermyon Serverless AI

Tue, 05 Sep 2023 16:00:00 +0000

Fermyon Serverless AI gives you the building blocks for integrating Artificial Intelligence into your serverless applications, with AI inferencing for Large Language Models (LLMs) for Llama2 and CodeLlama, support for generating sentence embeddings and storing them in a vector-ready database, built-in key-value storage, and a seamless developer experience.

Spin 1.0 — The Developer Tool for Serverless WebAssembly

Wed, 22 Mar 2023 16:00:00 +0000

Introducing the first stable release for Spin, the open source developer tool for building, distributing, and running serverless applications built with WebAssembly.

The Six Ways of Optimizing WebAssembly

Thu, 26 Jan 2023 02:00:00 +0000

This post is co-authored with Matt Butcher, and it originally appeared on InfoQ.com.

Key Takeaways

While many languages support Wasm, some are faster than others.
Some compilers natively support optimizing Wasm for efficiency and speed.
The wasm-opt tool can optimize a Wasm binary regardless of the original language it was used to create it.
Using a JIT-enabled runtime can improve runtime performance depending on the hardware platform you are using.
Some Wasm runtimes can even compile applications ahead-of-time (AOT) to reach native execution speed.
The experimental Wizer project achieves a further performance boost by pre-initializing a Wasm binary to reduce the time it takes to launch it.
In our practice, we saw good optimization can reduce Wasm binary size by a factor of ten.

WebAssembly (often abbreviated to Wasm) is a binary executable format. Many different languages can be executed via Wasm, including Rust, C, JavaScript, Python, Ruby, and the .NET languages.

Building host implementations for WebAssembly interfaces

Thu, 20 Jan 2022 00:00:00 +0000

WebAssembly and WASI show great promise for the future of computing outside the browser, and the WebAssembly component model aims to improve the portability, cross-language, and composition story for Wasm. This article introduces host implementations, and how to use tooling from the Bytecode Alliance to build and use such implementations.

Introduction to WebAssembly components

Thu, 16 Dec 2021 00:00:00 +0000

WebAssembly and WASI show great promise for the future of computing outside the browser, and the WebAssembly component model aims to improve the portability, cross-language, and composition story for Wasm. This article explains the goals of the component model, and showcases how to use tooling from the Bytecode Alliance to build and consume such components.

Neural network inferencing for PyTorch and TensorFlow with ONNX, WebAssembly System Interface, and WASI NN

Wed, 07 Jul 2021 00:00:00 +0000

WASI NN is a proposal that allows WebAssembly guest modules running outside the browser to perform neural network inferencing by using host-provided implementations that can leverage CPU multi-threading, host optimizations, or hardware devices such as GPUs or TPUs. This article explores the goals of WASI NN, existing implementations, and details a new experimental implementation targeting ONNX, the Open Neural Network Exchange , which allows the either usage of models built with PyTorch or TensorFlow from guest WebAssembly modules.

Using Azure services from WebAssembly modules

Tue, 11 May 2021 00:00:00 +0000

With WAGI, the WebAssembly Gateway Interface, it is easier than ever to build microservices using WebAssembly. In this article, we explore building Wasm modules that use Azure services and how to run them using WAGI.

Updates on WAGI, the WebAssembly Gateway Interface

Mon, 10 May 2021 00:00:00 +0000

New features such as pulling from container registries and outbound HTTP connections are now part of WAGI.

An experimental outbound HTTP library for the WebAssembly System Interface

Mon, 08 Mar 2021 00:00:00 +0000

Send HTTP requests from Rust and AssemblyScript Wasm modules running in Wasmtime

A simple WebAssembly linker in JavaScript

Fri, 13 Nov 2020 00:00:00 +0000

An experimental JavaScript library that helps instantiating WebAssembly modules with imports by providing functionality to link JavaScript objects as imports, as well as automatically perform name based resolution for linking entire modules.

TensorFlow inferencing using WebAssembly and WASI

Sun, 18 Oct 2020 00:00:00 +0000

In this article, we experiment with building a Rust program that performs image classification using the MobileNet V2 TensorFlow model, compile it to WebAssembly, and instantiate the module using two WebAssembly runtimes that use the WebAssembly System Interface (WASI), the native NodeJS WASI runtime, and Wasmtime. A special interest is given to writing model and image data into the module’s linear memory, with implementations in both JavaScript and Rust. Finally, a simple prediction API is exemplified running on top of the Wasmtime runtime, and some limitations of this approach are discussed.

Towards sockets and networking in WebAssembly and WASI

Fri, 16 Oct 2020 00:00:00 +0000

In this article we look at the current state of the networking API in WASI, and add a minimal implementation together with socket clients in AssemblyScript and Rust (with an upfront disclaimer that this should definitely not be used for anything other than experimentation).

Introduction to Brigade - video demo

Tue, 28 Jul 2020 00:00:00 +0000

Video demonstration of getting started with Brigade

Getting started with NodeJS and the WebAssembly System Interface

Sun, 19 Jul 2020 00:00:00 +0000

NodeJS recently added experimental support for executing WebAssembly modules using WASI, or the WebAssembly System Interface. In this article we explore how to get started with the WASI sandbox and writing various modules we can execute, in Rust, or AssemblyScript.

Writing a simple WASM API layer using interface types and Wasmtime

Tue, 23 Jun 2020 00:00:00 +0000

In this short article we explore how to get started with WebAssembly interface types by defining a simple API layer, then implementing that using Wiggle and Wasmtime

A beginner's guide to adding a new WASI syscall in Wasmtime

Tue, 31 Mar 2020 00:00:00 +0000

In this article, we explore how to add a new system call to WASI, the WebAssembly System Interface, and implement it in Wasmtime

Random WSL tips & tricks

Sat, 09 Nov 2019 00:00:00 +0000

If you’re getting started with using WSL2, here are a few tips for making the most of your experience - from running Linux GUI apps, to accessing the Linux filesystem from Windows Explorer or exporting your distribution.

Version control for your WSL distribution with a Dockerfile

Thu, 07 Nov 2019 00:00:00 +0000

In this article, we will explore how to build a WSL distribution using a Dockerfile, allowing us to version our entire WSL configuration.

Securely distributing and signing WebAssembly modules using OCI and TUF

Sun, 03 Nov 2019 00:00:00 +0000

Attacks on software repositories happen all the time, and any future WebAssembly repository and client tooling should be prepared to mitigate these attacks. In this article we will explore a minimum security model for WebAssembly registries and client tooling based on The Update Framework, and how to integrate this model when distributing WebAssembly modules using OCI registries.

Distributing WebAssembly modules using OCI registries

Sun, 13 Oct 2019 00:00:00 +0000

WebAssembly (WASM) is a binary instruction format for a stack-based virtual machine. In familiar terms, WASM is used as a compilation target for various programming languages (C, C++, Rust, or Golang, for example), generating a compact binary with a known format. Mozilla Developer Network describes WebAssembly as having huge implications for the web platform — it provides a way to run code written in multiple languages on the web at near native speed, with client apps running on the web that previously couldn’t have done so.

Cross platform GitHub Action for downloading, extracting, and adding tools to path

Tue, 17 Sep 2019 00:00:00 +0000

Ever since I started to use GitHub Actions, one of the tasks I copy and pasted the most contained the following steps:

download a file or an archive containing a statically compiled tool
extract if it is an archive
copy the target tool to a directory in the path

And after an embarrassing number of tries, my jobs would contain a step that would resemble the following (taken from an actual GitHub Action):

Glottal stops and alveolar taps as a non-native English speaker

Sat, 07 Sep 2019 00:00:00 +0000

Because of the notoriously confusing nature of English pronunciation in terms of phonemes, rather than letters of the alphabet, one must be aware, for example, that the word ‘enough’ begins with the same vowel phoneme as the beginning of the word ‘inept’, and ends with the same consonant as ‘stuff’.

The state of CNAB: Part 2 - CNAB Registries

Thu, 05 Sep 2019 00:00:00 +0000

In this series, we explore the state of the Cloud Native Application Bundles (CNAB) specifications, and do a deep dive into the distribution of bundles, and security and attestation.

The state of CNAB: Part 1 - CNAB Core

Wed, 04 Sep 2019 00:00:00 +0000

In this series, we explore the state of the Cloud Native Application Bundles (CNAB) specifications, and do a deep dive into the distribution of bundles, and security and attestation.

Building self-contained, single executable .NET Core 3 CLI tools

Mon, 02 Sep 2019 00:00:00 +0000

This is the .NET Core’s first iteration at self-contained binaries. It is not ideal - the resulting size of ~40M is probably way too large for simple applications. But the fact that now we can actually create a global tool with .NET and distribute it without requiring users to install .NET is extremely exciting! Not to mention the ease of packaging applications in containers, and not having to copy tens of files.

Adding dark mode to a Hugo static website without learning CSS

Sun, 01 Sep 2019 00:00:00 +0000

How I added a dark theme toggle to my Hugo website without writing a single line of CSS

Building Reusable GitHub Actions in TypeScript, using the official toolkit

Fri, 23 Aug 2019 00:00:00 +0000

GitHub Actions now supports CI/CD - and while the workers for Actions come pre-configured with support for lots of programming languages and frameworks, you have the option to use an existing action to configure the environment, or build your own. In this article we will see how to build reusable actions using the Actions toolkit

Running Kubernetes end-to-end tests with Kind and GitHub Actions

Wed, 21 Aug 2019 00:00:00 +0000

Using Kubernetes in Docker in GitHub Actions

Running end-to-end tests on your Kubernetes cluster with Kind and Brigade

Sat, 10 Aug 2019 00:00:00 +0000

The goal of this article is to show you how to configure running Kind in a pod in Kubernetes, then abstract the configuration and automate it using Brigade.

Rendering Helm templates in the browser, with WebAssembly

Sat, 11 May 2019 00:00:00 +0000

I’ve been trying to find a weekend to play around with Web Assembly for at least a couple of months now - I had previously read the hello world examples for both Go and Rust, but never had the time to actually try things out. So I decided to take a piece of real world Go code, that is used today in Helm, and see if I can get it to execute in the browser - I chose to replicate a simpler version of helm template, where you input the template, values file, and metadata in the web page, and the rendered template gets printed out.

Writing controllers for Kubernetes CRDs with C#

Mon, 06 May 2019 00:00:00 +0000

The goal of this article is to show you how to use the Kubernetes C# client to write extremely simple controllers for your Kubernetes custom resources, and start watching resources in a few lines of C#

Instant Scaling on Demand: Serverless Kubernetes with Brigade

Mon, 01 Apr 2019 00:00:00 +0000

This article originally appeared on the Microsoft open source blog.

Microservices built on Kubernetes are fast becoming one of the core scenarios where computing is done, and Kubernetes development and operations skills are therefore becoming a larger part of any cloud-native toolset. This article shows how to use some of the Cloud Native Computing Foundation (CNCF) and CNCF sandbox projects together to build a Kubernetes-native application that listens for events and then runs serverless pipelines on Virtual Kubelet instances, each of which are dynamically created (and recycled when the pipeline is done).

Filter secrets from Kubernetes logs

Mon, 20 Aug 2018 00:00:00 +0000

Running any non-trivial application on Kubernetes will most likely require authorized access to other components - databases, storage buckets, APIs - all of which require a connection string or some sort of access key. Storing these values in Kubernetes is done through Secrets, and while there are plenty of ways to make sure the secrets are safe while at rest, as well as how to configure an external KMS provider, once the secret is injected into your application container, its value will be plain text.

The state of debugging microservices on Kubernetes

Sat, 05 May 2018 00:00:00 +0000

For as long as we have been writing software, we have also introduced bugs in our applications. Back when we were developing monoliths, we could simply start the IDE of choice, add a couple of breakpoints, step through the code and hopefully solve the issue. There was a single place where the application was running, where logs were visible and where the application could be diagnosed.

Debug Helm and Tiller using VS Code and Draft

Sun, 29 Apr 2018 00:00:00 +0000

In today’s article we will explore how to take a real-world application and start developing, debugging and deploying it to a Kubernetes cluster and how to use a couple of open-source tools to make our lives easier in the process. Specifically, we will use Helm, the package manager for Kubernetes, the newly released Kubernetes extension for VS Code and Draft to develop, debug and deploy is Helm itself.

Using Draft to develop front-end + back-end applications. Experimenting with Draft, VS Code and remote debugging.

Tue, 10 Apr 2018 00:00:00 +0000

Application containers have skyrocketed in popularity over the last few years. In recent months, Kubernetes has emerged as a popular solution for orchestrating these containers. While many turn to Kubernetes for its extensible architecture and vibrant open-source community, some still view Kubernetes as too difficult to use. Learn how to use Draft to simplify your cloud-native application development!

kube-toolkit: Toolkit for creating gRPC-based CLI tools for Kubernetes, written in Go

Mon, 18 Dec 2017 00:00:00 +0000

Building tools like Helm and Draft for Kubernetes using gRPC and Go

Update Azure Container Instances with Docker Hub webhooks

Thu, 14 Dec 2017 00:00:00 +0000

Back in July, Microsoft announced Azure Container Instances, a new Azure service delivering containers with great simplicity and speed and without any Virtual Machine infrastructure to manage. ACIs are the fastest and easiest way to run a container in the cloud. In this article we will see how to update Azure Container Instances based on webhooks from Docker Hub

Getting started with SignalR Alpha 2

Sun, 26 Nov 2017 00:00:00 +0000

In this article we will explore how to get started with the Alpha 2 version of SignalR for ASP.NET Core 2.0 and understand streaming, sending binary data, using the Redis scaleout and, of course, chat!

Best of Both worlds: Azure App Service and Kubernetes

Tue, 17 Oct 2017 00:00:00 +0000

In this article we will explore how to integrate Azure App Service and Kubernetes within the same Azure Virtual Network and consume Kubernetes services from an Azure App Service app without exposing them on the public Internet. There will be lots of situations when we want to use both the simplicity and features of a PaaS service (such as autoscaling, easy SSL, or any other cool feature) for a component and the flexibility of Kubernetes for others - in this article we will see how to achieve this without exposing services on the Internet.

Jenkins pipelines with Kubernetes

Sun, 08 Oct 2017 00:00:00 +0000

The goal of this article is to show you how to deploy Jenkins to your Kuberentes cluster using Helm and write Jenkins pipelines that execute builds within pods in your cluster - all of this while replicating your Jenkins configuration and persisting everything with Kubernetes persistent storage.

Get started with Helm and Draft for Kubernetes

Sat, 07 Oct 2017 00:00:00 +0000

This post shows you how to automatize and simplify working with multiple Kubernetes clusters and multiple tools such as kubectl, helm or draft - creating a container image with your desired version of the tools and mounting the config files to the container

Kubernetes 1.8 on Azure

Fri, 06 Oct 2017 00:00:00 +0000

In this post you’ll see how to deploy Kubernetes 1.8 and later on Azure using ACS Engine, an open-source tool that creates the entire configuration for your orchestration cluster and deploys it on Azure Container Service.

The Hybrid Cluster: A CI/CD Story [Part 1] - Configuring a hybrid swarm mode cluster in Azure with acs-engine

Mon, 03 Jul 2017 00:00:00 +0000

We’ll explore how to create a hybrid Docker Swarm Mode cluster with Linux and Windows agents, deploy it on Azure Container Service using ACS Engine, see how to connect to the cluster and manage it and finally how to deploy hybrid services with both Linux and Windows Server containers.

Real-Time ASP .NET Core

Sat, 18 Feb 2017 00:00:00 +0000

We will write an ASP.NET Core middleware for providing real-time functionality to your applications. To its core, this is a WebSockets middleware for ASP .NET Core applications with TypeScript / JavaScript and .NET clients - all this wile exploring the inner workings of ASP.NET Core middleware.

Creating a WebSockets middleware for ASP .NET Core 3

Fri, 30 Dec 2016 00:00:00 +0000

We’ll explore the low-level websockets API in .NET Core, understand the Middleware concept and finally write a websocket manager middleware that handles communication between various clients and your ASP.NET Core application.

Dockerizing an ASP.NET Core application with GitHub, Docker Cloud and Azure

Sat, 26 Nov 2016 00:00:00 +0000

In this article, we will take the simplest ASP.NET Core application, run it with Docker locally, then create Continuous Integration and Continuous Deployment flows using a GitHub repository, Docker Cloud and an Azure virtual machine that will act as a node for Docker Cloud.

Get started with Raspberry Pi3, Sense HAT and Azure IoT Suite

Mon, 10 Oct 2016 00:00:00 +0000

In this blog post, we will get started with the Raspberry Pi3, the Sense HAT and Azure IoT Suite. More specifically, from the IoT Suite we will use IoT Hub, and Stream Analytics, and the end goal of this little project is to acquire data from the sensors, upload the data to IoT Hub, which feeds it into Stream Analytics, with outputs to an Azure SQL database (for storage) and to Service Bus (for consuming the data in real-time from various applications).

ASP.NET Core MVC and SignalR Core

Fri, 09 Sep 2016 00:00:00 +0000

Inject ASP.NET Core Dependencies from JSON files

Thu, 18 Aug 2016 00:00:00 +0000

Back in the days of ASP.NET 4.x, each of the framework components - MVC, WebAPI, OWIN, SignalR - had its own dependency resolver and its own way of integrating with the framework. ASP.NET Core brings a consistent dependency injection mechanism with a unified meaning for lifetime or service registration,that is designed to server the needs of the framework and most consumer applications built on it. In this article, we will see a way of defining the service types and the implementation types we want to use based on a JSON file and switch between implementations without changing the code.

Introduction to ASP .NET Core MVC API

Fri, 05 Aug 2016 00:00:00 +0000

In this article we will be looking at ASP .NET Core MVC, more specifically at how to build an API that can be consumed from any type of application, be it web, mobile or desktop. We will build a very simple application that will enable the creation of posts (much like messages) and that will take us through adding the MVC services, creating models, controllers and consuming some data.

ASP .NET Core JSON Configuration and Dependency Injection

Sat, 23 Jul 2016 00:00:00 +0000

The new configuration system provides support for JSON, XML, INI and for in-memory configuration, while also allowing you to create your custom configuration provider. Let’s assume that in our application we want the response messages not to be hard-coded in Startup anymore, but stored in a configuration file so we don’t have to stop, modify or recompile our application every time the messages or the routes change.

ASP .NET Core Routing

Wed, 20 Jul 2016 00:00:00 +0000

So far we built simple web applications that responded with the same message for each request. However, any real-world application is going to need a more complex way of handling requests, so in this article we will see how to create route handlers for specific routes and how to extract parameters from the request URI - we will explore the low-level Routing API.

ASP .NET Core Startup

Tue, 19 Jul 2016 00:00:00 +0000

Any non-trivial application is going to need a mechanism to handle different types of requests and map them to specific services and middleware and configure services. This is accomplished through the Startup class, which is also the entry point for any incoming HTTP request.

ASP .NET Core Introduction

Mon, 18 Jul 2016 00:00:00 +0000

ASP.NET Core is a new open-source and cross-platform framework for building modern cloud based internet connected applications, such as web apps, IoT apps and mobile backends and a complete re-write of the 4.6 framework that came out last year and comes with a completely new architecture based on .NET Core. In this article we will see how to get started with ASP.NET Core.

Getting Started with .NET Core and VS Code

Sun, 17 Jul 2016 00:00:00 +0000

We will see how to get started with VS Code and .NET Core

Introduction to .NET Core

Sat, 16 Jul 2016 00:00:00 +0000

Introduction to .NET Core

Hi!

Mon, 01 Jan 0001 00:00:00 +0000

I’m the CTO and co-founder of Fermyon, where I created the Spin project and I work on building a new generation of computing platforms using Wasm.

In the past I worked at Microsoft in the DeisLabs research and development team, where I was a core maintainer for several server-side WebAssembly and distributed systems projects like Krustlet, Draft, Brigade, or the Cloud Native Application Bundle project.

Sometimes I write about serious topics, and sometimes I write short notes about personal projects and experiments.