SciRS2 is a comprehensive scientific computing and AI/ML infrastructure in Rust, providing SciPy-compatible APIs while leveraging Rust's performance, safety, and concurrency features. The project aims to provide a complete ecosystem for scientific computing, data analysis, and machine learning in Rust.

• Linear Algebra: Matrix operations, decompositions, eigensolvers, and specialized matrix types
• Statistics: Distributions, descriptive statistics, tests, and regression models
• Optimization: Unconstrained and constrained optimization, root finding, and least squares
• Integration: Numerical integration, ODE solvers, and boundary value problems
• Interpolation: Linear, spline, and multi-dimensional interpolation
• Special Functions: Mathematical special functions including Bessel, gamma, and elliptic functions
• Signal Processing: FFT, wavelet transforms, filtering, and spectral analysis
• Sparse Matrices: Multiple sparse matrix formats and operations
• Spatial Algorithms: Distance calculations, KD-trees, and spatial data structures

• N-dimensional Image Processing: Filtering, feature detection, and segmentation
• Clustering: K-means, hierarchical, and density-based clustering
• I/O Utilities: Scientific data format reading and writing
• Sample Datasets: Data generation and loading tools

• Automatic Differentiation: Reverse-mode and forward-mode autodiff engine
• Neural Networks: Layers, optimizers, and model architectures
• Graph Processing: Graph algorithms and data structures
• Data Transformation: Feature engineering and normalization
• Metrics: Evaluation metrics for ML models
• Text Processing: Tokenization and text analysis tools
• Computer Vision: Image processing and feature detection
• Time Series: Analysis and forecasting tools

• Memory Management: Efficient handling of large datasets
• GPU Acceleration: CUDA and hardware-agnostic backends for computation
• Parallelization: Multi-core processing for compute-intensive operations
• Safety: Memory safety and thread safety through Rust's ownership model
• Type Safety: Strong typing and compile-time checks
• Error Handling: Comprehensive error system with context

• Create a comprehensive scientific computing and machine learning library in Rust
• Maintain API compatibility with SciPy where reasonable
• Provide specialized tools for AI and machine learning development
• Leverage Rust's performance, safety, and concurrency features
• Build a sustainable open-source ecosystem for scientific and AI computing in Rust
• Offer performance similar to or better than Python-based solutions
• Provide a smooth migration path for SciPy users

SciRS2 adopts a modular architecture with separate crates for different functional areas, using Rust's workspace feature to manage them:

/
# Core Scientific Computing Modules
├── Cargo.toml                # Workspace configuration
├── scirs2-core/              # Core utilities and common functionality
├── scirs2-linalg/            # Linear algebra module
├── scirs2-integrate/         # Numerical integration
├── scirs2-interpolate/       # Interpolation algorithms
├── scirs2-optimize/          # Optimization algorithms
├── scirs2-fft/               # Fast Fourier Transform
├── scirs2-stats/             # Statistical functions
├── scirs2-special/           # Special mathematical functions
├── scirs2-signal/            # Signal processing
├── scirs2-sparse/            # Sparse matrix operations
├── scirs2-spatial/           # Spatial algorithms

# Advanced Modules
├── scirs2-cluster/           # Clustering algorithms
├── scirs2-ndimage/           # N-dimensional image processing
├── scirs2-io/                # Input/output utilities
├── scirs2-datasets/          # Sample datasets and loaders

# AI/ML Modules
├── scirs2-autograd/          # Automatic differentiation engine
├── scirs2-neural/            # Neural network building blocks
├── scirs2-optim/             # ML-specific optimization algorithms
├── scirs2-graph/             # Graph processing algorithms
├── scirs2-transform/         # Data transformation utilities
├── scirs2-metrics/           # ML evaluation metrics
├── scirs2-text/              # Text processing utilities
├── scirs2-vision/            # Computer vision operations
├── scirs2-series/            # Time series analysis

# Main Integration Crate
└── scirs2/                   # Main integration crate
    ├── Cargo.toml
    └── src/
        └── lib.rs            # Re-exports from all other crates

This modular architecture offers several advantages:

• Flexible Dependencies: Users can select only the features they need
• Independent Development: Each module can be developed and tested separately
• Clear Separation: Each module focuses on a specific functional area
• No Circular Dependencies: Clear hierarchy prevents circular dependencies
• AI/ML Focus: Specialized modules for machine learning and AI workloads
• Feature Flags: Granular control over enabled functionality
• Memory Efficiency: Import only what you need to reduce overhead

The core module (scirs2-core) provides several advanced features that are leveraged across the ecosystem:

