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

• MIT License
• Apache License, Version 2.0

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.

Copyright © TPT Solutions. All rights reserved.