Building Sentence Transformers in Rust: A Practical Guide with Burn, ONNX Runtime, and Candle

Rust is emerging as a powerful platform for ML inference, offering memory safety, blazing performance, and tiny deployment footprints. This comprehensive guide shows you how to build sentence transformation models using three leading Rust frameworks: Burn, ONNX Runtime, and Candle. You’ll learn when to use each framework, how to work with real datasets, and how to optimize for production.

What are sentence transformers and why should you care?

Sentence transformers convert text into dense vector embeddings that capture semantic meaning. Unlike word embeddings, they encode entire sentences as fixed-length vectors, enabling powerful applications:

Semantic search: Find documents by meaning, not just keywords. A search for “fixing a broken laptop” matches “repairing computer hardware” even without shared words.

Duplicate detection: Identify paraphrases and duplicate content. Quora uses this to merge duplicate questions, improving answer quality for millions of users.

Text clustering and classification: Group similar documents automatically or classify sentiment with minimal training data.

Recommendation systems: Match user preferences to content based on semantic similarity rather than exact matches.

The typical workflow involves three steps: tokenization converts text to token IDs, a transformer model generates token-level embeddings, and pooling aggregates these into a single sentence embedding. The magic happens in the transformer’s ability to understand context—the word “bank” gets different embeddings in “river bank” versus “savings bank.”

Rust ML frameworks: which one fits your needs?

As of early 2025, three frameworks lead the Rust ML ecosystem for sentence transformers. Each excels in different scenarios.

ONNX Runtime: the production workhorse

When to use it: You have existing models from PyTorch/TensorFlow and need production-grade inference performance right now.

ONNX Runtime (via the ort crate) provides battle-tested inference with impressive numbers: 3-5x faster than Python equivalents with 60-80% less memory usage. It supports multiple execution providers including CUDA, TensorRT, and OpenVINO for hardware acceleration.

Key strengths: Mature ecosystem, exceptional performance, seamless HuggingFace model integration via ONNX export, production-proven at scale. FastEmbed-rs and other libraries build on it successfully.

Limitations: Inference only (no training), requires ONNX conversion step, slightly less “Rusty” than pure alternatives.

Candle: HuggingFace’s minimalist approach

When to use it: You want PyTorch-like syntax with native HuggingFace integration for serverless or edge deployments.

Developed by HuggingFace, Candle emphasizes simplicity and deployment efficiency. It loads models directly from safetensors, integrates seamlessly with the tokenizers crate, and produces small binaries suitable for serverless functions.

Key strengths: Direct HuggingFace Hub integration, PyTorch-like API, growing community libraries (sentence-transformers-rs provides 15+ pre-built models), excellent for WASM/browser deployment.

Limitations: Some reports indicate 3-4x slower GPU performance than PyTorch for certain workloads, primarily inference-focused though training exists.

Burn: the comprehensive native solution

When to use it: You need maximum flexibility, training capabilities, or deployment across diverse hardware (embedded systems to data centers).

Burn represents the most ambitious pure-Rust approach with backend-agnostic code that runs unchanged on CPU, CUDA, Metal, WGPU, and even WebAssembly. Write once, deploy anywhere with near-native performance across all backends thanks to automatic kernel fusion.

Key strengths: Pure Rust with strong safety guarantees, comprehensive training infrastructure, innovative CubeCL technology for cross-platform performance, excellent for custom architectures.

Limitations: Sentence transformer support requires community projects, smaller model zoo, API still evolving toward 1.0 release.

Decision matrix

Choose ONNX Runtime for: production inference systems, existing model deployment, teams needing immediate results, scenarios where a Python training → Rust inference workflow makes sense.

Choose Candle for: serverless functions (Lambda, Cloud Run), edge/embedded deployment, browser-based inference via WASM, projects already using HuggingFace ecosystem.

Choose Burn for: custom model architectures, training and inference in Rust, safety-critical systems (medical, automotive), embedded/no_std environments, research projects exploring novel approaches.

Hands-on tutorial: building with ONNX Runtime

Let’s build a complete sentence transformer pipeline using ONNX Runtime, the most production-ready option. We’ll load a pre-trained model, implement pooling strategies, and create a reusable API.

Step 1: export your model to ONNX

