Trucking optimization for everyone

From one-truck owner-operators to 10,000+ truck mega-fleets. Route planning, fuel cost minimization, Hours of Service compliance, and fleet scheduling. Same algorithms for everyone—runs free in your browser or scales to enterprise.

279+ tests WASM-first Zero dependencies C11 MIT License

Why OTTO

Large fleet optimization vendors build for fleet-level KPIs—"how do I move 10,000 loads with 2,000 trucks?" But the 350,000+ owner-operators and small trucking companies need a different question answered: "I'm in Tulsa with an empty trailer—what's my best next move?"

OTTO serves both. Fleet-level assignment for enterprises AND driver-centric decision support for small operators. The algorithms are the same; the interface and questions are different.

Superior optimization means fewer empty miles, lower fuel costs, HoS compliance without violations, and better margins. What's good for a mega-fleet is good for a family operation.

We believe logistics optimization shouldn't be locked behind enterprise contracts or priced out of reach for small operators. OTTO's core engines are open source—free in the browser for a family operation, managed platform for enterprises, full code ownership for anyone who wants it.

+25%

Fleet utilization target

−15%

Fuel cost reduction

100%

HoS compliance

<100ms

Optimization latency

No Lock-In

The Vendor Risk

Vendor gets acquired, roadmap shifts to new owner's priorities
Support team restructured, your contacts disappear
Pricing "aligns with portfolio strategy"
Product gets folded into a suite you don't need
Years of integration work held hostage

The OTTO Answer

Code is MIT licensed—fork it, own it forever
Self-host at current capability, no permission needed
Hire anyone to maintain your fork
Roadmap diverges? Extend it yourself
Audit the algorithms, verify the logic

"Pay for convenience, not captivity. OTTO is yours whether you stay with us or not."

Core Engines

Ralph C

LP/MIP solver engine. Revised Simplex with LU factorization, Branch & Bound, Gomory cuts.

73 tests · 23K loc · <100ms for 1000 vars

Velo C

OSM routing engine. Dijkstra, A*, bidirectional search, landmark preprocessing.

47 tests · 6.4K loc · <100ms country-scale

Carta C

Map tile generator. Vector tiles (MVT) and raster tiles (PNG) from OSM PBF.

33 tests · 11K loc · ~75ms per 512x512 tile

Locus C

OSM geocoding engine. Forward search, autocomplete, reverse lookup with trie + trigram index.

52 tests · 7.3K loc · <20μs per query

FuelWise C

Refueling optimization. LP formulation for minimum-cost fuel stops along a route.

33 tests · 2.9K loc · Uses Ralph solver

ClayShards C + JS

Immediate-mode UI components. WebGL renderer, MSDF fonts, map widgets.

84 tests · 9.5K loc · ~140KB WASM

Planned Engines

HoSE C planned

Hours of Service Engine. FMCSA 4-clock model, EU EC/561 rules, break scheduling.

Tempo C planned

Time-window and Event Management Policy Orchestrator. Time windows, facility hours, blackout periods.

Arbor C planned

Algorithmic Recursive Branching and Optimization Runtime. State-space search, beam search, pruning.

Sigma C planned

Selection and Integration for Global Multi-assignment Allocation. Fleet plan selection via MIP.

Pulse C planned

Plan Utilization and Live State Estimator. PTA computation, execution tracking, break insertion.

Forge C planned

Flexible Orchestration and Runtime for General Execution. Async job queue for background tasks.

Apex C planned

Asynchronous Pre-computation Execution. Tile pyramid generation, route corridor pre-computation, cache warming, demand prediction.

Nexus C planned

Normalized External Unified Snapshots. TMS/ELD/LoadBoard integration gateway.

Iris Python planned

Intelligent Request Interpretation System. Natural language interface via LLM. Translates dispatcher queries into API calls, explains results in human terms.

Architecture

┌─────────────────────────────────────────────┐
│                                             │
│     UI: React + ClayShards + WASM + APIs    │
│                                             │
└──────────────────────┬──────────────────────┘
                       ▼
