Veecle Studio & Core
How developers build and operate vehicle software with Veecle

Try the Future of Vehicle Software

Veecle Studio is moving to the browser.
Cloud-native or fully local — define, simulate, and deploy vehicle software from one place.

  • ✅ Design your entire vehicle architecture visually
  • ✅ Program services in Rust with full type safety
  • ✅ Simulate logic and verify constraints across ECUs
  • ✅ Deploy to real hardware — from MCUs to HPCs

We’re now inviting a limited number of teams to join the early access program.

We'll only contact you once the product is ready for early access.
Please enter a valid email address.
Please enter a position or job title

Veecle is two parts:

  • Studio – where teams define and test full-vehicle logic, across all ECUs
  • Core – the runtime that runs on every ECU and guarantees real-time, safety-critical behavior One platform. From draft to production. From MCUs to HPCs. Unlike legacy setups with isolated teams, undocumented glue code, and manual integration, Veecle treats the vehicle like a single software system. Apps are modular, communication is typed and unified, and deployment targets (from MCUs to HPCs) share the same programming model.

Studio and Core

Veecle Studio: Model, Program, Simulate

Veecle Studio is the visual programming environment where vehicle logic is defined, tested, and deployed.

  • Single Source of Truth: All control logic, interface definitions, and signals are defined in one place.
  • Simulation Built-In: Test applications using simulated inputs (e.g. CAN, DDS) and virtual ECUs before hardware is available.
  • AI-Assisted Design: Automate repetitive tasks and get suggestions for interface definitions, service models, and test coverage.
  • Designed for Teams: Collaborative editing, code reviews, and role-based workflows keep everyone aligned.

Veecle Studio abstracts hardware and OS differences so engineers can focus on functionality — not middleware or low-level drivers.

Veecle Core: Run Everywhere, Same Logic

Veecle Core is the runtime that runs on each ECU in the system. It guarantees that software behaves deterministically, regardless of hardware or OS.

It handles:

  • Scheduling, isolation, memory safety
  • IPC and cross-ECU communication
  • Timing guarantees, diagnostics, and supervision

Apps built in Studio run unchanged across AUTOSAR, Linux, QNX, or RTOS-based systems. Developers never write glue code or device-specific variants.

What Veecle Enables

One Architecture, All Vehicles

Standardize software across vehicle lines — from entry-level to premium — without rewriting logic for new platforms, networks, or ECUs.

Modular, Reusable Software

Functions are apps, not monoliths. Isolated, typed, and testable — logic is portable across teams, ECUs, and product lines.

Legacy Integration

Veecle runs on mixed setups. Add new software on top of legacy ECUs without replacing the whole system.

Safety by Design

Memory-safe Rust, no shared state, and deterministic scheduling ensure real-time guarantees and ISO26262 compliance.



Vehicles with Veecle

OEMs and Tier1s use Veecle to develop full-vehicle software stacks in parallel to legacy programs. Veecle Studio gives them a top-down view of all control units, software services, communication, and real-time logic — all testable in simulation or real cars.

Veecle’s architecture supports both greenfield and legacy integration. Because the system is modular and typed, updates can be made safely without side effects. This reduces integration time and improves maintainability.

Infotainment controls through Veecle

An OEM used Veecle to automatically generate the complete Android Automotive VHAL (Vehicle Hardware Abstraction Layer), giving Android access to all vehicle functions through standardized APIs.

This enabled Android app developers to build rich UIs in Android Studio that directly interact with the vehicle. The CarManager API provided auto-completion and verified access to real functionality — such as car.headlights.on() — without writing any glue code or custom middleware.

In short: Android became a fully integrated frontend to control the car.

Internal Prototype

We converted a production car to run core vehicle logic on Veecle in under 6 months. Existing ECUs were kept in place, and Veecle logic was layered on top.

Examples:

  • Dynamic LED matrix headlights showing user states
  • HVAC and comfort logic implemented as standalone apps
  • Apps react to vehicle state: e.g., one app controls music volume when a window opens; another loads seat positions based on profile

This shows how Veecle allows modular control logic — each app isolated, typed, and deployable independently.

Check out the Tech

Visit the Tech page to learn how the runtime works, how apps are structured, and how Veecle enables scalable SDV architectures.