First, convert a HuggingFace sentence transformer to ONNX format using Optimum:

# Install Optimum
pip install optimum[onnxruntime]

# Export with O3 optimization (recommended for production)
optimum-cli export onnx \
  --model sentence-transformers/all-MiniLM-L6-v2 \
  --task feature-extraction \
  --optimize O3 \
  ./models/all-MiniLM-L6-v2-onnx/

The all-MiniLM-L6-v2 model provides excellent quality at 384 dimensions with just 22M parameters—perfect for learning. Optimization level O3 applies GELU approximation and transformer-specific fusions, delivering 30-40% speedup with negligible accuracy loss.

For GPU deployment, use O4 optimization with mixed precision:

optimum-cli export onnx \
  --model sentence-transformers/all-MiniLM-L6-v2 \
  --task feature-extraction \
  --optimize O4 \
  --device cuda \
  ./models/all-MiniLM-L6-v2-fp16/

Step 2: set up your Rust project

Create a new project and add dependencies:

[package]
name = "sentence_transformer_rust"
version = "0.1.0"
edition = "2021"

[dependencies]
ort = "2.0.0-rc.10"
tokenizers = "0.19"
ndarray = "0.15"
anyhow = "1.0"

The ort crate wraps ONNX Runtime with safe Rust bindings, tokenizers provides HuggingFace’s fast tokenization, and ndarray handles tensor operations.

Step 3: create the sentence transformer

Here’s a complete implementation with proper pooling and normalization:

use anyhow::Result;
use ndarray::{Array2, ArrayD, Axis};
use ort::{inputs, GraphOptimizationLevel, Session};
use tokenizers::Tokenizer;

pub struct SentenceTransformer {
    session: Session,
    tokenizer: Tokenizer,
}

impl SentenceTransformer {
    pub fn new(model_path: &str, tokenizer_path: &str) -> Result<Self> {
        // Initialize ONNX Runtime session with optimizations
        let session = Session::builder()?
            .with_optimization_level(GraphOptimizationLevel::Level3)?
            .with_intra_threads(4)?
            .commit_from_file(model_path)?;

        // Load HuggingFace tokenizer
        let tokenizer = Tokenizer::from_file(tokenizer_path)?;

        Ok(Self { session, tokenizer })
    }

    pub fn encode(&self, texts: &[&str]) -> Result<Vec<Vec<f32>>> {
        texts.iter().map(|text| self.encode_single(text)).collect()
    }

    fn encode_single(&self, text: &str) -> Result<Vec<f32>> {
        // Step 1: Tokenize text
        let encoding = self.tokenizer.encode(text, true)?;
        let input_ids: Vec<i64> = encoding
            .get_ids()
            .iter()
            .map(|&id| id as i64)
            .collect();
        let attention_mask: Vec<i64> = encoding
            .get_attention_mask()
            .iter()
            .map(|&mask| mask as i64)
            .collect();

        let seq_len = input_ids.len();

        // Step 2: Convert to ndarray tensors
        let input_ids_array = Array2::from_shape_vec((1, seq_len), input_ids)?;
        let attention_mask_array = Array2::from_shape_vec((1, seq_len), attention_mask)?;

        // Step 3: Run inference through ONNX model
        let outputs = self.session.run(inputs![
            "input_ids" => input_ids_array.view(),
            "attention_mask" => attention_mask_array.view()
        ]?)?;

        // Step 4: Extract token embeddings from model output
        let token_embeddings: ArrayD<f32> = outputs["last_hidden_state"]
            .try_extract_tensor()?
            .into_owned();

        // Step 5: Apply mean pooling
        let sentence_embedding = self.mean_pooling(&token_embeddings, &attention_mask_array)?;

        // Step 6: L2 normalization (critical for cosine similarity)
        Ok(self.normalize_l2(&sentence_embedding))
    }