┌─────────────────────────────────────────────┐
│                                             │
│ Fleet: HoSE + Tempo + Arbor + Sigma + Pulse │  ◄── planned
│                                             │
└──────────────────────┬──────────────────────┘
                       ▼
┌─────────────────────────────────────────────┐
│                                             │
│   Domain: FuelWise + Velo + Carta + Locus   │
│                                             │
└──────────────────────┬──────────────────────┘
                       ▼
┌─────────────────────────────────────────────┐
│                                             │
│             Core: Ralph + Shared            │
│                                             │
└──────────────────────┬──────────────────────┘
                       ▼
┌─────────────────────────────────────────────┐
│                                             │
│       Vendor: miniz + mongoose + Clay       │
│                                             │
└─────────────────────────────────────────────┘

Dependencies:
  FuelWise ──► Ralph (LP solver)
  FuelWise ──► Velo (routing)
  Velo, Carta, Locus ──► Shared (geo, protobuf)
  Shared ──► miniz (compression)
  ClayShards ──► Clay (layout)
  APIs ──► mongoose (HTTP)

Design Principles

Zero Dependencies

No package managers, no external runtimes. Vendor libraries (miniz, mongoose, Clay) are vendored source—auditable, won't disappear, compiles with just a C compiler.

WASM-First

All engines compile to WebAssembly. Same code runs in browsers and on servers.

Layered Architecture

Solver → Domain → API → UI. Each layer has a clean C API.

Arenas & Memory Pools

Bulk allocate, bulk free. Memory pools for fixed-size objects. No fragmentation, no leaks, cache-friendly.

Compound Literals

C11 features for inline configuration. Self-documenting, type-safe APIs.

Portable

Linux, macOS, Windows, browsers. Same codebase everywhere.

Secure by Design

No strcpy/sprintf, bounded buffers only. Arenas and memory pools prevent use-after-free. Overflow checks on all allocations. WASM sandbox limits blast radius.

Not a TMS

OTTO is an optimization layer, not a System of Record. Your TMS stays your source of truth. We enhance your stack, we don't replace it. You stay in control. No TMS? Nexus connects to Excel and SharePoint too.

Runs Everywhere

🌐

Browser

Try before you buy, no install

🖥️

Server

Traditional API deployment

⚡

Edge

Cloudflare Workers, CDN

📱

Mobile

In-app via WASM

🚚

In-Cab

Offline tablet, no connectivity needed

🔌

Embedded

IoT, telematics devices

OTTO (full stack) ~2 MB WASM + your data

Commercial alternatives GB+ runtime + your data, server-only

Scales With You

Same codebase from laptop to enterprise. Only the deployment changes.

💻

Local

Single process, in-memory queue

🏪

Small Business

Redis-backed job queue

🏢

Enterprise

Kubernetes, horizontal scaling

☁️

Managed

We run it, you use it

Why C?

Smallest WASM ~2MB for entire stack

Zero GC Predictable <100ms latency

Universal FFI Embed in any language

Max Portability Browser to embedded

Auditable Enterprise clients can read it

Proven Linux, SQLite, Redis, Nginx

Memory Safety via Discipline

Arenas & pools — bulk alloc, bulk free, fixed-size pools, no use-after-free
Bounded buffers — no strcpy/sprintf, snprintf everywhere
WASM sandbox — even bugs can't escape the sandbox
Sanitizers — ASan + UBSan in all development builds
279+ tests — edge cases and stress conditions covered

Factor	C	Rust	Go	Zig	C++
WASM size	~2MB	~4MB	~10MB+	~2MB	~4MB
GC pauses	None	None	Yes	None	Optional
WASM maturity	Excellent	Good	Poor	Good	Good
Compile speed	Fast	Slow	Fast	Fast	Slow
Complexity	Low	High	Low	Medium	Very High
Enterprise trust	High	Growing	High	Low	High

AI-Ready

