awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
spinframework avatar

spinframework/spin

0
View on GitHub↗

Spin

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.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
spinframework.dev
↗

Features

  • Serverless Microservices - Provides a platform for fast, secure microservices that run only when HTTP requests or Redis messages arrive, with custom triggers.
  • WebAssembly Serverless Frameworks - Provides a framework for building, running, and distributing event-triggered microservices compiled to sandboxed WebAssembly components.
  • CLI Workflow Automations - Provides one command-line tool to scaffold, build, run, publish and extend applications through plugins without switching between utilities.
  • WebAssembly Cloud-Native Applications - Builds and runs fast, secure, composable microservices compiled to WebAssembly and executed on a sandboxed runtime.
  • Event-Driven Triggers - Starts application components when events such as HTTP requests or Redis messages arrive, and supports custom triggers for other event sources.
  • Event-Driven Function Triggers - Starts application components in response to HTTP requests or Redis messages, with support for custom triggers for other event sources.
  • HTTP Request Routing - Runs WebAssembly components in response to incoming HTTP requests, routing each request to the matching component defined in the manifest.
  • Server-Side WebAssembly Runtimes - Runs sandboxed WebAssembly components as server-side application handlers with built-in key-value, SQL, Redis, outbound HTTP, and variable access.
  • Sandboxed Component Execution - Runs each application component as a WebAssembly module in an isolated sandbox that receives only the capabilities explicitly granted to it.
  • Cross-Language Component Models - Lets components be written in JavaScript, Rust, Go, Python and other languages using language-specific SDKs, and reused across languages.
  • Polyglot Component Models - Allows components written in Rust, Go, JavaScript, and Python to be combined and reused as library dependencies within one application.
  • WebAssembly Component Models - Supports authoring and combining WebAssembly components written in Rust, Go, JavaScript, Python, and other languages using language-specific SDKs.
  • WebAssembly Platforms - Builds and runs small, sandboxed cloud services compiled to WebAssembly, triggered by HTTP requests or Redis messages without managing servers.
  • Event Trigger Mapping - Starts application components only when an HTTP request or Redis message arrives, so code runs just in response to events.
  • Host-Call Interfaces - Exposes key-value storage, SQL, HTTP, AI inference and variables to sandboxed components through typed host-implemented interfaces.
  • Data Storage and Search - Lets components save and query data through key-value storage, SQLite, MySQL, PostgreSQL, and Redis with runtime-supplied configuration.
  • WebAssembly Build Systems - Compiles source code into WebAssembly components and assembles them into one application as described in its manifest.
  • Component SQL Database Access - Lets components run SQL queries against SQLite, Postgres, or MySQL databases through built-in outbound connection support.
  • Key-Value Persistence Stores - Provides built-in access to key-value storage, SQLite, MySQL, PostgreSQL, and outbound Redis so components can persist and query data.
  • Key-Value Stores - Lets components read and write key-value data backed by a local database, Redis, Azure, or AWS chosen through runtime configuration.
  • Command Line Applications - Provides a single terminal tool that scaffolds apps from templates, builds, runs locally, publishes to registries, and adds commands through plugins.
  • WebAssembly Plugin Scaffolders - Generates new WebAssembly microservice projects from templates, producing the files needed to start building a component.
  • Application Packaging - Packages finished applications as registry artifacts so teams can publish, share, fetch, and run them across environments.
  • Application Variable and Secret Providers - Supplies configuration values and secrets to components at runtime from environment variables, static values, Vault, or Azure.
  • OCI-Compliant Packaging - Bundles applications as OCI artifacts that can be pushed to and pulled from container registries for sharing and deployment.
  • OCI Application Packaging - Packages applications as OCI artifacts that ordinary container registries can store, version and deliver for others to pull and run.
  • Registry-Based Application Publishing - Packages finished applications and shares them through a registry so other people can fetch and run them.
  • Redis Message-Triggered Components - Invokes WebAssembly components when messages arrive on subscribed Redis channels for event-driven publish-subscribe processing.
  • Multi-Language Wasm Compilers - Compiles Rust, JavaScript, Go and Python code into WebAssembly components using language-specific SDKs that expose platform features.
  • Component Instantiation - Creates components fresh when an HTTP request or Redis message arrives and discards them afterwards, so no idle processes remain.
  • Event Trigger Extensibility - Shows how to build custom event triggers so applications can be started by event sources beyond the built-in HTTP and Redis ones.
  • Manifest-Driven Initializations - Describes all components, triggers, variables and permissions in one declarative manifest that the runtime uses to assemble and route the application.