    fn mean_pooling(&self, token_embeddings: &ArrayD<f32>, attention_mask: &Array2<i64>) 
        -> Result<Vec<f32>> 
    {
        let shape = token_embeddings.shape();
        let hidden_size = shape[2];
        let seq_len = shape[1];

        let mut pooled = vec![0.0; hidden_size];
        let mut sum_mask = 0.0;

        // Sum embeddings for attended tokens only
        for i in 0..seq_len {
            if attention_mask[[0, i]] == 1 {
                for j in 0..hidden_size {
                    pooled[j] += token_embeddings[[0, i, j]];
                }
                sum_mask += 1.0;
            }
        }

        // Compute average
        for val in pooled.iter_mut() {
            *val /= sum_mask;
        }

        Ok(pooled)
    }

    fn normalize_l2(&self, embedding: &[f32]) -> Vec<f32> {
        let norm: f32 = embedding.iter().map(|x| x * x).sum::<f32>().sqrt();
        embedding.iter().map(|x| x / norm).collect()
    }
}

// Utility function for computing similarity
pub fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
    a.iter().zip(b.iter()).map(|(x, y)| x * y).sum()
}

Key implementation details: Mean pooling averages token embeddings weighted by attention mask, ensuring padding tokens don’t dilute the representation. L2 normalization converts embeddings to unit length, making cosine similarity equivalent to dot product (faster computation). The attention mask handling is crucial—without it, padding tokens would skew the average.

Step 4: use the transformer

Here’s how to generate embeddings and compute semantic similarity:

fn main() -> Result<()> {
    let model = SentenceTransformer::new(
        "models/all-MiniLM-L6-v2-onnx/model.onnx",
        "models/all-MiniLM-L6-v2-onnx/tokenizer.json",
    )?;

    let texts = vec![
        "The cat sits on the mat",
        "A feline rests on a rug",
        "Dogs are great pets",
    ];

    let embeddings = model.encode(&texts)?;

    // Compute pairwise similarities
    println!("Similarity (cat/feline): {:.4}", 
        cosine_similarity(&embeddings[0], &embeddings[1]));
    println!("Similarity (cat/dogs): {:.4}", 
        cosine_similarity(&embeddings[0], &embeddings[2]));

    Ok(())
}

You’ll see high similarity (~0.85) between the cat sentences and lower similarity (~0.45) with the dog sentence—the model understands semantic relationships beyond keyword matching.

GPU acceleration

For production workloads, enable CUDA:

use ort::{CUDAExecutionProvider, ExecutionProvider};

let session = Session::builder()?
    .with_execution_providers([
        ExecutionProvider::CUDA(CUDAExecutionProvider::default()
            .with_device_id(0)
            .with_memory_limit(2 * 1024 * 1024 * 1024) // 2GB
        )
    ])?
    .commit_from_file(model_path)?;

Expect 10-50x speedup on GPU depending on batch size. Larger batches amortize kernel launch overhead—batch size 32-64 typically optimal for sentence transformers.

Alternative: using Candle for rapid prototyping

For a batteries-included experience, try the sentence-transformers-rs library built on Candle:

[dependencies]
sentence-transformers-rs = "0.1"
candle-core = "0.3"

use sentence_transformers_rs::{
    SentenceTransformerBuilder, Which,
    utils::cosine_similarity,
};
use candle_core::Device;

fn main() -> Result<()> {
    let device = Device::cuda_if_available(0)?;

    let model = SentenceTransformerBuilder::with_sentence_transformer(
        &Which::AllMiniLML6v2
    )
    .batch_size(2048)
    .with_device(&device)
    .build()?;

    let sentences = vec![
        "Machine learning in Rust is powerful",
        "Rust provides memory safety",
    ];

    let embeddings = model.embed(&sentences)?;
    let sim = cosine_similarity(&embeddings[0], &embeddings[1])?;

    println!("Similarity: {:.4}", sim);
    Ok(())
}

This approach handles model downloading from HuggingFace Hub automatically and supports 15+ pre-trained models out of the box. Perfect for getting started quickly, though you sacrifice some control over the inference pipeline.

Working with Kaggle datasets

Real-world sentence transformers need training data. Here are the best Kaggle datasets for different use cases:

Paraphrase detection: Quora Question Pairs

404,290 question pairs with duplicate/non-duplicate labels make this the gold standard for paraphrase detection.

kaggle datasets download -d quora/question-pairs-dataset

Load and parse in Rust:

use csv::ReaderBuilder;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct QuestionPair {
    id: u32,
    qid1: u32,
    qid2: u32,
    question1: String,
    question2: String,
    is_duplicate: u8,
}