use scirs2_core::gpu::{GpuContext, GpuBackend, GpuBuffer};

// Create a GPU context with the default backend
let ctx = GpuContext::new(GpuBackend::default())?;

// Allocate memory on the GPU
let mut buffer = ctx.create_buffer::<f32>(1024);

// Execute a computation
ctx.execute(|compiler| {
    let kernel = compiler.compile(kernel_code)?;
    kernel.set_buffer(0, &mut buffer);
    kernel.dispatch([1024, 1, 1]);
    Ok(())
})?;

use scirs2_core::memory::{ChunkProcessor2D, BufferPool, ZeroCopyView};

// Process large arrays in chunks
let mut processor = ChunkProcessor2D::new(&large_array, (1000, 1000));
processor.process_chunks(|chunk, coords| {
    // Process each chunk...
});

// Reuse memory with buffer pools
let mut pool = BufferPool::<f64>::new();
let mut buffer = pool.acquire_vec(1000);
// Use buffer...
pool.release_vec(buffer);

use scirs2_core::memory::metrics::{track_allocation, generate_memory_report};
use scirs2_core::profiling::{Profiler, Timer};

// Track memory allocations
track_allocation("MyComponent", 1024, 0x1000);

// Time a block of code
let timer = Timer::start("matrix_multiply");
// Do work...
timer.stop();

// Print profiling report
Profiler::global().lock().unwrap().print_report();

Each module has its own README with detailed documentation and is available on crates.io:

• scirs2: Main integration crate

• scirs2-core: Core utilities and common functionality
• scirs2-linalg: Linear algebra module
• scirs2-integrate: Numerical integration
• scirs2-interpolate: Interpolation algorithms
• scirs2-optimize: Optimization algorithms
• scirs2-fft: Fast Fourier Transform
• scirs2-stats: Statistical functions
• scirs2-special: Special mathematical functions
• scirs2-signal: Signal processing
• scirs2-sparse: Sparse matrix operations
• scirs2-spatial: Spatial algorithms

• scirs2-cluster: Clustering algorithms
• scirs2-ndimage: N-dimensional image processing
• scirs2-io: Input/output utilities
• scirs2-datasets: Sample datasets and loaders

• scirs2-autograd: Automatic differentiation engine
• scirs2-neural: Neural network building blocks
• scirs2-optim: ML-specific optimization algorithms
• scirs2-graph: Graph processing algorithms
• scirs2-transform: Data transformation utilities
• scirs2-metrics: ML evaluation metrics
• scirs2-text: Text processing utilities
• scirs2-vision: Computer vision operations
• scirs2-series: Time series analysis

We follow a phased approach:

1. Core functionality analysis: Identify key features and APIs of each SciPy module
2. Prioritization: Begin with highest-demand modules (linalg, stats, optimize)
3. Interface design: Balance Rust idioms with SciPy compatibility
4. Scientific computing foundation: Implement core scientific computing modules first
5. Advanced modules: Implement specialized modules for advanced scientific computing
6. AI/ML infrastructure: Develop specialized tools for AI and machine learning
7. Integration and optimization: Ensure all modules work together efficiently
8. Ecosystem development: Create tooling, documentation, and community resources

All modules in the SciRS2 ecosystem are expected to leverage functionality from scirs2-core:

• Validation: Use scirs2-core::validation for parameter checking
• Error Handling: Base module-specific errors on scirs2-core::error::CoreError
• Numeric Operations: Use scirs2-core::numeric for generic numeric functions
• Optimization: Use core-provided performance optimizations:
  • SIMD operations via scirs2-core::simd
  • Parallelism via scirs2-core::parallel
  • Memory management via scirs2-core::memory
  • Caching via scirs2-core::cache

SciRS2 uses workspace inheritance for consistent dependency versioning:

• All shared dependencies are defined in the root Cargo.toml
• Module crates reference dependencies with workspace = true
• Feature-gated dependencies use workspace = true with optional = true

# In workspace root Cargo.toml
[workspace.dependencies]
ndarray = { version = "0.16.1", features = ["serde", "rayon"] }
num-complex = "0.4.3"
rayon = "1.7.0"

# In module Cargo.toml
[dependencies]
ndarray = { workspace = true }
num-complex = { workspace = true }
rayon = { workspace = true, optional = true }

[features]
parallel = ["rayon"]

SciRS2 leverages the Rust ecosystem:

• ndarray: Multidimensional array operations
• num: Numeric abstractions
• rayon: Parallel processing
• rustfft: Fast Fourier transforms
• ndarray-linalg: Linear algebra computations
• argmin: Optimization algorithms
• rand and rand_distr: Random number generation and distributions

