LlamaMlx-RS

High-performance MLX models in Rust for Apple Silicon

Overview

LlamaMlx-RS is a comprehensive Rust ecosystem for running MLX models on Apple Silicon devices. It provides efficient, type-safe Rust bindings to Apple's MLX framework along with high-level libraries for different ML tasks.

The ecosystem consists of the following components: e

• Core Library: llamamlx-rs - Rust bindings to MLX with tensor operations, device management, and model loading
• ML Libraries:
  • llama-textgen-rs - Text generation with LLMs
  • llama-embed-rs - Text embedding generation
  • llama-image-rs - Computer vision tasks (classification, detection, segmentation)
  • llama-vlm-rs - Vision-language models for multimodal processing
• Utility Libraries:
  • llama-shard-rs - Model sharding for distributed inference
  • llama-arxiv-rs - ArXiv paper downloading and processing
  • llama-moonlight-rs - Web scraping and CAPTCHA solving
• Integration Tools:
  • Server applications
  • CLI tools
  • Example applications

Features

• 🚀 High Performance: Optimized for Apple Silicon M1/M2/M3 chips
• 🔄 Easy Conversion: Utilities for converting models from PyTorch/ONNX to MLX
• 📦 Production-Ready: Comprehensive error handling, performance monitoring, and testing
• 🌐 Distributed Inference: Shard large models across multiple devices
• 🔌 API Compatibility: Drop-in replacement for popular APIs like OpenAI
• 📊 Flexible I/O: Load and save models, weights, and tensors in various formats
• 📈 Visualization: Rich tools for visualizing tensors, model outputs, and performance metrics
• 🧩 Modular Design: Use only the components you need

Installation

Prerequisites

• macOS 13+ with Apple Silicon (M1/M2/M3)
• Rust 1.75+
• Xcode Command Line Tools
• Python 3.9+ (for model conversion)

Setting up the Ecosystem

# Clone the repository
git clone https://github.com/llamamlx-rs/llamamlx-rs.git
cd llamamlx-rs

# Run the setup script
./setup-ecosystem.sh

# Build all components
cargo build --release

Quick Start

Text Generation with Llama 3

use llamamlx_rs::device::Device;
use llama_textgen::{TextGenerator, GenerationOptions};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a text generator with Llama 3
    let generator = TextGenerator::new_from_path(
        "models/Llama-3-8B-iq4", 
        &Device::gpu(0)
    )?;

    // Generate text
    let options = GenerationOptions {
        temperature: 0.7,
        top_p: 0.9,
        max_tokens: 100,
        stop_sequences: vec!["\n\n".to_string()],
    };
    
    let result = generator.generate(
        "Explain quantum computing in simple terms:", 
        &options
    )?;
    
    println!("{}", result.text);

    Ok(())
}

Image Classification

use llamamlx_rs::device::Device;
use llama_image::{
    image::Image,
    classification::ImageClassifier,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load an image
    let image = Image::from_file("examples/cat.jpg")?;
    
    // Create a classifier with MobileNet
    let classifier = ImageClassifier::new_from_path(
        "models/mobilenet-v2-mlx",
        Some("models/mobilenet-v2-mlx/labels.txt"),
        &Device::gpu(0)
    )?;
    
    // Classify the image
    let result = classifier.classify(&image)?;
    
    println!("Class: {} ({:.2}% confidence)", 
        result.class_name, 
        result.confidence * 100.0
    );

    Ok(())
}

Visualization

use llamamlx_rs::{
    tensor::Array,
    visualization::{
        terminal::print_tensor_heatmap,
        file::save_classification_tsv,
    },
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a sample 2D tensor
    let data = vec![
        0.1, 0.2, 0.3, 0.4,
        0.5, 0.9, 0.8, 0.7,
        0.2, 0.3, 0.8, 0.5,
        0.4, 0.5, 0.6, 0.1,
    ];
    let tensor = Array::from_slice(&data, [4, 4]);
    
    // Display as a heatmap in the terminal
    print_tensor_heatmap(&tensor, Some("Sample Heatmap"), None, None)?;
    
    // Create classification results
    let categories = vec![
        ("Cat".to_string(), 0.85),
        ("Dog".to_string(), 0.12), 
        ("Bird".to_string(), 0.03),
    ];
    
    // Save classification results to TSV file
    save_classification_tsv(&categories, "classification.tsv")?;
    
    Ok(())
}

