fermyon/spin

Features

• Event-Driven Orchestration - Functions as an event-driven orchestrator mapping HTTP, Redis, and cron events to Wasm components.
• AI Model Inference - Provides a Wasm-based AI inference gateway for executing models and generating text responses.
• Inference Gateways - Implements an AI inference gateway connecting Wasm components to large language models.
• Text Embeddings - Implements text embeddings generation to transform strings into vector representations for semantic analysis.
• WASI-Based - Uses WASI and the Gateway Interface to provide portable host interfacing and system call access.
• Wasm Component Wiring - Wires components together via WIT interfaces using local paths, registries, or URLs for language-agnostic composition.
• Wasm Execution Engines - Runs WebAssembly microservices as isolated processes from local manifests or remote OCI registries.
• HTTP Request Routing - Maps incoming HTTP requests to specific components using exact paths or wildcards.
• Multi-Language Wasm Compilers - Compiles source code from multiple programming languages into WebAssembly bytecode for serverless execution.
• Multilingual Runtime Support - Supports a wide array of programming languages by targeting WebAssembly and WASI standards for cloud services.
• Wasm Component Runtimes - Provides a runtime that executes WebAssembly modules as portable microservices using the Component Model.
• Wasm Development Toolchains - Provides a complete toolset for bootstrapping, compiling, and deploying Wasm microservices.
• Capability-Based Access Controls - Implements a capability-based security system to delegate a subset of permissions to dependent modules.
• Capability-Based Security - Restricts component access to network, storage, and system resources via a declarative permission system.
• Configuration Manifests - Uses a centralized configuration file to define application structure, routing, and resource permissions.
• WebAssembly Component Models - Implements the WebAssembly Component Model for language-agnostic composition of microservices using WIT interfaces.
• Trigger-Based Execution - Maps external events like HTTP requests, Redis messages, and cron schedules to specific Wasm components.
• HTTP Request Handling - Handles incoming HTTP requests and returns responses through defined handler classes.
• Serverless Frameworks - Offers a developer framework for building and running event-driven serverless applications using WebAssembly.
• Event Trigger Mapping - Maps incoming events such as HTTP requests, Redis messages, and cron schedules to specific Wasm components.
• MCP Servers - Enables the creation of Model Context Protocol servers for standardized communication between AI agents and tools.
• Key-Value Stores - Provides a built-in key-value store for persisting application state.
• Redis Clients - Provides capabilities to interact with external Redis instances for data operations.
• Hot Reloading - Automatically builds and restarts the application when source files are modified to accelerate the development cycle.
• Project Bootstrapping Templates - Provides predefined templates and blueprints to generate initial directory structures and manifests for new projects.
• Project Scaffolding Templates - Enables the creation of reusable blueprints for services with custom value prompts and text transformations.
• OCI-Compliant Packaging - Packages and distributes WebAssembly applications using OCI-compliant registries.
• OCI Container Registry Clients - Implements clients to push and pull applications from OCI-compliant registries.
• Environment Variable Configurations - Injects runtime settings and secrets into components via key-value pairs to control service behavior.
• Kubernetes Cluster Orchestration - Automates the setup of clusters and workload identities for hosting applications on Kubernetes.
• Local Service Execution - Provides a local server to instantiate components and route traffic for development.
• Recurring Job Scheduling - Provides the ability to execute components on fixed timetables using standard cron expressions.
• Edge Deployments - Publishes applications to a global edge environment for low-latency execution near users.
• Asynchronous Task Spawning - Allows components to trigger asynchronous background functions that run to completion independently of the main entry point.
• In-Memory Private Endpoints - Provides internal microservices accessible only via in-memory service chaining.
• HTTP Request Dispatchers - Allows components to send outbound network requests to interact with external APIs and services.
• In-Memory Service Chaining - Routes requests between internal microservices via direct runtime calls to avoid network latency.
• Tracing Context Propagation - Supports inbound and outbound trace context propagation to link requests across distributed services.
• WebAssembly Engine Embedding - Allows integrating the component execution engine into external applications to run WebAssembly modules.
• WAGI Module Execution - Handles HTTP requests using the WebAssembly Gateway Interface for languages without component model support.
• Network Access Control - Implements a whitelist of hosts and ports to regulate outbound network traffic from Wasm components.
• Component Access Isolations - Employs a capability-based security system to grant components specific permissions for key-value stores and storage services.
• OpenTelemetry Exporters - Exports traces, metrics, and logs to external collectors using the OpenTelemetry standard.
• Application Deployment - Packages applications and uploads them to remote deployment environments.
• Response Streaming - Supports incremental delivery of HTTP response bodies using a sink interface to optimize memory.
• Container Runtimes and Platforms - Framework for building Wasm-based microservices.
• Service Frameworks - Framework for building fast, secure WebAssembly microservices.

Star history