Apex.Grace

モビリティ、スマートマシン、IoT 向けのソフトウェア開発キット。安全認証済み。

TM

Apex.Grace 効率的なアプリケーション開発を可能にします。

認証済みに準拠した最高の安全基準

ISO26262。

豊富な機能セット、使用する準備ができて自動車で.

簡単な移行ROS 2 ベースのプロトタイピングから製品開発まで。

Apex.Grace は、安全性が重要なすべてのモビリティアプリケーションに対応します。

Apex.Grace provides

Best-in-class

Executor

Our best-in-class Executor is designed to deliver deterministic, efficient, and scalable execution of software components, particularly in real-time, safety-critical environments like autonomous systems.

System integrators can define tasks with a single executable item, sequential chains of items, or directed acyclic graphs (DAGs) of items executed with a thread pool. This separation of logical structure from execution policy means your application logic stays clean, while integrators fine-tune performance for the real world.

You also get full control over thread priorities, core affinities, and scheduling policies. This is especially valuable when deploying to systems with real-time or mixed-criticality requirements.

Dive Deeper

The Hidden Power
Behind High-
Performance

Apex.Grace delivers a highly optimized, deterministic runtime designed specifically for real‑time, embedded, safety‑critical systems. At its core lies a performance-focused executor and middleware (Apex.Ida) tightly integrated to eliminate common bottlenecks like message copying and context-switching. This stack enables remarkable throughput—hundreds of gigabits per second and tens of thousands of messages per second—while ensuring predictability, low latency, and minimal jitter even under heavy workloads.

Communication in Apex.Grace preserves the familiar ROS 2 publish/subscribe and request/reply patterns but upgrades them for zero-copy and minimal overhead. Features like loaned messages allow publishers to write directly into middleware buffers, polling-based subscribers avoid unnecessary context switches, and DDS QoS settings provide precise control over message caching—resulting in consistent, real‑time data exchanges suited for production-grade systems .

On the execution side, the Apex.Grace executor introduces a flexible, task-based model composed of “executable items.” These can be chained sequentially or arranged in DAGs and are managed by a thread pool with configurable thread priorities, core affinities, and scheduling policies. Combined with a real-time timer service that supports precise, phase-aligned task triggering and replayable behavior, this architecture enables highly deterministic execution—and paves the way for advanced concepts like Logical Execution Time for synchronized, race-free operations

Dive Deeper

Scaling ROS
Based Systems

Apex.Grace enables developers to seamlessly transition from R&D with ROS 2 to deploying software in safety-critical, production-grade systems. While ROS 2 is excellent for prototyping due to its flexibility and ease of use, it falls short when applied in real-time embedded environments that demand strict safety, reliability, and determinism. Apex.Grace addresses these limitations by maintaining API compatibility with ROS 2 while introducing the necessary architecture and constraints for real-time, certifiable systems.

Apex.Grace achieves this transformation by enforcing deterministic memory management, eliminating runtime dynamic memory allocations, and using static memory pools for predictable behavior. It ensures that existing ROS 2 codebases can be reused with minimal changes, preserving developer workflows and tools like rosbag2, RViz, and rclpy. Developers can migrate their software by swapping out the underlying runtime rather than rewriting application logic, which significantly reduces development risk and time to market. Apex.Grace also incorporates support for industrial standards like AUTOSAR, extending ROS 2’s utility into automotive and other embedded domains.

Ultimately, Apex.Grace empowers companies to “build once and deploy confidently” by bridging the gap between prototyping and production. It brings the benefits of ROS 2—modularity, reusability, and ecosystem support—into environments that demand rigorous validation and safety certification. This positions Apex.Grace as a key enabler for deploying modern robotics and autonomous systems in real-world, regulated applications without sacrificing development speed or code investment.

Dive Deeper

Unlocking System Observability

Observability Tools empower developers to build, debug, and deploy with unmatched transparency. Whether you're developing next-gen autonomous vehicles or safety-critical industrial systems, observability is a necessity.

Apex.Grace implements a robust logging infrastructure that goes beyond conventional frameworks. It’s real-time capable and embedded-system safe, avoiding blocking calls and dynamic memory allocation entirely. Log messages are created using deterministic methods and transmitted over the communication stack to an asynchronous log writer. Whether you're debugging locally or aggregating logs from multiple nodes, Apex.Grace supports flexible configuration, with runtime and compile-time options for log levels, output destinations, and formatting.

For deeper behavioral and performance analysis, Apex.Grace incorporates LTTng-based tracing, enabling detailed inspection of both userspace and kernel-level activity on Linux systems. With tracepoints integrated throughout the Executor and middleware layers, developers can capture end-to-end performance data right out of the box. This trace data becomes an actionable visualization using the Apex.Grace Compass GUI. See execution timelines, identify bottlenecks, and compare system states across different builds or configurations. Whether you’re tuning load distribution across cores or investigating latency spikes, Compass delivers the clarity needed to move with confidence.

