FluidAudio

FluidAudio - Transcription, Text-to-speech, VAD, Speaker diarization with CoreML Models

FluidAudio is a Swift SDK for fully local, low-latency audio AI on Apple devices, with inference offloaded to the Apple Neural Engine (ANE), resulting in less memory and generally faster inference.

The SDK includes state-of-the-art speaker diarization, transcription, and voice activity detection via open-source models (MIT/Apache 2.0) that can be integrated with just a few lines of code. Models are optimized for background processing, ambient computing and always on workloads by running inference on the ANE, minimizing CPU usage and avoiding GPU/MPS entirely.

For custom use cases, feedback, additional model support, or platform requests, join our Discord. We’re also bringing visual, language, and TTS models to device and will share updates there.

Below are some featured local AI apps using Fluid Audio models on macOS and iOS:

Want to convert your own model? Check möbius

Highlights

• Automatic Speech Recognition (ASR): Parakeet TDT v3 (0.6b) and other TDT/CTC models for batch transcription supporting 25 European languages and Japanese, plus SenseVoice and Paraformer for Mandarin Chinese, Nemotron 3.5 Transcribe Lite for fast meeting transcripts with speakers, and LFM3-Audio-2B for ASR, live captions and TTS from one audio LM; Parakeet EOU (120m) for streaming ASR with end-of-utterance detection (English only). See all ASR models.
• Inverse Text Normalization (ITN): Post-process ASR output to convert spoken-form to written-form (“two hundred” → “200”). See text-processing-rs. Optional: ASR-only apps can drop the engine (~8 MB per slice) with traits: [] (Swift 6.2+), see PostProcessing.md
• Text-to-Speech (TTS): Kokoro (82m) for parallel synthesis with SSML and pronunciation control across 9 languages (EN, ES, FR, HI, IT, JA, PT, ZH); PocketTTS for streaming TTS with voice cloning support (EN, DE, ES, FR, IT, PT — 6L and 24L variants); Chatterbox Multilingual (520M, 18 languages) and Chatterbox Nano (110M, English with [laugh]/[chuckle] paralinguistic tags) in beta — see Documentation/TTS/Chatterbox.md; Paradee (8M Kokoro distill, English, four voices incl. two British, 11 MB) in beta — see Documentation/TTS/Paradee.md; Gradium’s Phonon 31m (Apache-2.0, English, 103 voices) on the Neural Engine at ~20x real time — see Documentation/TTS/PocketTTS.md
• Speaker Diarization (Online + Offline): Speaker separation and identification across audio streams. Streaming pipeline for real-time processing and offline batch pipeline with advanced clustering.
• Speaker Embedding Extraction: Generate speaker embeddings for voice comparison and clustering, you can use this for speaker identification
• Voice Activity Detection (VAD): Voice activity detection with Silero models
• Speech Enhancement (AEC + Noise Suppression): LocalVQE (4.8M) removes loudspeaker echo, noise and reverb from 16 kHz mic audio given a far-end reference; streaming with 16 ms latency (beta)
• Apple Neural Engine: Models run efficiently on Apple’s ANE for maximum performance with minimal power consumption
• Open-Source Models: All models are publicly available on HuggingFace — converted and optimized by our team; permissive licenses. See full model catalog.

Video Demos

Showcase

Make a PR if you want to add your app, please keep it in chronological order.

More apps built with FluidAudio are listed in Documentation/Showcase.md.

Installation

Add FluidAudio to your project using Swift Package Manager:

dependencies: [
    .package(url: "https://github.com/FluidInference/FluidAudio.git", from: "0.12.4"),
],

In Xcode:

1. Add the FluidAudio package to your project
2. In the “Add Package” dialog, select FluidAudio
3. Add it to your app target

In Package.swift:

.product(name: "FluidAudio", package: "FluidAudio")

Package traits (Swift 6.2+ / Xcode 26+): all three are on by default. Drop the subsystems an app never reaches to shrink the build:

.package(url: "https://github.com/FluidInference/FluidAudio.git", from: "0.17.7", traits: [])            // ASR + VAD only
.package(url: "https://github.com/FluidInference/FluidAudio.git", from: "0.17.7", traits: ["Diarizer"])  // + diarization

traits: [] turns off all three. Before #990 it only dropped the NeMo engine, so apps that use diarization and pass traits: [] should switch to traits: ["Diarizer"]. Older toolchains always build everything.