fn load_quora_pairs(path: &str) -> Result<Vec<QuestionPair>> {
    let mut reader = ReaderBuilder::new()
        .has_headers(true)
        .from_path(path)?;

    reader.deserialize()
        .collect::<Result<Vec<_>, _>>()
        .map_err(Into::into)
}

Use case: Train with contrastive loss—pull duplicates together in embedding space, push non-duplicates apart. Fine-tune on this after pre-training on NLI data for best results.

Semantic similarity: STS Benchmark

8,628 sentence pairs with continuous similarity scores (0-5 scale) provide gold-standard evaluation data.

kaggle datasets download -d astha0410/sts-benchmark

#[derive(Debug, Deserialize)]
struct STSPair {
    #[serde(rename = "sentence1")]
    sentence1: String,
    #[serde(rename = "sentence2")]
    sentence2: String,
    #[serde(rename = "score")]
    similarity_score: f32,
}

Use case: Evaluate model quality by computing Pearson correlation between predicted and actual similarity scores. Good models achieve 0.85+ correlation.

Training universal embeddings: All NLI Dataset

943,000 sentence pairs (SNLI + MultiNLI) with entailment labels remain the industry standard for training sentence embeddings.

kaggle datasets download -d akkefa/all-nli-dataset

The dataset provides multiple formats—use the “Pair Class” format for training classification heads:

#[derive(Debug, Deserialize)]
struct NLIPair {
    premise: String,
    hypothesis: String,
    label: u8, // 0=entailment, 1=neutral, 2=contradiction
}

Training approach: Create siamese network that embeds premise and hypothesis separately, concatenates them (with element-wise difference and product), then classifies. This teaches the model general semantic understanding applicable across domains.

Challenging paraphrases: PAWS Dataset

For models that need to understand word order and composition, PAWS provides adversarial examples with high word overlap but different meanings.

Use case: Prevents models from relying on superficial lexical matching. Essential for robust paraphrase detection.

Dataset selection guide

Start with All NLI (943K pairs) for pre-training universal embeddings. Fine-tune on Quora Question Pairs (404K) for paraphrase tasks or domain-specific data. Evaluate on STS Benchmark and SICK datasets to measure quality. Add PAWS for robustness testing.

For multilingual models, use Contradictory My Dear Watson (15 languages, 12K pairs) to test cross-lingual transfer.

Best practices that prevent headaches

Memory management

Rust’s ownership system prevents most memory issues automatically, but tensor operations need care:

// ❌ Bad: Allocates new tensor every iteration
for text in texts {
    let embedding = model.encode(text)?; // New allocation
    process(embedding);
}

// ✅ Good: Pre-allocate and reuse
let batch_size = 32;
for chunk in texts.chunks(batch_size) {
    let embeddings = model.encode_batch(chunk)?; // Batch allocation
    process_batch(embeddings);
}

Batching reduces allocations and amortizes inference overhead. For ONNX Runtime, batch size 16-64 optimal on GPU, 4-8 on CPU.

Tokenization pitfalls

Always configure tokenizer padding/truncation explicitly:

use tokenizers::{Tokenizer, PaddingParams, TruncationParams};

let mut tokenizer = Tokenizer::from_file("tokenizer.json")?;

// Configure padding to max length in batch
tokenizer.with_padding(Some(PaddingParams {
    strategy: tokenizers::PaddingStrategy::BatchLongest,
    ..Default::default()
}));

// Truncate sequences exceeding model's max length
tokenizer.with_truncation(Some(TruncationParams {
    max_length: 512,
    ..Default::default()
}))?;

Without truncation, sequences exceeding 512 tokens will crash. Without padding, batch processing fails due to shape mismatches.

Quantization for deployment

8-bit quantization provides 75% size reduction with minimal accuracy loss:

# Export quantized ONNX model
optimum-cli export onnx \
  --model sentence-transformers/all-MiniLM-L6-v2 \
  --task feature-extraction \
  --optimize O3 \
  --quantize avx512_vnni \  # For Intel CPUs with VNNI
  ./models/quantized/

For dynamic quantization in ONNX Runtime:

