WebAssembly + WebGPU
A C/C++ core compiled to WASM for browsers and native binaries for devices, with GPU acceleration through Dawn as the native WebGPU backend.
Edge AI Infrastructure
Unified edge AI inference, compiled once, running everywhere.
AlPa is the foundational, standalone Edge AI Inference Platform: a secure, portable, vendor-neutral runtime built on WebAssembly + WebGPU with Dawn as the native backend. One codebase delivers GPU-accelerated inference to browsers, edge devices, servers, and embedded systems — with license-gated security at every step.
Version 1.0.0-beta
What is AlPa?
AlPa compiles once and runs everywhere: browsers, edge devices, servers, and embedded systems. The same codebase powers browser (WASM) and native builds, backed by WebGPU acceleration via Dawn — so inference travels to where the data lives instead of forcing data toward the cloud. Zero-cloud dependency is the design principle, not a deployment afterthought.
The core promise
License-gated security
Pre-execution validation on every model load and inference call, background heartbeat re-validation, and Ed25519-signed offline licenses.
Portable model distribution
Progressively loaded, GGUF-compatible model artifacts behave identically on every target — start inference before the full model arrives.
Zero-cloud dependency
Inference runs on the user's own hardware. No server GPUs, no egress costs, no PHI leaving the device — privacy and margins by construction.
Technical architecture
One codebase, four execution surfaces
WebAssembly defines the portable instruction set; WebGPU — via browser implementations or Dawn as the native backend — defines the portable GPU layer. Together they give AlPa a vendor-neutral hardware abstraction that spans the entire deployment spectrum.
| Execution surface | Runtime | Deployment notes |
|---|---|---|
| Browser | WASM module + browser WebGPU | Chrome 113+ / Edge 113+ — zero-install inference on the user's own GPU |
| Edge devices | Native binary + Dawn backend | On-prem appliances and gateways running licensed local inference |
| Servers | Native binary + Dawn backend | Batch and fallback workloads where centralized compute is intentional |
| Embedded | Native binary + Dawn backend | Medical devices and kiosks with strict offline and licensing constraints |
Platform features
License-gated inference
Only authenticated, licensed users can run inference. Every model load and inference call is validated before execution.
WebGPU backend
GPU-accelerated inference via Dawn or browser WebGPU, delivering native-class performance on consumer hardware.
GGUF model loading
Progressive loading of llama.cpp-compatible models — start inference before the full model has arrived.
OpenAI-compatible API
A standard chat completions interface means existing tooling and clients work with AlPa out of the box.
Offline support
Ed25519-signed offline licenses with a grace period keep deployments running without a constant connection.
Multi-tenant
White-label support with per-tenant branding and SSO for platform-style deployments.
Browser + native
One codebase for both browser (WASM) and native builds — no forked runtimes to maintain.
Code demos
The same license chain and model artifacts, whether the runtime ships as a WASM module or a native binary.
WASM module — Web (TypeScript)
// Load the licensed AlPa runtime in the browser
import { AlPaRuntime } from "@alpa/runtime-web"
const alpa = await AlPaRuntime.create({
license: "YOUR_ALPA_TOKEN",
backend: "webgpu", // browser WebGPU, WASM fallback
})
await alpa.loadModel("https://models.example.com/clinical-8b.gguf", {
progressive: true, // start before the full model arrives
})
const stream = alpa.chat.completions.create({
model: "clinical-8b",
messages: [{ role: "user", content: "Summarize this finding." }],
stream: true,
})
for await (const chunk of stream) {
console.log(chunk.choices[0]?.delta?.content)
}Native runtime — edge / embedded (C++)
// Same artifacts, same license chain — native via Dawn
#include "alpa/runtime.hpp"
alpa::RuntimeConfig config;
config.license_token = "YOUR_ALPA_TOKEN";
config.backend = alpa::Backend::DawnWebGPU;
alpa::Runtime runtime(config);
auto model = runtime.load_model("/opt/models/clinical-8b.gguf",
/*progressive=*/true);
auto result = runtime.chat_completions.create({
{"model", "clinical-8b"},
{"messages", "[\"Summarize this finding.\"]"},
});Security model
The C/C++ runtime validates a license token before every model load and inference call. Heartbeat re-validation runs in the background, and offline use is supported via Ed25519-signed licenses — security is enforced at the runtime layer, not bolted on.
Pre-execution validation
License tokens are checked before every model load and every inference call — no valid license, no execution.
Background heartbeat
Re-validation runs continuously in the background so revoked or expired licenses are enforced mid-session.
Ed25519-signed offline licenses
Cryptographically signed offline licenses with a grace period enable air-gapped and edge deployments.
Quick start
Get up and running with AlPa in 5 minutes.
- 01
Get your license
You need a valid license to use AlPa. Contact your administrator, or go to the AlPa platform, sign up for an account, and get your license token from the dashboard.
- 02
Choose your interface
Browser (recommended for beginners): open Chrome 113+ or Edge 113+, navigate to the AlPa demo page, enter your license token, click "Validate License", and start chatting. Command line: download the CLI binary for your platform and run it with your license token.
- 03
Load a model
Using the CLI with a local model, point AlPa at any llama.cpp-compatible GGUF file — loading is progressive, so you can start before the full model has arrived.
- 04
Start chatting
Type your message and press Enter. The AI will respond — through the OpenAI-compatible chat completions interface.
Run with a local model (CLI)
alpa_cli_demo --license "YOUR_TOKEN_HERE" --model /path/to/model.ggufRequest AlPa v1.0.0-Beta access
AlPa is proprietary software shipping as version 1.0.0-Beta. Request beta access for your deployment, or talk to the team about licensing, integrations, and the security model.