-
hf-hub
Rust client for the Hugging Face Hub API
-
rmcp
Rust SDK for Model Context Protocol
-
safetensors
functions to read and write safetensors which aim to be safer than their PyTorch counterpart. The format is 8 bytes which is an unsized int, being the size of a JSON header, the JSON…
-
ort
A safe Rust wrapper for ONNX Runtime 1.24 - Optimize and accelerate machine learning inference & training
-
burn
Flexible and Comprehensive Deep Learning Framework in Rust
-
tract-onnx
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
tiktoken-rs
encoding and decoding with the tiktoken library in Rust
-
candle-nn
Minimalist ML framework
-
lance
A columnar data format that is 100x faster than Parquet for random access
-
tch
Rust wrappers for the PyTorch C++ api (libtorch)
-
ollama-rs
interacting with the Ollama API
-
mlx-rs
Unofficial rust wrapper for Apple's mlx machine learning library
-
smartcore
Machine Learning in Rust
-
rten
Machine learning runtime
-
linfa
A Machine Learning framework for Rust
-
candle-transformers
Minimalist ML framework
-
systemstat
Get system information/statistics in a cross-platform way
-
rstats
Statistics, Information Measures, Data Analysis, Linear Algebra, Clifford Algebra, Machine Learning, Geometric Median, Matrix Decompositions, Mahalanobis Distance, Hulls, Multithreading
-
rv
Random variables
-
openvino
High-level bindings for OpenVINO
-
lightgbm3
Rust bindings for LightGBM library
-
google-tpu1
A complete library to interact with TPU (protocol v1)
-
rstructor
Rust equivalent of Python's Instructor + Pydantic: Extract structured, validated data from LLMs (OpenAI, Anthropic, Grok, Gemini) using type-safe Rust structs and enums
-
google-ml1-cli
A complete library to interact with Cloud Machine Learning Engine (protocol v1)
-
ferrotorch-nn
Neural network modules for ferrotorch — layers, losses, initialization
-
dlpark
dlpack Rust binding for Python
-
mistralrs
Fast, flexible LLM inference
-
surrealml-core
The core machine learning library for SurrealML that enables SurrealDB to store and load ML models
-
scirs2-series
Time series analysis module for SciRS2 (scirs2-series)
-
fsrs
including Optimizer and Scheduler
-
ruvllm
LLM serving runtime with Ruvector integration - Paged attention, KV cache, and SONA learning
-
ruvector-attention
Attention mechanisms for ruvector - geometric, graph, and sparse attention
-
cuvs
RAPIDS vector search library
-
petal-clustering
A collection of clustering algorithms
-
flodl
— a flow-graph deep learning framework built on libtorch
-
irithyll
Streaming ML in Rust -- gradient boosted trees, neural architectures (TTT/KAN/MoE/Mamba/SNN), AutoML, kernel methods, and composable pipelines
-
constriction
Entropy coders for research and production (Rust and Python)
-
cueward-cli
CLI for capturing and searching local knowledge from macOS native sources
-
xgb
Machine learning using XGBoost
-
perpetual
A self-generalizing gradient boosting machine that doesn't need hyperparameter optimization
-
hdbscan
clustering in pure Rust. A huge improvement on DBSCAN, capable of identifying clusters of varying densities.
-
lance-bitpacking
Vendored copy of https://github.com/spiraldb/fastlanes for use in Lance
-
axonml-nn
Neural network modules for Axonml ML framework
-
heddle-objects
An AI-native version control system
-
cervo-cli
High level APIs for RL in games
-
aws-sdk-marketplacecatalog
AWS SDK for AWS Marketplace Catalog Service
-
birdnet-onnx
Bird species detection using BirdNET, Perch, and BSG Finland ONNX models
-
pc-rl-core
Predictive Coding Actor-Critic reinforcement learning framework — pure Rust, zero ML dependencies
-
renegade-ml
Zero-config nonparametric supervised learning — KNN with auto-tuned K, metric learning, and VP-tree indexing
-
oar-ocr
An Optical Character Recognition (OCR) and Document Layout Analysis library written in Rust
-
zyx
Zyx machine learning library
-
pmetal-metal
Metal GPU compute kernels for PMetal - FlashAttention and optimized ML primitives
-
tract-onnx-opl
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
aprender
Next-generation ML framework in pure Rust —
cargo install aprenderfor theaprCLI -
ocrs
OCR engine
-
genetic_algorithms
solving genetic algorithm problems
-
papers-cli
CLI for academic paper search, management, and local RAG
-
kenosis-cli
CLI for ONNX model quantization, casting, inspection, and comparison — powered by kenosis-core
-
lle
Cooperative MARL environment based on laser-blocking
-
lowfat
CLI binary for lowfat
-
lace
A probabilistic cross-categorization engine
-
gam
Generalized penalized likelihood engine
-
mcp-core
implementing the Modern Context Protocol (MCP)
-
forust-ml
A lightweight gradient boosting implementation in Rust
-
discorec
Recommendations for Rust using collaborative filtering
-
monkeyfetch
a CLI tool to fetch your monkeytype stats and pretty-print them
-
easy-ml
Machine learning library providing matrices, named tensors, linear algebra and automatic differentiation aimed at being easy to use
-
langdb_clust
An unofficial Rust client for the Anthropic/Claude API
-
tensorflow
Rust language bindings for TensorFlow
-
ck-embed
Text embedding providers for ck semantic search
-
mamba-rs
Mamba SSM and Mamba-3 SISO in Rust with optional CUDA GPU acceleration. Inference and training (BPTT through SSM state, AdamW), CPU + GPU paths, custom CUDA kernels, CUDA Graph capture…
-
kornia-tensor
Lightweight tensor library in Rust for computer vision
-
miniplan
A PDDL planner library built around the pddl crate, with grounding and search utilities
-
metatensor
Self-describing sparse tensor data format for atomistic machine learning and beyond
-
hf-fetch-model
Download, inspect, and compare HuggingFace models from Rust. Multi-connection parallel downloads plus safetensors header inspection via HTTP Range. No weight data downloaded.
-
ngboost-rs
Natural Gradient Boosting for Probabilistic Prediction - A Rust implementation of NGBoost
-
scandir
A fast file tree scanner written in Rust
-
terraphim-session-analyzer
Analyze AI coding assistant session logs to identify agent usage patterns
-
is-it-slop
Detect AI-generated slop text using machine learning
-
autogpt
🦀 A Pure Rust Framework For Building AGIs
-
freebsd-geom-exporter
Prometheus exporter for FreeBSD's GEOM device statistics
-
coglet
High-performance prediction server for Cog ML models
-
noru
Zero-dependency NNUE training & inference library in pure Rust
-
zen
A modal Kanban TUI for personal task management
-
petite-ad
A lightweight automatic differentiation library for learning and educational purposes
-
bhtsne
Exact and Barnes-Hut implementations of t-SNE
-
web-rwkv
RWKV language model in pure WebGPU
-
lgbm
Unofficial Rust bindings for LightGBM
-
ztensor
Unified, zero-copy, and safe I/O for deep learning formats
-
dfdx
Ergonomic auto differentiation in Rust, with pytorch like apis
-
lele
Bare-metal machine learning inference library in Rust
-
lance-datafusion
Internal utilities used by other lance modules to simplify working with datafusion
-
iron_learn
ML library with GPU-accelerated gradient descent. Supports tensors, complex numbers, linear/logistic regression, and CUDA optimization.
-
candle-optimisers
Optimisers for use with candle, the minimalist ML framework
-
scirs2-datasets
Datasets module for SciRS2 (scirs2-datasets)
-
ruvector-gnn
Graph Neural Network layer for Ruvector on HNSW topology
-
rustyml
A high-performance machine learning & deep learning library in pure Rust, offering ML algorithms and neural network support
-
annembed
dimension reduction à la Umap
-
rstsr-kml-ffi
Huawei Kunpeng Math Library FFI bindings
-
blots
A small, simple, expression-oriented programming language
-
cjc-ast
Abstract syntax tree definitions for CJC
-
boostr
ML framework built on numr - attention, quantization, model architectures
-
libdd-trace-stats
compute stats from Datadog traces
-
underthesea_core
Underthesea Core
-
rustorch
Production-ready PyTorch-compatible deep learning library in Rust with special mathematical functions (gamma, Bessel, error functions), statistical distributions, Fourier transforms (FFT/RFFT)…
-
libsvm-rs
FFI-free Rust implementation of LIBSVM-compatible SVM training and prediction
-
native_neural_network
Lib no_std Rust for native neural network (.rnn)
-
dlpk
DLPack integration for Rust
-
neat
working with NEAT in rust
-
kmedoids
k-Medoids clustering with the FasterPAM algorithm
-
mmd-mpl
MPL is a rule-based Domain-Specific Language for creating MMD poses and animations using natural semantic syntax
-
nexus-inference
ML inference engine for pre-trained models
-
darjeeling
Machine learning tools for rust. Currently comprising of categorization and generation neural network model training
-
runnx
A minimal, verifiable ONNX runtime implementation in Rust
-
torch-sys
Low-level FFI bindings for the PyTorch C++ api (libtorch)
-
ara2
Rust client library for the Kinara ARA-2 neural network accelerator on NXP i.MX platforms
-
executorch
Rust bindings for ExecuTorch - On-device AI across mobile, embedded and edge for PyTorch
-
bfi
Print a configurable list of info about a file or directory
-
toktrie
LLM Token Trie library
-
metco
Metrics Collector inspired by StatsD
-
xq-vision
High-performance ONNX recognition pipeline for Chinese chessboard corners and pieces
-
yscv-quantize-cli
Post-training quantization CLI: calibrate fp32 ONNX + sample inputs into a QDQ-format INT8 model
-
ask-sh
An AI command line assistant, which is context-aware and multi-turn capable
-
peregrine-ml
A from-scratch deep learning library in Rust — tensors, autograd, NEON SIMD, Metal GPU, and working models
-
lattice-tune
Training infrastructure for Lattice neural models
-
kornia
low-level 3D computer vision library in Rust
-
axonml-tensor
N-dimensional tensor operations for the Axonml ML framework
-
asteria
Safe Rust. No Deps. RL for the CPU.
-
fast-umap
Configurable UMAP (Uniform Manifold Approximation and Projection) in Rust
-
cp2k-rs
Rust bindings for CP2K with Python interface
-
gbdt
Gradient Boosting Regression Tree in Rust programming language
-
burn-onnx
importing ONNX models into the Burn framework
-
crfsuite-compliant-rs
Pure Rust implementation of CRFsuite (Conditional Random Fields) for labeling sequential data
-
cv-convert
Type conversions among famous Rust computer vision libraries
-
linfa-clustering
A collection of clustering algorithms
-
rust-bert
Ready-to-use NLP pipelines and language models
-
tl-lang
A differentiable programming language with tensor support for machine learning
-
similari-trackers-rs
Machine learning framework for building object trackers and similarity search engines
-
onnx-extractor
Lightweight ONNX model parser for extracting tensor shapes, operations, and data
-
qwen_tts
Qwen3-TTS text-to-speech model implementation for Candle
-
os-checker
Run a collection of checkers targeting Rust crates, and report bad checking results and statistics
-
llms-from-scratch-rs
Rust (candle) code for Build a LLM From Scratch by Sebastian Raschka
-
itransformer
models
-
faiss-next
Rust bindings for Faiss (Facebook AI Similarity Search)
-
metalog
probability distribution library and CLI
-
metal-candle
Production-quality Rust ML crate for Apple Silicon - LoRA training, inference, and text generation using Candle with Metal backend
-
ainl-runtime
AINL unified-graph orchestration: load/validate memory artifacts, compile turn context, minimal graph walk, extraction scheduling, host TurnHooks, and optional Tokio run_turn_async…
-
neurons
Neural networks from scratch, in Rust
-
pav_regression
The pair adjacent violators algorithm for isotonic regression
-
rustnn
W3C WebNN implementation with ONNX, CoreML, and TensorRT backends [DO NOT USE IN PRODUCTION - Development Release]
-
xlog-prob
Probabilistic inference engines for XLOG
-
secretary
Transform natural language into structured data using large language models (LLMs) with powerful derive macros
-
ndatafusion
Extensions and support for linear algebra in DataFusion
-
shlf
Empower Development Journey with AI-Driven Tools
-
pyroduct
Dual trust computation framework
-
wifi-densepose-signal
WiFi CSI signal processing for DensePose estimation
-
rustorch-nn
Neural network modules for RusTorch
-
multiscreen-rs
Multiscreen neural language model — training and inference powered by Burn
-
peft-rs
Comprehensive PEFT (Parameter-Efficient Fine-Tuning) adapter library for Rust
-
tlparse
Parse TORCH_LOG logs produced by PyTorch torch.compile
-
quill-mlx
Rust bindings for Apple's MLX machine learning framework, with Metal memory management
-
prolog-squared
A Meta-Interpretive Learning framework implementing second-order SLD resolution
-
rust-lstm
A complete LSTM neural network library with training capabilities, multiple optimizers, and peephole variants
-
qex-mcp
Lightweight MCP server for semantic code search — BM25 + optional dense vectors + tree-sitter chunking
-
gengo
Get the language distribution stats of your repository
-
onnx-infer
Pure Rust ONNX inference engine for computer vision models
-
randomforest
Random forest regressor and classifier
-
karma
A sophisticated Hidden Markov Model (HMM) implementation using the Baum-Welch algorithm
-
smelt-ml
Machine learning framework with spatial modeling, conformal prediction, and gradient boosting competitive with C++
-
deep-delta-learning
Rust MVP implementation of Deep Delta Learning on Burn
-
rsmultigit
Manage multiple git repositories at once
-
kmeans_uni
Fast, safe K-Means++ with SIMD acceleration, mini-batch training and WASM support
-
komando
A command line utility to better organize and keep track of your commands
-
rusty_scrfd
A high-performance face detection library using SCRFD model with OpenCV integration
-
gguf-rs-lib
reading and writing GGUF (GGML Universal Format) files
-
concision
toolkit for designing machine-learning models in Rust
-
octoroute
Intelligent multi-model router for self-hosted LLMs
-
nnlang
Compiler for the NNLang (Neural Network Language)
-
scrat
Release management tooling focused on sanity retention
-
liboxen
Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust
-
embellama
High-performance Rust library for generating text embeddings using llama-cpp
-
terraphim_tracker
Issue tracker abstraction for Gitea and Linear with PageRank support
-
catgrad
a categorical deep learning compiler
-
hermes-llm
LLM training from scratch using Candle
-
car-reason
Code reasoning engine for Common Agent Runtime — adaptive, graph-driven, learning
-
rusty-logging
Logging for OpsML
-
airust
Trainable, modular AI engine in Rust with compile-time knowledge
-
bitnet-core
Core BitNet implementation with fundamental data structures and algorithms
-
seqpacker
High-performance sequence packing for LLM training
-
arrowspace
Graph Wiring for embeddings using physical networks wiring. Provides graph analysis, vector search and a energy-distribution stats.
-
redeem-properties
A repository of deep-learning peptide property prediction models for mass spectrometry data
-
rumus
A native-Rust deep learning framework with explicit memory safety and hardware acceleration
-
relayrl_framework
A system-oriented multi-agent reinforcement learning framework
-
sectxt
working with security.txt files as specified in RFC 9116
-
rns-hooks-abi
Shared ABI definitions for rns-hooks host and SDK
-
bunsen
acceleration tooling for burn
-
minimum_ml
Experimental Machine Learning Library
-
hodu
A user-friendly ML framework built in Rust for rapid prototyping and embedded deployment
-
sonr
High-performance semantic search tool for local codebases
-
lift-tensor
AI dialect — tensor types, attention, KV cache, MoE, quantisation
-
rstsr
An n-Dimension Rust Tensor Toolkit
-
openni2
Rust interface to OpenNI2
-
ferrotorch-optim
Optimizers and learning rate schedulers for ferrotorch
-
mosec
Model Serving made Efficient in the Cloud
-
vernier-panoptic
Panoptic-quality (PQ) evaluation for the vernier evaluation library (ADR-0025)
-
weirwood
Privacy-preserving XGBoost inference via Fully Homomorphic Encryption
-
tract-pulse
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
mech-stats
Statistics library for the Mech language
-
rsomics-compute-matrix
bigWig signal → score matrix over BED regions — Rust port of deeptools computeMatrix
-
dipstick
Fast, all-purpose metrics library decoupling instrumentation from reporting backends. Like logging frameworks but with counters, timers and gauges. Supports combined outputs (e.g…
-
aphelion-core
Core library for Aphelion AI framework - unified frontend for AI model development
-
trtx
Safe Rust bindings to NVIDIA TensorRT-RTX (EXPERIMENTAL - NOT FOR PRODUCTION)
-
ocl-convolution
OpenCL-accelerated 2D convolutions
-
axonml-data
Data loading utilities for the Axonml ML framework
-
cake-cli
Distributed LLM inference for mobile, desktop and server
-
finalfusion
Reader and writer for common word embedding formats
-
llama-cpp-sys-2
Low Level Bindings to llama.cpp
-
depyler-oracle
ML-powered compile error classification and auto-fixing using aprender models
-
gitnapped
Find out why you didn't sleep – a Git commit timeline analyzer
-
nps-ndp
NPS — Neural Discovery Protocol frames and in-memory registry + announce validator
-
tsetlin-rs
A professional Rust implementation of the Tsetlin Machine algorithm
-
hextral
Comprehensive neural network library with dataset loading, batch normalization, 9 activation functions, 5 loss functions, multiple optimizers, regularization, and clean async-first API
-
gg-github
A Github CLI tool to make it easier to get where you want to go on Github.com
-
mlx-models
Model architectures and weight loading for mlx-server (LLaMA, Mistral, Qwen2/3)
-
lgp
CLI for Linear Genetic Programming experiments
-
anamnesis
Parse any tensor format, recover any precision — framework-agnostic FP8/GPTQ/AWQ/BnB dequantization, NPZ parsing, and PyTorch .pth conversion for Rust
-
oaxaca_blinder
performing Oaxaca-Blinder decomposition on Polars DataFrames, with support for categorical variables and bootstrapped standard errors
-
runnt
Easy Neural Network for machine learning
-
plural2bin
Plural data recovery
-
symbios-neat
NEAT engine for morphogenetic engineering with CPPN support
-
train-station
A high-performance, PyTorch inspired, zero dependency Rust machine learning library
-
jon
Natural language interface for Joy and Jot - CLI, TUI, and desktop app
-
meganeura
E-graph optimized neural network training on Blade
-
tensorrs
Tensors is a lightweight machine learning library in Rust
-
shapels
Shape inference for torch on your editor
-
ghostflow-core
Core tensor operations for GhostFlow ML framework - optimized for maximum performance
-
hstats
Online histogram statistics calculations
-
edgefirst-hal
EdgeFirst Hardware Abstraction Layer for edge AI inference pipelines
-
mecha10-nodes-behavior-executor
Behavior tree executor node for autonomous robot behaviors
-
border
Reinforcement learning library
-
veloxx
High-performance, lightweight Rust library for in-memory data processing and analytics. Features DataFrames, Series, advanced I/O (CSV, JSON, Parquet), machine learning (linear regression…
-
rf-detr-ort
High-performance RF-DETR object detection inference via ONNX Runtime (TensorRT / CUDA / CPU)
-
instmodel_inference
High-performance neural network inference library with instruction-based execution
-
onnxruntime
Wrapper around Microsoft's ONNX Runtime
-
chromaframe-sdk
Deterministic, privacy-preserving color measurement and ranking SDK
-
coreml-native
Safe, ergonomic Rust bindings for Apple CoreML inference with ANE acceleration
-
ember-rl
Reinforcement learning algorithm implementations (DQN, PPO, SAC) using Burn
-
hdbscan-rs
HDBSCAN clustering algorithm, compatible with scikit-learn
-
morok-onnx
ONNX model importer for the Morok ML compiler
-
asimov-runner
ASIMOV Software Development Kit (SDK) for Rust
-
csep
Cosine Similarity Embeddings Print
-
prodex-codex-config
Codex config parsing helpers for prodex
-
ochat
A chatbot cli that uses Ollama AIs
-
ffsvm
A libSVM compatible support vector machine, but up to 10x faster, for games or VR
-
foray
Persistent, forkable investigation journals via MCP
-
syft-git
Git bridge helpers for syft
-
meuron
modular neural network library written in rust for training simple neural networks
-
plskit
PLS regression with modern inference. Rust implementation; the same engine drives the Python, R, and Julia wrappers.
-
tantale
Automated Machine Learning (AutoML) focusing on Hyperparameter Optimization and Neural Architecture Search. It provides a modular and extensible framework for defining search spaces…
-
yolo-rs
YOLO object detection model in Rust. Currently on YOLO v11.
-
psycho-killer
Interactive process killer, manager and system resources monitor
-
calib-targets-chessboard
Invariant-first chessboard detector built on top of ChESS corners
-
ml-launcher
machine-learning train
-
hf-mem
CLI to estimate inference memory requirements from the Hugging Face Hub
-
xlog-logic
Parser, compiler, and optimizer for XLOG logic programs
-
velox_graph
VeloxGraph is an extremely fast, efficient, low-level, in-memory, minimal graph database (wow, that is a mouth full). It is not revolutionary in its design but has a few key features…
-
space_trav_lr_rust
Spatial gene regulatory network inference and in-silico perturbation (Rust port of SpaceTravLR)
-
picard-ica
Fast Independent Component Analysis using preconditioned L-BFGS optimization
-
fastkmeans-rs
A fast and efficient k-means clustering implementation in Rust, compatible with ndarray
-
manopt-rs
A high-performance Rust library for manifold optimization built on the Burn deep learning framework
-
lmm
A language agnostic framework for emulating reality
-
ssb
benchmarking for Rust, with hierarchical call tree, based on fastrace
-
mnn-rs
Safe Rust bindings for Alibaba MNN (Mobile Neural Network) inference engine
-
anima-tagger-captioner
Qwen3-VL ONNX image captioner used by anima-tagger, with an OpenAI-compatible HTTP backend as an alternative
-
changepoint
Change Point Detection in Rust
-
ngram-trie
Internal MegaHAL implementation detail; APIs are not stable. Arena-based n-gram frequency trie.
-
microcnn
A minimal CNN framework in Rust with Quantization
-
Rust_Simple_DNN
making optimized modular neural networks in rust
-
perceptron-ai
Rust SDK for Perceptron models
-
diffusion-rs
High level API for stable-diffusion.cpp
-
wildberries_sdk_promotion
Wildberries OpenAPI client (generated)
-
algorithmia
Client for calling algorithms and managing data hosted using Algorithmia
-
harper-stats
The language checker for developers
-
bitpolar
near-optimal vector quantization with zero training overhead — 3-bit precision, provably unbiased inner products (ICLR 2026)
-
autograd
Tensors and differentiable operations in Rust
-
minidx
compile-time-sized neural networks
-
t_trace
High-performance, command-line statistics tracker for your shell
-
catboost-rust
Rust bindings for CatBoost, a gradient boosting library for machine learning. Downloads CatBoost binaries at runtime for cross-platform compatibility.
-
rust-doubao-watermark
豆包 AI 图片去水印命令行工具
-
mistralrs-paged-attn
Fast, flexible LLM inference
-
augurs-prophet
Prophet: time-series forecasting at scale, in Rust
-
ungai
A unique name generator based on Markov Chain
-
proxima-ml
Generic distance and similarity metrics for machine learning
-
rlox-core
Rust-accelerated RL core: VecEnv, replay/prioritized/offline buffers, GAE, V-trace, KL, GRPO, async pipeline
-
kalosm-llama
interface for Llama models
-
nbml
Machine Learning Primitives
-
elara-math-community
Rust-native tensor and math library (community edition)
-
ruvector-sparse-inference
PowerInfer-style sparse inference engine for efficient neural network inference on edge devices
-
optimiz-rs
High-performance optimization algorithms in Rust with Python bindings
-
kbnf
A fast constrained decoding engine based on context free grammar
-
amsterdam
A gateway for observing, routing, and transforming prompts
-
pyo3-hyperspec
Fast hyperspectral processing for remote sensing and machine learning (Python bindings)
-
candle-onnx
ONNX support for Candle
-
consta
Git contribution statistics tool
-
journey-sequencer
Journey Engine: A custom 2D game engine built with Rust and wGPU
-
ctx-config
Configuration loading and defaults for CTX
-
template-switch-statistics
Compute statistics for experiments with tsalign
-
ctranslate2-src-build-support
Build support for ctranslate2-src
-
tensor_optim
A tiny tensor engine lacking compromise on portability
-
isutra
Intelligent command suggestor for your typo or wrong commands
-
cuda-energy
ATP budgets, circadian rhythm, apoptosis, epigenetic memory
-
obelyzk
obelyzk.rs — Verifiable AI engine built on STWO Circle STARKs. Provable inference for every model.
-
betterFANN
Vortex physics-inspired & ground-up redesign of FANN (credit to Steffen Nissen). Its original implementation is described in Nissen's 2003 report Implementation of a Fast Artificial Neural Network Library (FANN).
-
miniml
A minimal, blazing-fast WASM-powered machine learning library with SIMD acceleration
-
perfos
Benchmark parts of your Rust code with stats insights
-
hotcoco
pycocotools — COCO dataset API for object detection, segmentation, and keypoint evaluation
-
entrix
fitness function engine — Rust implementation of tools/entrix
-
hirn-graph
Property graph, spreading activation, and Hebbian learning for hirn
-
bitnet-llm
Safe Rust bindings to Microsoft's BitNet b1.58 inference engine
-
wifi-densepose-wifiscan
Multi-BSSID WiFi scanning domain layer for enhanced Windows WiFi DensePose sensing (ADR-022)
-
rmqtt-session-storage
Connection information, subscription relationships, offline messages, and inflight messages will be stored
-
mecha10-behavior-runtime
Behavior tree runtime for Mecha10 - unified AI and logic composition system
-
plato-cli
PLATO CLI component for the Cognitive Capacity Protocol Network
-
axonml
— a complete ML/AI framework in pure Rust (umbrella crate)
-
bleuscore
A fast bleu score calculator
-
cjc-lang
(Computational Jacobian Core) — a deterministic numerical programming language for reproducible computation, ML pipelines, scientific computing, and physics-informed neural networks
-
biosphere
fast random forests
-
skrytsam
generate pretty svgs for your profile on GitHub
-
lace_cc
Core of the Lace cross-categorization engine library
-
voice-nn
Neural network modules: ALBERT, BiLSTM, vocoder, prosody
-
hashirama
Gemini ai based CLI in the taste of Hashirama Senju
-
datafusion-expr-common
Logical plan and expression representation for DataFusion query engine
-
rollping
A ping time statistics aggregator
-
emotiv
Async Rust client and TUI for Emotiv EEG headsets via the Cortex API WebSocket (JSON-RPC 2.0)
-
rsomics-bam-ampliconstats
Amplicon sequencing statistics from primer BED + BAM — Rust port of samtools ampliconstats
-
native_neural_network_std
Ergonomic std wrapper for the
native_neural_networkcrate (no_std) — std-friendly re-exports and utilities -
qora-fl
Qora: Quorum-Oriented Robust Aggregation for Federated Learning
-
azure_mgmt_machinelearningservices
generated REST API bindings
-
hebb
Spiking-neural-network substrate — pure-Rust, no I/O, embed-anywhere
-
genetic_regression
Nonlinear regresson by genetic algorithm
-
feagi
Framework for Evolutionary Artificial General Intelligence - Bio-Inspired Neural Computation
-
automl
Automated machine learning for classification and regression
-
gbt-quantile
Pure-Rust gradient-boosted trees with quantile regression. First GBT crate with pinball loss, early stopping, and JSON-serializable models.
-
rkhs
Reproducing Kernel Hilbert Space: kernels, MMD, and kernel quantile embeddings (re-exports hopfield for AM)
-
arrow-ml
Optimized tensor operations and machine learning primitives for Apache Arrow
-
tensor-crab
Rust-native ML library. No Python. No GIL. Just speed.
-
zuna-rs
ZUNA EEG Foundation Model — inference in Rust with Burn ML
-
ifpaclient
Async Rust client for the IFPA Pinball API
-
spvirit-scry
capturing and analyzing pvAccess EPICS packets
-
ailed-soulsteal
Fast game data extractor — drains PGN into tokenized training data for ML models. 60K+ games/sec.
-
spars
💥 Disk-based sparse matrix statistics and subsetting 💥
-
genai-media
AI image and video generation CLI — fal.ai + OpenAI
-
dataset-core
A generic, thread-safe dataset container with lazy loading and caching, plus optional utilities and built-in dataset loaders
-
varpulis-pst
Prediction Suffix Tree (PST) for complex event forecasting
-
car-memgine
Memgine — graph-based memory engine for Common Agent Runtime
-
nsr-nodejs
Node.js bindings for the NSR (Neuro-Symbolic Recursive) AI framework
-
mem7-graph
Graph store trait and providers for mem7
-
atlas-cli
Machine Learning Lifecycle & Transparency Manager - Create and verify manifests for ML models and datasets
-
ferrum-testkit
Testing utilities for Ferrum LLM inference engine
-
tml
Experimental, nightly-only, type-safe machine learning library
-
vivalaakam_neuro_neat
work with neat network
-
omega-snn
Spiking Neural Network substrate for ExoGenesis Omega - biologically-inspired neural dynamics
-
hodu_cpu_kernels
hodu cpu kernels
-
burn-ndarray
Ndarray backend for the Burn framework
-
llama-core
The core library of LlamaEdge
-
mnist
data set parser
-
xdl-stdlib
XDL standard library functions
-
jotun
A lightning-fast, terminal-native note-taking tool built in Rust
-
eml-core
EML (exp-ln) universal function approximation — O(1) learned functions from data
-
logprob
A wrapper around floats to handle log probabilities
-
pmetal-models
LLM model architectures for PMetal
-
fekan
building and training Kolmogorov-Arnold neural networks
-
bitnet-quant
1.58-bit quantization engine for BitNet neural networks
-
uv-torch
internal component crate of uv
-
megahal-markov
Internal MegaHAL implementation detail; APIs are not stable. Bidirectional Markov model with context window.
-
dlib-face-recognition
Unofficial Rust wrappers to the C++ library dlib, face recognition tools
-
lumen-nn
A tiny ML framework
-
browserslist-data
Data for browserslist-rs
-
cvx-server
ChronosVector server binary — bootstrap, config, and runtime
-
pyrao
Python wrapper for rao rust package
-
ferriclink-core
building AI applications, inspired by LangChain
-
atomic-neural-transistors
Ultra-small (<5K param) composable ternary neural primitives for CPU-only AI
-
llm-optimizer-decision
Intelligent decision-making engine
-
yolo_detector
YOLO object detection wrapper for OpenCV and ONNX in Rust
-
gorse_rs
Rust SDK for gorse recommender system
-
onde-mistralrs
Fast, flexible LLM inference
-
arc-agi
submission
-
ai_gettext_translator
A command-line tool that uses OpenAI’s models to automatically translate
gettextmessages in source code and.pofiles. Thought for Phoenix projects. -
vecpac
A spatial indexing algorithm in Rust that maps 2D data (like maps or pixels) onto a hexagonal grid
-
rstsr-openblas-ffi
OpenBLAS FFI bindings
-
chobitlibs
Single file libraries for my project
-
rknpu2
Unofficial bindings to rknpu2 (librknnrt and librknnmrt)
-
phago-distributed
Distributed colony implementation for horizontal scaling
-
rlkit
deep reinforcement learning library based on Rust and Candle, providing complete implementations of Q-Learning and DQN algorithms, supporting custom environments, various policy choices…
-
lattice-fann
Fast neural network primitives for Lattice - tiny models, fast inference
-
g3-planner
Fast-discovery planner for G3/GB AI coding agent
-
cargodisttest
💬 a CLI for learning to distribute CLIs in rust
-
m1nd-core
Core graph engine and reasoning primitives for m1nd
-
tenebris
A from-scratch machine learning library written in pure Rust
-
bayestest
Bayesian A/B testing calculations for Rust
-
scirs2-autograd
Automatic differentiation module for SciRS2 (scirs2-autograd)
-
rupia-cli
CLI for rupia LLM output validation harness
-
ahuvista-nn
A multi-modal neural network focused on maternal health predictions
-
arct-ai
AI integration for Arc Academy Terminal - OpenAI, Anthropic, and local LLM support
-
rustyasg
Graph-based deep learning framework in Rust: define-then-run ASG, graph-to-graph autograd, wgpu GPU backend, and an interactive egui graph visualizer
-
converge-embassy-scb
Statistics Sweden (SCB) port — national statistical tables via PxWeb
-
karbuche
DOJ-aligned inmate tablet monitoring engine. Supervised classification and K-Means clustering over .mp4 session signals produce auditable JusticeOutcome records — punitive, corrective…
-
pixelpwnr-exporter
PixelPwnr Prometheus metrics exporter
-
baibot
A Matrix bot for using diffent capabilities (text-generation, text-to-speech, speech-to-text, image-generation, etc.) of AI / Large Language Models
-
agentkit-task-manager
Task manager abstractions and implementations for tool execution scheduling
-
gpt_sovits_rs
A GPT_Sovits inference lib in Rust base on pytorch
-
cublas-hgemm
HGEMM kernels with Tensor Core support built on cuda-oxide
-
vexus
A neural network builder and trainer struct to make your own AI models
-
shrew-cli
CLI runner for Shrew .sw deep learning programs
-
odesign
optimal design of experiments library written in pure rust
-
cog-rust
Rust containers for machine learning
-
parent_ai_json_engine
JSON engine for collecting, aggregating, and managing models
-
nabled-ml
ML-oriented algorithms built on ndarray-native nabled primitives
-
rlevo
Deep Reinforcement Learning with Evolutionary Optimization
-
llm-chain
running chains of LLMs (such as ChatGPT) in series to complete complex tasks, such as text summation
-
gollum
Knowledge-based Logic Computation and Reasoning System
-
kenosis-core
Pure-Rust ONNX model optimization toolkit — static INT8 quantization, precision casting, and model analysis
-
bimm
burn image models
-
nnl
A high-performance neural network library for Rust with CPU and GPU support
-
mogi_statelearner
State learning algorithms for MOGI
-
node2vec-rs
A node2vec implementation in Rust via the Burn tensor framework
-
juice
Machine Learning Framework for Hackers
-
dev-cleaner
A smart developer tool for cleaning temporary build directories
-
vernier-partial
Shared wire envelope and partition policy for vernier's distributed-eval partials (ADR-0032)
-
turbo-quant
Experimental vector compression sidecars with PolarQuant, TurboQuant, QJL sketches, wire formats, and benchmark receipts
-
ohlcv-ai
AI agents focused on processing ohlcv data structures
-
hpt
High Performance Tensor (HPT) - A fast, efficient, and user-friendly tensor computation library for Rust
-
xlog-cli
Command-line interface for deterministic and probabilistic XLOG execution
-
intel-mkl-sys
Rust binding of unique functions in Intel(R) MKL
-
dkdc-lm
Local LLM inference management via llama-server
-
maxpro
Maximum Projection and Maximin Latin Hypercube Design creation and optimization
-
gengo-language
Get the language distribution stats of your repository
-
klaster
Machine learning library providing modern clusterning algorithms for the Rust programming language
-
jutella
Chatbot API client library and CLI interface
-
medmodels-utils
Limebit MedModels Crate
-
ort-sys
Unsafe Rust bindings for ONNX Runtime 1.24 - Optimize and Accelerate Machine Learning Inferencing
-
alpha-micrograd-rust
Expression tree, automatic gradients, neural networks, layers and perceptrons
-
pay-respects-select
Selection UI for the pay-respects CLI tool
-
clinical-tasks
Clinical prediction task windowing — Arrow event streams to ML-ready datasets
-
pkboost
Shannon-guided gradient boosting for extreme class imbalance with adaptive drift detection. Outperforms XGBoost/LightGBM on imbalanced data.
-
neurocore
Full-featured high-level neural network engine in Rust, including dense/LSTM layers, activations, optimizers, training, serialization, and real-time prediction
-
bayesian
A naive Bayesian classifier with optional TF-IDF support
-
koharu
Manga translation tools
-
hyperopt
Tree-of-Parzen-estimators hyperparameter optimization
-
candle-cudnn-attn
cuDNN attention bindings for candle - flash-attention compatible API
-
candle-nn-mold
Minimalist ML framework (mold fork with LTX Video models, Metal fixes)
-
rlx-cortexm
Cortex-M backend for RLX — INT8 kernels for ARMv7E-M microcontrollers (e.g. nRF52840)
-
nexish
experimental shell written in Rust for learning purpose
-
deep_quokka
Unofficial deep learning library
-
boruta-rs
Fast parallel Boruta feature selection algorithm in Rust — OOB permutation importance, classification and regression
-
tansig-lut
CLI generation of a Look Up Tables for tansig function with fixed-point arithmetic
-
mcp_client_rs
Rust client SDK for the Model Context Protocol (MCP)
-
gai-cli
Git operations for AI workflow
-
widget_intelligence
intelligent Kyma widget suggestion and learning
-
moshi-server-db
moshi, a real-time voice AI
-
treeboost
High-performance Gradient Boosted Decision Tree engine for large-scale tabular data
-
invariant-cli
Semantic code analysis CLI for the AI era — powered by DataGrout
-
cervo
High level APIs for RL in games
-
anomaly_detection
Time series anomaly detection for Rust
-
miniplan-cli
CLI for the miniplan PDDL planner
-
genetica
that helps with creating genetic algorithms
-
oxen-server
Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust
-
mininn
A minimalist deep learnig crate for rust
-
hanzo-hmm
Hidden Markov Model + Hamiltonian MarketMaker for heterogeneous compute pricing
-
volta
A PyTorch-like Machine Learning framework
-
linfa-bayes
Collection of Naive Bayes Algorithms
-
alembic-adapter-netbox
NetBox adapter for Alembic
-
hanzo-embedding
Hanzo AI - Embedding generators (native + remote) for text vectorization
-
rten-tensor
Tensor library for the RTen machine learning runtime
-
tlq
Tiny Little Queue
-
deepbiop-utils
Deep Learning Preprocessing Library for Biological Data
-
tblis
wrapper in Rust
-
bhed
High-performance duplicate line filter written in Rust, inspired by anew
-
aleph_ollama
Aleph Ollama Code Translator
-
interactive-worktree
Interactive CLI for managing git worktrees
-
serenade
Session-based recommender system
-
magi-openai
OpenAI compatible API SDK for Magi AI agents
-
mlmf
Machine Learning Model Files - Loading, saving, and dynamic mapping for ML models
-
fbleau
measuring black-box security via Machine Learning
-
xlog-stats
Runtime statistics and optimizer feedback utilities for XLOG
-
affinitree
distill faithful decision trees out of neural networks
-
statistical
statistics library
-
erhannis_misc
Erhannis's collection of misc utils
-
rknpu
Rockchip NPU library
-
onnxruntime-sys-ng
Unsafe wrapper around Microsoft's ONNX Runtime
-
sapiens
Core - Sapiens
-
lumen-provider-json
The AI-Native Programming Language
-
burn_gdn
Burn-native Gated DeltaNet 2 memory blocks and fused-kernel boundary
-
jepa-vision
Vision-specific JEPA implementations (ViT encoder, patch embedding, I-JEPA)
-
const_cge
Neural network compiler with a focus on no_std targets
-
openvino-finder
A helper crate for finding OpenVINO installations on a system
-
fsst
FSST string compression for Lance
-
eval-metrics
Evaluation metrics for machine learning
-
axonml-vision
Computer vision utilities for the Axonml ML framework
-
tga-collect
Stage 1 (collection) for trusty-git-analytics: git extraction via libgit2 and HTTP clients for GitHub/JIRA
-
openai4rs
A non-official Rust crate for calling the OpenAI service
-
nanoq
Minimal but speedy quality control and summaries of nanopore reads
-
cmeans-rs
A high-performance Rust crate for soft clustering and subspace clustering algorithms (Fuzzy C-Means, Subspace K-Means)
-
noid
Neural boids — flocking behavior learned by neural networks
-
domlist
Collects stat infomation from virsh. Mainly for OpenStack admin.
-
ctranslate2
Rust bindings for OpenNMT/CTranslate2
-
axolotlsay
💬 a CLI for learning to distribute CLIs in rust
-
ryft
A Framework for Tracing, Automatic Differentiation, and Just-In-Time Compilation
-
tesser-cortex
High-performance, hardware-agnostic AI inference engine for Tesser
-
darknet
wrapper for Darknet, an open source neural network framework written in C and CUDA
-
bitnet-training
Training and fine-tuning utilities for BitNet models
-
proteus-engine
Advanced zero-day static analysis engine built with Rust and Python
-
blazon
A fast minimal badge generator for Rust crate stats
-
call-me-in-cli
CLI for learning purposes
-
ruthril
A powerful AI/ML framework is under development
-
statpick
Pick one system stat and report on it at the CLI, for scripts
-
neuron-otel
OpenTelemetry instrumentation for AI agents — GenAI semantic conventions with tracing spans
-
goap-ai
Goal-Oriented Action Planning (GOAP) AI
-
mlx-core
Safe Rust API for MLX tensors, devices, and core operations
-
flerp
CLI tool that does XYZ
-
auto-diff
A neural network library in Rust
-
pyro-artifacts
Cli commands for pyroduct
-
apr-cli
CLI tool for APR model inspection, debugging, and operations
-
librefang
Official Rust client for LibreFang Agent OS
-
eryon-mem
implements the memory-related aspects of the eryon framework
-
knowledge
The launcher and updater for Knowledge.Dev Workbench
-
onnx-protobuf
ONNX protocol buffers messages
-
flashlight
neural network library
-
cecile-supercool-tracker
Machine learning framework for building object trackers and similarity search engines
-
krcflib
Modified https://github.com/aws/random-cut-forest-by-aws
-
antitransformer
AI text detector via statistical fingerprints — Zipf deviation, entropy uniformity, burstiness dampening, perplexity consistency, TTR anomaly
-
candle-metal-kernels-mold
Metal kernels for Candle (mold fork with quantized matmul precision fix)
-
relayrl_env_trait
Traits for training and testing environments in the RelayRL framework
-
onednn-src
Source of oneAPI Deep Neural Network Library (oneDNN)
-
neat-gru
NEAT algorithm with GRU gates
-
bindgen_cuda
Bindgen like interface to build cuda kernels to interact with within Rust
-
ncps-rust
Neural Circuit Policies - Sparse RNNs inspired by C. elegans, implemented in Rust with Burn
-
elinor
Evaluation Library in Information Retrieval
-
rns-git
Reticulum Git transport tools
-
context-footprint
A static analysis tool for measuring architectural context exposure in codebases
-
awpak-ai
orchestrate AI agents, commands, and URL calls using an execution graph
-
atlas-c2pa-lib
creating, signing, and verifying machine learning assets with C2PA
-
r2l-examples
reinforcement learning library
-
asimov-runtime
ASIMOV Software Development Kit (SDK) for Rust
-
fuelcheck-cli
Rust CLI to fetch usage and cost data from multiple AI providers with CodexBar-compatible output
-
rusty-reactor
A learning playground for rust based on a nuclear powerplant
-
oris-governor
Promotion, cooldown, and revocation policies for Oris EvoKernel
-
sgr-agent-ml
ML primitives for sgr-agent — ONNX embeddings, centroid classifier, k-NN store
-
tract-hir
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
calib-targets-marker
Checkerboard marker target detector (checkerboard + 3 central circles)
-
instmodel
Instruction-based neural network model training library using Burn
-
txtai
Rust client for txtai
-
glowstick
Gradual typing for tensor shapes
-
web-page-classifier
Fast web page type classification using XGBoost with compact binary model
-
adjustp
handle different p-value adjustments
-
cfg-generate
manipulating context-free grammars
-
sys_metrics
Cross-platform library to gather stats/information from the host
-
corn_stats
tools for status bar for linux
-
sophus
geometry for robotics and computer vision
-
clust
An unofficial Rust client for the Anthropic/Claude API
-
priors
prior-fitted networks
-
tflitec
A safe Rust wrapper of TensorFlow Lite C API supporting x86_64 and ARM (iOS, Android)
-
nusy-graph-review
Proposal and review workflow for Arrow knowledge graph changes, with safety gates
-
fabryk-mcp-graph
Graph query MCP tools for Fabryk
-
fann
Wrapper for the Fast Artificial Neural Networks library
-
fibpetokenizer
A blazing fast Byte Pair Encoding (BPE) tokenizer library with Python bindings
-
cge
Common Genetic Encoding (CGE) for directly-encoded neural networks
-
tflite
Rust bindings for TensorFlow Lite
-
serdes-ai-mcp
Model Context Protocol (MCP) implementation for serdes-ai
-
tictonix
that provides the ability to convert tokens into embeddings, as well as to encode their positions
-
llm-worker
building autonomous LLM-powered systems
-
pc_core
Predictive Coding Actor-Critic reinforcement learning framework — pure Rust, zero ML dependencies
-
devsper-memory
Distributed AI Swarm Runtime
-
flodl-hf
HuggingFace integration for flodl: safetensors, hub, tokenizers, pre-built models
-
bigml
Unofficial BigML client bindings
-
oar-ocr-vl
Vision-Language models for oar-ocr
-
model-rs
CLI tool for downloading HuggingFace models and running local LLM inference
-
quantize-rs
Neural network quantization toolkit for ONNX models
-
arrOgpu
GPU Computing Library
-
cgroupfs
reading cgroupv2 data
-
spaces
Set/space primitives for defining machine learning problems
-
minet_ai
MiNET AI (Miniaturized Neural Evolutionary Topology) is a minimalistic Rust library that evolves small neural networks via genetic algorithm. With a focus on producing compact, adaptive…
-
paddle-inference-rs
Rust bindings for PaddlePaddle inference library
-
montycarlo
Generic Monte Carlo simulation engine for Rust
-
graphrox
A graph library for graph compression and fast processing of graph approximations
-
FerrousLearn
dependancy free, machine learning
-
nu_plugin_gstat
A git status plugin for Nushell
-
robopages
CLI and API server for Robopages, a YAML based files for describing tools to large language models (LLMs)
-
crossref
API
-
trace2power
Reads VCD and FST signal traces and extracts accumulated power activity data for use with power analysis tools
-
cublas-batched-gemm
Batched GEMM kernels built on cuda-oxide
-
yscv-video
Video decoding (H.264, HEVC), MP4 parsing, and camera I/O
-
intricate
A GPU accelerated library that creates/trains/runs machine learning prediction models in safe Rust code
-
lance-geo
Lance's geospatial extension providing geospatial UDFs
-
unmtx-gpu
Micro matrix library for neural networks that uses GPU
-
svod-onnx
ONNX model importer for the Svod ML compiler
-
hanzo-ug
Minimalist ML framework
-
free-code
AI coding assistant CLI
-
formica
High-performance Rust clustering library for financial data analysis
-
nncombinator
neural networks that can be written type-safely
-
haagenti-hct
Haagenti Compressed Tensor (HCT) format with HoloTensor holographic compression
-
rten-vecmath
SIMD vectorized implementations of various math functions used in ML models
-
ai-chain
running chains of LLMs (such as ChatGPT) in series to complete complex tasks, such as text summation
-
aspirina
A modular neural network library with matrix operations and backpropagation
-
rustml
doing maching learning in Rust
-
rusty-crab-ap2025
crab group module, used in the unitn ap2025 class. It contains the planet definition.
-
cogent
Basic neural network library for classification
-
oxide-rs
AI Inference library and CLI in Rust - llama.cpp style
-
ruv-fann
A pure Rust implementation of the Fast Artificial Neural Network (FANN) library
-
llama-cpp-v3
Safe and ergonomic Rust wrapper for llama.cpp with dynamic loading
-
open_ttt_lib
that provides common Tic Tac Toe logic
-
psyche
AI Toolset
-
kstat-rs
Rust interface to illumos's libkstat
-
naptrace-llm
LLM clients (Anthropic, OpenAI, Ollama) for Naptrace
-
bfrunner
A Brainfuck interpreter in Rust, for shits and giggles. Not for production.
-
geddle
AI & SaaS affiliate marketplace for creators
-
egobox-ego
efficient global optimization
-
vikos
A machine learning library for supervised training of parametrized models
-
agentsmith
AI Agent forging utilities
-
random-world
Machine Learning methods for confident prediction (e.g., Conformal Predictors) and related ones introduced in the book Algorithmic Learning in a Random World (ALRW)
-
wwml
Tensor library for AI
-
lumen-dataset
A tiny ML framework
-
ellip-dev-utils
Development utilities for Ellip
-
arrfounder
curated directory of verified founders and entrepreneurs with their products and revenue data
-
propago
Graph Neural Network primitives and training loops
-
wonnx-preprocessing
Preprocessing utility crate for WONNX. WONNX is an ONNX runtime based on wgpu aimed at being a universal GPU runtime, written in Rust.
-
boggle-maker
Rust tools for Boggle enthusiasts: board generation and analysis
-
cai-core
Core types and utilities for Coding Agent Insights
-
ruvector-graph-transformer
Unified graph transformer with proof-gated mutation substrate — 8 verified modules for physics, biological, manifold, temporal, and economic graph intelligence
-
rai
ML framework with Ergonomic APIs in Rust
-
attnres
Attention Residuals (MoonshotAI/Kimi) implementation in Rust using burn
-
harness-skill
Skill tool for AI agent harnesses — authored SKILL.md activation with progressive disclosure, permission-gated activation, trust-gated project skills, and pluggable SkillRegistry
-
qsar
small Rust library for computing molecular descriptors and integrating with Linfa for QSAR modeling
-
nps-nop
NPS — Neural Orchestration Protocol frames (TaskFrame, DelegateFrame, SyncFrame, AlignStreamFrame) and async client
-
einops
Simplistic API for deep learning tensor operations
-
analyst
A command line tool that supports quick browsing of csv data
-
mlinrust
A machine learning library in Rust from scratch
-
tritonserver-rs
Pefrorm easy and efficient ML models inference
-
wifi-densepose-vitals
ESP32 CSI-grade vital sign extraction (ADR-021): heart rate and respiratory rate from WiFi Channel State Information
-
deep_thought
Feed-forward neural networks in rust
-
nove
lightweight deep learning library wrapped around Candle Tensor
-
simple_behavior_tree
behavior tree
-
gguf-llms
parsing GGUF (GGML Universal Format) files
-
avx-clustering
State-of-the-art clustering algorithms for Rust - surpassing scikit-learn, HDBSCAN, and RAPIDS cuML
-
ncpig
Non-Cooperative Perfect Information Games, and algorithms to play them
-
paga
A new more/less alternative written in Rust. Currently in development and for my own learning purposes only.
-
nnsplit
split text using a neural network. For sentence boundary detection, compound splitting and more.
-
candle-metal-kernels
Metal kernels for Candle
-
nutorch
wrapper for tch-rs, itself a wrapper for libtorch, the C++ backend for PyTorch. It provides a plugin for Nushell to use PyTorch tensors on the command line.
-
rustorch-core
Core tensor library for RusTorch
-
kategorize
K-modes and K-prototypes clustering algorithms for categorical and mixed data
-
a8e-acp
Articulate (a8e): The sovereign AI operator for your terminal
-
anima-tagger-tagger
WD14-family ONNX image tagger used by anima-tagger
-
regioncam
Visualize linear regions in neural networks
-
cocli
A command line tool for generating Call Of Cthulhu RPG character stats
-
rustRet
mass-spectroscopy analyzer
-
cjc-ad
Automatic differentiation: forward-mode dual numbers and reverse-mode tape
-
brainwires-mdap
Multi-Dimensional Adaptive Planning (MAKER voting framework) for the Brainwires Agent Framework — k-out-of-n voting, recursive decomposition, microagent dispatch, red-flag validation, scaling estimation
-
leaf
Machine Learning Framework for Hackers
-
rgen-cli-lib
CLI interface for rgen
-
bbt
A skill-rating system similar to Elo, Glicko or TrueSkill
-
moshi
real-time voice AI
-
kasi-kule
CIECAM02 color spaces in Rust
-
rsomics-bam-flagstat
SAM/BAM/CRAM flag statistics — Rust port of samtools flagstat
-
numrs-c
C ABI bindings for NumRs
-
sbv2_core
Style-Bert-VITSの推論ライブラリ
-
bigml-parallel
CLI tool for executing multiple BigML scripts in parallel
-
splendor_arena
facilitating Splendor game play between autonomous agents
-
jams-serve
http and gRPC API for jams-core
-
data-gov-mcp-server
MCP Server for AI integration with Data.Gov
-
singe-cuda-find
CUDA toolkit discovery and library path resolution utilities
-
tldr-core
Core analysis engine for TLDR code analysis tool
-
strava_client
Client API for Strava. https://developers.strava.com/
-
csv2parquet
Convert CSV files to Parquet
-
openai-rust
An unofficial library for the OpenAI API
-
ofc
A command-line Ollama Function Caller
-
listenbrainz-cli-tools
A CLI app containing a set of useful tools for Listenbrainz
-
cstats-core
Core library for cstats - statistical analysis and metrics collection
-
mutter
bindings to the Whisper.cpp machine learning transcription library!
-
rusty-gradients
A full-stack deep learning framework in Rust for training and deploying Transformer models. Features multi-backend support (CPU/CUDA/Metal/WASM), 62x GPU acceleration, Safetensors serialization, and BPE tokenization.
-
gollum-neurosymbolic-planning
Use Machine Learning to guide an Automated Planner
-
medrs
Ultra-high-performance medical imaging I/O for deep learning
-
fastapprox
Fast approximate versions of certain functions that arise in machine learning
-
ghost-flow
Complete machine learning framework in Rust - tensors, neural networks, 85+ ML algorithms, GPU acceleration, WASM, FFI, model serving, compiler optimizations, distributed training…
-
cuda-assembler
Two-pass text-to-bytecode assembler
-
dandelion-jetson
NVIDIA Jetson Orin backend for dandelion LLM inference engine
-
fswtch-sys
Rust bindings and helpers for writing FreeSWITCH modules
-
ort-tract
ort + tract = 🦀 - An alternative backend for ort, powered by tract
-
nanogbm
A small, pure-Rust gradient boosting library (GBDT, binary classification, CPU only)
-
cmac_rust
CMAC (Cerebellar Model Articulation Controller) utilities for imputing missing floating-point values
-
sample_planning
Sample Based Planner
-
RustGLM
High-performance, Reliable Zhipu ChatGLM SDK natural language processing in Rust Language
-
pipeless-ai
An open-source computer vision framework to build and deploy applications in minutes
-
statoxide
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
rec_rsys
different maths functions related to recsys and ML
-
mli
Machine Learning Interface for Rust
-
ask_ai
interacting with various AI frameworks
-
changelog
generator
-
miniboosts
collection of boosting algorithms written in Rust 🦀
-
heddle-oplog
An AI-native version control system
-
ollama-inquire
Query any LLM found on Ollama from the terminal!
-
xtalk
A general-purpose CLI for chat models
-
egg-viz
View statistics for egg e-graphs
-
scivex
A comprehensive Rust library replacing the Python data science ecosystem
-
re_smart_channel
A channel that keeps track of latency and queue length
-
spacetravlr
Spatial gene regulatory network inference and in-silico perturbation (Rust port of SpaceTravLR)
-
TokenLedgerRs
Token management and pricing governance CLI for AI coding agents
-
moe-ddel
Deterministic distributed execution layer for MoE-13 graphs
-
nnv-rs
Verification and Statistics on Deep Neural Networks
-
haagenti-fragments
Cross-model fragment sharing library for HoloTensor compression
-
booted
bootstrapping estimators on arbitrary data structures
-
burn-mlx
MLX backend for Burn deep learning framework - native Apple Silicon GPU acceleration
-
scirs2-text
Text processing module for SciRS2 (scirs2-text)
-
hybrid-predict-trainer-rs
Hybridized predictive training framework with warmup, full-train, predict, and residual correction phases for accelerated deep learning
-
burn-store
Storage and serialization infrastructure for Burn
-
ClawFoxyVision
Advanced financial time series forecasting library using LSTM, GRU, and CNN-LSTM neural networks for price prediction with Rust and Burn
-
promptkit_rs
LLM structured prompting library
-
frlearn_api
Facade crate and pipeline API for the FuzzyRough Rust workspace
-
trackio-rs
High-performance, thread-safe Rust client for Trackio experiment tracking
-
linked-markov
A minimal, thread-safe Markov chain implementation using reference-counted steps and weighted transitions
-
custos-math
Matrix operations with custos
-
rmqtt-sys-topic
RMQTT periodically publishes its own operational status, message statistics, and client online/offline events to system topics starting with $SYS/
-
tquant
High-performance vector quantization for AI embeddings with 8x compression and minimal quality loss
-
similari
Machine learning framework for building object trackers and similarity search engines
-
mpsgraph
Modern Rust bindings for Apple's Metal Performance Shaders Graph framework
-
forestfire-data
Tabular data preprocessing and storage for ForestFire
-
bitnet-benchmarks
Comprehensive benchmarking suite for BitNet implementation
-
kn0sys-nn
A collection of nearest neighbour algorithms
-
rustpy-ml
seamless Python integration, enabling ML workflows with type safety
-
bye_pcl_rs
The Point Cloud Library (PCL) is a standalone, large scale, open project for 2D/3D image and point cloud processing.Implemented in pure Rust
-
aliyah
Terminal based machine learning training monitor
-
npc_maker
Evolve AIs in simulated environments
-
mlx-rs-burn
Unofficial rust wrapper for Apple's mlx machine learning library (fork with slice, scatter, flip operations for burn-mlx)
-
ezllama
An opinionated, simple Rust interface for local LLMs, powered by llama-cpp-2
-
rlox-nn
Backend-agnostic neural network traits for rlox
-
vit_tch
Vision Transformer models and building blocks for Rust using tch
-
theory_core
Neuro-symbolic reasoning core with SMT solver integration
-
rfann
A pure Rust implementation of the Fast Artificial Neural Network (FANN) library
-
samvada
Chat with AI assistant in markdown file
-
phynexus
Empowering Intelligent Futures, One Edge at a Time
-
burn_dsa
Burn-native dynamic sparse attention reference blocks and kernel boundary
-
newron
train and infer deep learning models
-
geochunk
Split a CSV semi-evenly based on ZIP population stats
-
litert-lm-rs
Rust bindings for LiteRT-LM C API - Engine, Session, and Conversation support
-
neuralneat
Kenneth Stanley's NeuroEvolution of Augmenting Topologies
-
mz_rusoto_glue
AWS SDK for Rust - AWS Glue @ 2017-03-31
-
fast-stats
efficient calculation of statistics from streaming data
-
deepbiop-bam
Deep Learning Processing Library for Bam Format
-
neuralib
Neural Network Library in Rust
-
cjc
A deterministic numerical programming language for reproducible computation, ML pipelines, and scientific computing
-
spdkit
Structure Predication Development Kit
-
codemerge
A command-line tool for merging multiple code files into a single output file
-
hayride-llama-rs-sys
Hayride llama.cpp rust bindings
-
egobox-gp
gaussian process modeling
-
radient
designed for automatic differentiation. It leverages the power of computational graphs to perform forward and backward passes for gradient calculations.
-
sagacity
A Rust-based project for conversing with your codebase and handling codebase contextualization
-
prophet
A neural network implementation with a focus on cache-efficiency and sequential performance
-
prompt-graph-exec
Execution of Chidori, interprets a given graph of prompts and nodes, provides grpc api to the runtime
-
mistralrs-quant
Fast, flexible LLM inference
-
burn-remote
Backend router decorator over the network
-
pmetal
High-performance LLM fine-tuning framework for Apple Silicon
-
rustic_ml
A machine learning library created from scratch with Rust
-
candle-flash-attn
Flash attention layer for the candle ML framework
-
is-it-slop-preprocessing
Preprocessing for is-it-slop: fast TF-IDF vectorization
-
ferrotorch-serialize
State dict and checkpoint serialization for ferrotorch
-
augurs-changepoint
Changepoint detection using Bayesian Online Change Point Detection and more
-
uni-store-core
The high-performance core engine for the UniStore ecosystem. A foundation for AI-generated functional units.
-
cargo-cog
A cargo subcommand to build, run and publish machine learning containers
-
slippy-provider-openai
AI Linter for Rust projects
-
orkhon
Machine Learning Inference Framework and Server Runtime
-
fast_pl
A plane-sweep implementation to compute persistence landscapes
-
openvino-genai
High-level bindings for OpenVINO GenAI
-
ai00-core
RWKV language model in pure WebGPU
-
aither
Providing unified trait abstractions for AI models
-
parley-cli
Terminal-first review tool for AI-generated code changes
-
scirs2-metrics
Machine Learning evaluation metrics module for SciRS2 (scirs2-metrics)
-
cublas-dgemm
DGEMM kernels built on cuda-oxide
-
luminal_cudarc
Safe wrappers around CUDA apis
-
oxidizr
A Rust-based LLM training framework built on Candle
-
sensorlm-rs
SensorLM – wearable sensor foundation model in Rust (Burn + WGPU)
-
unda
General purpose machine learning crate for neural network development and analysis
-
so-python
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
runn
feature-rich, easy-to-use library for building, training, and evaluating feed-forward neural networks in Rust
-
rust-mnist
MNIST parser/loader written in rust
-
libbusperf
Base library for Busperf
-
omikuji
an efficient implementation of Partitioned Label Treesand its variations for extreme multi-label classification
-
ainojimakugumi
aI NO jimaKu gumI, a subtitle maker using AI
-
calib-targets-puzzleboard
PuzzleBoard self-identifying chessboard target detector (Stelldinger 2024)
-
gradientlss
Distributional Gradient Boosting for Location, Scale, and Shape
-
poisson-rate-test
Tests the equivalence of Poisson process rates, per Gu 2008 'Testing Ratio of Two Poisson Rates'
-
gsem-sem
Minimal structural equation modeling engine: DWLS/ML estimation, lavaan syntax, sandwich SEs
-
linfa-linear
A Machine Learning framework for Rust
-
mallockit
A framework for building malloc implementations in Rust
-
helldivers2_rs
A wrapper for the unofficial helldivers-2/api
-
svod-model
Pretrained models inference abstraction
-
l2
Pytorch-style Tensor+Autograd library written in Rust
-
openpilot
Towards fully autonomous driving
-
savfox
AI assistant
-
alembic-adapter-nautobot
Nautobot adapter for Alembic
-
captcha_breaker
多种验证码识别实现
-
chronicle-proxy
LLM Provider Abstraction and Logging
-
orchestra-rs
An orchestration framework for building AI agents using multiple LLM providers
-
anda_assistant
Anda -- an AI Assistant powered by the Knowledge Interaction Protocol (KIP)
-
jawe-cuvs-iii
RAPIDS vector search library
-
tic
a high-performance stats library focused on rates and latencies from timestamped events
-
tensorite_ml
Tensorite ML | Machine Learning Library
-
turing-machine-ai
Tools and an AI for the Turing Machine board game
-
libtashkeel_base
Arabic-text diacritic restoration using neural networks
-
chatty-rs
A terminal-based chat client for OpenAI's GPT models
-
mynn
Hobby no_std neural network
-
hpt-iterator
An internal library implements iterator for hpt
-
gh-sparkle
Generate AI-powered commit messages
-
rus-torch
A comprehensive deep learning framework in Rust, merging core, nn, vision, text, and wasm
-
intellichip-rs
Tiny Recursive Models for fast opcode routing and sequence prediction
-
temporal-compare
High-performance framework for benchmarking temporal prediction algorithms inspired by Time-R1
-
rten-text
Text tokenization and other ML pre/post-processing functions
-
libinfer
Rust interface to TensorRT for high-performance GPU inference
-
tangram_zip
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
mcai-onnxruntime
Wrapper around Microsoft's ONNX Runtime
-
visual-search
Visual search engine for images using Deep Learning models to extract features
-
recoreco
Fast item-to-item recommendations on the command line
-
easy_ga
implement genetic algorithms
-
hmll
Safe, idiomatic Rust bindings to the hmll library for high-performance ML model loading
-
oxen-cli
Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust
-
juggernaut
Neural Network in Rust
-
pocketflow_rs
PocketFlow implemented by rust
-
rig-candle
Candle backend scaffolding for Rig
-
mgrad
A minimal automatic differentiation library
-
bullpen
unofficial library for AI Model APIs
-
rten-gemm
Machine-learning oriented matrix multiplication
-
stable-diffusion-trainer
Stable Diffusion Trainer
-
onde-mistralrs-quant
Fast, flexible LLM inference
-
cuvs-sys
Low-level rust bindings to libcuvs
-
tract-tflite
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
vinyana
A neural network library written in Rust
-
nasbench
port of NASBench: https://github.com/google-research/nasbench
-
rust-mlp
Small, from-scratch MLP (dense feed-forward) for Rust: predictable, allocation-free hot path, batched training, and optional fast GEMM backend
-
thalamus
A deep learning mesh node server platform for linux/mac/unix
-
rustorch-text
NLP utilities and datasets for RusTorch
-
neural-network-rs
A neural network library
-
ecrs
Evolutionary computation tools & algorithms
-
agtrace-providers
Internal provider adapters for the agtrace CLI. Not intended for direct use.
-
vivalaakam_neuro_utils
calculation some things
-
kalman_clustering
Clustering vectors using Kalman Filter
-
luminal
Deep learning at the speed of light
-
sevens-neural-network
A very basic Neural Network system with some nice activation functions and an easy to understand and execute training process
-
xlog-gpu
High-level Rust API for running XLOG programs on NVIDIA GPUs
-
gemm-benchmark
BLAS [sd]gemm benchmark
-
poro
toy neural network library
-
ruvector-gnn-node
Node.js bindings for Ruvector GNN via NAPI-RS
-
agentic-connect-ffi
FFI bindings for AgenticConnect — C-compatible interface
-
libgvproxy-sys
FFI bindings to gvproxy-bridge C library
-
wminml
A minimal, blazing-fast WASM-powered machine learning library with SIMD acceleration
-
bwapi_wrapper
Bindings to BWAPI
-
cogni
Unix native interface for LLMs
-
greencurves
Generate statistics on Bezier paths
-
transformers
Looking for HuggingFace Transformers in Rust? Check out candle-pipelines!
-
ragegun
Performs lexica based analysis on text (i.e. age, gender, PERMA, OCEAN personality traits, ..)
-
collenchyma-nn
collenchyma plugin providing Neural Network operations
-
lingua
An accurate natural language detection library, suitable for short text and mixed-language text
-
rust_hero
Rust assistant that utilizes NLP to enhance the quality of rust code
-
asimov-platform
ASIMOV Software Development Kit (SDK) for Rust
-
xrf
Generic library to build Random Forest implementations
-
scratch_genetic
A from-scratch genetic-algorithm library used in my march-madness-predictor project
-
katago-analysis
A wrapper around KataGo's analysis engine
-
prmpt
A command-line tool to convert code repositories into LLM prompts and inject code back into repositories
-
concision-params
implements the core modules for the concision framework
-
lance-namespace-impls
Lance Namespace Implementations
-
alumina
An Experimental Deep Learning Library
-
pasta-msm
Optimized multiscalar multiplicaton for Pasta moduli for x86_64 and aarch64
-
neal
naive incremental dependency graphs. Don't use this. Not done.
-
easy_llm
Provide an asynchronous LLM caller that can integrate with various LLM services, including Ollama
-
tl_runtime
Runtime library for TL differentiable programming language
-
dictator-python
Python language decree for Dictator structural linter
-
trustflow-attestation-rs
TrustFlow Attestation Rust Library
-
fksainetwork
neural network
-
statistical_computing
statistical computing in Rust
-
steelix
Your one stop CLI for ONNX model analysis. Featuring graph visualization, FLOP counts, memory metrics and more!
-
ndrs
A tensor library with GPU support
-
gtars-tokenizers
Genomic region tokenizers for machine learning in Rust
-
cjc-hir
High-level intermediate representation for CJC
-
flashlight_tensor
gpu/cpu tensor library focused around matrix and neural network operations
-
aorist_ast
AST (Abstract Syntax Tree) building blocks for the aorist project
-
rhai-ml
Machine learning in the Rhai scripting language
-
loop-bin
Run a command in loop, nothing else
-
rlgym_sim_rs
Rust port of RLGym-sim
-
instructor-ai
that allows for users to do validated structured outputs
-
hasty
interface to system BLAS libraries for fast linear algebra operations
-
experience-rs
help Actuaries monitor experience in Rust (i.e. perform experience studies).
-
p2o
A PaddlePaddle New IR (PIR) to ONNX model converter
-
ecoz2
Linear Predictive Coding Vector Quantization and Hidden Markov Modeling for Pattern Recognition
-
palm_api
Client library for Google's large language model PaLM API
-
ronn-python
Python bindings for RONN - enables Python ML workflows with RONN runtime
-
hms-common
Common lib for Hold my Snip!
-
george-ai
George is an API leveraging AI to make it easy to control a computer with natural language
-
zyx-nn
Zyx nn modules
-
bellande_artificial_intelligence_framework
A comprehensive artificial intelligence and computer vision training framework developed by Bellande AI Research. Provides tools and utilities for machine learning model development, training, and deployment.
-
plato-constraints
Constraint assertion engine — forbidden patterns, validation, checking
-
dendritic
Iterative Optimization Library
-
buddy-up-lib
The brains behind the buddy-up crate
-
deno_core
A modern JavaScript/TypeScript runtime built with V8, Rust, and Tokio
-
reservoir-infer
Inference-time building blocks for Echo State Networks: reservoirs and readouts (dense/sparse, dynamic/static) built on reservoir-core
-
axonml-optim
Optimizers and learning rate schedulers for the Axonml ML framework
-
nps-sdk
NPS — Neural Protocol Suite Rust SDK: NCP + NWP + NIP + NDP + NOP umbrella crate
-
rsvd
randomized singular value decomposition (rSVD)
-
mancala
Play a variant of mancala
-
ug
Micro compiler for tensor operations
-
cairn-knowledge-graph
An embedded and in-memory knowledge graph for static specification analysis
-
oris-spec
OUSL YAML spec contracts and compilers for Oris
-
fashion-clip-rs
complete(grpc service and lib) Rust inference with multilingual embedding support. This version leverages the power of Rust for both GRPC services and as a standalone library, providing…
-
read-logger
Wrap
Readwith a read statistics logger -
gammatest
code to perform Gamma Test for machine learning feature selection
-
jepa-world
Action-conditioned world model and hierarchical JEPA (H-JEPA)
-
onnxruntime-ng
Wrapper around Microsoft's ONNX Runtime
-
tract-cli
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
bevy_zeroverse_burn
bevy zeroverse synthetic dataset rust generator
-
baracuda-cutlass-kernels-sys
Compiled CUTLASS template instantiations for the baracuda ecosystem. Hosts curated .cu kernel sources, builds them via baracuda-forge, exposes extern "C" entry points for the safe baracuda-cutlass crate.
-
syft-cli
CLI binary for syft, an AI-native version control experiment
-
oww-rs
Minimalistic version of the OpenWakeWord inference in Rust and ONNX runtime
-
lance-datagen
A columnar data format that is 100x faster than Parquet for random access
-
warkov-wordgen
Use markov-chains to generate new items
-
oxillama-arch
Model architecture implementations — LLaMA, Qwen3, Mistral, Gemma, Phi
-
scivex-ml
Scivex — Classical machine learning: trees, ensembles, clustering, pipelines
-
tinguely
Machine learning library
-
minidx-vis
Visualization crate for minidx, a simple + compile-time neural-network library
-
rlevo-environments
RL benchmark environments and landscapes for rlevo (internal crate — use
rlevofor the full API) -
neurox
providing core building blocks for numerical computing and machine learning, including tensor operations, model abstractions, and future GPU acceleration support
-
rsrl
A fast, extensible reinforcement learning framework in Rust
-
nove_tensor
lightweight deep learning library wrapped around Candle Tensor
-
reustmann
Von Neumann architecture
-
fabric-platform
Rust client SDK for the Fabric platform
-
deepphonemizer
G2P model (inference only)
-
ai_kit
Collection of classic AI algorithms with convenient interfaces
-
fit-connect-rs
fit syncing tool
-
unsafe_bst
bst crate, created as a project for class
-
normalize-session-analysis
Session analysis metrics for AI coding agent logs
-
gpt-pipe
GPT use with UNIX pipes
-
rotta_rs
a Deep Learning library with rust language
-
bytesandbrains-ml
Machine learning utilities for BytesAndBrains
-
quickstart-rs
package for learning about rust programming language
-
xneuron
A Freestanding, Zero dependency AI/ML library written in Rust with maximum portability
-
irithyll-core
Core types, training engine, and inference for irithyll streaming ML — no_std + alloc, histogram binning, Hoeffding trees, SGBT ensembles, drift detection, f32 + int16 packed formats
-
sovran-mcp
A synchronous Rust client for the Model Context Protocol (MCP)
-
cake-core
Distributed LLM inference for mobile, desktop and server
-
wingfoil-python
python bindings for wingfoil - graph based stream processing framework
-
openvx
1.3.1 wrapper
-
phonetisaurus-g2p
Phonemization in Rust using a finite state transducer (FST) trained with Phonetisaurus
-
flux-trust
Trust scoring with Bayesian updates and decay — how agents decide who to believe
-
nah_chat
Lightweight LLM chat completion API
-
trustedflow-attestation-rs
Trustedflow Attestation Rust Library
-
smarty_pants
A light wheight Neural Network library with a focus on ease of use and speed
-
rlx-fusion
Fusion passes and fused-op decomposition for RLX MIR
-
rstsr-blis-ffi
BLIS and FLAME FFI bindings
-
wordmarkov
but flexible Markov chain library, specifically for text sentences, which handles punctuation and whitespace
-
easynn
quick-and-dirty neuro network developing and training
-
calib-targets-aruco
Embedded ArUco/AprilTag dictionaries and fast marker decoding on rectified grids
-
ccache_stats_reader
A read-only API for CCACHE_DIR
-
rustrees
Decision trees in Rust
-
ai-firewall
The runtime firewall for AI, blocks LLM vulnerabilities in real time
-
burn-deblur
An optimizer for burn which is suitable for training on non-I.I.D data
-
rstat
Probability distributions and statistics in Rust with integrated fitting routines, convolution support and mixtures
-
linkedin-headlines
LinkedIn Headlines Generator, a Rust library to generate high-quality headlines for LinkedIn posts or profiles
-
moondream
Client for interacting with the Moondream API
-
rustneat
NeuroEvolution of Augmenting Topologies NEAT http://nn.cs.utexas.edu/downloads/papers/stanley.ec02.pdf with a Continuous-Time Recurrent Neural Networks
-
sfs-cli
Tools for working with site frequency spectra
-
yscv-threadpool
Custom work-stealing thread pool with priority-aware cold-idle spin — drop-in for rayon::ThreadPool in yscv inference paths
-
mermin-theory
Continuum theory: Frank energy, Landau-de Gennes fitting, activity estimation
-
oxkart
Kart utils
-
tl_cuda
CUDA GPU tensor library for TL
-
r2l-api
reinforcement learning library
-
opensrdk-kernel-method
Standard Kernel Method library for OpenSRDK toolchain
-
linear_algebra_ws
An open-source Rust library for linear algebra operations, designed with privacy and transparency
-
variational-regression
Regression models trained using variational inference
-
candle-transformers-mold
Minimalist ML framework (mold fork with LTX Video models, Metal fixes)
-
briny_ai
A tiny & efficient AI inference engine
-
omni-llm-kit
omni llm agent for all ai provider
-
tsai_models
Model zoo for tsai-rs: CNN, Transformer, ROCKET, RNN, and Tabular architectures
-
potato-prompt
Tell your potatoes what to do
-
figif
Interactive TUI for GIF manipulation
-
memer-rs
a meme generation rust cli tool
-
covid_cert_uvci
parse EU Digital COVID Certificate UVCI (Unique Vaccination Certificate/Assertion Identifier)
-
herta-lib
Backend library for herta-bin
-
rusty-ggml
Idiomatic bindings for the GGML library (pre-alpha)
-
throttle-timer
Throttle events and record event stats with a simple library
-
neuralnetwork
A small neural network lib written from scratch
-
candle-crf
porting pytorch-crf to candle
-
tritter-accel
Rust acceleration for Tritter - BitNet, ternary ops, VSA optimization
-
ferrolearn-model-sel
Model selection utilities for the ferrolearn ML framework
-
cervo-runtime
Multi-model multi-agent RL runtime for games
-
bep-core
An opinionated library for building LLM powered applications
-
syntaxdot-transformers
Transformer architectures, such as BERT
-
margaret-is-a-cat
A collection of crates for working with cats
-
catboost-rs
Unofficial Rust bindings for Catboost (Machine Learning Gradient Boosting Library from Yandex)
-
world-count
Word Frequency Statistics
-
provekit-cli
ProveKit CLI for generating and verifying zero-knowledge proofs
-
super-auto-pets-ai
Super Auto Pets AI, built with Rust
-
tn
AI/ML
-
wasm-nn
deep learning framework for WebAssembly
-
cv_nested
just wraps cv_nested_impl
-
koharu-renderer
Manga translation tools
-
puffpastry
basic rust neural network framework
-
wifi-densepose-train
Training pipeline for WiFi-DensePose pose estimation
-
rusty-llm-jury
CLI tool for estimating success rates when using LLM judges for evaluation
-
agtrace-engine
Internal core engine for the agtrace CLI. Not intended for direct use.
-
moshi-db
moshi, a real-time voice AI
-
simple_neat
NEAT like create for rust
-
primitiv
A Neural Network Toolkit
-
tsai
Time series deep learning in Rust - a feature-parity port of Python tsai
-
cornerstone
A behavior tree library
-
dual_threshold_optimization
Dual Threshold Optimization compares two ranked lists of features (e.g. genes) to determine the rank threshold for each list that minimizes the hypergeometric p-value of the overlap of features…
-
neural_lib
lib to declare multiple groups of neurons, classicals learning process are includes
-
schlandals
probabilistic inference by projected weighted model counting
-
replicate-rs
A minimal async http client for Replicate
-
content-semantic
UCFP semantic fingerprinting (embedding generation) crate
-
codex-utils-cache
Cache utilities for Codex AI agent
-
mcp_rust_schema
Rust Schema for the Model Context Protocol (MCP)
-
rustreg
data preprocessing (Normalization and Standartization). The goal for this crate is to become a Rust Machine Learning 101.
-
axonml-cli
Command-line interface for the Axonml ML framework
-
axonml-distributed
Distributed training utilities for the Axonml ML framework
-
tame-webpurify
client for the WebPurify REST API
-
agent-chain-core
Core library for agent-chain crate
-
genimtools
Performance-critical tools to manipulate, analyze, and process genomic interval data. Primarily focused on building tools for geniml - our genomic machine learning python package.
-
am-compact
Qwen3 inference engine with Attention Management KV-cache compaction (CUDA + Apple Silicon via MLX)
-
vk_method
Standart of VK Method
-
hotcoco-cli
CLI for COCO dataset evaluation
-
hanzo-llm
Hanzo AI - Llm Library
-
burn_dino
burn dino model inference and training
-
fnn
Feedforward Neural Network library for Rust
-
dendritic-metrics
Metrics package for dendritic
-
gptask
chatGPT CLI
-
rprofile
measure processor timings in selected samples of execution
-
next-web-ai
Next Web Ai!
-
claude_runner_core
Claude Code process execution with builder pattern
-
rust_shap
A lightweight Rust implementation of Kernel SHAP
-
cld3
Rust binding for Compact Language Detector v3 (CLD3), a neural network model for language identification. the C++ code is from https://github.com/google/cld3
-
jams
CLI application for interaction with J.A.M.S - Just Another Model Server
-
cublas-rs
A BLAS implementation built on cuda-oxide
-
claude-tokenizer
tokenizing text with the Anthropic Claude models
-
my1
My1
-
converge-crucible-models
Trained-model packs for the Converge Engine — Decision Trees, Random Forests, SVMs (linfa) and ANFIS (Burn)
-
ncnnrs
ncnn, a lightweight neural network inference framework, with separated static library for cross-platform compilation
-
tokio-channels-console
Like tokio-console, but for channels
-
google-ml1_beta1-cli
A complete library to interact with Cloud Machine Learning Engine (protocol v1beta1)
-
netidx-sysinfo
Publishes top-like stats from sysinfo into netidx
-
qwen3-tts-rs
Rust port of Qwen3 TTS - Text-to-Speech model
-
reorger
reorganizing a large number of files by splitting and unsplitting files into subdirectories
-
toy_ml
designed to be a “Hello World” for machine learning enthusiasts looking to get started with Rust
-
blingfire
Wrapper for the BlingFire tokenization library
-
atuin-history
The history crate for Atuin
-
qmachina
A small library for Quant Machine Learning development
-
rapid-nn
Rapid Neural Networks in Rust: A lightweight and fast neural network library that's easy to use
-
tensorboard-rs
Write data for Tensorboard from Rust
-
frlearn_neighbor
Neighbour search abstractions and brute-force backend for FuzzyRough
-
ort_batcher
Small crate to batch inferences of ONNX models using ort (onnxruntime)
-
rs-jsonl2stats
Create basic stats from jsonl
-
codeplz
generating and applying code changes using AI
-
kalosm-learning
A simplified machine learning library for building off of pretrained models
-
ruvector-gnn-wasm
WebAssembly bindings for RuVector GNN with tensor compression and differentiable search
-
moe-uril
Unified Runtime Integration Layer for MoE-13 ecosystem
-
yolo_io
loading and validating YOLO data
-
anima-tagger-booru
Danbooru-API tag fetcher used by anima-tagger to enrich sidecars with human-curated booru tags
-
jsonstat
jsonpath stat
-
renacer-core
Core tracing primitives for renacer — zero-dep span/event types for CPU-GPU pipelining instrumentation
-
crates-mcp
MCP server for querying Rust crates from crates.io and docs.rs. Search crates, get info, versions, dependencies, and documentation.
-
munin-if1sec
munin interface graph plugin, 1second resolution
-
rwrd
A reinforcement learning framework for Rust, powered by Burn
-
volition-core
Core library for the Volition AI agent
-
cuda-instruction-set
80 opcodes with assembler and A2A encoding
-
pcl
Point cloud library in Rust
-
decision
c4.5和cart分类算法
-
rust-imbalanced-learn
High-performance resampling techniques for imbalanced datasets in Rust
-
candle-ug
Minimalist ML framework
-
wireguard-embeddable
embeddable wireguard library that wraps the C implementation by Jason Donfeld. Allows interacting with the kernel-land wireguard native implementation from Rust to create, modify, delete…
-
qbittorrent-metrics-exporter
A Prometheus exporter for qBittorrent that provides detailed torrent metrics with support for categories and tags. Collects both per-torrent statistics and aggregated metrics grouped by categories and tags.
-
tangram_finite
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
bone-rs
炳翰牛逼 !!!
-
gradients
An OpenCL, CUDA and CPU based Deep Learning Library
-
cjc-lexer
Tokenizer for the CJC programming language
-
shrew
A deep learning library built from scratch in Rust
-
busperf_gui
GUI library for Busperf
-
huggingface
-
mnn-rs-sys
Raw FFI bindings for Alibaba MNN (Mobile Neural Network) inference engine
-
micrograd_rs_nt
Andrej Karpathy's micrograd scalar-valued engine
-
my_crate_2025
我的第一个项目
-
paddle-sys
Bindings to Paddle Inference for running deep learning models
-
triadic-memory
Basic triadic memory implementation
-
f-trak
A neural network based face detection program that tracks face movement in screen space
-
rusticsom
Self Organising Maps (SOM)
-
rcudnn
safe Rust wrapper for CUDA's cuDNN
-
perceptron
A super fast online learning library using perceptron
-
rustkernel-ml
Statistical ML kernels: clustering, anomaly detection, regression
-
compiled-nn
A JIT Compiler for Neural Network Inference
-
linfa-nn
A collection of nearest neighbour algorithms
-
coreml-proto
CoreML protobuf definitions and decoders
-
rust-halcon
Rust bindings for Halcon C API
-
aprender-zram-adaptive
ML-driven compression algorithm selection for trueno-zram
-
tiny-recursive-rs
Tiny Recursive Models for efficient puzzle solving
-
blitzagent
multi api Ai-agent framework
-
kn-cuda-eval
A CUDA executor for neural network graphs
-
smart-turn-rs
livekit's smart turn detection v3 using ONNX Runtime
-
fuel
A machine learning framework with an autonomous DAG scheduler
-
wordtop
Counts words in stream and update while processing input
-
lance-namespace
Lance Namespace Core APIs
-
ferrum-tokenizer
Tokenization wrapper for Ferrum inference engine
-
scirs2-neural
Neural network building blocks module for SciRS2 (scirs2-neural) - Minimal Version
-
ata
Ask the Terminal Anything² — ChatGPT¾ in your terminal
-
mua
❤️
-
turngate
Prevent or reduce abuse of your public service
-
liblinear
Rust bindings for the liblinear C++ library
-
avila-clustering
State-of-the-art clustering algorithms for Rust - surpassing scikit-learn, HDBSCAN, and RAPIDS cuML
-
ghostflow-data
Data loading utilities for GhostFlow ML framework
-
histat
Zsh history stats
-
hpt-display
An internal library for displaying tensors
-
openai_chatgpt_api
OpenAI ChatGPT API
-
mistralrs-server-core
Fast, flexible LLM inference
-
ruml-ox
Test setup (hellow world) for ruml-ox
-
csta_metropolis
Adds metropolis and compatibility with montecarlo
-
trackforge
A unified, high-performance computer vision tracking library
-
crabby_ai
chatbot that is NOT AN LLM
-
optical-embeddings
DeepSeek-OCR - compress text into images
-
howtoshell
Get directions for how to do anything in the terminal. Powered by ChatGPT. Like TLDR, but smarter.
-
torsh-tensor
Tensor implementation for ToRSh with PyTorch-compatible API
-
chatgpt
Markov chain implementation. It's natural langauge generation abilities far surpasses that of any modern LLM (obviously).
-
cstats-hook
Hook generation for cstats shell integration
-
lace_stats
Contains component model and hyperprior specifications
-
cv2-crate
sample description
-
neat_lib
NeuroEvolution of Augmenting Topologies
-
neat-edu
Interactive educational platform using NEAT neural networks for mathematical learning with real-time network visualization
-
tsuga
An early-stage machine learning library for building neural networks in Rust
-
hodu_xla
Bindings for the XLA C++ library
-
rai-models
ML framework with Ergonomic APIs in Rust
-
rustgpt
command-line chat GPT frontend written in Rust
-
steam-profile
get basic profile statistics from steam
-
twitter/rustcommon-streamstats
Statistics calculated for a stream of samples
-
eventgraph
Hash-chained, append-only, causal event graph
-
detexify
The
detexifycrate is a port of the classifier that powers https://detexify.kirelabs.org/classify.html -
nexcore-cognition
Typed cognitive engine — transformer algorithm as strict Rust. Attention, transformation, generation, and self-measurement.
-
lfa
Native rust implementations of linear function approximators
-
zccache-cli
PyO3 cdylib hosting the
zccache._nativeextension module -
qtransformers-core
Quantum-inspired attention mechanisms for transformer models
-
sentence2vec
convert a sentence to a vector. It can be used to partition word2vec data. It can also be used to extract a list of words from a word2vec data file.
-
neuronika
Tensors and dynamic neural networks
-
llmvm-outsource
An llmvm backend which sends text and chat generation requests to known hosted language model providers
-
nba_api
provide access to various NBA APIs (Stats & Live)
-
neural_network
Modular neural network with an implementation of back propagation learning algorithm
-
ibm-watson
A wrapper for interacting with the IBM Watson API
-
eegdino
EEG-DINO Foundation Model — inference in Rust with Burn ML
-
file2txt
将目录下所有文本文件内容聚合到一个文件
-
array_stat_functions
Array and Statistics functions in rust
-
iron_torch
A very basic neuralnet set up and user will keep updated for abit
-
maildir_ai
connects a maildir to your LLMs
-
candle-approx
Approximate comparison of Candle tensors
-
ice-nine
ML library
-
neuroflow
The neural network library implemented in Rust
-
hala-rproxy
reverse proxy for hala os
-
idx-lib
read the IDX data format as used in, for example, the MNIST dataset
-
glmnet
Rust API to the fortran glmnet library
-
pddl-ish-parser
parsing a relaxed version of the Planning Domain Definition Language (PDDL), designed to handle PDDL-like inputs generated by autoregressive language models like ChatGPT
-
bunnynet_prometheus
Expose Bunny.net statistics as a scrapable prometheus endpoint
-
simplestats
Generate simple statistics on line delimited numbers
-
neural-dynamics
Large-scale neural network simulation library with advanced connectivity patterns and dynamics
-
approximate
Scalable Approximate Counters
-
cfg-classify
manipulating context-free grammars
-
elara-math
Rust-native tensor and math library
-
budoux
Rust port of BudouX (machine learning powered line break organizer tool)
-
ricecoder-local-models
Local model management for RiceCoder (Ollama integration)
-
daft-stats
Statistics functionality for the Daft project
-
fahrenheit_to_celsius_converter
Converts Fahrenheit to Celsius. Simple, portable, and FFI-ready.
-
continuous_density_estimation
Density estimation for continuous distributions
-
swarm-rs
A minimalist framework for building agentic workflow
-
lib-magic
magic
-
lazygitrs
A faster, memory-safe, more ergonomic slopfork of lazygit
-
pmetal-mlx
MLX backend implementation for PMetal LLM fine-tuning
-
bnomial-cli
Get a fun machine learning question everyday in your terminal!
-
babichjacob-llama-cpp-2
llama.cpp bindings for Rust
-
leastsquares
Miller Updating Regression
-
llmprogram
that provides a structured and powerful way to create and run programs that use Large Language Models (LLMs). It uses a YAML-based configuration to define the behavior of your LLM programs…
-
axonml-serialize
Model serialization for Axonml ML framework
-
reductionml-core
Reduction based machine learning toolkit core library
-
success
A great crate, much successful
-
r2l-gym
reinforcement learning library
-
rstsr-native-impl
An n-Dimension Rust Tensor Toolkit
-
muffler
Undupervised denoising pf time-series data
-
snail_nn
small neural network libary, running on the cpu with parallelized stochastic gradient descent
-
statistics
The package provides a statistics toolbox
-
ghostflow-nn
Neural network layers for GhostFlow ML framework
-
scirs2-vision
Computer vision module for SciRS2 (scirs2-vision)
-
torsh-backend
Backend abstraction layer for ToRSh
-
r2rs
Statistics programming for Rust based on R
-
moonlander-gp
Genetic Programming framework providing AST abstraction and evolution routines
-
temporal-neural-solver
Ultra-fast neural network inference with sub-microsecond latency
-
neurotic
A neural network library written for Rust
-
pcp
A brute-force pcp solution searcher
-
hs-hackathon-car
Car control support crate for Helsing's Rust Nation hackathon
-
neuro
A deep learning library that runs on the GPU
-
behrens-fisher
Find the difference of the means of two Normal distributions
-
cc-downloader
A polite and user-friendly downloader for Common Crawl data
-
hotg-runecoral
Bindings to the librunecoral library for doing hardware-accelerated inference
-
dectree-rs
A decision tree implementation in Rust
-
policy-rs
Policy library for working with protobuf-defined policy objects
-
forger
reinforcement learning with Rust
-
egobox-moe
mixture of expert gaussian processes
-
nnapi
safe abstraction of the Android NNAPI FFI bindings
-
zeta-reticula
High-performance LLM inference engine with advanced quantization and salience-based optimization
-
cog-core
Core types and traits for rust-cog, a Rust toolkit for machine learning
-
rusvm
Solve SVM training problems
-
hotg-rune-codegen
Code generation for compiling a Runefile to WebAssembly
-
codemem-hooks
PostToolUse hook handler for passive capture from AI coding assistants
-
lm
Linear models
-
lumen-tokenize
A tiny ML framework
-
aleph-alpha-api
Interact with large language models provided by the Aleph Alpha API in Rust code
-
wyrm
A low-overhead, define-by-run autodifferentiation library
-
ferrotorch
PyTorch in Rust — deep learning framework built on ferray
-
neurs
feed-forward-only, but efficient, neural network and reinforcement learning library
-
openai2
OpenAi client, generated from the OpenAPI spec
-
hodu_nn
hodu nn
-
rhineai
machine learning modules of Rhine Lab
-
finalfusion-utils
finalfusion utilities
-
coreason-codegen
Code generator for CoReason AI
-
mincost
A collection of modern heuristic optimization toolkit
-
psalms
See
psalmcrate instead -
kders
A basic library for 2D kernel density estimation
-
usl
usl builds Universal Scalability Law models from sets of observed measurements
-
re_tensor_ops
Helpers for using ndarray together with Rerun tensors
-
stateset-nsr
Neuro-Symbolic Reasoning (NSR) framework for hybrid AI systems combining neural networks with symbolic logic
-
single_algebra
A linear algebra convenience library for the single-rust library. Can be used externally as well.
-
egobox-doe
design of experiments
-
dariotd_simple_ml
A single-threaded simple machine learning
-
ferris_grad
A PyTorch-like autograd engine in under 1000 lines of Rust code.🦀
-
crabst
download statistics on your cli
-
zenu
Deep Learning library for Rust
-
netlib-provider
The package provides BLAS and LAPACK using the Netlib implementation
-
layered-clauses
Clauses plugin for layered-nlp
-
llama_cpp_sys
Automatically-generated bindings to llama.cpp's C API
-
fann-sys
Low-level bindings to the Fast Artificial Neural Networks library
-
bosonnlp
SDK for Rust
-
kstat
providing an ffi wrapper around the native illumos kstat library
-
candle-einops
python einops package for the Candle ML library
-
egg-stats
Generate and view statistics for egg e-graphs
-
rumus-graph
Sparse graph engine for RUMUS — WebGPU-native fused SpMM for GNNs
-
plato-instinct
Unified instinct engine for PLATO agents — flux-instinct + cuda-genepool merged, enforced by plato-constraints assertions
-
netr
Display network interface throughput by second and by minute along with a graph. This is quick and easy to use via a mobile handset or similar device where typing is cumbersome.
-
monte
Fundamental operations for scientific computing directly with Polars
-
codemem-engine
Domain logic engine for Codemem: indexing, hooks, watching, scoring, recall, consolidation
-
sproutml
Machine Learning Library built in Rust
-
Cryptonic
This project includes a tensor library, utilities for FHE functionality and most importantly an FHE based ML library
-
tensor-tools
Minimalist ML framework
-
border-tch-agent
TCH agent for Border
-
axonml-quant
Model quantization for the Axonml ML framework
-
microsoft-cognitive-computer-vision
Microsoft - Cognitive Services - Computer Vision API
-
bcl2fq-stats
designed to give a quick overview of read count distribution over the given indices, and identify potential index mismatches from the undetermined read counts
-
ferrite-rs
An ML Library for fast and memorysafe inference
-
rlx-gguf
GGUF v1/v2/v3 parser + dequantization to f32. Standalone — no rlx-* deps.
-
siarne
Fast simulation of artificial neurons
-
dice
calculating arbitrary dice probabilities
-
cervo-asset
A unified asset type for Cervo using ONNX or NNEF models
-
syntaxdot-summary
TensorBoard summary writer
-
luminal_metal
Metal compiler for luminal
-
RayBNN_Raytrace
Ray tracing library using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
labello
label encoder with configurable types
-
stability_rs
Stability API
-
artha
A dead simple neural network built as a learning exercise
-
kerasty
Keras for Rust with support for Web Assembly
-
httpstat
-
stochastic-rs-ai
AI / neural surrogates for volatility models
-
asimov-token
ASIMOV Software Development Kit (SDK) for Rust
-
autd3-backend-cuda
CUDA Backend for AUTD3
-
axonml-llm
Large Language Model architectures for the Axonml ML framework
-
tract-extra
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
xaynet
Xayn Network project is building a privacy layer for machine learning so that AI projects can meet compliance such as GDPR and CCPA. The approach relies on Federated Learning as enabling…
-
lib-neural-mesh
ML/AI optimization layer for routing and compression
-
decy-oracle
CITL (Compiler-in-the-Loop) oracle for C-to-Rust transpilation pattern mining
-
vigil-pulse
Metacognitive monitoring for AI entities — pipeline enforcement, reflection quality, outcome tracking
-
oscirs
Scientific computing environment for Rust
-
gbrt-rs
Gradient Boosted Regression Trees in Rust
-
dumb_ai
My own AI, which doesn't work that great, but it still works!
-
ffnn
A very simple feedfoward neural network library
-
wasmedge_tensorflow_interface
that provides Rust to WebAssembly developers with syntax for using tensorflow functionality
-
eVaiutilities
variant analyzer for human genomics
-
nsl-errors
Error types and diagnostic reporting for the NeuralScript compiler
-
deeprust
DeepLearnng Crate in rust - Testing stage
-
burn-vision
Vision processing operations for burn tensors
-
burn-import
Legacy crate for ONNX import - use burn-onnx instead
-
pgml-dashboard
Web dashboard for PostgresML, an end-to-end machine learning platform for PostgreSQL
-
advance-router
A unified Rust SDK for multiple LLM providers - like Vercel AI SDK for Rust
-
stable-diffusion-cli
Stable Diffusion CLI
-
google-genai
Bindigns for the Google AI Platform API
-
ort-candle
ort + candle = 🦀 - An alternative backend for ort, powered by candle
-
phago-embeddings
Embedding backends for Phago semantic intelligence
-
train-map
A trained hash map
-
unfault
— a cognitive context engine for thoughtful engineers
-
cortenforge-training
Burn-based training and eval for LinearClassifier/MultiboxModel models in the CortenForge stack
-
scirs2-transform
Data transformation module for SciRS2 (scirs2-transform)
-
dlpackrs
DLPack safe Rust binding
-
pca
principal component computation using SVD
-
finalfrontier
Train/use word embeddings with subword units
-
vil_stats
VIL Expression function — statistical aggregation (mean, median, percentile)
-
rembg-rs
removing backgrounds from images using neural networks
-
ndarray-einsum
einsum function for the Rust ndarray crate. Fork of https://github.com/oracleofnj/einsum
-
jawe-cuvs-iv
RAPIDS vector search library
-
descend
Training infrastructure primitives: optimizers, LR schedules, gradient clipping, early stopping
-
layoutparser-ort
A simplified port of LayoutParser for detecting layout elements on documents
-
ember-vision
Vision utilities for the Ember project
-
montague-fol
First-order logic profile (and, or, not, implies, forall, exists, iota, eq) for Montague
-
the_one
bst crate, created as a project for class
-
brass_tensor
Tensor type implementation for the Brass library
-
neuroforge
A neural network library with advanced features including quantum-inspired neurons, adaptive architecture, and neuro-symbolic integration
-
sann
Neural Network
-
cblas-src
C interface to Legacy BLAS
-
r
a set of utils for machine learning
-
wbt-core
Core library for wbt – technical analysis indicators
-
git-statistics
Collect commits from Git repository and present statistics in a comfortable way
-
every-other-token
A real-time LLM stream interceptor for token-level interaction research
-
dei-clustering
Clustering analysis for DEI
-
daipendency
AI coding assistants with public API from dependencies
-
axonml-profile
Profiling tools for the Axonml ML framework
-
stat
-
reservoir-train
Training utilities for Echo State Networks: ridge/lasso readout solvers, ESN builder helpers, and optional static code generation for embedded inference
-
estimators
A estimator API for Machine Learning in Rust
-
ctranslate2-sys
Compiles CTranslate2 from source or uses pre-built binaries
-
llm-chain-llama
implementing
llm-chainsfor LLamA. Chains can be use to apply the model series to complete complex tasks, such as agents. -
sapiens_cli
The cli - Sapiens
-
gpt_commit
ChatGPT create a commit message based on a
git diff -
hpt-common
An internal library for common utilities for hpt
-
litert-lm-sys
Raw FFI bindings to Google's LiteRT-LM on-device LLM engine C API
-
astrai
A pretty bad neural network library
-
oxionnx
Pure Rust ONNX inference engine — zero C/C++ dependencies
-
rusty-whisper
Whisper
-
corty
AI Native Code Intelligence Platform
-
b4sam
review code with AI
-
march
A Markov chain implementation
-
onde-mistralrs-paged-attn
Fast, flexible LLM inference
-
mlearning-studio
under development de mlearning.studio
-
dent
summarizing and comparing small data sets
-
ofnn
An open (accessible parameters), feed-forward-only NN (neural net) library to use it in an dynamic and free way in evolutionary algorithms. Design is influenced by the Keras Sequetial model.
-
jepa-train
Training loop utilities for JEPA models
-
korah
A CLI utility for natural language queries
-
sciron
inspired by scikit-learn, providing machine learning tools
-
bench
Run a program, measure execution time and print statistics
-
conformal-prediction
Conformal prediction with formal verification: CPD, PCP, streaming calibration, and Lean4 proofs
-
gamlr
estimating clock offset in networked systems based on the Gamma distribution
-
linfa-reduction
A collection of dimensionality reduction techniques
-
rustats
A statistical library
-
oxur-cli
CLI infrastructure and unified command-line tool for Oxur
-
stablediffusion-wgpu
Stable diffusion burn with wgpu
-
instant-clip-tokenizer
Fast text tokenizer for the CLIP neural network
-
gtensor
Reverse-mode autodifferentiation of computational graphs with tensors and more for machine learning
-
ionian-core
Core tensor engine and hardware abstraction for the Ionian AI framework
-
rstsr-mkl-ffi
Intel oneAPI MKL FFI bindings
-
zyx-optim
Zyx optimizers
-
num-peek
A CLI tool that can peek into
*.npyfiles -
so-stats
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
rf1
F1 statistics
-
ncps
Neural Circuit Policies - Sparse RNNs inspired by C. elegans, implemented in Rust with Burn
-
ort-web
ONNX Runtime on the web 🌐 - An alternative backend for ort
-
gitstats
fetch stats from a git repository
-
resurface
Search AI coding chat history from Claude Code, Codex, and OpenCode
-
psyche-core
Core module for Psyche AI Toolset
-
pmetal-mhc
Manifold-Constrained Hyper-Connections (mHC) for stable deep network training
-
arkgan
An open source GAN toolkit
-
dense
An encoder/decoder to/from dense files
-
boolnetevo
Evolve populations of boolean networks to approximate bitstring functions and their (unknown) inverses
-
rs-cel-mcp
CEL MCP Server
-
measured
A better way to measure your application statistics
-
cvc5
High-level Rust bindings for the cvc5 SMT solver
-
cox-hazards
Cox proportional hazards regression with elastic net regularization
-
pmetal-mlx-rs
pmetal-maintained fork of mlx-rs: unofficial rust wrapper for Apple's mlx machine learning library
-
oaapi
An unofficial Rust client for the OpenAI API
-
ferrite_ml_framework
A modern, robust and simple to use ML framework written in Rust for pure performance and memory safety
-
readapt
A reinforcement learning library
-
gmarkov
An app that uses markov chains to generate text
-
ccache_stats_reader_extras
Extras (examples, tests, etc) for ccache_stats_reader
-
dynamecs-analyze
Functionality for working with dynamecs-app log files
-
seesaw_utils
patterns for seesaw-based applications — batching, dataloader, and more
-
batched-fn
Middleware for serving deep learning models with batched prediction
-
mvnc
Wrapper around the Movidius Neural Computing stick C API
-
simple_ml
Functions required for data analysis and machine learning tasks
-
keystr
A keystroke monitor for Unix OSs using Rust, and tracks the number of key strokes made when active
-
opensrdk-optimization
Standard mathematical optimization library for OpenSRDK toolchain
-
unsloth-rs-core
Fast, efficient implementation of Unsloth optimization kernels and training loop in Rust
-
nite2-sys
Rust bindings for NiTE2
-
syft-types
Shared domain types for syft
-
scivex-nn
Scivex — Neural networks, autograd, layers, optimizers
-
ellie
echo "It's dangerous to go alone" | ellie
-
eevee
Generalized NeuroEvolution toolkit, based on NEAT
-
rotoml
A native Rust AutoML pipeline toolkit
-
rustkov
Markov chain chatbot library
-
pllm
Portable LLM
-
lance-file
Lance file format
-
pr-ml
Ground-up implementations of neural network and SVM for classifying MNIST dataset
-
rustorch-vision
Computer vision models and utilities for RusTorch
-
oxicuda-dnn
OxiCUDA DNN - GPU-accelerated deep learning primitives (cuDNN equivalent)
-
chatgpt-cli
Talk with ChatGPT from your terminal
-
litert
Safe, idiomatic Rust bindings to Google's LiteRT (TFLite) on-device ML runtime
-
machine_learning
machine learning algorithms
-
only-brain
Neural Network library, without the learning part
-
cgpt
A command-line ChatGPT client
-
skynet_ai
creating neural networks
-
llm-chain-qdrant
For using Qdrant with llm-chain
-
nabled
A linear algebra library written in Rust with an ndarray-first architecture
-
pathrex-sys
Native FFI bindings for SuiteSparse:GraphBLAS and LAGraph used by the pathrex crate
-
neural
Genetic Algorithms in Rust
-
candle-core
Minimalist ML framework
-
cuda-neurotransmitter
Receptors, synapses, and cascades
-
shuttlings
Types for Shuttlings libraries
-
alith-prompt
LLM Prompting
-
reverse
mode automatic differentiation
-
otelite
OTLP receiver, dashboard, and CLI for local OpenTelemetry observability
-
candle-core-mold
Minimalist ML framework (mold fork with LTX Video models, Metal fixes)
-
rstsr-blas-traits
An n-Dimension Rust Tensor Toolkit
-
vsa-optim-rs
Deterministic training optimization using VSA compression and closed-form gradient prediction
-
alnstats
A high-performance command-line tool designed to calculate yield and duplicate statistics from BAM, SAM, or CRAM alignment files
-
gruq
Groq Rust SDK
-
trios-training
IGLA-GF16 Training Pipeline
-
llm-bridge
SDK for interacting with various Large Language Model (LLM) APIs using a common interface
-
popgetter-llm
LLM integration for popgetter
-
speakers-qwen3-tts
Vendored Qwen3-TTS inference backend used by the speakers crates.io packages
-
openvino-sys
Low-level bindings for OpenVINO (use the
openvinocrate for easier-to-use bindings) -
yolo_binding
A yolo prediction frame with torch-rs
-
cortenforge-inference
Detector factory and inference helpers (Burn-backed or heuristic) for the CortenForge stack
-
another-tiktoken-rs
encoding and decoding with the tiktoken library in Rust
-
freecut
A cut optimizer gui for cutting rectangular pieces from panels
-
singe
A machine learning framework that sets tensors ablaze
-
gcp-vertex-ai-generative-ai
An async client library for GCP Vertex AI Generative models - Examples
-
chatti
Terminal-based chat application that interfaces with Ollama
-
math_images_processor
preprocessing images of mathematical formulas, ideally for machine learning applications for formula recognition
-
autoagents-burn
Agent Framework for Building Autonomous Agents
-
nove_lossfn
lightweight deep learning library wrapped around Candle Tensor
-
howcani
A generative AI-powered CLI for getting step-by-step instructions for how to perform various tasks using the command line
-
running-average
Calculate running average with specified time window width using constant memory
-
csskit_ast
Refreshing CSS!
-
millardjn/rusty_sr
Deep learning superresolution in pure rust
-
ml
A package for M and L
-
learntk
machine learning toolkit, written in Rust
-
ollamars
ollama sdk using async rust
-
burn_dragon
burn dragon inference and training
-
moshi-backend
moshi, a real-time voice AI
-
vernier-semantic
Semantic-segmentation evaluation for the vernier evaluation library (ADR-0028)
-
perspt-tui
Ratatui-based TUI for Perspt
-
simple_genetic
aid with genetic learning
-
openai-rs
OpenAI
-
fabryk-cli
CLI framework for Fabryk-based applications
-
neuros
package for Artificial (Feedforward) Neural Networks (ANNs) processing
-
cuticula
Data Preprocessing library for Machine Learning
-
yscv-tensor
SIMD-accelerated tensor library with f32/f16/bf16 support and 80+ operations
-
nsfw
detecting NSFW images using a neural network
-
rml-core
N-gram language model implementation in Rust
-
gitoxide
A command-line application for interacting with git repositories
-
aocl-types
Shared types and enums used by AOCL safe wrappers (Layout, Trans, Uplo, Diag, Side, ...)
-
mistralrs-cli
Command-line interface for mistral.rs LLM inference
-
llama_cpp_rs
Rust bindings for LLAMA.CPP inference
-
google-ai-edge-litert
LiteRT Rust language binding
-
dendritic-preprocessing
Package for preprocessing datasets to convert to numerical representation
-
tensorite_ml_ff
Tensorite ML FF | Feed-Forward Neural Network Implementation
-
ortn
Rust bindings for ONNXRuntime
-
mushin
Computational graphs with reverse automatic differentation in the GPU
-
algocline-engine
algocline Lua execution engine — VM, session, bridge
-
open-routerer
An unofficial Rust client for the OpenRouter API
-
tensor_frame
A PyTorch-like tensor library for Rust with CPU, WGPU, and CUDA backends
-
word2vec
Rust interface to word2vec
-
olinker
natively linking ollama and rust code
-
toyai
A small collection of ai algorithms to perform some simple prediction on structured data
-
transxlab
Training architect: design, validate, and preflight ML training runs
-
llama-rust
LLM inference in Rust
-
whisper-rs-sys
Rust bindings for whisper.cpp (FFI bindings)
-
rlevo-reinforcement-learning
Deep reinforcement learning algorithms for rlevo (internal crate — use
rlevofor the full API) -
diffusion-rs-sys
Rust bindings for stable-diffusion.cpp (FFI bindings)
-
rust-halcon-xl
Rust bindings for Halcon C API
-
breakout
detection for Rust
-
ai-chain-openai-compatible
implementing
ai-chainsfor OpenAI’s models. Chains can be use to apply the model series to complete complex tasks, such as text summation. -
tsai_cli
Command-line interface for tsai-rs time series deep learning
-
rlox-candle
Candle backend for rlox neural network training
-
htmx_llamacpp_server
server for the htmx_llamacpp project
-
neural_networks
neural network library
-
quantrs2-ml
Quantum Machine Learning module for QuantRS2
-
peon-cli
The interactive Unix-style command-line interface for the zero-trust Peon Agent layer
-
eryon-actors
focuses on implementing various actors for the eryon framework
-
movingai
Benchmark Map/Scen File Parser
-
ecosystem
A small genetic algorithms library
-
vowpalwabbit-sys
Rust bindings for VowpalWabbit
-
lumen-transformer
A tiny ML framework
-
nexcore-downloads-scanner
Downloads Intelligence Scanner - classifies files by NexVigilant Core relevance
-
pmetal-gguf
GGUF file format implementation for PMetal
-
tva
Tab-separated Values Assistant
-
quavil-provider
LLM provider abstraction for quavil (OpenAI, Anthropic, Gemini)
-
ssvm_tensorflow_interface
that provides Rust to WebAssembly developers with syntax for using tensorflow functionality
-
shitpost_markov
Backend for training a Markov bot at compile-time
-
rustlib-core
A DeepLearning Library in Rust
-
langhub-core
The core framework of LangHub is called Crates
-
candle-kernels
CUDA kernels for Candle
-
build2cmake
Generate CMake files for kernel-builder projects
-
etke_openai_api_rust
(Temporary etke.cc fork) A very simple Rust library for OpenAI API, free from complex async operations and redundant dependencies
-
ferrotorch-jit
Tracing JIT compiler and graph optimizer for ferrotorch
-
baracuda-cutlass
Safe Rust wrapper for compiled CUTLASS kernels: plan-based GEMM and grouped GEMM with caller-supplied workspace, typed device-buffer arguments, and capture-safe launch
-
autograph
A machine learning library for Rust
-
rai-nn
ML framework with Ergonomic APIs in Rust
-
rust-ai-core
Unified AI engineering toolkit: orchestrates peft-rs, qlora-rs, unsloth-rs, axolotl-rs, bitnet-quantize, trit-vsa, vsa-optim-rs, and tritter-accel
-
aocl-data-analytics
Safe Rust wrappers for AOCL-DA (data analytics, statistics, ML primitives)
-
ggblas
Matrix multiplicatiosn in simple pure rust multithreadded blas-like interface. Exploits intrinsics on available targets
-
aicore
subprogram library for an artificial neural network
-
segfaultai
Segfault.ai Tracing SDK
-
jams-core
thin abstraction around common machine learning and deep learning models and model stores like AWS S3, Azure Blob Storage, MinIO, Local Filesystem. You can think of each component as…
-
suitesparse_sys
sys crate for suitesparse library
-
tract-pulse-opl
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
omni_search
A unified Rust SDK for multimodal embedding and similarity search
-
tiny_chatgpt_cli
A small tool to access ChatGPT from the command line
-
lace_consts
Default constants for Lace
-
weave-writer
collaborative generative writing
-
ruvector-tiny-dancer-core
Production-grade AI agent routing system with FastGRNN neural inference
-
openai-req
Client for OpenAI API, written with reqwest and tokio
-
hyperspec
Fast hyperspectral processing for remote sensing and machine learning
-
MA_rs
A Machine Learning framework written and used in Rust
-
aigc
ChatGPT rust sdk and cli set
-
tensorflow-sys
The package provides bindings to TensorFlow
-
scikit
machine learning, inspired by scikit-learn
-
lumosai-vector-fastembed
FastEmbed integration for LumosAI vector storage - local embedding generation
-
spvirit-server
PVAccess server library for EPICS
-
zenu-matrix
Matrix library for ZeNu
-
ohnomore-utils
Transformation utilities for TüBa-D/Z lemmas
-
flodl-sys
Raw FFI bindings to libtorch via a thin C++ shim
-
hanzo-transformers
Minimalist ML framework
-
burn-wgpu
WGPU backend for the Burn framework
-
neuburn
Spiking neural network framework on top of Burn — Rust-native alternative to snntorch
-
shrew-nn
Neural network layers, activations, and loss functions for Shrew
-
markov
A generic markov chain implementation in Rust
-
unillm
LLM abstraction. Multiple backends, decision trees.
-
icebreaker_core
The pure data types of icebreaker
-
lgbm-sys
Unofficial Rust bindings for LightGBM
-
gptshell
developers to query and interact with ChatGPT's language capabilities. GPTshell's aim is to simplify the process of using natural language processing while developing.
-
rust-lstm-1025
BMI (Basic Model Interface) adapter for LSTM-based streamflow prediction
-
truston
A high-performance Rust client library for NVIDIA Triton Inference Server
-
postagger
NLTK-inspired parts-of-speech tagger
-
onnx-rs
Zero-dependency ONNX model parser in Rust
-
vernier-core
Pure-Rust core for the vernier evaluation library
-
tiny-data
A cli tool for building computer vision datasets
-
aann
Arbitrary Artificial Neural Network
-
sklears-tree
Decision tree algorithms for sklears: CART, ID3, C4.5
-
rust-optimal-transport
optimal transport solvers for Rust
-
below-gpu-stats
GPU stats crate for below
-
burn-tensor
Tensor library with user-friendly APIs and automatic differentiation support
-
rgpt
fast shell client for ChatGPT
-
deepbiop-core
Deep Learning Preprocessing Library
-
ghostflow-ml
Classical ML algorithms for GhostFlow
-
codive-providers
LLM provider implementations for Codive
-
tml-utils
Core tensor and network utilities for the tml machine learning library
-
cuda11-cublasLt-sys
cuda ffi
-
rlx-flow
Block assembly-line API for RLX model builders — fusion-first, config-driven
-
asimov-repository
ASIMOV Software Development Kit (SDK) for Rust
-
synapse-models
Biophysical synapse models for neural simulations with short-term plasticity
-
hal-ml
HAL: a machine learning library that is able to run on Nvidia, OpenCL or CPU BLAS based compute backends. It currently provides stackable classical neural networks, RNN's and soon to be LSTM's…
-
rust_neural_network
Rust Neural Network
-
axonml-fusion
Kernel fusion optimization for the Axonml ML framework
-
ferrotorch-llama
Llama 3 / Meta LLaMA model composition and weight loading for ferrotorch
-
stable-diffusion
Stable Diffusion
-
minidx-core
Core crate for minidx, a simple + compile-time neural-network library
-
scientist
Machine Learning Algorithms in Rust
-
dumbnet
a [no_std] neural network library
-
sentinellm_ai
A custom version for tch 1.18.1 of rust-bert for my personal project
-
koharu-models
Manga translation tools
-
gpt-model
Pure-Rust inference wrapper for GPT-2 large language models
-
scorch
A straightforward and customizable neural network crate, built for machine learning tasks
-
sapiens_bot
The discord bot - Sapiens
-
mcai-graph
Graph definition for Media Cloud AI Workflows representation
-
thatched
Reinforcement learning but oxidised
-
rsblas
BLAS in Rust
-
pjrt
A safe PJRT C API bindings for Rust
-
convolutions-rs
Fast, minimal dependency, completely Rust implementation of convolutions for machine learning
-
frlearn_preprocess
Preprocessing models (for example range normalization) for FuzzyRough
-
grain-agent-harness
Rust port of @earendil-works/pi-agent-core harness: session persistence, system-prompt assembly, truncation, custom message helpers
-
zenu-cuda
CUDA bindings for Rust
-
confusion_matrix
Confusion matrix implementation for storing results from a classification experiment and providing statistical information
-
yarnn
Neural Network framework
-
stable-diffusion-a1111-webui-client
client for Automatic1111's Stable Diffusion Web UI
-
cedar-db
In memory vector database for semantic search in Rust
-
micro_metrics
Performance monitoring and metrics collection for micro-neural networks
-
reductionml-cli
Reduction based machine learning toolkit CLI
-
mlx-optim
Optimizers (AdamW, SGD) and learning rate schedulers
-
iac-rs
🛰️ IAC Protocol for Inter and Intra Agents Communications
-
nnrs
Rust Neural Network Library
-
tocken
Clustering algorithms
-
so-tsa
High-performance statistical computing library written in Rust, exposed to Python via PyO3
-
cubecl-cuda
CUDA runtime for CubeCL
-
langchain
Rust port of the ideas produced in langchain-py and langchain-js
-
smart_ape
A genetic algorithms library
-
concision-ext
implements additional models using the concision framework
-
bevy_rl
Build environments for reinforcement learning with bevy
-
chat-gpt-rs
Rust API Client for OpenAI's GPT3.5 AND GPT4 (ChatGPT) API
-
openblas-provider
The package provides BLAS and LAPACK using the OpenBLAS implementation
-
edgefirst-tflite-sys
Low-level FFI bindings for the TensorFlow Lite C API with runtime symbol loading
-
syft-validate
Local validation runner for syft snapshots
-
mcp-medical
Clinical reference and global health intelligence MCP server — PubMed, WHO GHO, health statistics, medical literature
-
imbalanced-sampling
Resampling algorithms for imbalanced datasets in Rust - SMOTE, ADASYN, RandomUnderSampler
-
tch-plus
Rust wrappers for the PyTorch C++ api (libtorch)
-
edic
command with dictionaries and funcionalities on natural languages
-
mnist_read
Reads generic data and label files in the MNIST file format
-
agnosai
Provider-agnostic AI orchestration framework
-
reply
makes any command-line application a (stateless) REPL
-
rstsr-lapack-ffi
Netlib LAPACK FFI bindings
-
git_statistic
statistic git repository
-
tl_cpu
CPU tensor backend for TL
-
wifi-densepose-nn
Neural network inference for WiFi-DensePose pose estimation
-
hanzo-ai-format
Hanzo AI - Universal .ai file format for AI artifacts
-
blasphemy
Inspired by Keras, powered by BLAS. Construct neural networks with one line of code per layer. That's BLASphemy.
-
gstats
Summarizes repositories under a directory for developers
-
magi-tool
provide tools for Magi AI agents
-
hypersearch
hyperparameter search library
-
easy_stats
package to perform basic descriptive stats on a data set
-
scirs2-graph
Graph processing module for SciRS2 (scirs2-graph)
-
openvino-genai-sys
Low-level bindings for OpenVINO GenAI (use the
openvino-genaicrate for easier-to-use bindings) -
ruqu-neural-decoder
Neural Quantum Error Decoder (NQED) - GNN-based decoder with O(d^2) Mamba state-space architecture
-
perestroika
genetic algorithms
-
sevensense-learning
GNN-based learning and embedding refinement for 7sense bioacoustics platform
-
nerve-ai
Nerve is a tool that allows creating stateful agents with any LLM of your choice - without writing a single line of code. The tool provides to the model a framework of functionalities for planning…
-
baracuda-kernels
Unified ML op facade for the baracuda CUDA ecosystem. Exposes every primitive an ML framework would expect (union of PyTorch torch.* + nn.functional and JAX lax.* / numpy ops) through a single Plan-based Rust surface…
-
glowstick-candle
Integration of glowstick with the candle tensor
-
ai-cli
A CLI tool for all things AI (generating images or audio, chatting with LLM's, you name it)
-
aionic
unified, user-friendly Rust library for seamless integration with various public Language Model APIs, such as openAI
-
oscirs_stats
Statistical analysis crate for scientific computing
-
learnwell
Framework for reinforcement learning
-
web-rwkv-converter
Converts an RWKV PTH model to SafeTensors
-
rs-llama-cpp
Automated Rust bindings generation for LLaMA.cpp
-
cublas
safe Rust wrapper for CUDA's cuDNN
-
brumby-racing
Derivatives and multiples pricing for racing and sports
-
coaster-nn
coaster plugin providing Neural Network operations
-
stitch_core
A scalable abstraction learning library
-
jiro_nn
Neural Networks framework with model building & data preprocessing features
-
ppca
Probabilistic Principal Component Analysis model
-
arrow-ml-activations
Neural network activation functions (ReLU, GELU, Sigmoid, SiLU, Tanh, Softmax) for Apache Arrow arrays
-
tract-nnef
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
muonts
Timeseries models in rust
-
raybnn
RayBNN
-
libffm
Field-aware factorization machines in Rust
-
micro_grad
A minimal autograd + MLP engine in Rust
-
chatgpt_wd
personalize your web experience
-
onnxruntime-sys
Unsafe wrapper around Microsoft's ONNX Runtime
-
ai-proxy
The runtime firewall for AI, blocks LLM vulnerabilities in real time
-
agentgraph
Interface for agent graph persistence
-
mlx-sys-burn
Low-level interface and binding generation for the mlx library (fork with additional operations for burn-mlx)
-
llm_devices
Device management and build system for LLM inference
-
forester
implementing various flavors of random forests and decision trees
-
hyperparameter
A high performance configuration system for Rust
-
superluminal
Deep learning at the speed of light
-
stonnx
run inference on ONNX models
-
google-translate2
A complete library to interact with Translate (protocol v2)
-
mlx-nn
Neural network modules: Linear, LayerNorm, Attention, etc
-
jepa-compat
Checkpoint and ONNX compatibility utilities for jepa-rs models
-
niura
Automatic differentiation in pure Rust
-
tensorflowlite
A safe Rust wrapper of TensorFlow Lite
-
mnemefusion-llama-cpp-sys-2
Low Level Bindings to llama.cpp (MnemeFusion fork with build fixes)
-
ghostflow-optim
Optimizers for GhostFlow ML framework
-
linfa-logistic
A Machine Learning framework for Rust
-
cervo-onnx
Extends cervo with ONNX support from tract-onnx
-
blazon-core
Core functionality for blazon - a fast minimal badge generator for Rust crate stats
-
imbalanced-core
Core traits and abstractions for imbalanced learning in Rust
-
burn-tch
LibTorch backend for the Burn framework using the tch bindings
-
savant
Generate flash cards from PDF files using an LLM
-
rstsr-linalg-traits
An n-Dimension Rust Tensor Toolkit
-
brainy
neural networks
-
tensorrt-infer
Safe Rust wrappers for NVIDIA TensorRT inference
-
chatgpt_api
Use ChatGPT easily from Rust. Or from the command line.
-
tract-tensorflow
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
burn-mnist
train a simple neural network on mnist dataset using burn
-
border-tensorboard
Tensorboard for Border
-
emixai
Feature-gated AI helpers (audio, imaging, language, vision) for EssentialMix
-
kalosm-common
Helpers for kalosm downloads and candle utilities
-
noether-engine
Noether composition engine: Lagrange graph AST, type checker, planner, executor, semantic index, LLM-backed composition agent
-
mli_mep
Multi Expression Program implementation for mli
-
lance-index
Lance indices implementation
-
mcp-langbase-reasoning
MCP server providing structured reasoning via Langbase Pipes - linear, tree, divergent, Graph-of-Thoughts, and decision framework modes
-
esopt
General Evolution-Strategy-Optimizer implementation according to https://arxiv.org/abs/1703.03864 in Rust
-
rogue-net
Pure Rust implementation of the RogueNet neural network
-
descartes-metrics
Metrics crate for DesCartes
-
parenchyma
A high-performance computing (HPC) framework
-
oar-ocr-core
Core types and predictors for oar-ocr
-
tensorflow-protos-rs
Protobuf codegen crate for tensorflow
-
mlx-sys
Low-level interface and binding generation for the mlx library
-
rs_ai_core
(UNSTABLE; in active development) Core traits, types, middleware, cache config, UI stream, and observability for the Rusty AI SDK. Includes: LanguageModel trait, Prompt/StreamEvent types…
-
prefrontal
A blazing fast text classifier for real-time agent routing, built in Rust
-
alith-models
Load and Download LLM Models, Metadata, and Tokenizers
-
rten-imageio
loading images for use with RTen
-
haagenti-importance
ML-guided fragment importance scoring for intelligent model loading
-
basilisk
autonomous AI written in rust
-
ray_4
Minimal Rust package for Ray 4 AI image generator tool page metadata and docs.rs indexing
-
relayrl_algorithms
A collection of Multi-Agent Deep Reinforcement Learning Algorithms (IPPO, MAPPO, etc.)
-
simple-chatgpt
ChatGPT library for chatbot and CLI tool using this library
-
rcublas
safe Rust wrapper for CUDA's cuBLAS
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
openml
interface to OpenML
-
sklears-neighbors
Neighbor-based algorithms for sklears: k-NN, radius neighbors
-
fpl_api
Rust bindings for the Fantasy PL API
-
hpt-dataloader
An internal library for data loading for hpt
-
palace
mounting datasets into memory for fast loading in deep learning tasks
-
moshi-cli
moshi, a real-time voice AI
-
lumen-python
A tiny ML framework
-
compiled-nn-bindings
A JIT Compiler for Neural Network Inference
-
ferrite-dl
Deep learning library written in pure Rust
-
xvc-logging
Logging crate for Xvc
-
torsh-autograd
Automatic differentiation engine for ToRSh with PyTorch-compatible API
-
mwa_hyperbeam
Primary beam code for the Murchison Widefield Array (MWA) radio telescope
-
gcn_agg
Aggregates GCN data
-
entity-gym-rs
Rust bindings for the entity-gym library
-
imbalanced-ensemble
Ensemble methods for imbalanced learning in Rust - Balanced Random Forest and more
-
infernum-asmodeus
Model fine-tuning and adaptation layer - The King of Demons shapes minds
-
forestfire-inference
Inference-facing traits and helpers for ForestFire models
-
elm
A minimalist framework for Extreme Learning Machines (ELMs)
-
wisard
nets implementation in Rust
-
pyrus-nn
Micro Neural Network framework
-
yscv-detect
Object detection pipeline with YOLOv8, NMS, and heatmap decoding
-
relearn
A Reinforcement Learning library
-
gen-ai
Generative AI
-
apiari-codex-sdk
Rust SDK for the Codex CLI — spawn and stream codex exec sessions
-
ml_kit
A Machine Learning library for Rust
-
pharia-skill-test
Test helpers for testing Pharia Kernel skill components locally
-
cnocr_rs
一份来自python cnocr的Rust实现
-
rlox-burn
Burn backend for rlox neural network training
-
inference
managing the machine learning inference process
-
sarek
A work-in-progress, experimental neural network library utilizing TensorFlow Keras
-
cervo-nnef
Extends cervo with nnef support from tract-nnef
-
dset
processing and managing dataset-related files, with a focus on machine learning datasets, captions, and safetensors files
-
converge-knowledge
A self-learning knowledgebase with vector search, gRPC, and MCP interfaces
-
cldnn-sys
Low-level Rust bindings to Intel's Compute Library for Deep Neural Networks
-
rl_examples
Examples of reinforcement learning algorithms
-
rust-faces
face detection
-
crabml
core package
-
crabml-llama2
crabml llama2 support
-
pixverse_c1
Minimal Rust package for Pixverse C1 tool page metadata and docs.rs indexing
-
block-graph
Uses the Burn library to provide block level graph neural network structure
-
coraline
semantic code knowledge graph for faster AI-assisted development
-
rlevo-evolution
Evolutionary algorithms for rlevo (internal crate — use
rlevofor the full API) -
asimov-snapshot
ASIMOV Software Development Kit (SDK) for Rust
-
tensorflow-serving-client
A prebuilt tensorflow serving client from the tensorflow serving proto files
-
egraph
variant machine learning
-
ghostflow-cuda
CUDA backend for GhostFlow ML framework
-
micro_cartan_attn
Complete Cartan matrix attention mechanisms with proper Lie algebra structures
-
llama_link
A llama.cpp server interface
-
concision-data
additional tools for working with datasets
-
jawe-cuvs-sys-ii
Low-level rust bindings to libcuvs
-
cuda11-cudnn-sys
cuda ffi
-
rlx-driver
RLX driver layer — device handles, arenas, buffers, command streams
-
shrew-ir
Parser and IR for the .sw (Shrew) declarative model format
-
ai-dataloader
PyTorch DataLoader
-
mistralrs-vision
Fast, flexible LLM inference
-
stamm
implementing custom decision trees and random forests
-
eulumdat-ffi
FFI bindings for eulumdat - enables use from Swift, Kotlin, Python, and other languages
-
quill-mlx-sys
Low-level FFI bindings for Apple's MLX machine learning framework
-
genetic
a little lib to use genetic algorithm
-
sklearn-rs
A scikit-learn inspired machine learning library in Rust
-
openai_gpt_rs
A wrapper for OpenAI API written in Rust
-
cntk
Wrapper around Microsoft CNTK library
-
lightgbm-rust
Rust bindings for LightGBM, a gradient boosting framework. Downloads LightGBM binaries at build time for cross-platform compatibility.
-
ferrolearn-python
Python bindings for ferrolearn via PyO3
-
linfa-trees
A collection of tree-based algorithms
-
rs-cinic-10-burn
Burn bindings for rs-cinic-10
-
menoh
Binding for Menoh
-
bytepiece
Rust version of bytepiece tokenizer
-
tease
Rapidly prototype interfaces for your machine learning models
-
blis-sys2
FFI bindings for BLIS library (depends on blis-src)
-
ferrotorch-diffusion
Stable-Diffusion-family model composition for ferrotorch (Phase B.3: VAE decoder)
-
hodu_utils
hodu utils
-
darknet-sys
-sys crate for Rust darknet wrapper
-
greenglas
Data Preprocessing library for Machine Learning
-
micro_swarm
Swarm orchestration and coordination for micro-neural networks
-
onde-mistralrs-vision
Fast, flexible LLM inference
-
aiha
🦉 AIHA helps you to find the minimal requirements for any model on the 🤗 Hub
-
ferrolearn
A scikit-learn equivalent for Rust — re-export crate
-
transcript-bot
Sits in Telegram groups, listens for audio and voice files, transcribes them using AssemblyAI and summarises them using OpenAI GPT3
-
lmql
A general-purpose async streaming large language model interface
-
burn-flex
A fast, portable CPU backend for the Burn framework
-
collenchyma-blas
Collenchyma library for full BLAS support
-
forge-core-executors
Task executors for the Forge framework - handles task lifecycle and execution
-
dndtools
Various CLI tools and library for D&D 5e
-
fast_text
Binding for Facebook's FastText package
-
edge-transformers
wrapper over ONNXRuntime that implements Huggingface's Optimum pipelines for inference and generates bindings for C# and C
-
live-iron
A performant, extensible cellular and genetic automata library for Rust
-
purpur
A data loading and image augmentation library
-
hotg-rune-proc-blocks
Core tools and abstractions for developing proc blocks in Rune
-
rstsr-aocl-ffi
Intel AMD Optimizing CPU Libraries FFI bindings
-
burn-efficient-kan
An efficient pure-Rust implementation of Kolmogorov-Arnold Network (KAN)
-
dandelion-core
Core framework for dandelion multi-backend LLM inference engine
-
syft-core
Core application services for syft
-
oxidized-transformers
Transformers library (not functional yet)
-
jaime
j.a.i.m.e. is an ergonomic all purpose gradient descent engine
-
scirs2-python
Python bindings for SciRS2 - A comprehensive scientific computing library in Rust (SciPy alternative)
-
neuralassimilator
fine-tuning Language Learning Models (LLMs) from unstructured text
-
cuttle
A large language model inference engine in Rust
-
hpt-cudakernels
implements cuda kernels for hpt
-
vailence
command-line utility designed for detecting violence or threats by leveraging the OpenAI omni-moderation model
-
xgboostrs
Machine learning using XGBoost
-
callm
Run Generative AI models directly on your hardware
-
grain-llm-models
Standardized LLM model registry for grain-agent. Embeds a vendored snapshot of model metadata (context window, capabilities, pricing, thinking profile); the
fetchfeature pulls live data from models.dev. -
ai-chain-openai
implementing
ai-chainsfor OpenAI’s models. Chains can be use to apply the model series to complete complex tasks, such as text summation. -
blis-src
Rust native linking for BLIS library
-
mcai-onnxruntime-sys
Unsafe wrapper around Microsoft's ONNX Runtime
-
accelerate-provider
The package provides BLAS and LAPACK using Apple’s Accelerate framework
-
baracuda-kernels-sys
Compiled bespoke .cu kernel template instantiations for the baracuda ML kernel facade plus C-ABI FFI facades for the library-backed plans (cuDNN conv/pool, cuSOLVER linalg, cuFFT/cuRAND…
-
tsai_analysis
Analysis utilities: confusion matrix, top losses, permutation importance for tsai-rs
-
axonml-onnx
ONNX import/export support for the Axonml ML framework
-
smartcore_proba
Fork of smartcore with predict_proba support
-
gathers
Clustering algorithms
-
sysblas
Minimal CBLAS FFI bindings to system BLAS
-
rblas
BLAS bindings and wrappers
-
onde-mistralrs-audio
Fast, flexible LLM inference
-
libxc
wrapper for Rust
-
neural-trader-predictor
Conformal prediction SDK/CLI for neural trading with guaranteed intervals
-
executorch-sys
Unsafe Rust bindings for ExecuTorch - On-device AI across mobile, embedded and edge for PyTorch
-
oximedia-scene
Scene understanding and AI-powered video analysis for OxiMedia
-
rstorch
from scratch of a neural network framework in Rust inspired by PyTorch
-
bmls
Basic Machine Learning Subsystems
-
mcai-graph-renderer
Graph renderer for Media Cloud AI Workflows representation
-
nove_model
lightweight deep learning library wrapped around Candle Tensor
-
frlearn_core
Core traits, errors, and score utilities for the FuzzyRough Rust workspace
-
open_ai_api
wrapper for the OpenAI API
-
libsvm
High level Rust bindings for libsvm
-
evo-rl
A neuroevolution-based ML library for reinforcement learning inspired by NEAT
-
ttv
Create train, test and validation sets from text files
-
candle-ext
An extension library to Candle that provides PyTorch functions not currently available in Candle
-
vernier-mask
COCO RLE codec, polygon rasterizer, and mask kernels for the vernier evaluation library
-
lance-tokenizer
Tokenizer abstractions and implementations for Lance
-
ruqu-qgat-mol
Quantum Graph Attention for Molecules - combines quantum mechanics with graph attention networks for molecular simulation
-
imbalanced-metrics
Performance metrics for imbalanced learning in Rust - F1, precision, recall, confusion matrix
-
umi-memory
Memory library for AI agents with deterministic simulation testing
-
xgboost-rs
Bindings to dmlc/xgboost
-
tsai_train
Training loop, callbacks, metrics, and checkpointing for tsai-rs
-
tensorlib
Tensor library
-
hpt-allocator
An internal library for memory allocator for hpt
-
cortenforge-burn-dataset
Dataset loading, splitting, and Burn-compatible batching utilities for CortenForge
-
aorist
Cdylib for aorist project. Can be accessed from Python.
-
fast-neural-network
A heavily parallelized neural network library designed for speed and flexability
-
architect-linter-pro
Multi-language software architecture linter written in Rust
-
RayBNN_Cell
Cell Position Generator for RayBNN
-
smelte-rs
Efficient inference ML framework written in rust
-
candle_embed
Text embeddings with Candle. Fast and configurable. Use any model from Hugging Face. CUDA or CPU powered.
-
glowstick-burn
Integration of glowstick with the burn tensor
-
nove_learner
lightweight deep learning library wrapped around Candle Tensor
-
cust
High level bindings to the CUDA Driver API
-
libcantal
submit statistics to cantal monitoring server
-
whisper-cpp-plus-sys
Low-level FFI bindings for whisper.cpp
-
naivebayes
Naive Bayes classifier
-
replic
Replicate Rust SDK
-
mlua-tract
Lua bindings for tract, the tiny, no-nonsense, self-contained, Rust-based Tensorflow and ONNX inference runtime
-
openai-magic-instantiate
Use LLMs to instantiate well-typed values
-
lrclassifier
logistic regression classifier implementation
-
koharu-runtime
Manga translation tools
-
nove_optimizer
lightweight deep learning library wrapped around Candle Tensor
-
gpt_tokenizer
Rust BPE Encoder Decoder (Tokenizer) for GPT-2 / GPT-3
-
lumen-io
A tiny ML framework
-
calib-targets-print
Printable calibration target generation for chessboard, ChArUco, PuzzleBoard, and marker boards
-
koho
A deep learning model for spectral diffusion over k-cells in arbitrary cell complexes, built on
candle -
oxicuda-recsys
Recommender-system primitives for OxiCUDA — ALS/BPR/NMF, NCF, Two-Tower, DeepFM/AutoInt, SASRec/BERT4Rec, LightGCN/NGCF, MMoE/PLE/ESMM, negative sampling, ranking metrics
-
onnxruntime-sys-patch
Unsafe wrapper around Microsoft's ONNX Runtime
-
hodu_core
hodu core
-
feature-factory
A high-performance feature engineering library for Rust powered by Apache DataFusion
-
HPGO
Hybrid Parallelism Global Orchestration
-
ta-goal
GoalRun lifecycle management and event dispatch for Trusted Autonomy
-
zyx-compiler
Zyx OpenCL backend
-
axonml-autograd
Automatic differentiation engine for Axonml ML framework
-
webpack-q-cli
Ask questions about webpack compilation statistics
-
candle-examples
Minimalist ML framework
-
ferrotorch-distributions
Probability distributions for ferrotorch — PyTorch in Rust
-
concision-transformer
implements the transformer model using the concision framework
-
candle-flash-attn-v3
Flash attention v3 layer for the candle ML framework
-
simple_llama
run llama.cpp in Rust. based on llama-cpp-2
-
ghostflow-autograd
Automatic differentiation for GhostFlow ML framework
-
neural_networks_rust
Neural Networks framework with model specification & data preprocessing features
-
lance-table
Lance table format
-
torsh-linalg
Linear algebra operations for ToRSh with SciRS2 integration
-
zlearn
neural network implementation library in Rust
-
openblas-blas-provider
BLAS/LAPACK provider using the OpenBLAS implementation
-
constensor-core
Experimental ML framework featuring a graph-based JIT compiler
-
kv-cache
LLM inference in Rust
-
tangram_kill_chip
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
trustformers
port of Hugging Face Transformers
-
mongodb-voyageai
A client for generating embeddings and reranking with Voyage AI
-
aiassistant
AI API library
-
jepa-core
Core traits and abstractions for JEPA (Joint Embedding Predictive Architecture)
-
syron
building, training and running basic neural networks
-
ducky-learn
ML rust framework
-
tsai_data
Dataset and dataloader implementations for tsai-rs time series deep learning
-
asimov-graph
ASIMOV Software Development Kit (SDK) for Rust
-
torsh-data
Data loading and preprocessing utilities for ToRSh
-
tract-gpu
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
decision_transformer_dfdx
A fast, extensible implementation of Decision Transformers in Rust using dfdx. Based on the paper Decision Transformer: Reinforcement Learning via Sequence Modeling.
-
rai-opt
ML framework with Ergonomic APIs in Rust
-
ug-metal
Micro compiler for tensor operations
-
rail
A GPU-Accelerated ML Library akin to Keras
-
vil_cli
VIL CLI - Vastar Intermediate Language zero-copy streaming pipelines for Rust
-
kn-graph
A neural network inference graph intermediate representation, with surrounding utilities
-
taskstats
high-level encapsulation of Linux's per-task statistics interface
-
burn_depth
burn depth pro model inference
-
cudnn
safe Rust wrapper for CUDA's cuDNN
-
hs-predict
HS code prediction for chemical products — Akinator-style interactive classification with rule-based and LLM hybrid engine
-
mistralrs-audio
Fast, flexible LLM inference
-
bitnet-cpp
bitnet.cpp bindings for Rust
-
libtenx
building AI-assisted coding tools, with session management, patch validation, and multiple model support
-
airsim
an unofficial Airsim SDK written in Rust
-
hanzo-ml
Minimalist ML framework
-
ltx_3
Minimal Rust package for LTX 3 tool page metadata and docs.rs indexing
-
quizx
Quantum Circuit Optimisation and Compilation using the ZX-calculus
-
agent-code
An AI-powered coding agent for the terminal, written in pure Rust
-
prior
generating priors for prior fitted networks
-
yscv-kernels
CPU and GPU compute backends with SIMD dispatch and BLAS integration
-
hodu_internal
hodu internal
-
jawe-cuvs-sys-iii
Low-level rust bindings to libcuvs
-
pmetal-bridge
Zero-allocation MLX bridge — standalone C++ layer that replaces mlx-rs
-
candle-mi
Mechanistic interpretability for language models in Rust, built on candle
-
mnist_reader
Download the MNIST dataset and simply read it
-
clblast
bindings for rust
-
shrew-optim
Optimizers (SGD, Adam, AdamW) for Shrew
-
openai-api-stream-rs
that provides a simple function for interacting with the OpenAI API and performing language-based tasks. This crate focuses on streaming responses from the API, enabling real-time processing of large amounts of data.
-
border-async-trainer
Asynchronous trainer for Border
-
tensor-rs
A typeless tensor library
-
rlevo-benchmarks
Benchmarking harness for rlevo (internal crate — use
rlevofor the full API) -
tract-api
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
syft-store
Metadata and object store abstractions for syft
-
lightgbm
Machine learning using LightGBM
-
rstsr-openblas
An n-Dimension Rust Tensor Toolkit
-
tensorgraph-math
backbone for tensorgraph, providing math primitives
-
slow_nn
A slow neural network library
-
ruvector-attention-node
Node.js bindings for ruvector-attention
-
ones
sdk for ones.ai
-
localgpt-core
Core library for LocalGPT — agent, memory, config, security
-
azure_mgmt_machinelearningexperimentation
generated REST API bindings
-
tract-libcli
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
rmlx
High-performance ML inference framework for Apple Silicon (Metal GPU)
-
torch-sys-plus
Low-level FFI bindings for the PyTorch C++ api (libtorch)
-
gptrust_api
Rust binding of OpenAI/GPT-3 API
-
custos
A minimal OpenCL, WGPU, CUDA and host CPU array manipulation engine
-
blingfire-sys
Bindings to the BlingFire C++ library
-
kornia-core-ops
Tensor operations library in Rust for computer vision
-
hipblas-sys
Bindings for HIP blas
-
aprender-zram
SIMD-accelerated LZ4/ZSTD compression engine for Linux zram devices
-
ai-chain-glm
implementing
ai-chainsfor moonshot OpenAI’s models. Chains can be use to apply the model series to complete complex tasks, such as text summation. -
lance-examples
Lance examples in Rust
-
intent-classifier
A flexible few-shot intent classification library for natural language processing
-
kaffe
Pytorch, but make it rust :)
-
rgen-core
Core graph-aware code generation engine
-
litert-sys
Raw FFI bindings to Google's LiteRT (TFLite) C API
-
neurorvq
biosignal tokenizer — inference in Rust with Burn ML
-
moshi-server
moshi, a real-time voice AI
-
mlx-internal-macros
Internal procedural macros for mlx-rs
-
potato-utils
your potatoes
-
nano-consciousness
High-performance consciousness-inspired AI framework with nanosecond scheduling and temporal processing
-
infernum-core
Core types and traits for the Infernum ecosystem
-
alith-interface
The Backend for the alith-client Crate
-
mkl_link
linking with MKL
-
huggingface_inference_rs
this package is a small wrapper for hugging face Inference API
-
lemma
scientific computation in Rust
-
proximal-optimize
port of proxmin
-
onnx-runner
Use ORT to run ONNX model
-
xn
minimalist deep-learning framework optimized for inference
-
burn-cubecl
Generic backend that can be compiled just-in-time to any shader language target
-
aw-watcher-agent
ActivityWatch watcher for code agent sessions — tracks session duration, models, token usage, and costs
-
llm_models
Load and download LLM models, metadata, and tokenizers
-
aperature
Object detection using single shot multibox detector
-
openai-rusty
wrapper for the OpenAI API
-
linfa-ensemble
A general method for creating ensemble classifiers
-
aprender-core
Next-generation machine learning library in pure Rust
-
solrstice
A Solr 8+ client
-
tensorrt-rs
using Nvidia's TensorRT deep learning acceleration library
-
copilot-sdk-supercharged
Rust SDK for programmatic control of GitHub Copilot CLI via JSON-RPC 2.0
-
tvm-rt
Rust bindings for the TVM runtime API
-
bindgen-litert-debug-maxgubin
LiteRT rust binding
-
axonml-core
Core abstractions for the Axonml ML framework
-
tf-rs
High level (Pythonic) API for the TensorFlow framework
-
ferrotorch-grammar
Constrained-decoding grammar processors (JSON-schema → token-allow masks) for ferrotorch
-
rstsr-tblis
An n-Dimension Rust Tensor Toolkit
-
xgboost
Machine learning using XGBoost
-
tensorflow-sys-runtime
The package provides runtime bindings to TensorFlow
-
eryon-surface
works to materialize the surface of individual actors within the eryon framework using topological data analysis and machine learning techniques
-
rust_sls
Sequential Line Search for Design Optimization
-
concision-kan
implements the kan model using the concision framework
-
kiss-ai
Code-quality metrics tool for Python and Rust
-
openairs
efficient wrapper around the OpenAI API
-
linfa-preprocessing
A Machine Learning framework for Rust
-
rsrl_domains
Toy domains for reinforcement learning research in Rust
-
ferrotorch-gpu
CUDA GPU backend for ferrotorch
-
soma-core
World's first production-ready self-aware development system with meta-cognitive capabilities and cognitive reasoning engine for intelligent development platforms
-
kornia-core
Lightweight tensor library in Rust for computer vision
-
forge-core-utils
Core utilities for the Forge task execution framework
-
rusty_science
An easy to learn and use ML toolkit for rust
-
libsvm-sys2
FFI bindings to libsvm
-
tensorrt
Rust wrapper for NVIDIA TensorRT
-
chat
AI platform agnostic cli
-
nove_dataset
lightweight deep learning library wrapped around Candle Tensor
-
llm-chain-llama-sys
bindings based on bindgen for LLaMA.cpp
-
nove_dataloader
lightweight deep learning library wrapped around Candle Tensor
-
openai_http_client
A strongly-typed client for the OpenAI HTTP API
-
aocl-data-analytics-sys
Unsafe FFI bindings to AOCL-DA (Data Analytics)
-
tsai_explain
Explainability: activation/gradient capture, attribution maps for tsai-rs
-
tensorrt-sys
Low level wrapper around Nvidia's TensorRT library
-
luminal_cuda
Cuda compiler for luminal
-
hanzo-datasets
Minimalist ML framework
-
openai-schemars
generate JSON Schemas compatible with OpenAI's function calling API
-
asimov-registry
ASIMOV Software Development Kit (SDK) for Rust
-
oximedia-neural
Lightweight neural network inference for media processing — pure Rust tensor ops, conv2d, and pre-defined media models
-
drfoo
OpenAI ChatGPT framework
-
dendritic-trees
Pacakge for tree based modeling
-
aotinductor
Rust wrappers for the PyTorch AOTInductor api
-
zyx-torch
Zyx libtorch backend
-
deep_rust
Machine learning crate in Rust (under dev)
-
cuda-rt
Manga translation tools
-
axonml-train
High-level training, benchmarking, and adversarial training infrastructure for AxonML
-
shogun
bindings for Rust
-
c-wrapper
wrapper crate providing C bindings for SurrealML
-
RayBNN_Optimizer
Gradient Descent Optimizers and Genetic Algorithms using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
calib-targets
Main entry point crate for a collection of plain calibration target detectors built on top of ChESS corners
-
jawe-cuvs-sys-iv
Low-level rust bindings to libcuvs
-
ug-cuda
Micro compiler for tensor operations
-
tensorlogic-trustformers
Transformer-as-rules: Self-attention and FFN layers as einsum expressions
-
hanzo-nn
Minimalist ML framework
-
aprender-serve
Pure Rust ML inference engine built from scratch - model serving for GGUF and safetensors
-
linfa-svm
Support Vector Machines
-
cudf
Safe Rust bindings for NVIDIA libcudf -- GPU-accelerated DataFrame operations
-
rl
A reinforcement learning library
-
entrenar-lora
LoRA/QLoRA configuration optimizer and memory planner
-
chat-splitter
Never exceed OpenAI's chat models' maximum number of tokens when using the async_openai Rust crate
-
yscv
Rust computer vision and deep learning framework
-
lance-io
I/O utilities for Lance
-
coaster-blas
Coaster library for full BLAS support
-
ferrolearn-metrics
Classification and regression metrics for the ferrolearn ML framework
-
lance-arrow-scalar
Arrow scalar type with Ord, Hash, and Eq support
-
linfa-elasticnet
A Machine Learning framework for Rust
-
zeph-common
Shared utility functions and security primitives for Zeph crates
-
mlx-macros
Procedural macros for mlx-rs
-
tract
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
ai-chain-qdrant
For using Qdrant with ai-chain
-
mai-sdk-core
MAI SDK Core
-
pmetal-trainer
Training loops and optimization for PMetal
-
cudnn-sys
FFI bindings to cuDNN
-
border-py-gym-env
Python Gym environment for Border
-
tenflowers
Pure Rust implementation of TensorFlow - A comprehensive deep learning framework
-
mcp-commune
Rust client and server for building discoverable Model Context Protocol (MCP) networks
-
tangram_features
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
vibeland-conf
Shared configuration and LLM client harness for Vibeland project
-
wandb
Weights & Biases Rust SDK
-
burn-named-tensor
Named tensor support for burn tensors
-
baracuda-cutensor-sys
Raw FFI bindings and dynamic loader for NVIDIA cuTENSOR (tensor contraction)
-
rgpot-core
Core Rust library for rgpot: RPC-based potential energy surface calculations
-
rai-datasets
ML framework with Ergonomic APIs in Rust
-
burn_dragon_core
burn dragon core model and utilities
-
burn-collective
Backend extension for collective calculations
-
tangram_id
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
iro-cuda-ffi
IRO CUDA FFI - A minimal, rigid ABI boundary for Rust to orchestrate nvcc-compiled CUDA kernels
-
tensorgraph-sys
backbone for tensorgraph, providing memory manamagement across devices
-
pmrs
Rust support to process mining functions. Includes a library and a small cli-interface.
-
kalosm-learning-macro
A macro to derive kalosm learning traits
-
rcudnn-sys
FFI bindings to cuDNN
-
tblis-ffi
FFI bindings of TBLIS
-
egemma
Rust ONNX inference library for Google's EmbeddingGemma (text embeddings)
-
tract-data
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
burn-common
Common crate for the Burn framework
-
ipopt-ad
Blackbox NLP solver using IPOPT and automatic differentiation
-
machinebox
A client SDK for communicating with machinebox boxes
-
aphelion-macros
Procedural macros for Aphelion AI pipeline framework
-
burn-train
Training crate for the Burn framework
-
openai-fork
An unofficial Rust library for the OpenAI API
-
rknpu2-sys
Unofficial bindings to rknpu2 (librknnrt and librknnmrt)
-
child_ai_json_engine
JSON engine for collecting, aggregating, and managing models
-
llm-chain-mock
Use
llm-chainwith a mock backend. Useful for testing. -
micro_core
Core no_std Semantic Cartan Matrix implementation for rUv-FANN
-
ghostflow-ffi
C FFI bindings for GhostFlow ML framework
-
gpt-doc-gen
A CLI to document Rust code
-
training-tools
Training monitoring, HuggingFace integration, and checkpoint management for rust-ai
-
randomforests
random forest classifier
-
gpt_core
chatGPT UI's core crate. Offer the basic functionalities and mock server for chatGPT UI.
-
candle-pyo3
Minimalist ML framework
-
trustformers-debug
Advanced debugging tools for TrustformeRS models
-
gpqa
assess Egor GPs quality saved using GP recorder
-
cervo-core
High level APIs for RL in games
-
rusty-ai
Machine Learning
-
optirs
Advanced ML optimization and hardware acceleration library (main integration crate)
-
mobilenet_v2
This application is designed to be used as a command from a WebAssembly function running inside the SSVM to perform native tensorflow operations. Please see documentation for more details.
-
lgp-core
solve problems using linear genetic programming
-
ferrotorch-vision
Vision models, datasets, and transforms for ferrotorch
-
eryon-plants
focuses on implementing various actors for the eryon framework
-
mltop
Resource monitor for ML engineers written in Rust
-
hibachi
Asynchronous Batched Inference Platform
-
asimov-universe
ASIMOV Software Development Kit (SDK) for Rust
-
linfa-kernel
Kernel methods for non-linear algorithms
-
concision-utils
Concision is a toolkit for designing machine-learning models in Rust
-
float4
MXFP4-compatible 4-bit floating point types and block formats for Rust
-
ai-buddy
On-Device centric multi-provider AI Assistant library to be used in CLI or on-device applications
-
tiny-ml
A very basic ml libary
-
cuda_dnn
cuDNN API bindings
-
nanograd
A nano neural network library. Scalar valued types with a PyTorch like API.
-
torsh-nn
Neural network modules for ToRSh with PyTorch-compatible API
-
rlevo-hybrid
Hybrid evolutionary + RL strategies for rlevo (internal crate — use
rlevofor the full API) -
maidenx
Rust ML Framework for Maiden Engine
-
babichjacob-llama-cpp-sys-2
Low Level Bindings to llama.cpp
-
oxicuda-anomaly
Anomaly detection primitives for OxiCUDA — DeepSVDD, AE/VAE reconstruction, LOF, COPOD, isolation scoring, statistical methods, ensemble
-
davinci
simply using davinci model from OpenAi API
-
bropilot
A fun and efficient Rust library to count tokens in text files using different tokenizers
-
mtcnn
This application is designed to be used as a command from a WebAssembly function running inside the SSVM to perform native tensorflow operations. Please see documentation for more details.
-
ferrolearn-preprocess
Preprocessing transformers for the ferrolearn ML framework
-
condor
ergonomic wrapper around the tch library for Rust
-
galois-kernels
galois cuda kernels
-
pfile
A cli wrapper around OpenAI to generate files/snippets in different languages that work for me
-
libdt
training neural networks
-
a8e-core
Articulate (a8e): The sovereign AI operator for your terminal
-
candle-birnn
implement Pytorch LSTM and BiDirectional LSTM with Candle
-
hmll-sys
Low-level FFI bindings to the hmll library for high-performance ML model loading
-
lance-linalg
A columnar data format that is 100x faster than Parquet for random access
-
zyx-opencl
Zyx OpenCL backend
-
hpt-types
An internal library define primitive types functions for hpt
-
aprender-quant
K-quantization formats (Q4_K, Q5_K, Q6_K) for GGUF/APR model weights
-
image_captioner
Create captions for images automatically using the BLIP deep learning model
-
burn_dragon_hatchling
burn (baby) dragon hatchling inference and training
-
menoh-sys
Low-level binding for Menoh
-
glowrs
SentenceTransformers for candle-rs
-
border-candle-agent
Candle agent for Border
-
xgboost-rust
Rust bindings for XGBoost, a gradient boosting library for machine learning. Downloads XGBoost binaries at build time for cross-platform compatibility.
-
llm-chain-milvus
Driver for the Milvus vector store
-
lrtc
Compression-based low-resource text classification as introduced in Jiang et al (2023)
-
burn-nn
Neural network building blocks for the Burn deep learning framework
-
ferrolearn-linear
Linear models for the ferrolearn ML framework
-
diffusion_rs_core
Core package of diffusion_rs
-
nove_metric
lightweight deep learning library wrapped around Candle Tensor
-
pmetal-merge
Model merging toolkit for PMetal - SLERP, TIES, DARE, and more
-
lumen-core
A tiny ML framework
-
ferrotorch-mps
Apple Silicon (Metal Performance Shaders) backend skeleton for ferrotorch
-
lightgbm2
Machine learning using LightGBM
-
gene-evo
Standard and novel genetic evolution algorithm implementations, using advanced rust std functionality and zero dependencies
-
rcublas-sys
FFI bindings to cuBLAS
-
mastishq
under construction, this is reserving the name
-
tflite-dyn
Rust bindings for TensorFlow Lite C API
-
calib-targets-charuco
ChArUco board detector built on top of calib-targets-core
-
openai_client
Client library for using the OpenAi Api
-
ferrolearn-neighbors
Nearest neighbor models for the ferrolearn ML framework
-
ferrolearn-fetch
Network fetchers + on-disk cache for sklearn-style datasets (California housing, OpenML, 20newsgroups, etc.)
-
baracuda-cvcuda-sys
Raw FFI bindings and dynamic loader for NVIDIA CV-CUDA (computer-vision operators)
-
zeph-sanitizer
Content sanitization, exfiltration guard, PII filtering, and quarantine for Zeph
-
diffusion_rs_cli
CLI for diffusion_rs
-
edgeflow
Edge ML inference — SDK and runtime
-
torsh-special
Special mathematical functions for ToRSh with SciRS2 integration
-
tract-linalg
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
lama
Manga translation tools
-
openai-test
A test for publishing to crates.io
-
hodu_cuda_kernels
hodu cuda kernels
-
ferrite-ml
was moved to ferrite-dl
-
openai_api_client
OpenAI API client for Rust
-
burn-fusion
Kernel fusion backend decorator for the Burn framework
-
zenu-cuda-config
CUDA configuration for Zenu
-
tinygrad
You like pytorch? You like micrograd? You love tinygrad! ❤️
-
candle-datasets
Minimalist ML framework
-
tangram_linear
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
tract-metal
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
inferno-ai
Enterprise AI/ML model runner with automatic updates, real-time monitoring, and multi-interface support
-
ksnn
or Kosiorek's Simple Neural Networks, is a crate that simplifies the creation, training, and validation of a neural network. The crate is heavily inspired by "Neural Networks from Scratch…
-
tvm
Rust frontend support for TVM
-
ndarray-tensorflow
Adapter for Tensorflow tensors to expose the ndarray API
-
Brains
Rust based Artificial Neural Network framework with TensorFlow
-
tvm-graph-rt
A static graph runtime for TVM
-
diffusion_rs_backend
Blazingly fast inference of diffusion models
-
tangram_text
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
asimov-proxy
ASIMOV Software Development Kit (SDK) for Rust
-
yscv-pipeline
TOML-driven pipeline configuration + multi-accelerator dispatch for FPV/edge deployments
-
zenu-layer
neural network layer library
-
rai-core
ML framework with Ergonomic APIs in Rust
-
concision-traits
implements the core modules for the concision framework
-
rust_nn
An educational Neural Network framework in Rust
-
lance-arrow
Arrow Extension for Lance
-
openai_http
A strongly-typed client for the OpenAI HTTP API
-
tensorlogic
Logic-as-Tensor planning layer - meta crate re-exporting all TensorLogic components
-
gollum-compute
Machine Learning and other Compute related support for Gollum
-
gpt4
a cli to interact with the openai gpt4 api
-
rstsr-sci-traits
An n-Dimension Rust Tensor Toolkit
-
openai-realtime
OpenAI Realtime client
-
lance-namespace-datafusion
Lance namespace integration with Apache DataFusion catalogs and schemas
-
DeepIron
machine learning and deep learning
-
shrew-data
Data loading, datasets, and batching for Shrew
-
quickbrain
neural network library
-
easyneural
will let you train neural networks easily
-
treerustler
that implement tree models
-
shimmy-llama-cpp-sys-2
Low Level Bindings to llama.cpp with MoE CPU offloading support
-
lance-tools
Tools for interacting with Lance files and tables
-
burn-autodiff
Automatic differentiation backend for the Burn framework
-
aineed-core
Core library for the aineed AI assistant tool
-
tract-transformers
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
RayBNN_Neural
Neural Networks with Sparse Weights in Rust using GPUs, CPUs, and FPGAs via CUDA, OpenCL, and oneAPI
-
linfa-pls
Partial Least Squares family methods
-
tensorlogic-sklears-kernels
Logic-derived similarity kernels for SkleaRS integration
-
quill-mlx-internal-macros
Internal procedural macros for quill-mlx
-
ai-chain-milvus
Driver for the Milvus vector store
-
zyx-cpu
Zyx cpu backend
-
border-atari-env
Atari environment for Border
-
oner_induction
1R rule induction algorithm
-
axonml-server
REST API server for AxonML Machine Learning Framework
-
eryon
harmonic, topological framework for managing computational entities at scale
-
dqn_variable_ratio_test
generator for a deep q-learning network. Allows for random training intervals, and will be updated to a more stable version later.
-
lance-encoding
Encoders and decoders for the Lance file format
-
ferrotorch-data
Data loading, batching, and transforms for ferrotorch
-
pmetal-lora
LoRA and QLoRA implementations for PMetal
-
ollama_translator
Ollama Translator for natural language
-
torsh
A blazingly fast, production-ready deep learning framework written in pure Rust
-
llm_interface
backend for the llm_client crate
-
ferrolearn-covariance
Covariance estimation for the ferrolearn ML framework
-
burn-cuda
CUDA backend for the Burn framework
-
llm_models_spider
Auto-updated registry of LLM model capabilities (vision, audio, etc.)
-
concision-neural
implements various abstractions for designing neural networks
-
kn-cuda-sys
A wrapper around the CUDA APIs
-
llm_providers
A unified source of truth for LLM providers, models, pricing, and capabilities
-
aprender-train
Training & Optimization library with autograd, LoRA, quantization, and model merging
-
rusty_learn
A small, educational, scikit-learn-like machine learning library written in Rust
-
burn-dataset
dataset APIs for creating ML data pipelines
-
zenu-autograd
autograd library for learning purposes
-
asimov-ontology
ASIMOV Software Development Kit (SDK) for Rust
-
tract-nnef-resources
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
bitnet-cpp-sys
Low Level Bindings to bitnet.cpp
-
zeph-agent-feedback
Implicit correction detection for the Zeph agent: regex-based and LLM-backed detectors
-
llm-chain-local
Use
llm-chainwith a localllmbackend -
openai-realtime-proxy
Safely deploy OpenAI's Realtime APIs in less than 5 minutes!
-
comic-text-detector
Manga translation tools
-
deep_q_network_bindings
generator for a deep q-learning network. Allows for random training intervals, and will be updated to a more stable version later.
-
linfa-tsne
Barnes-Hut t-distributed stochastic neighbor embedding
-
pyo3-tch
Manipulate PyTorch tensors from a Python extension via PyO3/tch
-
yscv-imgproc
100+ SIMD-accelerated image processing operations for u8 and f32
-
silva
A fast Rust inference engine for tree ensemble models supporting XGBoost, LightGBM, and native formats
-
chatgpt_blocking_rs
Blocking ChatGPT API Wrapper
-
tenrso
Production-grade tensor computing stack - meta crate re-exporting all TenRSo components
-
ferrolearn-tree
Decision tree and ensemble models for the ferrolearn ML framework
-
gpt_discord_bot
A Discord bot using GPT-4
-
rstsr-common
An n-Dimension Rust Tensor Toolkit
-
candle-lstm
optimize HuggingFace candle LSTM in some cases
-
diffusers
using Torch
-
aipack
Command Agent runner to accelerate production coding with genai
-
torsh-series
Time series analysis components for ToRSh - powered by SciRS2
-
ferrotorch-hub
Pretrained model registry, download, and caching for ferrotorch
-
rusty_kan
Kolmogorov-Arnold Networks in Rust
-
tensorflow-serving
client
-
cuda11-cutensor-sys
cuda ffi
-
zeph-tui
Ratatui-based TUI dashboard with real-time metrics for Zeph
-
shrew-cpu
CPU backend implementation for Shrew
-
baracuda-tensorrt
Safe Rust API for NVIDIA TensorRT runtime inference
-
llm-shield-models
ML model infrastructure for LLM Shield
-
torsh-functional
Functional programming utilities for ToRSh tensors
-
pmetal-data
Dataset handling and preprocessing for PMetal
-
onde-mistralrs-core
Fast, flexible LLM inference
-
ferrotorch-bert
BERT-family encoder-only model composition and sentence-embedding inference for ferrotorch
-
fleximl-models
Machine learning models available for FlexiML framework
-
cuda11-cudart-sys
cuda ffi
-
ferrotorch-cubecl
Portable GPU backend for ferrotorch via CubeCL (CUDA, ROCm, WGPU)
-
ptts
Pocket TTS inference and serving using xn
-
trustformers-wasm
WebAssembly bindings for TrustformeRS transformer library
-
rlevo-core
Core traits and types for rlevo (internal crate — use
rlevofor the full API) -
cubecl-runtime
that helps creating high performance async runtimes for CubeCL
-
tiktoken-rust
a fast BPE tokeniser for use with OpenAI's models
-
ferrolearn-bayes
Bayesian methods for the ferrolearn ML framework — naive Bayes classifiers and conjugate priors
-
cumath
Cuda-based matrix/vector computations
-
localllm
qwen2 model lib by llama.cpp
-
openai-chat
chatgpt api
-
burn_bdh
burn baby dragon hatchling inference and training
-
border-mlflow-tracking
MLFlow tracking for Border
-
tangram_tree
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
xctch
Bindings for executorch
-
yscv-model
Neural network layers, training loop, model zoo, and data loading
-
linfa-hierarchical
Agglomerative Hierarchical clustering
-
lance-testing
A columnar data format that is 100x faster than Parquet for random access
-
tensorrt-infer-sys
Raw FFI bindings for NVIDIA TensorRT inference
-
zenu-optimizer
optimizer for neural networks
-
dlpack-ffi
DLPack FFI binding
-
eryon-rt
the runtime modules for the eryon framework
-
ferrolearn-kernel
Kernel methods for the ferrolearn ML framework: Nadaraya-Watson and local polynomial regression, Gaussian processes (regression and Laplace-approximation classification), kernel ridge…
-
rstsr-test-manifest
An n-Dimension Rust Tensor Toolkit
-
mimi-pyo3
moshi, a real-time voice AI
-
ferrolearn-cluster
Clustering algorithms for the ferrolearn ML framework
-
tract-cuda
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
diffusion_rs_common
Blazingly fast inference of diffusion models
-
torsh-cluster
Unsupervised learning and clustering algorithms for ToRSh, powered by SciRS2
-
torch
Thin torch bindings for rust
-
concision-s4
implements the s4 model using the concision framework
-
ckpt-analyzer
fetching the name and short hash for PyTorch ckpt or Safetensors model files
-
manga-ocr
Manga translation tools
-
kapsl-quantization
Model weight quantization formats and conversion utilities for Kapsl
-
sklears-multiclass
Multiclass classification strategies
-
burn-ir
Intermediate representation for the Burn framework
-
ferrolearn-sparse
Sparse matrix types for the ferrolearn ML framework
-
simple-open-ai
using openai api
-
cublas-sys
Safe CUDA cuBLAS wrapper for the Rust language
-
tract-proxy
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
pmetal-distill
Knowledge distillation toolkit for PMetal - KL divergence, hidden state alignment, and offline distillation
-
torsh-models
Pre-trained models and model zoo for ToRSh deep learning framework
-
ferrotorch-xpu
Intel XPU (Arc / Data Center GPU Max) backend for ferrotorch via CubeCL wgpu
-
burn-rocm
ROCm HIP backend for the Burn framework
-
auto-diff-data-pipe
A data loader
-
shrew-cuda
NVIDIA CUDA GPU backend for Shrew
-
sklears-decomposition
Matrix decomposition algorithms for sklears: PCA, ICA, NMF, SVD
-
ai-buddy-cli
Personal AI Assistant CLI using the multi-ai-provider ai-buddy library
-
linfa-lars
Least Angle Regression methods
-
torsh-sparse
Sparse tensor operations for ToRSh with SciRS2 integration
-
ferrolearn-decomp
Dimensionality reduction and decomposition for the ferrolearn ML framework
-
torsh-graph
Graph neural network components for ToRSh - powered by SciRS2
-
rstsr-kml
An n-Dimension Rust Tensor Toolkit
-
cuda-forth
Minimal Forth agent language
-
asimov-cache
ASIMOV Software Development Kit (SDK) for Rust
-
yscv-onnx
ONNX runtime with 128+ operators, quantization, and graph optimization
-
cuda11-cuda-sys
cuda ffi
-
kizzasi-model
Model architectures for Kizzasi AGSP - Mamba, RWKV, S4, Transformer
-
border-policy-no-backend
Policy for Border without backend
-
tenrso-ad
Automatic differentiation support for TenRSo
-
cuda_blas
cuBLAS API bindings
-
auto-pilot
oprate your computer using GPT4 Vision
-
linfa-ica
A collection of Independent Component Analysis (ICA) algorithms
-
concision-models
implements additional models using the concision framework
-
ferrotorch-train
Training loop, metrics, and callbacks for ferrotorch
-
torsh-optim
Optimization algorithms for ToRSh with PyTorch-compatible API
-
zeph-mcp
MCP client with multi-server lifecycle and Qdrant tool registry for Zeph
-
tblis-src
TBLIS Source Code
-
burn_hatchling
burn (baby) dragon hatchling inference and training
-
tsai_transforms
Time series augmentations, label-mixing, and imaging transforms for tsai-rs
-
rstsr-blis
An n-Dimension Rust Tensor Toolkit
-
blowtorch
running and creating Rust models trained in Pytorch
-
zeph-experiments
Experiment engine for adaptive agent behavior testing and hyperparameter tuning
-
ferrotorch-whisper
Whisper-family audio encoder model composition and log-mel preprocessing for ferrotorch
-
xn-moshi
minimalist deep-learning framework optimized for inference
-
baracuda-cublas-sys
Raw FFI bindings and dynamic loader for NVIDIA cuBLAS (classic, Lt, Xt) libraries
-
eryon-nrt
research-oriented project focusing on establishing the foundation for a harmonic, topological computing system
-
sklears-svm
Support Vector Machines for sklears: SVC, SVR with various kernels
-
linfa-ftrl
A Machine Learning framework for Rust
-
asimov-construct
ASIMOV Software Development Kit (SDK) for Rust
-
pmetal-cli
Command-line interface for PMetal LLM fine-tuning
-
tsai_core
Core tensor types, shapes, and transform traits for tsai-rs time series deep learning
-
xla
Bindings for the XLA C++ library
-
yscv-autograd
Dynamic computation graph with tape-based reverse-mode autodiff
-
lance-jni
JNI bindings for Lance Columnar format
-
ruvector-onnx-embeddings
ONNX-based embedding generation for RuVector - Reimagined embedding pipeline in pure Rust
-
libcint
FFI binding and GTO wrapper for libcint (C library)
-
oxidized-cuda-kernels
Additional CUDA kernels for Oxidized Transformers
-
tangram_model
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
border-core
Core functionality for Border
-
ferrolearn-numerical
Numerical foundations for the ferrolearn ML framework: sparse eigensolvers, graph algorithms, distributions, optimization, interpolation, and quadrature
-
torsh-jit
JIT compilation and kernel fusion for ToRSh deep learning framework
-
aprender-zram-core
SIMD-accelerated LZ4/ZSTD compression for memory pages
-
rstsr-cblas-base
CBLAS enums and blas_int, lapack_int definition
-
concision-math
Concision is a toolkit for designing machine-learning models in Rust
-
lance-encoding-datafusion
Encoders and decoders for the Lance file format that rely on datafusion
-
rstsr-mkl
An n-Dimension Rust Tensor Toolkit
-
burn-dispatch
Backend dispatch for the Burn framework
-
asimov-account
ASIMOV Software Development Kit (SDK) for Rust
-
torsh-package
Model packaging and distribution utilities for ToRSh
-
mlx-internal-macros-burn
Internal procedural macros for mlx-rs-burn
-
pmetal-mcp
MCP server exposing PMetal ML toolkit
-
tensorlogic-train
Training loops, loss composition, and optimization schedules for TensorLogic
-
tract-rs
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
ferrolearn-datasets
Built-in datasets and synthetic data generators for the ferrolearn ML framework
-
ferrotorch-ml
Sklearn-compatible adapter for ferrotorch — Tensor ↔ ndarray + curated ferrolearn re-exports
-
tangram_table
Tangram makes it easy for programmers to train, deploy, and monitor machine learning models
-
baracuda-cudnn-sys
Raw FFI bindings and dynamic loader for NVIDIA cuDNN (classic-API subset)
-
yscv-cli
CLI for inference, benchmarking, and evaluation
-
torsh-quantization
Model quantization for ToRSh neural networks
-
oxirs-embed
Knowledge graph embeddings with TransE, ComplEx, and custom models
-
rstsr-aocl
An n-Dimension Rust Tensor Toolkit
-
zenu-cudnn-sys
Rust bindings for cuDNN
-
tract-ffi
Tiny, no-nonsense, self contained, neural network inference
-
trustformers-mobile
Mobile deployment support for TrustformeRS (iOS, Android)
-
mistralrs-core
Fast, flexible LLM inference
-
eryon-net
research-oriented project focusing on establishing the foundation for a harmonic, topological computing system
-
asimov-directory
ASIMOV Software Development Kit (SDK) for Rust
-
burn-optim
Optimizer building blocks for the Burn deep learning framework
-
ferrolearn-neural
Neural network estimators for the ferrolearn ML framework
-
aocl
Umbrella crate re-exporting the per-component safe wrappers for AMD AOCL
-
hibiki
real-time speech-to-speech translation model
-
yscv-track
Multi-object tracking with DeepSORT, ByteTrack, and Kalman filter
-
pmetal-serve
OpenAI-compatible inference server for PMetal
-
ferrotorch-distributed
Distributed training for ferrotorch — backends, collectives, and DDP
-
yscv-optim
Optimizers (SGD, Adam, LAMB), LR schedulers, and gradient clipping
-
zenu-cublas-sys
Rust bindings for cuBLAS
-
ferrotorch-tokenize
Text tokenization wrapper around the HuggingFace tokenizers crate for ferrotorch
-
burn-cpu
MLIR based CPU backend for the Burn framework
-
oxigdal-ml-foundation
Deep learning training infrastructure and model architectures for OxiGDAL - Transfer learning, training loops, optimizers, and augmentation
-
sklears-linear
Linear models for sklears: linear regression, logistic regression, and GLMs
-
oxionnx-ops
Operator implementations for OxiONNX — 88+ ONNX operators in Pure Rust
-
baracuda-cusparse-sys
Raw FFI bindings and dynamic loader for NVIDIA cuSPARSE
-
torsh-python
Python bindings for ToRSh - PyTorch-compatible deep learning in Rust
-
xctch-sys
Bindings for executorch
-
asimov-agent
ASIMOV Software Development Kit (SDK) for Rust
-
sklears-covariance
Covariance estimation algorithms
-
zenu-cuda-kernel-sys
CUDA kernel bindings for Rust
-
trustformers-optim
Optimizers for TrustformeRS
-
pmetal-mlx-sys
pmetal-maintained fork of mlx-sys: low-level interface and binding generation for the mlx library
-
pmetal-hub
HuggingFace Hub integration for PMetal
-
torsh-fx
Graph-based model representation and transformation for ToRSh
-
mistralrs-macros
Proc macros for mistral.rs tool definitions
-
burn-cubecl-fusion
Provide optimizations that can be used with cubecl based backends
-
shrew-core
Core tensor, dtype, shape, layout, backend traits, and autograd for Shrew
-
ferrotorch-profiler
Operation profiling and Chrome trace export for ferrotorch
-
concision-init
various random distribution and initialization routines for the concision framework
-
torsh-metrics
Comprehensive evaluation metrics for ToRSh - powered by SciRS2
-
tract-kaldi
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
cubecl-cpp
CPP transpiler for CubeCL
-
mlx-macros-burn
Procedural macros for mlx-rs-burn
-
oxicuda-tabular
Tabular deep learning primitives for OxiCUDA — TabNet, FT-Transformer, SAINT, NODE, sparsemax, quantile normalization
-
ferrotorch-rl
Reinforcement-learning policy composition for ferrotorch (Phase D.2: PPO MlpPolicy / sb3 CartPole)
-
burn-router
Multi-backend router decorator for the Burn framework
-
border-minari
Interface to Minari for Border
-
oximedia-recommend
Content recommendation engine for media libraries
-
asimov-sys
ASIMOV Software Development Kit (SDK) for Rust
-
torsh-cli
Command-line tools for the ToRSh deep learning framework
-
asimov-dataset
ASIMOV Software Development Kit (SDK) for Rust
-
tract-proxy-sys
Tiny, no-nonsense, self contained, TensorFlow and ONNX inference
-
oxirs-shacl-ai
AI-powered shape induction and data repair suggestions for SHACL validation