CocoaPods: We recommend using cocoapods-spm for better SPM integration, but if needed, you can also use our podspec: pod 'FluidAudio', '~> 0.12.4'

Other Frameworks

Building with a different framework? Use one of our official wrappers:

Post-Processing Tools

Enhance ASR output with post-processing:

Configuration

Quick Reference

Both solve the same problem: “I can’t reach HuggingFace directly.” They’re alternative approaches - pick whichever matches your setup:

How they work:

• Registry URL - App requests from your-mirror.com instead of huggingface.co
• Proxy - App still requests huggingface.co, but traffic routes through proxy to reach it

In most cases, you only need one. (You’d use both only if your mirror is behind the proxy and unreachable without it.)

import FluidAudio

// Set custom registry before using any managers
ModelRegistry.baseURL = "https://your-mirror.example.com"

// Only needed when the mirror does not preserve an upstream pinned commit.
ModelRegistry.revisionOverrides = [
    "FluidInference/speaker-diarization-coreml": "your-mirror-revision"
]

// Models will now download from the custom registry
let diarizer = DiarizerManager()

# Use custom registry
export REGISTRY_URL=https://your-mirror.example.com
swift run fluidaudiocli transcribe audio.wav

# Or use the MODEL_REGISTRY_URL alias
export MODEL_REGISTRY_URL=https://models.internal.corp
swift run fluidaudiocli diarization-benchmark --auto-download

export https_proxy=http://proxy.company.com:8080
# or for authenticated proxies:
export https_proxy=http://user:[email protected]:8080

swift run fluidaudiocli transcribe audio.wav

import FluidAudio

// Set once before any FluidAudio loader runs.
ModelHub.offlineMode = true

// Load via manual APIs that read from your bundled directory:
let asr = try await AsrModels.load(from: bundledModelURL, configuration: config)

Documentation

DeepWiki for auto-generated docs for this repo.

Documentation Index

• Guides
  • Audio Conversion for Inference
  • Manual model download & loading options: ASR, Diarizer, VAD
  • Routing Hugging Face (or compatible) requests through a proxy? Set https_proxy before running the download helpers (see Documentation/API.md).
• Models
  • Automatic Speech Recognition/Transcription
    • Getting Started
    • Last Chunk Handling
  • Speaker Diarization
    • Speaker Diarization Guide
  • VAD: Getting Started
    • Segmentation
  • Speech Enhancement: LocalVQE (AEC + NS)
    • Model Conversion Code
• Benchmarks
• CUA-S1-FORMS decision scoring
• API Reference
• Command Line Guide

MCP Server

The repo is indexed by DeepWiki MCP server, so your coding tool can access the docs:

