Serverless-Bend: Massively Parallel APIs in a Single Command

Share:

Writing code that runs on thousands of GPU cores or multi-core CPU threads has historically been a dark art. Developers must wrestle with CUDA, C++, OpenCL, lock contention, thread synchronization, and unpredictable memory behavior. Even when the parallel code is written, hosting and serving it as a scalable API introduces another mountain of operational complexity.

This is why we built Serverless-Bend, an open-source CLI and framework designed to take the high-level, parallel-by-default execution model of the Bend programming language and expose it to the world as containerized serverless endpoints.

By combining the implicit parallelism of Bend with the auto-scaling capability of serverless clouds, developers can deploy complex, CPU- or GPU-bound algorithms in a single command.

The Core Paradigm: Parallel by Default

To understand why Serverless-Bend is a game-changer, we must look at Bend itself. Created by HigherOrderCO, Bend allows developers to write code using clean, Python-like syntax that compiles down to the HVM2 (Higher-Order Virtual Machine 2). HVM2 evaluates programs using Interaction Combinators, a breakthrough computational model that automatically parallelizes any operation that does not have sequential data dependencies.

In Bend, there is no thread management, no mutexes, and no concept of locks. If an algorithm contains recursive branches or tree-like computations, the runtime automatically fanned them out to all available CPU threads or GPU cores.

Serverless-Bend bridges the gap between this raw parallel computing runtime and standard web architecture. It wraps your Bend scripts in a high-performance Rust handler and deploys them to serverless container runtimes.

How Serverless-Bend Works under the Hood

When you execute the CLI to deploy a Bend script:

bend-cloud deploy script.bend --provider gcp

The CLI kicks off a multi-step orchestration pipeline:

  1. Environment Scaffolding: It dynamically initializes a workspace containing a custom Rust Axum web server, configuration manifests, and your Bend script.
  2. Containerization: It generates a optimized multi-stage Dockerfile containing the Bend runtime compiler (hvm and bend-lang) alongside the compiled Rust wrapper binary.
  3. Cloud Provisioning: It calls the respective cloud provider CLI to build and deploy the container.

The Rust wrapper handles the HTTP lifecycle, parsing inbound JSON payloads, translating arguments to Bend terms, running the compiler, and feeding the stdout back in the HTTP response.

Multi-Cloud Architecture

A key feature of Serverless-Bend is its native multi-cloud architecture. It target the leading serverless container platforms:

  • Google Cloud Run: Direct deployment from source using gcloud run deploy. The serverless instances dynamically spin up and execute Bend code in an isolated Linux container.
  • Azure Container Apps: Similar to GCP, Container Apps allow deploying the wrapper as a managed container with microservice scaling.
  • AWS Lambda: Deploying arbitrary containers to AWS Lambda usually requires integrating proprietary runtime APIs. To bypass this friction, Serverless-Bend dynamically bundles the AWS Lambda Web Adapter into the Dockerfile. The Web Adapter acts as an internal proxy that translates Lambda events to standard HTTP requests, allowing our Axum wrapper to run on AWS Lambda without altering a single line of Rust code.

Three Killer Use Cases

To prove the power of Serverless-Bend, we implemented three distinct proof-of-concepts, each targeting a classic parallel computing challenge.

1. Deep Tree and AST Transformations

Parsing or transforming massive, nested data structures (like ASTs or large JSON graphs) is recursive and sequential in languages like Python or JavaScript. In Bend, recursive traversals are parallelized by default. A Serverless-Bend API can ingest a deeply nested tree payload, distribute the recursive processing across all available hardware cores, and return the aggregated output in milliseconds.

2. On-Demand Monte Carlo Risk Simulations

Monte Carlo models rely on evaluating millions of independent random scenarios. We built a native u24 Linear Congruential Generator (LCG) inside Bend, fanned out the simulations using recursive halving, and estimated Pi. When deploying this script, Serverless-Bend evaluates 65,536 parallel mathematical paths in less than a second on Cloud Run.

3. Serverless Fractal and Rendering Engines

Calculating pixel arrays (like Mandelbrot or Sierpinski fractals) requires executing independent, pixel-specific arithmetic. By writing the pixel-generation logic recursively in Bend, Serverless-Bend computes the coordinate bounds in parallel and streams the raw nested AST structure back to a rendering client.

Getting Started

To install the Serverless-Bend CLI, clone the repository and run:

git clone https://github.com/dpuig/serverless-bend.git
cd serverless-bend
cargo install --path cli

Once installed, you can launch your first parallel API in minutes. Write your script, and let the cloud compiler handle the rest.

Check out the Serverless-Bend repository to get involved or open an issue. The future of serverless compute is parallel, and Serverless-Bend is here to make it accessible to everyone.