let session = Session::builder()?
    .with_optimization_level(GraphOptimizationLevel::Level3)?
    .with_graph_optimization_level(
        ort::GraphOptimizationLevel::ORT_ENABLE_ALL
    )?
    .commit_from_file(model_path)?;

Typical results: 3x faster CPU inference, 60-75% memory reduction, <1% accuracy degradation. Test thoroughly—some models more sensitive to quantization than others.

Testing strategies

Validate against Python implementations to catch bugs:

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_matches_python_output() {
        let model = SentenceTransformer::new(
            "models/model.onnx",
            "models/tokenizer.json"
        ).unwrap();

        let text = "This is a test sentence";
        let embedding = model.encode(&[text]).unwrap();

        // Load reference embedding from Python
        let reference: Vec<f32> = load_reference("test_embedding.json");

        // Allow small numerical differences
        for (a, b) in embedding[0].iter().zip(reference.iter()) {
            assert!((a - b).abs() < 1e-5, 
                "Embedding mismatch: {} vs {}", a, b);
        }
    }

    #[test]
    fn test_identical_text_similarity() {
        let model = SentenceTransformer::new(...).unwrap();
        let embeddings = model.encode(&["test", "test"]).unwrap();
        let similarity = cosine_similarity(&embeddings[0], &embeddings[1]);

        // Identical texts should have similarity ~1.0
        assert!(similarity > 0.99);
    }
}

Generate Python reference outputs during development, commit them to version control, and validate Rust outputs match during CI. This catches subtle bugs in pooling, normalization, or tokenization.

Performance optimization strategies

Backend selection matters

For ONNX Runtime, execution provider choice dramatically impacts performance:

Provider	Hardware	Typical Speedup	Notes
CUDA	NVIDIA GPU	10-50x	Best all-around, mature ecosystem
TensorRT	NVIDIA GPU	15-70x	Highest performance, more setup
OpenVINO	Intel CPU/GPU	3-8x	Excellent for Intel hardware
CoreML	Apple Silicon	5-15x	Best for M1/M2/M3 Macs

Enable multiple providers with fallback:

let session = Session::builder()?
    .with_execution_providers([
        ExecutionProvider::TensorRT(Default::default()),
        ExecutionProvider::CUDA(Default::default()),
        ExecutionProvider::CPU(Default::default()),
    ])?
    .commit_from_file(model_path)?;

ONNX Runtime tries each provider in order, falling back if unavailable.

Batch processing patterns

Process multiple texts efficiently using rayon for parallelism:

use rayon::prelude::*;

pub fn embed_large_corpus(
    model: &SentenceTransformer, 
    texts: &[String]
) -> Result<Vec<Vec<f32>>> {
    const BATCH_SIZE: usize = 32;

    texts.par_chunks(BATCH_SIZE)
        .map(|chunk| {
            let refs: Vec<&str> = chunk.iter().map(|s| s.as_str()).collect();
            model.encode(&refs)
        })
        .collect::<Result<Vec<_>>>()?
        .into_iter()
        .flatten()
        .collect()
}

This parallelizes across CPU cores, with each core processing a batch through the model. On 8-core CPU with GPU, expect 5-6x throughput improvement over serial processing.

Compilation flags for production

Always compile with optimizations:

# Basic release build
cargo build --release

# Maximum optimization for target CPU
RUSTFLAGS="-C target-cpu=native" cargo build --release

# Link-time optimization for additional 10-15% speedup
[profile.release]
lto = true
codegen-units = 1

Never benchmark debug builds—release mode provides 10-100x speedup depending on workload.

Deploying to production

REST API with Axum

Create a production-ready embedding service:

