silero

Quick start

use silero::{Session, SpeechOptions, detect_speech};

fn main() -> Result<(), silero::Error> {
    let model = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/models/silero_vad.onnx"));
    let audio_16k: Vec<f32> = vec![0.0; 16_000];
    let mut session = Session::from_memory(model)?;
    let segments = detect_speech(&mut session, &audio_16k, SpeechOptions::default())?;

    println!("detected {} speech segments", segments.len());
    Ok(())
}

Streaming usage

use silero::{Session, SpeechOptions, SpeechSegmenter, SpeechSegmenterExt, StreamState};

fn main() -> Result<(), silero::Error> {
    let model = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/models/silero_vad.onnx"));
    let mut session = Session::from_memory(model)?;
    let config = SpeechOptions::default();
    let mut stream = StreamState::new(config.sample_rate());
    let mut segmenter = SpeechSegmenter::new(config.clone());
    let audio_chunk = vec![0.0_f32; config.sample_rate().chunk_samples()];

    let print = |segment: silero::SpeechSegment| {
        println!(
            "speech {:.2}s -> {:.2}s",
            segment.start_seconds(),
            segment.end_seconds()
        );
    };

    if let Some(segment) = segmenter.push_samples(&mut session, &mut stream, &audio_chunk)? {
        print(segment);
        while let Some(more) = segmenter.push_samples(&mut session, &mut stream, &[])? {
            print(more);
        }
    }
    if let Some(segment) = segmenter.finish_stream(&mut session, &mut stream)? {
        print(segment);
        while let Some(more) = segmenter.push_samples(&mut session, &mut stream, &[])? {
            print(more);
        }
    }

    Ok(())
}

Batch inference

Silero's batch dimension represents independent streams at the same sample rate, not consecutive chunks from one stream.

use silero::{BatchInput, SampleRate, Session, StreamState};

let model = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/models/silero_vad.onnx"));
let mut session = Session::from_memory(model).unwrap();
let mut a = StreamState::new(SampleRate::Rate16k);
let mut b = StreamState::new(SampleRate::Rate16k);
let chunk_a = vec![0.0_f32; 512];
let chunk_b = vec![0.0_f32; 512];

let mut batch = [
    BatchInput::new(&mut a, &chunk_a),
    BatchInput::new(&mut b, &chunk_b),
];
let probabilities = session.infer_batch(&mut batch).unwrap();

assert_eq!(probabilities.len(), 2);

Session construction

The crate bundles models/silero_vad.onnx and exposes:

• Session::bundled() when the bundled feature is enabled
• Session::from_file(...)
• Session::from_memory(...)
• Session::from_ort_session(...)

SessionOptions only contains model-local options such as graph optimization. If a service needs to tune intra_threads / inter_threads, build the ORT session at the service layer and pass it into Session::from_ort_session(...).

Notes

• Direct sample rates: 8 kHz and 16 kHz.
• The crate does not do audio decoding or resampling.
• SpeechDetector is kept as a type alias for SpeechSegmenter.

Development

cargo fmt
cargo test

License

silero is under the terms of both the MIT license and the Apache License (Version 2.0).

See LICENSE-APACHE, LICENSE-MIT for details.

Copyright (c) 2026 FinDIT studio authors.

Third-party model notice

This crate bundles and redistributes models/silero_vad.onnx, a Silero VAD model from the upstream Silero project.

The bundled model is third-party content and remains subject to its upstream license terms. The upstream Silero model is distributed under the MIT license, and redistribution should retain the upstream copyright and permission notice.

See THIRD_PARTY_NOTICES.md for the bundled model's upstream sources, attribution, and MIT notice text.