This page covers the standalone Rust crate. For the Python workflow (training, validation, export, and prediction) see the main [Quickstart](../quickstart.md) and [Predict mode](../modes/predict.md). Export any Ultralytics model to ONNX with the [ONNX integration](../integrations/onnx.md), then run it here.

```bash
# Install the command-line tool from crates.io
cargo install ultralytics-inference

# Or with GPU support compiled in
cargo install ultralytics-inference --features cuda,tensorrt
```

The binary is placed at `~/.cargo/bin/ultralytics-inference` (Linux and macOS) or `%USERPROFILE%\.cargo\bin\` on Windows.

```bash
# Add the crate to your project
cargo add ultralytics-inference
```

```toml
# Or add it manually to Cargo.toml
[dependencies]
ultralytics-inference = "0.0.18"
```

# Detect on the built-in samples (downloads model and images)
ultralytics-inference predict

# Detect on your own image
ultralytics-inference predict --model yolo26n.onnx --source image.jpg

# Segmentation (auto-downloads yolo26n-seg.onnx)
ultralytics-inference predict --task segment --source image.jpg

# Pose on a video, shown live in a window
ultralytics-inference predict --task pose --source video.mp4 --show

# Tune thresholds and filter to specific classes
ultralytics-inference predict --source image.jpg --conf 0.5 --iou 0.45 --classes "0,1,2"

# Run a whole folder on the GPU in half precision
ultralytics-inference predict --source images/ --device cuda:0 --half

use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Metadata (classes, task, imgsz) is parsed from the model.
    let mut model = YOLOModel::load("yolo26n.onnx")?;

    let results = model.predict("image.jpg")?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let conf = boxes.conf()[i];
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("{name} {conf:.2}");
            }
        }
    }

    Ok(())
}

use ultralytics_inference::{Device, InferenceConfig, YOLOModel};

let config = InferenceConfig::new()
    .with_confidence(0.5)
    .with_iou(0.45)
    .with_imgsz(640, 640)
    .with_device(Device::Cuda(0))
    .with_half(true);

let mut model = YOLOModel::load_with_config("yolo26n.onnx", config)?;
let results = model.predict("image.jpg")?;

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(boxes) = &result.boxes {
            println!("{} detections", boxes.len());
            let xyxy = boxes.xyxy(); // rows of [x1, y1, x2, y2]
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", boxes.conf()[i], xyxy.row(i).to_vec());
            }
        }
    }

    Ok(())
}
```

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-seg.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(masks) = &result.masks {
            let (n, h, w) = masks.data.dim(); // mask data shape (N, H, W)
            println!("{n} instance masks ({h}x{w})");
        }
        if let Some(boxes) = &result.boxes {
            for i in 0..boxes.len() {
                let class_id = boxes.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2}", boxes.conf()[i]);
            }
        }
    }

    Ok(())
}
```

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-pose.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(kpts) = &result.keypoints {
            let (n, k, _) = kpts.xy().dim(); // keypoint coords shape (N, K, 2)
            println!("{n} pose(s), {k} keypoints each");

            // Optional per-keypoint confidence, shape (N, K)
            if let Some(conf) = kpts.conf() {
                println!("  keypoint confidence values: {}", conf.len());
            }
        }
    }

    Ok(())
}
```

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-cls.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(probs) = &result.probs {
            let top1 = probs.top1();
            let name = result.names.get(&top1).map_or("unknown", |s| s.as_str());
            println!("top-1: {name} ({:.2})", probs.top1conf());

            for (id, conf) in probs.top5().into_iter().zip(probs.top5conf()) {
                let name = result.names.get(&id).map_or("unknown", |s| s.as_str());
                println!("  {name} {conf:.2}");
            }
        }
    }

    Ok(())
}
```

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-obb.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(obb) = &result.obb {
            println!("{} oriented boxes", obb.len());
            let xywhr = obb.xywhr(); // rows of [cx, cy, w, h, angle]
            for i in 0..obb.len() {
                let class_id = obb.cls()[i] as usize;
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  {name} {:.2} {:?}", obb.conf()[i], xywhr.row(i).to_vec());
            }
        }
    }

    Ok(())
}
```

```rust
use ultralytics_inference::YOLOModel;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = YOLOModel::load("yolo26n-sem.onnx")?;
    let results = model.predict_default()?;

    for result in &results {
        if let Some(sem) = &result.semantic_mask {
            let (h, w) = sem.data.dim(); // per-pixel class map shape (H, W)
            println!("class map {h}x{w}");

            for class_id in sem.class_ids() {
                let name = result.names.get(&class_id).map_or("unknown", |s| s.as_str());
                println!("  present: {name}");
            }
        }
    }

    Ok(())
}
```

# Build the CLI with the providers you need
cargo install ultralytics-inference --features cuda,tensorrt

# Build with fused GPU preprocessing (implies cuda + tensorrt)
cargo build --release --features cuda-preprocess

use ultralytics_inference::{Device, InferenceConfig};

let config = InferenceConfig::new()
    .with_device(Device::TensorRt(0))
    .with_cuda_preprocess(false); // force CPU preprocessing

`cuda-preprocess` requires a matching CUDA toolkit at build time and uses NVRTC at runtime for the fused preprocessing kernel. See the [CUDA and TensorRT acceleration guide](https://docs.rs/ultralytics-inference/latest/ultralytics_inference/cuda_guide/index.html) for version requirements and troubleshooting.

cargo install ultralytics-inference --features video
cargo install ultralytics-inference --features cuda,tensorrt

[dependencies]
ultralytics-inference = { version = "0.0.18", features = ["video"] }

runs/
└── detect/
    └── predict/          # then predict2, predict3, ...
        └── image.jpg     # annotated result