Convert Figma logo to code with AI

fermyon logospin

Spin is the open source developer tool for building and running serverless applications powered by WebAssembly.

5,142
248
5,142
271
View on GitHub

Top Related Projects

wasmerio's avatar

wasmer

18,623

🚀 The leading Wasm Runtime supporting WASIX, WASI and Emscripten

bytecodealliance's avatar

wasmtime

15,263

A fast and secure runtime for WebAssembly

Quick Overview

Spin is an open-source framework for building and running WebAssembly (Wasm) microservices and applications. It provides a developer-friendly environment for creating, testing, and deploying Wasm components, with a focus on serverless and edge computing scenarios.

Pros

  • Lightweight and fast execution of WebAssembly modules
  • Language-agnostic, supporting multiple programming languages for writing Wasm components
  • Easy deployment to various platforms, including cloud and edge environments
  • Built-in support for common patterns like HTTP servers and key-value stores

Cons

  • Limited ecosystem compared to more established serverless frameworks
  • Learning curve for developers new to WebAssembly concepts
  • Potential performance overhead for certain types of applications compared to native code
  • Dependency on WebAssembly support in target environments

Code Examples

  1. Creating a simple HTTP handler in Rust:
use anyhow::Result;
use spin_sdk::http::{Request, Response};
use spin_sdk::http_component;

#[http_component]
fn handle_request(req: Request) -> Result<Response> {
    println!("Received a request: {:?}", req.headers());
    Ok(http::Response::builder()
        .status(200)
        .header("content-type", "text/plain")
        .body(Some("Hello, Spin!".into()))?)
}
  1. Using key-value store in JavaScript:
import { HandleRequest, HttpRequest, HttpResponse } from "@fermyon/spin-sdk"

export const handleRequest: HandleRequest = async function(request: HttpRequest): Promise<HttpResponse> {
    const store = spinSdk.kv.openDefault();
    await store.set("mykey", "Hello from Spin!");
    const value = await store.get("mykey");
    
    return {
        status: 200,
        headers: { "content-type": "text/plain" },
        body: value || "Key not found"
    };
}
  1. Defining a Spin application in TOML:
spin_version = "1"
name = "my-spin-app"
version = "1.0.0"

[[component]]
id = "hello"
source = "target/wasm32-wasi/release/hello.wasm"
[component.trigger]
route = "/hello"
[component.build]
command = "cargo build --target wasm32-wasi --release"

Getting Started

  1. Install Spin:

    curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash
sudo mv spin /usr/local/bin/

  2. Create a new Spin project:

    spin new http-rust hello-spin
cd hello-spin

  3. Build and run the project:

    spin build
spin up

  4. Access your application at http://localhost:3000

Competitor Comparisons

wasmerio logo

wasmer

18,623

🚀 The leading Wasm Runtime supporting WASIX, WASI and Emscripten

Pros of Wasmer

  • More mature and established project with a larger community
  • Supports multiple languages and runtimes beyond WebAssembly
  • Offers a wider range of features and use cases

Cons of Wasmer

  • Higher complexity and steeper learning curve
  • Larger footprint and potentially slower startup times
  • Less focused on serverless and cloud-native scenarios

Code Comparison

Spin (Rust):

spin_sdk::http_component(|req, res| {
    res.set_body("Hello, Spin!");
    Ok(())
})

Wasmer (Rust):

let module = Module::from_file(&store, "example.wasm")?;
let instance = Instance::new(&module, &imports)?;
let result = instance.exports.get_function("main")?.call(&[])?;

Both Spin and Wasmer are WebAssembly-focused projects, but they serve different purposes. Spin is tailored for building and running serverless WebAssembly applications, while Wasmer is a more general-purpose WebAssembly runtime. Spin offers a simpler, more opinionated approach for cloud-native scenarios, whereas Wasmer provides broader language and runtime support with more flexibility for various use cases.

bytecodealliance logo

wasmtime

15,263

A fast and secure runtime for WebAssembly

Pros of Wasmtime

  • More mature and widely adopted WebAssembly runtime
  • Supports a broader range of WebAssembly features and proposals
  • Offers lower-level control and flexibility for WebAssembly execution

Cons of Wasmtime

  • Steeper learning curve for beginners
  • Requires more setup and configuration for application development
  • Less opinionated, which may lead to more decision-making for developers

Code Comparison

Wasmtime (low-level WebAssembly execution):

let engine = Engine::default();
let module = Module::from_file(&engine, "example.wasm")?;
let store = Store::new(&engine, ());
let instance = Instance::new(&store, &module, &[])?;

Spin (high-level application framework):

spin_sdk::http_component(|req, res| {
    res.set_body("Hello, Spin!");
    Ok(())
})

Summary