Introspection tools provide structural transparency and data flow clarity, which is critical to understanding your system’s structure and behavior and building reliable robotics applications. Apex.Grace enhances standard ROS 2 CLI tools with additional capabilities, such as visualization of process dependencies and state transition graphs. For visual inspection, Apex.Grace integrates with trusted tools like RViz2, RQt, and PlotJuggler—offering real-time graphing of DDS topic data and comprehensive graphical introspection. Developers can easily examine node health, communication pathways, and message throughput from both a micro and macro perspective.

Dive Deeper

Robust
Configuration
and Storage

Robust Configuration and Storage features provide a comprehensive framework for managing configuration and persistent data across the software lifecycle in safety-critical systems. This enables developers to focus on building the business logic, while Apex.Grace provides the tools to build deterministic applications from configuration to facilitating system and calibration post-deployment.

Dive Deeper

Message Storage Feature Enables Runtime Persistence

Apex.Grace’s message storage feature enables runtime persistence of any ROS‑type message—crucial for sharing and retaining vehicle parameters like steering orientation, sensor configurations, or user preferences across distributed ECUs. A central ECU typically distributes these configurations, but with message storage, each ECU can locally cache parameters in a database running as a separate QM process. This ensures availability even if the central node is down and supports offline use cases like ECU calibration or OTA parameter updates.

The storage system consists of a storage service and two client APIs—one strongly typed for ASIL‑D safety-certified applications and one dynamic for tooling or introspection. It uses a hierarchical model: communication object → database → typed data store, keyed by message type (and optional index). Messages can be saved as persistent or ‘transient’ (lost on reboot), and the database supports history and explicit commits. Clients can also “watch” stores, receiving callbacks whenever data updates, enabling reactive behaviors.

Dive Deeper

Unified Diagnostic Services

Apex.Grace includes a Unified Diagnostic Services (UDS) stack—based on the ISO 14229 standard—for native integration of automotive diagnostics into ROS-based systems. The stack supports Diagnostics over IP (DoIP) using ISO 13400 and follows a client-server model: external diagnostic tools connect via Ethernet (UDP/TCP), while an in-vehicle ROS node handles transport and routes UDS requests through standard ROS publish–subscribe mechanics. This modular architecture allows developers to swap transport layers (e.g., CAN or FlexRay) without modifying diagnostic logic.

Within the UDS server node, three layers operate in tandem. The session layer toggles between diagnostic modes (e.g., DiagnosticSessionControl, TesterPresent), the security layer handles challenge–response security (SecurityAccess), and the service layer delivers diagnostic operations (e.g., ReadDataByIdentifier, WriteDataByIdentifier) to application nodes via ROS services. A separate Diagnostic Fault Management component collects and persistently stores fault information—including codes, counts, and context—in the Apex.Grace storage database. This ensures mechanics or OEMs can access comprehensive diagnostic data, enhancing fault analysis and vehicular reliability.

Dive Deeper

Intelligent
Orchestration

Apex.Grace provides robust orchestration and fault handling for real-time, safety-critical systems. From clean startup to controlled shutdown, it manages system behavior across defined operational states, ensuring consistent, predictable transitions even under failure conditions.

Health is monitored at both hardware and software levels. The framework tracks CPU, memory, time sync, and process status, detecting anomalies before they escalate. An event-driven architecture allows custom responses to system events, while the Process Manager ensures processes start, stop, and recover in the right order.

At the core, the System Manager coordinates inputs from all monitors to enforce state transitions and react to faults, enabling resilient, intelligent systems that recover gracefully and operate reliably.

Dive Deeper

From Lab to Road

Apex.Grace transforms validation from a fragmented process into a unified, deterministic workflow. Engineers can record real-world data across distributed systems, replay it with guaranteed execution order, and drive simulations using the same application logic—no rewrites required. Whether you're running Software-in-the-Loop, Hardware-in-the-Loop, or full vehicle tests, Apex.Grace delivers consistent, reproducible results. With built-in support for rosbag2, MCAP, and leading simulators like CARLA, testing becomes continuous, scalable, and production-ready.

Dive Deeper

Apex.Grace

モビリティ、スマート マシン、IoT 向けのソフトウェア開発キット。安全認証済み。

TM

Apex.Grace 効率的なアプリケーション開発を可能にします。

Apex.Grace は、安全性が重要なすべてのモビリティ アプリケーションに対応します。

Apex.Grace provides

Scaling ROS Based Systems

モビリティ、スマートマシン、IoT 向けのソフトウェア開発キット。安全認証済み。

Apex.Grace は、安全性が重要なすべてのモビリティアプリケーションに対応します。

Scaling ROS
Based Systems