• tch-rs: Bindings to the PyTorch C++ API
• burn: Pure Rust neural network framework
• tokenizers: Fast tokenization utilities
• image: Image processing utilities
• petgraph: Graph algorithms and data structures

SciRS2 and all its modules are available on crates.io. You can add them to your project using Cargo:

# Add the main integration crate for all functionality
[dependencies]
scirs2 = "0.1.0-alpha.4"

Or include only the specific modules you need:

[dependencies]
# Core utilities
scirs2-core = "0.1.0-alpha.4"

# Scientific computing modules
scirs2-linalg = "0.1.0-alpha.4"
scirs2-stats = "0.1.0-alpha.4"
scirs2-optimize = "0.1.0-alpha.4"

# AI/ML modules
scirs2-neural = "0.1.0-alpha.4"
scirs2-autograd = "0.1.0-alpha.4"

// Using the main integration crate
use scirs2::prelude::*;
use ndarray::Array2;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a matrix
    let a = Array2::from_shape_vec((3, 3), vec![
        1.0, 2.0, 3.0,
        4.0, 5.0, 6.0,
        7.0, 8.0, 9.0
    ])?;
    
    // Perform matrix operations
    let (u, s, vt) = scirs2::linalg::decomposition::svd(&a)?;
    
    println!("Singular values: {:.4?}", s);
    
    // Compute the condition number
    let cond = scirs2::linalg::basic::condition(&a, None)?;
    println!("Condition number: {:.4}", cond);
    
    // Generate random samples from a distribution
    let normal = scirs2::stats::distributions::normal::Normal::new(0.0, 1.0)?;
    let samples = normal.random_sample(5, None)?;
    println!("Random samples: {:.4?}", samples);
    
    Ok(())
}

use scirs2_neural::layers::{Dense, Layer};
use scirs2_neural::activations::{ReLU, Sigmoid};
use scirs2_neural::models::sequential::Sequential;
use scirs2_neural::losses::mse::MSE;
use scirs2_neural::optimizers::sgd::SGD;
use ndarray::{Array, Array2};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a simple feedforward neural network
    let mut model = Sequential::new();
    
    // Add layers
    model.add(Dense::new(2, 8)?);
    model.add(ReLU::new());
    model.add(Dense::new(8, 4)?);
    model.add(ReLU::new());
    model.add(Dense::new(4, 1)?);
    model.add(Sigmoid::new());
    
    // Compile the model
    let loss = MSE::new();
    let optimizer = SGD::new(0.01);
    model.compile(loss, optimizer);
    
    // Create dummy data
    let x = Array2::from_shape_vec((4, 2), vec![
        0.0, 0.0,
        0.0, 1.0,
        1.0, 0.0,
        1.0, 1.0
    ])?;
    
    let y = Array2::from_shape_vec((4, 1), vec![
        0.0,
        1.0,
        1.0,
        0.0
    ])?;
    
    // Train the model
    model.fit(&x, &y, 1000, Some(32), Some(true));
    
    // Make predictions
    let predictions = model.predict(&x);
    println!("Predictions: {:.4?}", predictions);
    
    Ok(())
}

use scirs2_core::gpu::{GpuContext, GpuBackend};
use scirs2_linalg::batch::matrix_multiply_gpu;
use ndarray::Array3;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create GPU context
    let ctx = GpuContext::new(GpuBackend::default())?;
    
    // Create batch of matrices (batch_size x m x n)
    let a_batch = Array3::<f32>::ones((64, 128, 256));
    let b_batch = Array3::<f32>::ones((64, 256, 64));
    
    // Perform batch matrix multiplication on GPU
    let result = matrix_multiply_gpu(&ctx, &a_batch, &b_batch)?;
    
    println!("Batch matrix multiply result shape: {:?}", result.shape());
    
    Ok(())
}

The following SciRS2 modules are considered stable with well-tested core functionality:

• Linear Algebra Module (scirs2-linalg): Basic matrix operations, decompositions, eigenvalue problems
• Statistics Module (scirs2-stats): Descriptive statistics, distributions, statistical tests, regression
• Optimization Module (scirs2-optimize): Unconstrained & constrained optimization, least squares, root finding
• Integration Module (scirs2-integrate): Numerical integration, ODE solvers
• Interpolation Module (scirs2-interpolate): 1D & ND interpolation, splines
• Signal Processing (scirs2-signal): Filtering, convolution, spectral analysis, wavelets
• FFT Module (scirs2-fft): FFT, inverse FFT, real FFT, DCT, DST, Hermitian FFT
• Sparse Matrix (scirs2-sparse): CSR, CSC, COO, BSR, DIA, DOK, LIL formats and operations
• Special Functions (scirs2-special): Gamma, Bessel, elliptic, orthogonal polynomials
• Spatial Algorithms (scirs2-spatial): KD-trees, distance calculations, convex hull, Voronoi diagrams
• Clustering (scirs2-cluster): K-means, hierarchical clustering, DBSCAN
• Data Transformation (scirs2-transform): Feature engineering, normalization
• Evaluation Metrics (scirs2-metrics): Classification, regression metrics

