# spinframework/spin

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/spinframework-spin).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

6,564 stars · 318 forks · Rust · Apache-2.0

## Links

- GitHub: https://github.com/spinframework/spin
- Homepage: https://spinframework.dev
- awesome-repositories: https://awesome-repositories.com/repository/spinframework-spin.md

## Topics

`serverless` `spin` `webassembly`

## Description

Spin is a developer framework for building, running, and distributing serverless applications and microservices compiled to sandboxed WebAssembly components. Components start only when an event arrives, such as an HTTP request or a Redis message, and are discarded afterwards. A single command-line tool covers the workflow: scaffolding from templates, building, running locally, publishing to a registry, and adding commands through plugins.

Each application is described by one declarative manifest that lists its components, triggers, variables, and permissions. Components run in an isolated sandbox and receive only the capabilities they are granted, including checks on outbound network calls against configured rules. Host capabilities such as key-value storage, SQL databases, outbound HTTP, AI inference, and configuration variables are exposed through typed interfaces, with the backing provider chosen through runtime configuration rather than code changes. The runtime is modular, so an embedder can offer a subset of features or add custom triggers for other event sources.

Components can be written in several languages, including Rust, Go, JavaScript, and Python, using language-specific SDKs, and components from different languages can be reused as library dependencies of one another. Data access covers key-value storage, SQLite, MySQL, PostgreSQL, and Redis. Variables and secrets can come from environment variables, static values, Vault, or Azure. Components can also run language model inference using a local model or a remote provider. Templates cover HTTP and Redis components, static file serving, and request redirects.

Applications are packaged as OCI artifacts that container registries can store and deliver. For development, Spin exports OpenTelemetry traces and metrics, includes a Docker Compose observability stack, and provides a diagnostic command that reports misconfigurations with suggested fixes. A directory of example applications is available to start from.

## Tags

### Development Tools & Productivity

