Model training
Burn — MIT / Apache 2.0
- • Rust-native deep learning, trains and deploys in the same language, 8 hardware backends, competitive with PyTorch performance
Our approach
Why Rust & Open Source
Performance, portability, security, and transparency — every technology we use is open source, permissively licensed, and built in Rust. Your systems remain auditable, portable, and free from vendor lock-in.
Our stack at a glance
- Burn — Deep learning framework
- Candle / xinfer — Inference engines
- Dioxus — Cross-platform apps
- ADK-Rust — Custom agents
- OpenFang — Business agent OS
- OpenCode — Agentic coding
Foundation
Why Rust
For production AI workloads, Rust delivers capabilities that interpreted languages cannot match. The result is smaller, faster, more reliable systems that cost less to operate over time.
Single binary
A Rust inference server compiles to ~8 MB with zero runtime dependencies. No Python interpreter, no virtual environment, no Node runtime — just a binary you copy and run.
Memory safe
Rust's ownership model eliminates buffer overflows, use-after-free errors, and data races at compile time. For long-running AI services, this is a material reliability advantage.
Portable
The same code targets CPU, NVIDIA CUDA, AMD ROCm, Apple Metal, Vulkan, and WebGPU — without rewriting. Burn's CubeCL kernel system auto-tunes for your specific hardware.
Tools
Our Recommended Stack
Every tool below is open source, permissively licensed, and actively maintained. We select the right combination for each project.
Model inference
Candle / xinfer — Apache 2.0 / MIT
- • Minimal Rust inference engines, single-binary deployment, support for 30B+ models on consumer GPUs
App development
Dioxus — MIT / Apache 2.0
- • Single Rust codebase targets web, desktop, and mobile. React-like ergonomics with native performance
Custom agents
ADK-Rust / AutoAgents — Apache 2.0
- • Production-grade agent frameworks with voice pipelines, A2A protocol, WASM sandboxing, 26+ LLM providers
Business agent OS
OpenFang — Apache 2.0
- • Full agent operating system, 32 MB binary, 7 autonomous hands, 40+ messaging platforms, 53 built-in tools
Agentic coding
OpenCode — MIT
- • Leading open-source coding agent, 175K+ stars, model-agnostic, privacy-first, zero telemetry
Philosophy
Why Open Source
Every tool we recommend is permissively licensed (MIT, Apache 2.0, or both). We do not build dependency on proprietary platforms — your systems remain yours.
Auditable
Open-source code can be inspected, audited, and verified. You know exactly what your AI system does — no black-box API calls to opaque models.
No lock-in
Open formats (ONNX, safetensors, GGUF) mean you can switch providers, frameworks, or hosting without rewriting. Model providers compete on quality, not on captivity.
Community-driven
Burn (11K+ stars), Dioxus (36K+), OpenCode (175K+), and Candle (15K+) are maintained by thousands of contributors. Security issues are found and fixed faster than in closed source.
Air-gapped capable
Open-source AI runs anywhere — cloud, on-premises, edge device, or air-gapped with no internet. For regulated industries and compliance-driven deployments, this is essential.
Pragmatic approach
When We Use Python
Rust is not always the right answer. Python excels at rapid prototyping, data exploration, and accessing the broadest ecosystem of research models. We use Python where it is strongest and migrate to Rust where production requirements demand it.
We specialise in this transition. If you already have a Python-based AI prototype, we can productionise it in Rust without changing your model architecture.
- • Research & prototyping: PyTorch, HuggingFace, scikit-learn — fast iteration while the problem is still being understood
- • Data engineering: Python for scripts, notebooks, and ad-hoc analysis; Rust for production pipelines
- • Production deployment: Rust single binary — no Python runtime, no dependency conflicts, predictable performance
Comparison
Rust vs Python for AI in Production
Python dominates research and prototyping. Rust dominates deployment — smaller binaries, no runtime, predictable latency, and memory safety guaranteed at compile time.
Py
Prototyping strength
Python
Python dominates research and prototyping — notebooks, data exploration, and quick experiments.
- • Deployment: Python runtime + venv + 2 GB+ deps
- • Memory safety: GC + GIL — memory leaks in long-running services
- • GPU backends: CUDA (NVIDIA only)
- • Ecosystem: Massive — every model, paper, and tool
- • Prototyping: Fast — notebooks, dynamic typing, REPL
- • Production latency: GC pauses, interpreter overhead
- • Target platforms: Requires platform-specific builds
- • Quantization: Via third-party libs (bitsandbytes, GPTQ)
Rs
Production strength
Rust
Rust dominates deployment — smaller binaries, no runtime, predictable latency, and memory safety guaranteed at compile time.
Our approach: Python for research and rapid prototyping — notebooks, data exploration, and quick experiments. Rust for production deployment — training pipelines, inference servers, agent runtimes, and cross-platform applications. We specialise in bridging this gap.
- • Deployment: Single static binary (~8 MB)
- • Memory safety: Ownership model — no GC, no data races
- • GPU backends: CUDA, ROCm, Metal, Vulkan, WebGPU
- • Ecosystem: Growing — core features solid, niche ops manual
- • Prototyping: Slower — compile-check-iterate cycle
- • Production latency: Native code, deterministic performance
- • Target platforms: Compile once — runs on any target
- • Quantization: First-class PTQ and QAT support
FAQ
Common Questions
Isn't Rust harder to learn than Python?
Yes, Rust has a steeper learning curve than Python. But this is a cost that the engineering team bears once, while the benefits — smaller binaries, no runtime, memory safety, portable performance — compound over the entire life of the system. For clients who plan to maintain their AI system in-house, we include knowledge transfer and training as part of the engagement.
What about Python's larger ecosystem of AI models and tools?
Python's ecosystem is unmatched for research, and we use it there. For production, most needs are covered: Burn for custom training, Candle for HuggingFace model inference, safetensors for model interchange, and ONNX for cross-framework portability. The Rust ML ecosystem matures rapidly — what required a Python dependency six months ago often has a Rust native equivalent today.
Do you require clients to use Rust?
No. We build in Rust by default because it produces better production outcomes, but we work with any language stack. We integrate with existing Python, TypeScript, Go, or Java systems. If you have an existing team working in another language, we build Rust services that interface cleanly over REST, gRPC, or message queues — your team never needs to touch Rust code.
What happens if the open-source project I depend on is abandoned?
Open-source risk is real, and we manage it actively. We select tools with strong governance, multiple maintainers, and broad adoption. All tools we recommend use permissive licenses (MIT / Apache 2.0), so if a project is abandoned, the code remains available and forkable. For critical systems, we maintain internal mirrors and can take over maintenance if needed. This is strictly more freedom than being stranded on a deprecated proprietary API with no recourse.
Can I switch to another provider after you build the system?
Yes — this is a direct benefit of open source. Every model, agent, and application we build uses open standards and permissively licensed code. You own the full stack. You can take it to another team, host it with another provider, or modify it yourself. There are no license fees, platform fees, or proprietary formats to escape.
Is Rust really faster than Python for AI workloads?
For raw matrix multiplication, both Python and Rust call the same CUDA kernels — performance is similar. Rust's advantage is everything around the compute: serving the model (no interpreter overhead), managing memory (no GC pauses), handling concurrent requests (no GIL), and deploying (single binary vs 2 GB Docker image). The throughput difference for a production inference server is typically 2-5x before any optimisation.
Next step
Ready to build on a foundation you control?
Book a consultation and we'll discuss how Rust and open-source AI can deliver better performance, lower operational costs, and true ownership of your systems.