An open-source Software Defined Vehicle platform built on edge-first autonomous intelligence.

TrailCurrent is a complete, production-grade system architecture for intelligent vehicle and mobile platform management. From embedded microcontrollers on a CAN bus to cloud backends and mobile applications, TrailCurrent demonstrates how autonomous systems should work: local-first, offline-capable, and with data ownership in the hands of the user.

Most connected vehicle and IoT platforms assume persistent cloud connectivity. They ship your data upstream, process it remotely, and send decisions back down. This creates latency, privacy exposure, single points of failure, and a fundamental loss of control.

TrailCurrent takes the opposite approach:

• Edge-first intelligence -- Decisions happen locally, at the point of action, not in a distant data center.
• Offline-capable by design -- The system works without internet. Cloud is an enhancement, not a dependency.
• Data sovereignty -- Your telemetry, your sensors, your data. It stays with you unless you choose otherwise.
• Full-stack transparency -- Hardware schematics, firmware, gateway software, cloud services, and mobile apps are all open source.

TrailCurrent spans the full autonomous systems stack:

 Hardware Modules (ESP32 / ESP32-C6)
        |
     CAN Bus
        |
 Edge Gateway (MQTT / Docker / Node.js)
        |
     Cloud Backend (Node.js / PostgreSQL)
        |
     Mobile App (Kotlin / Jetpack Compose)

Custom PCBs designed in KiCAD with ESP32-based firmware written in C++ using PlatformIO. Modules communicate over CAN bus and ESP-NOW wireless, covering:

• Vehicle power distribution and monitoring
• GNSS positioning
• Air quality sensing
• Trailer monitoring (seven-pin interface, leveling, shunt current)
• MPPT solar charge controller integration
• Cabinet and door sensors
• Multi-button control panels
• Wall-mounted and in-vehicle displays

A Dockerized compute platform that runs inside the vehicle. Aggregates sensor data via MQTT, serves local dashboards with offline map tiles, and synchronizes selectively with cloud services when connectivity is available.

A Node.js backend with PostgreSQL for optional remote access and fleet-level visibility. A native Android application built with Kotlin and Jetpack Compose provides real-time monitoring and control.

Repositories are organized across two organizations:

Modular by default. Each module is an independent unit with its own firmware, communicating over standardized protocols. Swap, add, or remove modules without redesigning the system.

Hardware meets software rigor. PCB designs, firmware, and cloud services all follow the same standards: version controlled, documented, and reproducible.

No vendor lock-in. Standard protocols (CAN bus, MQTT, HTTP), commodity hardware (ESP32), and open-source tooling (KiCAD, PlatformIO, Docker) throughout.

Security as a constraint, not an afterthought. Secrets management, OTA update verification, and transport encryption are built into the architecture from the start.

Each repository includes its own README with setup instructions. For a system-level overview, start with the Documentation repository. For the edge computing platform, see InVehicleCompute. For hardware designs, browse the individual module repositories and reference KiCADLibraries for shared assets.

• Firmware development: PlatformIO, ESP-IDF toolchain
• Edge gateway: Docker, Docker Compose
• Cloud services: Node.js, PostgreSQL
• Hardware design: KiCAD 8+
• Mobile app: Android Studio, Kotlin

Contributions are welcome. Whether it's improving documentation, fixing bugs, adding features, or designing new hardware modules, open an issue or submit a pull request.

Individual repositories specify their own licenses. See each repository's LICENSE file for details.