- [Serverless Microservices](https://awesome-repositories.com/f/development-tools-productivity/python-development-tools/serverless-microservices.md) — Provides a platform for fast, secure microservices that run only when HTTP requests or Redis messages arrive, with custom triggers.
- [CLI Workflow Automations](https://awesome-repositories.com/f/development-tools-productivity/cli-workflow-automations.md) — Provides one command-line tool to scaffold, build, run, publish and extend applications through plugins without switching between utilities. ([source](https://github.com/spinframework/spin/blob/main/README.md))
- [Command Line Applications](https://awesome-repositories.com/f/development-tools-productivity/command-line-interfaces/command-line-applications.md) — Provides a single terminal tool that scaffolds apps from templates, builds, runs locally, publishes to registries, and adds commands through plugins.
- [WebAssembly Plugin Scaffolders](https://awesome-repositories.com/f/development-tools-productivity/project-scaffolding-config-code-generation/project-scaffolding-configuration/project-scaffolding/project-scaffolders/webassembly-plugin-scaffolders.md) — Generates new WebAssembly microservice projects from templates, producing the files needed to start building a component. ([source](https://github.com/spinframework/spin#readme))

### DevOps & Infrastructure

- [WebAssembly Serverless Frameworks](https://awesome-repositories.com/f/devops-infrastructure/serverless-application-frameworks/webassembly-serverless-frameworks.md) — Provides a framework for building, running, and distributing event-triggered microservices compiled to sandboxed WebAssembly components.
- [WebAssembly Cloud-Native Applications](https://awesome-repositories.com/f/devops-infrastructure/cloud-native-orchestration/cloud-native-application-development/webassembly-cloud-native-applications.md) — Builds and runs fast, secure, composable microservices compiled to WebAssembly and executed on a sandboxed runtime. ([source](https://github.com/spinframework/spin/blob/main/README.md))
- [Event-Driven Triggers](https://awesome-repositories.com/f/devops-infrastructure/event-driven-triggers.md) — Starts application components when events such as HTTP requests or Redis messages arrive, and supports custom triggers for other event sources. ([source](https://github.com/spinframework/spin#readme))
- [Event-Driven Function Triggers](https://awesome-repositories.com/f/devops-infrastructure/event-driven-triggers/event-driven-function-triggers.md) — Starts application components in response to HTTP requests or Redis messages, with support for custom triggers for other event sources.
- [Application Packaging](https://awesome-repositories.com/f/devops-infrastructure/application-packaging.md) — Packages finished applications as registry artifacts so teams can publish, share, fetch, and run them across environments.
- [Application Variable and Secret Providers](https://awesome-repositories.com/f/devops-infrastructure/application-variable-and-secret-providers.md) — Supplies configuration values and secrets to components at runtime from environment variables, static values, Vault, or Azure. ([source](https://github.com/spinframework/spin/tree/main/crates))
- [OCI-Compliant Packaging](https://awesome-repositories.com/f/devops-infrastructure/artifact-packaging-tools/oci-compliant-packaging.md) — Bundles applications as OCI artifacts that can be pushed to and pulled from container registries for sharing and deployment. ([source](https://github.com/spinframework/spin/tree/main/crates))
- [OCI Application Packaging](https://awesome-repositories.com/f/devops-infrastructure/artifact-registries/oci-application-packaging.md) — Packages applications as OCI artifacts that ordinary container registries can store, version and deliver for others to pull and run.
- [Registry-Based Application Publishing](https://awesome-repositories.com/f/devops-infrastructure/registry-based-application-publishing.md) — Packages finished applications and shares them through a registry so other people can fetch and run them. ([source](https://github.com/spinframework/spin#readme))

### Networking & Communication

- [HTTP Request Routing](https://awesome-repositories.com/f/networking-communication/http-request-dispatching/http-request-routing.md) — Runs WebAssembly components in response to incoming HTTP requests, routing each request to the matching component defined in the manifest. ([source](https://github.com/spinframework/spin/tree/main/crates))
- [Redis Message-Triggered Components](https://awesome-repositories.com/f/networking-communication/redis-message-triggered-components.md) — Invokes WebAssembly components when messages arrive on subscribed Redis channels for event-driven publish-subscribe processing. ([source](https://github.com/spinframework/spin/tree/main/crates))

### Programming Languages & Runtimes

- [Server-Side WebAssembly Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-webassembly-runtimes/extensible-webassembly-runtimes/server-side-webassembly-runtimes.md) — Runs sandboxed WebAssembly components as server-side application handlers with built-in key-value, SQL, Redis, outbound HTTP, and variable access.
- [Multi-Language Wasm Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/bytecode-compiled-languages/source-to-bytecode-compilers/multi-language-wasm-compilers.md) — Compiles Rust, JavaScript, Go and Python code into WebAssembly components using language-specific SDKs that expose platform features. ([source](https://github.com/spinframework/spin#readme))

### Security & Cryptography

- [Sandboxed Component Execution](https://awesome-repositories.com/f/security-cryptography/sandboxed-component-execution.md) — Runs each application component as a WebAssembly module in an isolated sandbox that receives only the capabilities explicitly granted to it.

### Software Engineering & Architecture

- [Cross-Language Component Models](https://awesome-repositories.com/f/software-engineering-architecture/cross-language-component-models.md) — Lets components be written in JavaScript, Rust, Go, Python and other languages using language-specific SDKs, and reused across languages. ([source](https://github.com/spinframework/spin/blob/main/README.md))
- [Polyglot Component Models](https://awesome-repositories.com/f/software-engineering-architecture/polyglot-component-models.md) — Allows components written in Rust, Go, JavaScript, and Python to be combined and reused as library dependencies within one application.
- [WebAssembly Component Models](https://awesome-repositories.com/f/software-engineering-architecture/polyglot-component-models/webassembly-component-models.md) — Supports authoring and combining WebAssembly components written in Rust, Go, JavaScript, Python, and other languages using language-specific SDKs.
- [Component Instantiation](https://awesome-repositories.com/f/software-engineering-architecture/component-lifecycle-management/application-component-lifecycles/component-instantiation.md) — Creates components fresh when an HTTP request or Redis message arrives and discards them afterwards, so no idle processes remain.
- [Event Trigger Extensibility](https://awesome-repositories.com/f/software-engineering-architecture/event-sourcing/custom-event-sources/event-trigger-extensibility.md) — Shows how to build custom event triggers so applications can be started by event sources beyond the built-in HTTP and Redis ones. ([source](https://github.com/spinframework/spin/tree/main/examples))
- [Manifest-Driven Initializations](https://awesome-repositories.com/f/software-engineering-architecture/manifest-driven-initializations.md) — Describes all components, triggers, variables and permissions in one declarative manifest that the runtime uses to assemble and route the application.

### Web Development

- [WebAssembly Platforms](https://awesome-repositories.com/f/web-development/serverless-platforms/webassembly-platforms.md) — Builds and runs small, sandboxed cloud services compiled to WebAssembly, triggered by HTTP requests or Redis messages without managing servers.
- [Event Trigger Mapping](https://awesome-repositories.com/f/web-development/web-infrastructure-deployment/web-infrastructure-servers/http-frameworks/http-route-handlers/event-trigger-mapping.md) — Starts application components only when an HTTP request or Redis message arrives, so code runs just in response to events. ([source](https://github.com/spinframework/spin/blob/main/README.md))

### Artificial Intelligence & ML

- [Host-Call Interfaces](https://awesome-repositories.com/f/artificial-intelligence-ml/function-calling-interfaces/webassembly-function-callings/host-call-interfaces.md) — Exposes key-value storage, SQL, HTTP, AI inference and variables to sandboxed components through typed host-implemented interfaces.

### Part of an Awesome List

- [Data Storage and Search](https://awesome-repositories.com/f/awesome-lists/data/data-storage-and-search.md) — Lets components save and query data through key-value storage, SQLite, MySQL, PostgreSQL, and Redis with runtime-supplied configuration.
- [WebAssembly Build Systems](https://awesome-repositories.com/f/awesome-lists/devtools/webassembly-build-systems.md) — Compiles source code into WebAssembly components and assembles them into one application as described in its manifest. ([source](https://github.com/spinframework/spin/tree/main/crates))

### Data & Databases

- [Component SQL Database Access](https://awesome-repositories.com/f/data-databases/component-sql-database-access.md) — Lets components run SQL queries against SQLite, Postgres, or MySQL databases through built-in outbound connection support. ([source](https://github.com/spinframework/spin/tree/main/crates))
- [Key-Value Persistence Stores](https://awesome-repositories.com/f/data-databases/key-value-persistence-stores.md) — Provides built-in access to key-value storage, SQLite, MySQL, PostgreSQL, and outbound Redis so components can persist and query data. ([source](https://github.com/spinframework/spin/blob/main/README.md))
- [Key-Value Stores](https://awesome-repositories.com/f/data-databases/key-value-stores.md) — Lets components read and write key-value data backed by a local database, Redis, Azure, or AWS chosen through runtime configuration. ([source](https://github.com/spinframework/spin/tree/main/crates))