TPT Chassis

An open-source, memory-safe vehicle operating system written in Rust — a drop-in-replacement for the AUTOSAR stack.

Status: Phases 0–6 and 10 complete (core vehicle OS functional on host and no_std targets; RTOS integration tracked but not yet hardware-validated). See todo.md for the full phased roadmap and spec.txt for the design document.

Why

Modern cars ship 100+ ECUs running bloated AUTOSAR C/C++ code. Updating that software takes years and billions of dollars. TPT Chassis replaces the AUTOSAR stack with safe Rust and provides a unified API for every vehicle subsystem (powertrain, brakes, steering, infotainment) — enabling true software-defined vehicles with secure, atomic over-the-air updates.

Architecture

TPT Chassis is organized as a Cargo workspace:

Component	Crate	Description
Core	`tpt-chassis-core`	`no_std`, `forbid(unsafe_code)` building blocks for bare-metal targets.
Simulation	`tpt-chassis-sim`	`std`-enabled host tooling: simulated CAN/LIN/SOME/IP buses and other stand-ins so the core can be tested without hardware.

Core modules (`tpt-chassis-core`)

Module	Purpose
`bus`	Unified `VehicleBus` trait + `Frame` contract shared by every network.
`can`	CAN frame, ID (standard/extended), and `CanBus` high-level interface.
`lin`	LIN frame, protected-ID parity, and `LinBus` interface.
`someip`	SOME/IP header + message + `SomeIpBus` for automotive Ethernet.
`autosar`	Safe-Rust AUTOSAR equivalents: DIO driver, COM signals.
`uds`	UDS (ISO 14229) diagnostic server over CAN.
`isotp`	ISO-TP (ISO 15765-2) segmentation for multi-frame CAN messages.
`ota`	Secure, atomic A/B update engine with rollback.
`autonomy`	Self-driving stack plugin contract + reference lane-keeper.
`safety`	Interlock kill-switch and `TelemetryRing` field-logging buffer.

The system is designed around these core components (per spec.txt):

AUTOSAR Replacement — the same interfaces as AUTOSAR, implemented in safe Rust.
Vehicle Bus Abstraction — one unified API over CAN, Ethernet (SOME/IP), and LIN.
OTA Update Engine — secure, atomic updates that cannot brick the vehicle.
Autonomous Driving Interface — plug-and-play integration with self-driving stacks (Apollo, Autoware).

Roadmap

Work is tracked in ten phases in todo.md. Highlights:

Phase 0 — Workspace, licensing, CI, contributor docs (done).
Phase 1 — CAN bus abstraction layer + simulated CAN bus (done).
Phase 2 — Ethernet (SOME/IP) & LIN bus support (done).
Phase 3 — AUTOSAR-compatible interface layer + UDS diagnostics (done).
Phase 4 — OTA update engine with atomic apply/rollback (done).
Phase 5 — Autonomous driving interface (done).
Phase 6 — RTOS integration (Zephyr / AGL) — plan (ports implemented, hardware validation pending).
Phase 7 — Hardware bring-up (NXP / Infineon) — plan.
Phase 8 — Real vehicle integration — plan.
Phase 9 — ISO 26262 safety certification track — plan.
Phase 10 — Ecosystem & market readiness — plan.

Building

# Build the whole workspace (host target)
cargo build

# Build the bare-metal core for a no_std target
cargo build -p tpt-chassis-core --target thumbv7em-none-eabihf

# Run tests (host)
cargo test

License

Licensed under either of

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 License, shall be dual licensed as above, without any additional terms or conditions.

tpt-chassis

Languages