Wasmtime is a more general-purpose WebAssembly runtime, offering greater flexibility and control. Spin, built on top of Wasmtime, provides a higher-level framework for building and deploying WebAssembly applications, with a focus on simplicity and developer experience. While Wasmtime is better suited for low-level WebAssembly operations, Spin offers a more streamlined approach for application development.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Fermyon Spin

spin logo

Spin is a framework for building, deploying, and running fast, secure, and composable cloud microservices with WebAssembly.

build status Discord

What is Spin?

Spin is an open source framework for building and running fast, secure, and composable cloud microservices with WebAssembly. It aims to be the easiest way to get started with WebAssembly microservices, and takes advantage of the latest developments in the WebAssembly component model and Wasmtime runtime.

Spin offers a simple CLI that helps you create, distribute, and execute applications, and in the next sections we will learn more about Spin applications and how to get started.

Getting started

See the Install Spin page of the Spin documentation for a detailed guide on installing and configuring Spin, but in short run the following commands:

curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash
sudo mv ./spin /usr/local/bin/spin

Alternatively, you could build Spin from source.

To get started writing apps, follow the quickstart guide, and then follow the Rust, JavaScript, Python, or Go language guides, and the guide on writing Spin applications.

Usage

Below is an example of using the spin CLI to create a new Spin application. To run the example you will need to install the wasm32-wasi target for Rust.

$ rustup target add wasm32-wasi

First, run the spin new command to create a Spin application from a template.

# Create a new Spin application named 'hello-rust' based on the Rust http template, accepting all defaults
$ spin new --accept-defaults -t http-rust hello-rust

Running the spin new command created a hello-rust directory with all the necessary files for your application. Change to the hello-rust directory and build the application with spin build, then run it locally with spin up:

# Compile to Wasm by executing the `build` command.
$ spin build
Executing the build command for component hello-rust: cargo build --target wasm32-wasi --release
    Finished release [optimized] target(s) in 0.03s
Successfully ran the build command for the Spin components.

# Run the application locally.
$ spin up
Logging component stdio to ".spin/logs/"

Serving http://127.0.0.1:3000
Available Routes:
  hello-rust: http://127.0.0.1:3000 (wildcard)

That's it! Now that the application is running, use your browser or cURL in another shell to try it out:

# Send a request to the application.
$ curl -i 127.0.0.1:3000
HTTP/1.1 200 OK
foo: bar
content-length: 14
date: Thu, 13 Apr 2023 17:47:24 GMT

Hello, Fermyon

You can make the app do more by editting the src/lib.rs file in the hello-rust directory using your favorite editor or IDE. To learn more about writing Spin applications see Writing Applications in the Spin documentation. To learn how to publish and distribute your application see the Publishing and Distribution guide in the Spin documentation.

For more information on the cli commands and subcommands see the CLI Reference.

Language Support for Spin Features

The table below summarizes the feature support in each of the language SDKs.

FeatureRust SDK Supported?TypeScript SDK Supported?Python SDK Supported?Tiny Go SDK Supported?C# SDK Supported?
Triggers
HTTPSupportedSupportedSupportedSupportedSupported
RedisSupportedNot SupportedSupportedSupportedNot Supported
APIs
Outbound HTTPSupportedSupportedSupportedSupportedSupported
Configuration VariablesSupportedSupportedSupportedSupportedSupported
Key Value StorageSupportedSupportedSupportedSupportedNot Supported
SQLite StorageSupportedSupportedSupportedSupportedNot Supported
MySQLSupportedSupportedNot SupportedSupportedNot Supported
PostgreSQLSupportedSupportedNot SupportedSupportedSupported
Outbound RedisSupportedSupportedSupportedSupportedSupported
Serverless AISupportedSupportedSupportedSupportedNot Supported
Extensibility
Authoring Custom TriggersSupportedNot SupportedNot SupportedNot SupportedNot Supported

Getting Involved and Contributing

We are delighted that you are interested in making Spin better! Thank you!

Each Monday at 2:30om UTC and 9:00pm UTC (alternating), we meet to discuss Spin issues, roadmap, and ideas in our Spin Project Meetings. Subscribe to this Google Calendar for meeting dates.

The Spin Project Meeting agenda is a public document. The document contains a rolling agenda with the date and time of each meeting, the Zoom link, and topics of discussion for the day. You will also find the meeting minutes for each meeting and the link to the recording. If you have something you would like to demo or discuss at the project meeting, we encourage you to add it to the agenda.

You can find the contributing guide here.

Fermyon also hosts a Discord server, where we discuss anything Spin: Discord server.

Stay in Touch

Follow us on Twitter: @spinframework

You can join the Spin community in our Discord server where you can ask questions, get help, and show off the cool things you are doing with Spin!