README

One web toolkit, every language.

Rust-centric polyglot web toolkit. Single Rust core compiled to 15 languages through alef-generated bindings — type-safe routing, OpenAPI/AsyncAPI/GraphQL/JSON-RPC codegen, tower-http middleware, and fixture-driven cross-language testing.

Rust core · Python · TypeScript · Ruby · PHP · Elixir · Go · Java · C# · Kotlin · Dart · Swift · Zig · WASM · C FFI

Install · Why spikard · Quick example · Docs

Why spikard

Capability	Details
Type-safe across bindings	HTTP routing with path, query, body, and header validation. Errors convert losslessly between languages.
Polyglot bindings	Python, TypeScript/Node, Ruby, PHP, Elixir, Go, Java, C#, Kotlin, Dart, Swift, Zig, WASM, Rust, and C FFI.
Schema codegen	Parse OpenAPI 3.0, AsyncAPI 3.0, GraphQL SDL, and JSON-RPC 2.0 specs. Generate handlers and validators per binding.
SQL to HTTP codegen	Annotate SQL queries with `@http GET /path`, `@http_auth bearer:jwt`, and emit route metadata and OpenAPI specs.
Tower middleware	Compression, rate limiting, timeouts, request IDs, JWT/API-key auth, and static file serving.
Lifecycle hooks	`onRequest`, `preValidation`, `preHandler`, `onResponse`, and `onError`.
WebSocket & SSE	Bidirectional streams and server-sent events.
Fixture-driven testing	Shared JSON fixtures drive tests across language bindings for behavioral consistency.
CLI & MCP server	Initialize projects, generate code, validate schemas, and integrate with MCP-compatible tools.

Installation

Each binding ships through its native package manager.

Target	Package	Install
Rust	`spikard` on crates.io	`cargo add spikard`
Python	`spikard` on PyPI	`pip install spikard`
Node.js	`@spikard/node` on npm	`npm install @spikard/node`
WASM	`@spikard/node-wasm` on npm	`npm install @spikard/node-wasm`
Ruby	`spikard` on RubyGems	`gem install spikard`
PHP	`goldziher/spikard` on Packagist	`composer require goldziher/spikard`
Elixir	`spikard` on Hex	Add `{:spikard, "~> 0.1"}` to `mix.exs`
Go	`github.com/Goldziher/spikard`	`go get github.com/Goldziher/spikard`
Java	`dev.spikard:spikard` on Maven Central	Maven/Gradle — see Java README
C#	`Spikard` on NuGet	`dotnet add package Spikard`
Kotlin	`dev.spikard:spikard` on Maven Central	Maven/Gradle — see Kotlin README
Dart	`spikard` on pub.dev	`dart pub add spikard`
Swift	`Spikard` via SwiftPM	Add to `Package.swift`
Zig	`spikard` via `build.zig.zon`	Add to build manifest
C FFI	`spikard-ffi` shared/static library	GitHub Releases

Quick example

Python

from spikard import Spikard
from msgspec import Struct

class User(Struct):
    id: int
    name: str

app = Spikard()

@app.get("/users/{id:int}")
async def get_user(id: int) -> User:
    return User(id=id, name="Alice")

if __name__ == "__main__":
    app.run(port=8000)

TypeScript

import { Spikard } from "@spikard/node";

const app = new Spikard();

app.get("/users/{id:int}", async (id: number) => {
  return { id, name: "Alice" };
});

app.run({ port: 8000 });

More examples (Ruby · PHP · Elixir · Go · Java · C# · Kotlin · Dart · Swift)

See the examples directory in the repository for working examples in every supported language.

Architecture

All bindings call a shared Rust core through thin language-native layers:

How bindings work

Language bindings (Python, Node, Ruby, Go, Java, C#...)
        |
        v
FFI / NAPI / PyO3 / Magnus / runtime bridge
        |
        v
crates/spikard-http      Router, middleware, auth
crates/spikard-core      HTTP types, validation, errors
crates/spikard-codegen   OpenAPI, GraphQL, AsyncAPI, JSON-RPC

Bindings are generated from the Rust API surface via alef. Binding code stays thin: type conversion, error conversion, and runtime integration. Business logic, validation, middleware, and codegen all live in Rust.

Specification support

OpenAPI 3.0 — Route definitions to specs, parameter validators, Swagger/ReDoc UI
GraphQL — SDL schema parsing, query execution, introspection, Handler trait integration
AsyncAPI 3.0 — Channel/operation extraction, message validators, WebSocket integration
OpenRPC — JSON-RPC 2.0 method handlers, parameter validation, batch requests

Middleware stack

Compression (gzip/brotli), rate limiting, timeouts, request IDs, authentication (JWT/API key), static files. Configured via ServerConfig structs. All middleware is implemented in Rust via tower-http.

Development

task setup     # Install dependencies
task build     # Build Rust core (debug)
task test      # Run Rust tests
task test:all  # Run all tests (Rust + bindings)
task e2e:all   # Generate + build + run e2e tests
task format    # Format all code

Run task --list for the full task catalog.

Project status

Rust core is stable and production-ready.
Binding packages follow the Rust crate version.
E2E coverage is fixture-driven and shared across supported language targets.
See CONTRIBUTING.md for guidelines on modifying generated bindings.

License

MIT License — see LICENSE for details.

goldziher / spikard

Maintainers

Package info

Statistics

Security