xybrid

val model = Xybrid.model("kokoro-82m").load()
val result = model.runAsync(Envelope.text("Hello world"))
// result → 24kHz WAV audio

Swift

Install in Package.swift:

dependencies: [
    .package(url: "https://github.com/xybrid-ai/xybrid.git", from: "0.17.0")
]

Run a model:

let model = try await Xybrid.model("kokoro-82m").load()
let result = try await model.runAsync(envelope: Envelope.text("Hello world"))
// result → 24kHz WAV audio

React Native

Install in a React Native 0.76+ app with the New Architecture (or an Expo SDK 52+ development build):

npm install @xybrid/react-native@0.17.0

For bare React Native, run cd ios && pod install. For Expo, run npx expo prebuild; Expo Go cannot load the native module.

On Android, releases 0.16.0 and later require minSdkVersion 29 (Android 10). The React Native and Expo templates default to 24; the React Native guide shows how to raise it.

Run a model:

import { Envelope, GenerationConfigs, ModelLoader } from '@xybrid/react-native';

const model = await ModelLoader.fromRegistry('lfm2.5-230m').load();
const result = await model.run(Envelope.text('Name three rivers.'), {
  generationConfig: GenerationConfigs.greedy({ maxTokens: 64 }),
});
console.log(result.text);
await model.release();

See the React Native guide for Expo setup, streaming, and cancellation. On the iOS Simulator, llama.cpp uses the CPU for reliable inference; iOS devices retain Metal acceleration.

Unity

Install via OpenUPM (recommended):

openupm add ai.xybrid.sdk

Or add https://package.openupm.com as a scoped registry for scope ai.xybrid.

Install manually — add the git subfolder as a UPM package:

https://github.com/xybrid-ai/xybrid.git?path=/bindings/unity

Native libraries download automatically on import. See the Unity SDK guide for details.

Run a model:

var model = XybridClient.LoadModel("kokoro-82m");
var result = model.Run(Envelope.Text("Hello world"));
// result → 24kHz WAV audio

Rust

Install in Cargo.toml:

[dependencies]
xybrid = "0.17.0"

Run a model:

let model = Xybrid::model("kokoro-82m").load()?;
let result = model.run(&Envelope::text("Hello world"))?;
// result → 24kHz WAV audio

CLI

Install:

# macOS / Linux
curl -sSL https://raw.githubusercontent.com/xybrid-ai/xybrid/master/install.sh | sh

# Windows (PowerShell)
irm https://raw.githubusercontent.com/xybrid-ai/xybrid/master/install.ps1 | iex

Run a model:

xybrid run --model kokoro-82m --input-text "Hello world" -o output.wav

Multi-Model Inference Pipelines — MMP (Experimental)

Chain models together into a single multi-model inference pipeline (MMP) — build a voice assistant in 3 lines of YAML:

# voice-assistant.yaml
name: voice-assistant
stages:
  - model: whisper-tiny-ggml  # Speech → text
  - model: qwen2.5-0.5b       # Process with LLM
  - model: kokoro-82m         # Text → speech

CLI:

xybrid run --config voice-assistant.yaml --input-audio question.wav -o response.wav

Flutter:

final pipeline = Xybrid.pipeline(yaml: yamlString);
final result = await pipeline.run(XybridEnvelope.audio(bytes: audioBytes, sampleRate: 16000));

Kotlin:

val pipeline = XybridPipeline.fromYamlAsync(yamlString)
val result = pipeline.runAsync(inputEnvelope)
val transcript = result.stage("asr")?.text  // every stage's output, not just the last

Swift:

let pipeline = try await XybridPipeline.fromYamlAsync(yamlString)
let result = try await pipeline.runAsync(envelope: inputEnvelope)
let transcript = result.stage("asr")?.text  // every stage's output, not just the last

Unity (C#):

using var pipeline = Pipeline.FromYaml(yamlString);
PipelineResult result = pipeline.Run(inputEnvelope);
string transcript = result.Stage("asr")?.Text;  // every stage's output, not just the last

Rust:

let pipeline = Xybrid::pipeline(&yaml_string).load()?;
pipeline.load_models()?;
let result = pipeline.run(&Envelope::audio(audio_bytes))?;

Supported Models

All models run entirely on-device. No cloud, no API keys required. Browse the full catalogue at xybrid.ai/models, or run xybrid models list.

Speech-to-Text

Text-to-Speech

LLM

Vision-Language

Tool calling: see the Tool Calling guide.

Bring Your Own Model (Experimental)

Note: BYM support is experimental. The model_metadata.json schema is stable, but the AI-assisted tooling (/xybrid-init) is under active development and may not handle all model types yet.

Xybrid works with any ONNX, GGUF, or SafeTensors model. You just need a model_metadata.json that tells xybrid how to run it.

With an AI assistant (Claude Code, Codex, etc.):

# Install xybrid skills into your project
curl -sSL https://raw.githubusercontent.com/xybrid-ai/xybrid/master/tools/scripts/install-skills.sh | sh

# Generate model_metadata.json from a HuggingFace model
claude /xybrid-init hexgrad/Kokoro-82M-v1.0-ONNX

Skills are agent-agnostic and live in agents/skills/. The installer symlinks them for Claude Code (.claude/skills) and Codex (.codex/skills).

Manually — create model_metadata.json in your model directory:

{
  "model_id": "my-model",
  "version": "1.0",
  "execution_template": { "type": "Onnx", "model_file": "model.onnx" },
  "preprocessing": [],
  "postprocessing": [],
  "files": ["model.onnx"],
  "metadata": { "task": "text-generation" }
}

See the model metadata docs for the full schema, or look at existing examples in integration-tests/fixtures/models/.

Features

SDK MMP support: Flutter ✅ · Rust ✅ · Kotlin ✅ · Swift ✅ · React Native ✅ · Unity ✅

Tool calling: local models call functions you define — your tools are plain data and the loop is your code. See the Tool Calling guide.

Embeddings: text embedding models (e.g. EmbeddingGemma 2, all-MiniLM) already run as bring-your-own models: see the custom models guide. Registry models are coming.

Why Xybrid?

• Private / offline — inference runs on-device and keeps working with no network after the first model download.
• One API, five platforms — iOS, Android, macOS, Linux, Windows.
• Many backends, one API — ONNX Runtime, llama.cpp (GGUF), whisper.cpp, Candle and CoreML.
• Multi-model pipelines — chain ASR → LLM → TTS in one call.
• Tool calling — local models call functions you define, on every SDK.
• Swap models without shipping an app — models resolve from the registry at runtime and cache on device.
• Cloud fallback — opt in per run (docs).
• Telemetry you control — opt-in behind an API key (docs).
• Hardware acceleration — Metal and the Apple Neural Engine on Apple, opt-in Vulkan on Linux; Android and Windows are CPU today (docs).

How it compares

Community

• Documentation
• Discord
• X (Twitter)
• GitHub Issues

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines on setting up your development environment, submitting pull requests, and adding new models.

New here? Browse the good first issue label for small, self-contained tasks. Tasks are also grouped by area: area: core, area: sdk, area: examples, area: bindings, area: tests. Medium-difficulty tasks live under help wanted.

Star History

License

Apache License 2.0 — see LICENSE for details.