{
  "mcpServers": {
    "deepwiki": {
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}

For claude code:

claude mcp add -s user -t http deepwiki https://mcp.deepwiki.com/mcp

Automatic Speech Recognition (ASR) / Transcription

• Models:
  • FluidInference/parakeet-ultra-coreml (multilingual, 25 European languages; recommended — more accurate than v3 at the same speed, see Parakeet Ultra)
  • FluidInference/parakeet-tdt-0.6b-v3-coreml (multilingual, 25 European languages; library default)
  • FluidInference/parakeet-redux-coreml (multilingual, smallest download at ~220 MB; iOS 18+ / macOS 15+ only, see Parakeet Redux)
  • FluidInference/parakeet-tdt-0.6b-v2-coreml (English-only, highest recall)
  • FluidInference/phonon-2-coreml (English-only; Fermion Research’s five-value re-training of v3, iOS 18+ / macOS 15+, see Phonon-2)
  • Muesli-HQ/phonon-2.5-coreml (multilingual, 25 languages; ~290 MB; GPU encoder, iOS 18+ / macOS 15+, see Phonon-2.5)
  • FluidInference/bark-3.0-coreml (English-only; Underdog Bark 3.0 (verbatim) and Bark 3.0 Clean (dictation, drops fillers), iOS 18+ / macOS 15+, see Bark 3.0)
• Processing Mode: Batch transcription for complete audio files
• Real-time Factor: ~190x on M4 Pro (processes 1 hour of audio in ~19 seconds)
• Streaming Support: Real-time streaming via SlidingWindowAsrManager with sliding window processing and cancellation support
• Backend: Same Parakeet TDT v3 model powers our backend ASR

ASR Quick Start

import FluidAudio

// Batch transcription from an audio file
Task {
    // 1) Initialize ASR manager and load models
    let models = try await AsrModels.downloadAndLoad(version: .ultra)  // .v3 is the default; .v2 for English-only
    let asrManager = AsrManager(config: .default)
    try await asrManager.loadModels(models)

    // 3) Transcribe the audio 16hz, already converted
    let result = try await asrManager.transcribe(samples)

    // 3) Transcribe a file
    // let url = URL(fileURLWithPath: sample.audioPath)

    // 3) Transcribe AVAudioPCMBuffer
    // let result = try await asrManager.transcribe(audioBuffer)
    print("Transcription: \(result.text)")
}

# Transcribe an audio file (batch)
swift run fluidaudiocli transcribe audio.wav

# English-only run with higher recall
swift run fluidaudiocli transcribe audio.wav --model-version v2

Speaker Diarization

Offline Speaker Diarization Pipeline

Pyannote Community-1 pipeline (powerset segmentation + WeSpeaker + VBx) for offline speaker diarization. Use this for most use cases, see Benchmarks.md for benchmarks.

import FluidAudio

let config = OfflineDiarizerConfig()
let manager = OfflineDiarizerManager(config: config)
try await manager.prepareModels()  // Downloads + compiles Core ML bundles if they are missing

let samples = try AudioConverter().resampleAudioFile(path: "meeting.wav")
let result = try await manager.process(audio: samples)

for segment in result.segments {
    print("\(segment.speakerId) \(segment.startTimeSeconds)s → \(segment.endTimeSeconds)s")
}

For processing audio files, use the file-based API which automatically uses memory-mapped streaming for efficiency:

let url = URL(fileURLWithPath: "meeting.wav")
let result = try await manager.process(url)

for segment in result.segments {
    print("\(segment.speakerId) \(segment.startTimeSeconds)s → \(segment.endTimeSeconds)s")
}

# Process a meeting with full VBx clustering
swift run fluidaudiocli process ~/FluidAudioDatasets/ami_official/sdm/ES2004a.Mix-Headset.wav \
  --mode offline --threshold 0.6 --output es2004a_offline.json

# Run the AMI single-file benchmark with automatic downloads
swift run fluidaudiocli diarization-benchmark --mode offline --auto-download \
  --single-file ES2004a --threshold 0.6 --output offline_results.json

offline_results.json contains DER/JER/RTFx along with timing breakdowns for segmentation, embedding extraction, and VBx clustering. CI now runs this workflow on every PR to ensure the offline models stay healthy and the Hugging Face assets remain accessible.

LS-EEND (LongForm Streaming End-to-End Neural Diarization)

End-to-end streaming diarization with CoreML inference. Default choice for online diarization — single model, no clustering pipeline, up to 10 speakers, 100ms frame updates with 900ms tentative preview. Supports both streaming and complete-buffer processing. See Documentation/Diarization/GettingStarted.md for details.

import FluidAudio

Task {
    let diarizer = try await LSEENDDiarizer(variant: .dihard3)

    let samples = try await loadSamples16kMono(path: "path/to/meeting.wav")
    let timeline = try diarizer.processComplete(samples, sourceSampleRate: 16_000)

    for speaker in timeline.speakers.values {
        for segment in speaker.finalizedSegments {
            print("Speaker \(speaker.index): \(segment.startTime)s - \(segment.endTime)s")
        }
    }
}

Sortformer (End-to-End Neural Diarization)

End-to-end neural diarization using NVIDIA’s Sortformer. Secondary streaming diarizer — trades LS-EEND’s higher speaker capacity and benchmark results for better speaker identity stability. Limited to 4 speakers. No separate VAD, segmentation, or clustering needed. Licensed under NVIDIA Open Model License.

Both LS-EEND and Sortformer emit results into a DiarizerTimeline with ultra-low-latency updates. See Documentation/Diarization/Sortformer.md for usage and comparison.

Streaming/Online Speaker Diarization (Pyannote)

Pyannote 3.1 pipeline (segmentation + WeSpeaker embeddings) for online/streaming diarization. This is the third choice behind LS-EEND and Sortformer. It can be useful if you specifically want the classic multi-stage pipeline, but it is much slower than LS-EEND or Sortformer for live diarization.

Why use the WeSpeaker/Pyannote pipeline:

• More modular pipeline if you want separate segmentation and embedding stages
• Better fit when you need to integrate external speaker identification or clustering logic
• Speaker pre-enrollment is reliable
• Speaker database management is much easier
• Purging or updating individual speakers is straightforward
• Not recommended when low-latency live diarization is the priority

In most applications:

• Use LS-EEND as the default online diarizer
• Use Sortformer as the second choice when its stronger identity stability and participant focus matter more than the 4-speaker limit
• Use the WeSpeaker/Pyannote pipeline only when you specifically need its modular design despite the speed cost

Tradeoffs:

• Slower in both inference time and practical latency than LS-EEND or Sortformer
• Needs larger chunks, with at least 5 seconds usually required for decent results
• Unlike LS-EEND and Sortformer, speaker state is much easier to manipulate explicitly

import FluidAudio

// Diarize an audio file
Task {
    let models = try await DiarizerModels.downloadIfNeeded()
    let diarizer = DiarizerManager() 
    diarizer.initialize(models: models)

    // Prepare 16 kHz mono samples (see: Audio Conversion)
    let samples = try await loadSamples16kMono(path: "path/to/meeting.wav")

    // Run diarization
    let result = try diarizer.performCompleteDiarization(samples)
    for segment in result.segments {
        print("Speaker \(segment.speakerId): \(segment.startTimeSeconds)s - \(segment.endTimeSeconds)s")
    }
}

For diarization streaming see Documentation/Diarization/GettingStarted.md

swift run fluidaudiocli diarization-benchmark --single-file ES2004a \
  --chunk-seconds 3 --overlap-seconds 2

CLI

# Process an individual file and save JSON
swift run fluidaudiocli process meeting.wav --output results.json --threshold 0.6

Voice Activity Detection (VAD)

Silero VAD powers our on-device detector. The latest release surfaces the same timestamp extraction and streaming heuristics as the upstream PyTorch implementation. Ping us on Discord if you need help tuning it for your environment.

VAD Quick Start (Offline Segmentation)

Simple call to return chunk-level probabilities every 256 ms hop:

let results = try await manager.process(samples)
for (index, chunk) in results.enumerated() {
    print(
        String(
            format: "Chunk %02d: prob=%.3f, inference=%.4fs",
            index,
            chunk.probability,
            chunk.processingTime
        )
    )
}

The following are higher level APIs better suited to integrate with other systems

import FluidAudio

Task {
    let manager = try await VadManager(
        config: VadConfig(defaultThreshold: 0.75)
    )

    let audioURL = URL(fileURLWithPath: "path/to/audio.wav")
    let samples = try AudioConverter().resampleAudioFile(audioURL)

    var segmentation = VadSegmentationConfig.default
    segmentation.minSpeechDuration = 0.25
    segmentation.minSilenceDuration = 0.4

    let segments = try await manager.segmentSpeech(samples, config: segmentation)
    for segment in segments {
        print(
            String(format: "Speech %.2f–%.2fs", segment.startTime, segment.endTime)
        )
    }
}

Streaming

import FluidAudio

Task {
    let manager = try await VadManager()
    var state = await manager.makeStreamState()

    for chunk in microphoneChunks {
        let result = try await manager.processStreamingChunk(
            chunk,
            state: state,
            config: .default,
            returnSeconds: true,
            timeResolution: 2
        )

        state = result.state

        // Access raw probability (0.0-1.0) for custom logic
        print(String(format: "Probability: %.3f", result.probability))

        if let event = result.event {
            let label = event.kind == .speechStart ? "Start" : "End"
            print("\(label) @ \(event.time ?? 0)s")
        }
    }
}

CLI

Start with the general-purpose process command, which runs the diarization pipeline (and therefore VAD) end-to-end on a single file:

swift run fluidaudiocli process path/to/audio.wav

Once you need to experiment with VAD-specific knobs directly, reach for:

# Inspect offline segments (default mode)
swift run fluidaudiocli vad-analyze path/to/audio.wav

# Streaming simulation only (timestamps printed in seconds by default)
swift run fluidaudiocli vad-analyze path/to/audio.wav --streaming

# Benchmark accuracy/precision trade-offs
swift run fluidaudiocli vad-benchmark --num-files 50 --threshold 0.3

swift run fluidaudiocli vad-analyze --help lists every tuning option, including negative-threshold overrides, max-speech splitting, padding, and chunk size. Offline mode also reports RTFx using the model’s per-chunk processing time.

Speech Enhancement (Echo Cancellation + Noise Suppression)

⚠️ Beta: port fidelity validated (scores identically to the upstream GGML engine on the 800-clip AEC-Challenge blind set); the published table is only partially reproduced, with unresolved v1.2 far-end values and an ambiguous ERLE protocol. Not yet exercised in production call pipelines.

LocalVQE (Apache-2.0) is a compact neural acoustic echo canceller + noise suppressor + dereverberator for 16 kHz speech. Feed it the mic capture and a far-end reference (what the speaker played) and it returns clean near-end speech, sample-aligned with the input. Two checkpoints (v1.3 4.8M, v1.2 1.3M) in 256 ms and 16 ms chunk exports; 36× / 14× real-time on CPU for v1.3. On an exploratory AEC-Challenge synthetic subset v1.3 lifts ASR near-end word recall from 44.1% to 77.6% and cuts far-end word leakage from 34.0% to 1.1%. See Documentation/Enhancement/LocalVQE.md.

let vqe = try await LocalVqeManager()
let clean = try await vqe.process(mic: micSamples, reference: farEndSamples)

// Live capture: push buffers of any size, 16 ms algorithmic latency
let stream = try await LocalVqeManager(config: LocalVqeConfig(chunk: .realtime16ms)).makeStream()
let out = try await stream.enhance(mic: micBuffer, reference: refBuffer)

swift run -c release fluidaudiocli enhance mic.wav --reference speaker.wav --output clean.wav

Text‑To‑Speech (TTS)

⚠️ Beta: TTS currently supports American English only. Additional language support is planned.

FluidAudio ships two TTS backends:

PocketTTS

Streaming-friendly TTS with voice cloning support from short audio samples. Available language packs: english (default, Kyutai’s current english_2026-10), english_2026-04 (the previous English pack), german, german_24l, italian, italian_24l, portuguese, portuguese_24l, spanish, spanish_24l, french_24l (24-layer only — no 6-layer French upstream).

import FluidAudio

Task {
    let manager = PocketTtsManager(language: .spanish)
    try await manager.initialize()
    let audioData = try await manager.synthesize(text: "Hola, mundo.")
    try audioData.write(to: URL(fileURLWithPath: "out.wav"))
}

# English (default)
swift run fluidaudiocli tts "Hello from FluidAudio." --output out.wav --backend pocket

# Other languages
swift run fluidaudiocli tts "Hola mundo" --backend pocket --language spanish --output es.wav
swift run fluidaudiocli tts "Bonjour" --backend pocket --language french_24l --output fr.wav

# Clone a voice from an audio sample (works with any language pack)
swift run fluidaudiocli tts "Hello world." --output out.wav --backend pocket --clone-voice speaker.wav

See Documentation/TTS/PocketTTS.md for the full language table.

Phonon 31m (Gradium)

Gradium’s Phonon 31m, Apache-2.0, is the Pocket TTS recipe trained by the Kyutai founders’ spin-off. It runs on the Neural Engine with 103 voices, including 12 characters, and Gradium’s English text normalizer, so numbers, currency, emails and URLs are read correctly. Requires macOS 15 / iOS 18.

let tts = PocketTtsSmallManager(model: .phonon31m)   // downloads phonon/phonon-31m-en (~171 MB)
try await tts.initialize()
let wav = try await tts.synthesize(text: "Your order of $42.50 ships today.", voice: "en_us_Easton")

swift run fluidaudiocli tts "Hello from Phonon." --backend pocket-small --model phonon \
  --voice en_gb_Maeve --output phonon.wav

# demo app: a ring that speaks
cd Examples/PhononDemo && swift run -c release PhononDemo

KokoroAne

Kokoro ANE v3 is available in v0.17.6 for English, Japanese and Mandarin, with native text frontends. Opt in with version: .v3; existing callers keep .legacy. V3 requires macOS 15 / iOS 18 and combines CPU/ANE model stages, a CPU/GPU generator and native Accelerate DSP. It is not ANE-only or .all.

import FluidAudio

let manager = KokoroAneManager(version: .v3)
try await manager.initialize()
let result = try await manager.synthesizeDetailed(text: "Hello from FluidAudio.")
// result.samples: 24 kHz mono Float32 PCM

let japanese = KokoroAneManager(variant: .japanese, version: .v3)
let mandarin = KokoroAneManager(variant: .mandarin, version: .v3)

swift run -c release fluidaudiocli tts "Hello from FluidAudio." \
  --backend kokoro-ane --kokoro-version v3 --output out.wav

Selected M5 Pro demo inputs produced 3.05–3.68 seconds of audio in 36–54 ms median inference, excluding text processing and loading. These are bounded local checks; see benchmark methodology and live-demo timings. Models compile/cache on first use. Physical iOS inference remains unvalidated. See setup, voices, model pins, caches and platform limits.

Base weights: hexgrad/Kokoro-82M (English/Japanese) and hexgrad/Kokoro-82M-v1.1-zh (Mandarin). Core ML assets: FluidInference/kokoro-82m-coreml.

Paradee (beta)

Kokoro-82M distilled into 8M parameters, English, 11 MB of int8 weights, ~100× real time on CPU. v1.2 (default) has four voices: af_heart, am_puck, and the British bf_isabella and bm_fable, which get British phonemes. Uses the Kokoro English frontend. See Documentation/TTS/Paradee.md.

let manager = ParadeeManager()
try await manager.initialize()
let samples = try await manager.synthesize(text: "Hello from FluidAudio.", voice: .bfIsabella)  // 24 kHz Float32

swift run fluidaudiocli tts "Hello from FluidAudio." --backend paradee --voice bm_fable --output out.wav

Continuous Integration

• tests.yml: Default build matrix covering SwiftPM tests and an iOS archive smoke test.
• diarizer-benchmark.yml: Runs the streaming diarization benchmark on ES2004a for regression tracking.
• offline-pipeline.yml: Executes the VBx offline pipeline end-to-end on ES2004a (fluidaudio diarization-benchmark --mode offline), posts DER/JER/RTFx to the PR, and fails if the run produces no results (for example when models fail to download) or RTFx is 0. It does not gate on DER. Use this workflow as a reference for provisioning model caches in your own CI.

Everything Else

FAQs

• CLI is available on macOS only. For iOS, use the library programmatically.
• Models auto-download on first use. If your network restricts Hugging Face access, set an HTTPS proxy: export https_proxy=http://127.0.0.1:7890.
• Windows alternative in development: fluid-server
• If you’re looking to get the system audio on a Mac, take a look at this repo for reference AudioCap

License

Apache 2.0 — see LICENSE for details.

Acknowledgments

This project builds upon the excellent work of the sherpa-onnx project for speaker diarization algorithms and techniques.

Pyannote: https://github.com/pyannote/pyannote-audio

WeSpeaker: https://github.com/wenet-e2e/wespeaker

Parakeet-mlx: https://github.com/senstella/parakeet-mlx

silero-vad: https://github.com/snakers4/silero-vad

Kokoro-82M: https://huggingface.co/hexgrad/Kokoro-82M

Paradee-8M: https://huggingface.co/sahilmahendrakar/Paradee-8M-v1.2 (v1.2), https://huggingface.co/sahilmahendrakar/Paradee-8M-v1.0 (v1.0)

Citation

If you use FluidAudio in your work, please cite:

FluidInference Team. (2025). FluidAudio: Local Speaker Diarization, ASR, and VAD for Apple Platforms (Version 0.12.4) [Computer software]. GitHub. https://github.com/FluidInference/FluidAudio

@software{FluidInferenceTeam_FluidAudio_2025,
  author = {{FluidInference Team}},
  title = {{FluidAudio: Local Speaker Diarization, ASR, and VAD for Apple Platforms}},
  year = {2025},
  month = {3},
  version = {0.12.4},
  url = {https://github.com/FluidInference/FluidAudio},
  note = {Computer software}
}

Show Your Support

Help the Fluid Inference community grow by adding a “Powered by Fluid Inference” badge to your project!

Copy and paste this prompt to your coding agent where you host your homepage:

Add a centered 'Powered by Fluid Inference' badge to the footer linking to fluidinference.com. Image: https://assets.inference.plus/fi-badge.png. Whitelist the image hostname in your framework's config.

Or use one of these code snippets:

<div className="flex justify-center py-8">
  <a href="https://fluidinference.com">
    <img
      src="https://assets.inference.plus/fi-badge.png"
      alt="Powered by Fluid Inference"
      height={80}
    />
  </a>
</div>

<div style="text-align: center; padding: 20px;">
  <a href="https://fluidinference.com">
    <img src="https://assets.inference.plus/fi-badge.png" alt="Powered by Fluid Inference" height="80">
  </a>
</div>

<p align="center">
  <a href="https://fluidinference.com">
    <img src="https://assets.inference.plus/fi-badge.png" alt="Powered by Fluid Inference" height="80">
  </a>
</p>

Compatible community weights, including Orukeet, can use the explicit local Core ML loader.