6,564 stars·318 forks·Rust·Apache-2.0·2 views

Star history

Star history chart for spinframework/spinStar history chart for spinframework/spin

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does spinframework/spin do?

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.

What are the main features of spinframework/spin?

The main features of spinframework/spin are: Serverless Microservices, WebAssembly Serverless Frameworks, CLI Workflow Automations, WebAssembly Cloud-Native Applications, Event-Driven Triggers, Event-Driven Function Triggers, HTTP Request Routing, Server-Side WebAssembly Runtimes.

Which projects share features with spinframework/spin?

Projects with overlapping indexed features include: fermyon/spin — Spin is a WebAssembly serverless framework and development toolchain for building and running portable microservices.… wasmedge/wasmedge — WasmEdge is an extensible WebAssembly runtime that executes WebAssembly bytecode in a secure sandbox for cloud, edge,… astrid-runtime/sdk-js — This is the TypeScript SDK for writing capsules that run on the Astrid runtime. It offers a typed JavaScript and… awslabs/chalice — Chalice is a Python development framework for building and deploying serverless applications and REST APIs on AWS. It… nginx/unit — NGINX Unit is an open-source application server designed to natively execute code across multiple programming language… marcuswestin/store.js — Store.js is a client-side state persistence library and web storage abstraction layer. It provides a consistent…

Projects sharing features with Spin

These projects share indexed features with Spin. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • fermyon/spinfermyon avatar

    fermyon/spin

    6,443View on GitHub↗

    Spin is a WebAssembly serverless framework and development toolchain for building and running portable microservices. It functions as an event-driven orchestrator and runtime that executes WebAssembly components, allowing developers to map HTTP requests, Redis messages, and cron schedules to specific modules. The project distinguishes itself by implementing a Wasm-based AI inference gateway, enabling components to perform model inference and generate text embeddings. It utilizes the WebAssembly Component Model and WASI for language-agnostic composition and portable host interfacing, while emp

    Rust
    View on GitHub↗6,443
  • wasmedge/wasmedgeWasmEdge avatar

    WasmEdge/WasmEdge

    10,855View on GitHub↗

    WasmEdge is an extensible WebAssembly runtime that executes WebAssembly bytecode in a secure sandbox for cloud, edge, and embedded applications. It functions as a multi-language compiler, compiling applications written in Rust, JavaScript, Go, and Python into WebAssembly bytecode for sandboxed execution, and as a server-side JavaScript runtime that runs JavaScript programs with ES6 modules, NPM packages, and Node.js-compatible APIs. The runtime also serves as an AI inference runtime, executing AI models from JavaScript using WASI-NN plug-ins for inference tasks on personal devices and edge har

    C++artificial-intelligencecloudcloud-native
    View on GitHub↗10,855
  • astrid-runtime/sdk-jsastrid-runtime avatar

    astrid-runtime/sdk-js

    8,088View on GitHub↗

    This is the TypeScript SDK for writing capsules that run on the Astrid runtime. It offers a typed JavaScript and TypeScript API for authoring sandboxed extensions, with modules for files, networking, processes, storage, messaging, web requests, and identity. These modules target the same host contract as the native Rust toolkit, so the runtime handles capsules from either toolkit the same way. Capsule behavior is declared with decorators on classes and methods. They mark tools, commands, hooks, interceptors, and the entry points that run on install, upgrade, and startup. A build pipeline type

    TypeScript
    View on GitHub↗8,088
  • awslabs/chaliceawslabs avatar

    awslabs/chalice

    11,062View on GitHub↗

    Chalice is a Python development framework for building and deploying serverless applications and REST APIs on AWS. It functions as a microservice tool that automates the deployment of code and infrastructure to AWS Lambda and orchestrates AWS API Gateway to route HTTP requests to specific serverless functions. The framework features an automated system that analyzes source code to generate the minimum required identity and access management permissions. It also provides a command line interface to manage the complete application lifecycle, from project creation and deployment to the removal o

    Python
    View on GitHub↗11,062
Compare all 30 related projects→