The following modules are in preview state and may undergo API changes:

• N-dimensional Image Processing (scirs2-ndimage): Filtering, morphology, measurements
• I/O utilities (scirs2-io): MATLAB, WAV, ARFF file formats, CSV
• Datasets (scirs2-datasets): Sample datasets and loaders

• Automatic Differentiation (scirs2-autograd): Tensor ops, neural network primitives
• Neural Networks (scirs2-neural): Layers, activations, loss functions
• ML Optimization (scirs2-optim): Optimizers, schedulers, regularization
• Graph Processing (scirs2-graph): Graph algorithms and data structures
• Text Processing (scirs2-text): Tokenization, vectorization, word embeddings
• Computer Vision (scirs2-vision): Image processing, feature detection
• Time Series Analysis (scirs2-series): Decomposition, forecasting

• GPU Acceleration with backend abstraction layer (CUDA, WebGPU, Metal)
• Memory Management for large-scale computations
• Logging and Diagnostics with progress tracking
• Profiling with timing and memory tracking
• Memory Metrics for detailed memory usage analysis
• Optimized SIMD Operations for performance-critical code

We are currently working on:

• Integrating advanced core features across all modules
• Performance optimization and benchmarking
• Comprehensive documentation and examples
• API refinement based on community feedback

All SciRS2 modules have been published to crates.io as alpha releases (0.1.0-alpha.3), making the entire ecosystem available to the Rust community while development continues.

• Alpha Release (0.1.0-alpha.1): Initial modules released on crates.io (April 2025)
• Alpha Release (0.1.0-alpha.2): All modules released on crates.io (May 2025)
• Alpha Release (0.1.0-alpha.3): Fixed memory metrics snapshot system and updated tests (May 2025)
• Alpha Release (0.1.0-alpha.4): Improved unittests and examples (June 2025)
• Beta Release (0.1.0-beta.1): Planned after incorporating feedbacks (July 2025)
• First Stable Release (0.1.0): Targeted after API stabilization and comprehensive testing (August 2025)

For a detailed development roadmap, check the TODO.md file.

SciRS2 prioritizes performance through several strategies:

• SIMD Vectorization: CPU vector instructions for numerical operations
• Cache Efficiency: Algorithms designed for modern CPU cache hierarchies
• GPU Acceleration: Hardware acceleration for compute-intensive operations
• Memory Management: Efficient allocation strategies for large datasets
• Parallelism: Multi-core utilization via Rayon
• Zero-cost Abstractions: Rust's compiler optimizations eliminate runtime overhead

Initial benchmarks on core operations show performance comparable to or exceeding NumPy/SciPy:

Note: Performance may vary based on hardware, compiler optimization, and specific workloads.

Contributions are welcome! Please see our CONTRIBUTING.md for guidelines.

• Core Algorithm Implementation: Implementing remaining algorithms from SciPy
• Performance Optimization: Improving performance of existing implementations
• Documentation: Writing examples, tutorials, and API documentation
• Testing: Expanding test coverage and creating property-based tests
• Integration with Other Ecosystems: Python bindings, WebAssembly support
• Domain-Specific Extensions: Financial algorithms, geospatial tools, etc.

See our TODO.md for specific tasks and project roadmap.

This project is dual-licensed under:

• MIT License
• Apache License Version 2.0

You can choose to use either license. See the LICENSE file for details.

SciRS2 builds on the shoulders of giants:

• The SciPy and NumPy communities for their pioneering work
• The Rust ecosystem and its contributors
• The numerous mathematical and scientific libraries that inspired this project

• Extended Hardware Support: ARM, RISC-V, mobile, embedded
• Cloud Deployment: Container optimization, serverless function support
• Domain-Specific Extensions: Finance, bioinformatics, physics
• Ecosystem Integration: Python and Julia interoperability
• Performance Monitoring: Runtime analyzers, configuration optimizers
• Automated Architecture Selection: Hardware-aware algorithm choices

For more detailed information on development status and roadmap, check the TODO.md file.