"Find the cheapest route for truck 47 to deliver in Prague by Thursday, he's got 6 hours left on his clock"

                    ┌─────────────────┐
                    │   LLM Agent     │
                    │ (intent → API)  │
                    └────────┬────────┘
                             │
        ┌────────────────────┼────────────────────┐
        ▼                    ▼                    ▼
   ┌─────────┐         ┌─────────┐         ┌─────────┐
   │  HoSE   │         │  Velo   │         │FuelWise │
   │(6h left)│         │ (route) │         │ (cost)  │
   └─────────┘         └─────────┘         └─────────┘

LLM is the UX layer. OTTO engines are the truth layer. The AI doesn't hallucinate routes—it translates natural language into API calls and explains results in human terms.

Dispatchers speak, OTTO optimizes, LLM explains. No training required.

Natural language queries

What-if scenarios

Plan explainability

Multi-language support

Voice interface ready

Document extraction

Performance

Operation	Target
LP solve (1000 variables)	<100ms
Route calculation (country-scale)	<100ms
PNG tile generation (512×512)	~75ms
Forward geocoding	<20μs
Autocomplete query	<20μs
Reverse geocoding	<30μs
PBF parse (300MB Hungary)	~10s

Quick Start

# Build all libraries
make all

# Run all tests (279+)
make test

# Start servers
make run-fuelwise-api   # :8080
make run-velo-api       # :8082
make run-carta-api      # :8081
make run-locus-api      # :8083

# Build for WebAssembly
make wasm

License Model

Open Source (MIT)

Core engines are MIT licensed. Use them freely, contribute back, audit the code. No vendor lock-in.

Ralph – LP/MIP solver
Velo – Routing engine
Carta – Tile generator
Locus – Geocoding
FuelWise – Refueling optimization
ClayShards – UI components
Shared – Geo utilities
HoSE, Tempo, Arbor, Sigma, Pulse

Commercial

Integration layer and managed platform require a commercial license or subscription.

Nexus – TMS/ELD/LoadBoard connectors
Managed hosting – Fully operated platform
Priority support – SLAs and dedicated help
Custom development – Fleet-specific tuning

For Owner-Operators & Small Trucking Companies

Route Planning

Optimal routes with truck restrictions, not Google Maps guesswork

Fuel Optimization

Find the cheapest stops on your route—save $50-100 per trip

HoS Calculator

Know exactly when you need to stop—avoid $16k violation fines

Load Decisions

"I'm in Tulsa empty"—what's my best next move?

Same algorithms the mega-fleets use

No install, no signup required. Runs entirely in your browser. The same optimization technology that Girteka uses for 10,000 trucks—available to you for free.

Free

Pro features from $29/mo

For Fleets

Don't want to run your own infrastructure?

We offer managed OTTO deployments with TMS/ELD integration, dedicated support, and guaranteed SLAs. Focus on moving freight, not managing servers.

Hosted platform TMS/ELD integration 24/7 support Custom tuning

Get in Touch

For Partners

Data Partners

Fuel Cards & Payments

Your fuel price data plus our optimization algorithms equals customer stickiness. Every optimized route drives transactions through your network.

You provide: Real-time fuel prices, station network

You get: Differentiation, transaction volume, retention

OEM Partners

Truck Manufacturers

Bundle OTTO with your telematics platform. "Buy our trucks, get optimization included." Turn vehicle sales into recurring software revenue.

You provide: Distribution, telematics data, R&D

You get: Differentiation, sustainability metrics, loyalty

Broker Partners

Digital Freight Platforms

Make your carriers more efficient and they'll stay loyal. "Haul for us, get free planning tools." Better carrier economics means tighter rates are possible.

You provide: Carrier network, distribution, volume

You get: Carrier retention, capacity visibility, margin

Technology Partners

TMS & ELD Providers

Add planning to your platform without building it. OTTO integrates via clean APIs. Resell to your customer base or bundle with your offering.

You provide: Sales channel, customer relationships

You get: Planning capability, upsell opportunity