use axum::{
    extract::State,
    routing::post,
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;

#[derive(Deserialize)]
struct EmbedRequest {
    texts: Vec<String>,
}

#[derive(Serialize)]
struct EmbedResponse {
    embeddings: Vec<Vec<f32>>,
    dimension: usize,
    count: usize,
}

async fn embed_handler(
    State(model): State<Arc<SentenceTransformer>>,
    Json(req): Json<EmbedRequest>,
) -> Json<EmbedResponse> {
    let texts: Vec<&str> = req.texts.iter().map(|s| s.as_str()).collect();
    let embeddings = model.encode(&texts).unwrap();

    Json(EmbedResponse {
        dimension: embeddings[0].len(),
        count: embeddings.len(),
        embeddings,
    })
}

#[tokio::main]
async fn main() {
    let model = Arc::new(
        SentenceTransformer::new("models/model.onnx", "models/tokenizer.json")
            .expect("Failed to load model")
    );

    let app = Router::new()
        .route("/embed", post(embed_handler))
        .with_state(model);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
        .await
        .unwrap();

    axum::serve(listener, app).await.unwrap();
}

Docker deployment

# Build stage
FROM rust:1.75 as builder
WORKDIR /app
COPY Cargo.* ./
COPY src ./src
RUN cargo build --release

# Runtime stage
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y \
    libgomp1 \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/sentence_transformer_rust /usr/local/bin/
COPY models /app/models

EXPOSE 8080
CMD ["sentence_transformer_rust"]

Production checklist: Add health check endpoints (/health, /ready), implement request timeouts (5-10s typical for sentence transformers), add Prometheus metrics, configure graceful shutdown, set resource limits, implement rate limiting for public APIs.

Performance benchmarks

Real-world results from production deployments:

Python (transformers + PyTorch): ~100 sentences/sec on CPU, ~1000 sentences/sec on GPU (batch 32)

Rust (ONNX Runtime): ~400 sentences/sec on CPU, ~5000 sentences/sec on GPU (batch 32)

Memory usage: Python ~2GB base + model size, Rust ~100MB base + model size

Cold start: Python ~3-5s, Rust ~200-500ms (serverless scenarios)

These numbers demonstrate why Rust excels for production ML: 3-5x throughput increase, 80-90% memory reduction, 10x faster cold starts.

Resources and next steps

Official documentation

Learn the frameworks in depth:

• ONNX Runtime Rust: https://ort.pyke.io
• Candle Guide: https://huggingface.github.io/candle
• Burn Book: https://burn.dev/book
• HuggingFace Tokenizers: https://huggingface.co/docs/tokenizers

Community resources

Join the growing Rust ML community:

• Are We Learning Yet: https://www.arewelearningyet.com (comprehensive ecosystem catalog)
• Rust ML Zulip: https://rust-ml.zulipchat.com (active chat community)
• GitHub rust-ml: https://github.com/rust-ml (curated projects)

Example repositories

Study working implementations:

• FastEmbed-rs: Production-ready embeddings (https://github.com/Anush008/fastembed-rs)
• rust-bert: Complete NLP pipelines (https://github.com/guillaume-be/rust-bert)
• sentence-transformers-rs: Candle-based transformers (https://github.com/jwnz/sentence-transformers-rs)

Recommended learning path

1. Start small: Use ONNX Runtime to deploy an existing model—quickest path to production
2. Experiment: Try Candle with sentence-transformers-rs for rapid prototyping
3. Go deep: Explore Burn when you need training, custom architectures, or maximum flexibility
4. Contribute: The ecosystem is young—your contributions have outsized impact

Advanced topics to explore

Once comfortable with basics, investigate:

• Cross-encoder models for reranking search results (2-10x better accuracy than bi-encoders)
• Multi-vector representations (ColBERT architecture) for retrieval
• Quantization techniques beyond 8-bit (4-bit, 2-bit with AQLM)
• Model distillation for creating smaller, faster models
• Continuous learning for domain adaptation without full retraining

Conclusion

Building sentence transformers in Rust has matured significantly in 2024-2025. With production-ready frameworks, comprehensive tooling, and excellent performance characteristics, Rust offers compelling advantages for ML inference: memory safety without garbage collection, 3-5x speedup over Python, tiny deployment footprints, and the ability to run anywhere from embedded systems to data centers.

The hybrid approach—training in Python/PyTorch, deploying with Rust—combines the best of both worlds: Python’s extensive ML ecosystem for experimentation and Rust’s performance for production. If you’re building production ML systems, Rust deserves serious consideration, especially for latency-sensitive applications, high-throughput services, or resource-constrained environments.

Start with ONNX Runtime for immediate wins, explore Candle for HuggingFace integration, and graduate to Burn for advanced use cases. The Rust ML ecosystem welcomes contributors—jump in and help shape the future of safe, fast machine learning.