Using the CLI for Visualization

# Generate a heatmap visualization of a tensor from a CSV file
llamamlx visualize --input tensor_data.csv --viz-type heatmap --terminal

# Generate a classification visualization from a JSON file
llamamlx visualize --input classification.json --viz-type classification --terminal

# Create an HTML report from model results
llamamlx visualize --input results.json --viz-type report --html --output report.html

# Create a PNG plot with a specific color scheme
llamamlx visualize --input tensor_data.csv --viz-type heatmap --output heatmap.png --color-scheme viridis

Distributed Inference

use llamamlx_rs::device::Device;
use llama_shard::{
    config::ShardingConfig,
    coordinator::Coordinator,
    sharding::ShardStrategy,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create sharding configuration
    let config = ShardingConfig::new(
        "models/Llama-3-8B-iq4".into(),
        2,  // number of shards
        ShardStrategy::LayerSharding,
    );
    
    // Create and start coordinator
    let coordinator = Coordinator::new(config)?;
    coordinator.start().await?;
    
    // In a production setup, you would run workers on different machines
    // For this example, we'll register local workers
    
    println!("Coordinator ready at localhost:50051");
    println!("Run worker instances with:");
    println!("  cargo run --bin llamashard -- worker --shard-id 0 --coordinator localhost:50051");
    println!("  cargo run --bin llamashard -- worker --shard-id 1 --coordinator localhost:50051");
    
    // Wait for Ctrl+C
    tokio::signal::ctrl_c().await?;
    coordinator.shutdown().await?;

    Ok(())
}

Available Models

Text Models

Vision Models

Multimodal Models

Documentation

• API Reference
• [User Guide](https://llamasearch.ai
• Examples
• Model Zoo

Architecture

The LlamaMlx-RS ecosystem is designed with a modular architecture:

┌───────────────────────────────────────────────────────────┐
│                      Applications                          │
│   ┌─────────────┐  ┌──────────────┐  ┌───────────────┐    │
│   │ REST Server │  │ CLI Tools    │  │ GUI Apps      │    │
│   └─────────────┘  └──────────────┘  └───────────────┘    │
└───────────────────────────────────────────────────────────┘
               │              │              │
┌───────────────────────────────────────────────────────────┐
│                     ML Libraries                           │
│ ┌──────────┐ ┌─────────┐ ┌─────────┐ ┌─────┐ ┌──────────┐ │
│ │TextGen   │ │Embedding│ │Image    │ │VLM  │ │Sharding  │ │
│ └──────────┘ └─────────┘ └─────────┘ └─────┘ └──────────┘ │
└───────────────────────────────────────────────────────────┘
                           │
┌───────────────────────────────────────────────────────────┐
│                       Core Library                         │
│  ┌────────┐ ┌─────────┐ ┌────────┐ ┌────────┐ ┌────────┐  │
│  │Tensor  │ │Device   │ │Model   │ │Graph   │ │Ops     │  │
│  └────────┘ └─────────┘ └────────┘ └────────┘ └────────┘  │
└───────────────────────────────────────────────────────────┘
                           │
┌───────────────────────────────────────────────────────────┐
│                     Apple MLX Framework                    │
└───────────────────────────────────────────────────────────┘

Performance

LlamaMlx-RS is designed to leverage the full power of Apple Silicon, with performance comparable to or better than Python-based MLX implementations:

Contributing

Contributions are welcome! Please check out our contribution guidelines for details.

License

LlamaMlx-RS is licensed under the MIT License.

Acknowledgements

• Apple MLX Team - For creating the MLX framework
• Rust Community - For the amazing language and tools
• Hugging Face - For model weights and architectures
• All Contributors