Product Overview

What This Chapter Covers

This chapter explains what kind of product PAIO is, what you can do with it, and how data flows through it. It does not cover the step-by-step operation of individual features; it only points you to the document that does. It is written for readers new to PAIO, and there are no prerequisites. Figures, versions, and lists of supported items are collected in 02. Specifications, and the meaning of any term used here can be found in 21. Glossary.

1.1 What Is PAIO

PAIO is an all-in-one AUTOSAR / SDV (Software Defined Vehicle) development IDE with built-in AI. A single Electron-based desktop application covers development for both the AUTOSAR Classic Platform and the Adaptive Platform.

Traditionally you used a separate tool for network design, another for the signal database, another for SWC design, another for BSW configuration, and yet another code IDE — and moved between them by exchanging ARXML files. PAIO puts that entire process on one workspace and one data model.

The basic product information is as follows.

Item	Value
Product name	PAIO
Supplier	PopcornSAR Co., Ltd.
Product page	https://autosar.io/products/paio
Support	https://autosar.io/support · Inquiries https://autosar.io/support/qna
License	PopcornSAR PAIO License (commercial)

You must sign in to use PAIO. The main window — the whole layout with the editors, the Explorer, and the menus — is built only after authentication finishes, so before you sign in you see nothing but the sign-in screen. Until license verification completes, the feature gates also default to locked (read-only). For details, see 03. Installation, Login and License.

Eight Terms to Know First

You do not need many terms to get started. The eight below are enough to read chapters 01 to 05; look up the rest in 21. Glossary as you need them.

Term	Meaning
ECU	One electronic control unit installed in a vehicle
HPC	A high-performance computer. Adaptive Platform software runs here
Bus / cluster	The communication network that connects ECUs. CAN, LIN, FlexRay, and Ethernet exist
Signal	One piece of data carried over the bus — for example, the vehicle speed value
Frame	The bundle that holds signals and is actually sent over the bus
SWC	A software component. The unit of software responsible for one function
Port	The point through which an SWC exchanges data
ARXML	The AUTOSAR standard file format. Used to exchange data with other companies and other tools

1.2 What You Can Do — Feature Map

Modeling Editors (8)

When you pick an editor for the first time, start from the task you want to perform.

What you want to do	Editor to open
Draw how many ECUs the vehicle holds and which buses connect them	IVC
Define which data travels over those buses	Signal
Design how the software is divided into components	VFB
Define the format of the data components exchange	Interface, DataType
Decide which component is deployed to which ECU	System
Create configuration values for the ECU basic software (BSW)	Module Definition, Module Configuration

What each editor actually edits and which file it saves to is listed below.

Under the design folder in the project Explorer there is a System node and a Module node. Expand System and the IVC / VFB / Interface / DataType / Signal nodes appear; expand Module and the Definition / Configuration nodes appear. Double-click a node to open the matching editor.

Editor	What it edits	Saved to	Document
IVC (In-Vehicle Network)	The vehicle network topology — ECUs, HPCs, Ethernet switches, connectors, controllers, communication clusters, physical channels	IVC model	06
Signal	The frame / PDU / signal dictionary	Signal model	07
VFB	SWC composition diagrams, ports, connectors, internal behavior, AP machine configuration	VFB model + SWC definitions	08
Interface	The seven port interface categories (Service, Sender-Receiver, Client-Server, Mode-Switch, Adaptive, Error Domain, Mapping) and service deployment	Interface model, Service model	09
DataType	Application and implementation data types, units	DataType model	10
System	System information, SWC-to-ECU mapping, statistics	System model	11
Module Definition	ECUC module definitions (the schema)	Module definitions	12
Module Configuration	ECUC BSW module configuration values	Module configurations	12

Beyond these eight, more viewers and editors open files: code files, Markdown documents (with live preview), images, plain text, HTML preview, and the AI workflow screen. For how to use them, see 16. Code Editing, Build, Terminal and Documents and 15. AI Assistant.

Double-clicking the Module node under design opens an empty tab that shows only a Coming Soon notice. Expand the node and double-click Definition / Configuration below it instead. Those two nodes do not expand any further in the tree; the module list lives inside the editor.

When Each Model Is Created

When you create a new project, the design tree holds only three items: System, VFB, and IVC. The contents for Signal, Interface, DataType, Service, and IDS, and everything under Module, appear the first time you save in the matching editor or when an import produces that content. Seeing only three items in a new project is therefore normal, not a loss of data.

The VFB editor keeps diagram layout in a separate file. For each composition a design/SWC/Layout/<composition name>.vfb.layout file is created, holding positions, sizes, and port coordinates. The SWC bodies themselves are split into folders by kind. There are seven folders: Composition, Application, AdaptiveApplication, ComplexDeviceDriver, Service, EcuAbstraction, and SensorActuator. AP machine configuration is kept separately under Module ▸ Machine.

Development Environment

Separately from modeling, these are the features you use to write and build application code.

Feature	Description	Document
Built-in code IDE	Monaco-based C/C++/Rust editing, clangd and rust-analyzer LSP, streaming GCC/CMake/Cargo builds	16
Integrated terminal	xterm + node-pty. Local PTY, SSH shell, container exec, and WSL support	16
Document editing	Markdown editor with live preview, and Mermaid, PlantUML, Draw.io, and ZenUML diagrams	16
Remote development	SSH / Docker Dev Container / WSL connections, with automatic LSP deployment to the remote	17

Conversion · Validation · Automation

These are the features you use to exchange models with external formats, to check a model against rules, or to generate a draft automatically.

Feature	Description	Document
ARXML import/export	Bidirectional round-trip conversion of AUTOSAR ARXML. A merge conflict resolution UI appears on re-import	13
DBC import	CAN database → Signal model	13
ECU / Machine Extract	Generates a partial ARXML cut down to the elements reachable by reference from one node	13
ECUC generation	Generates BSW module configuration from the IVC and Signal models (Can, CanIf, Com, EcuC, PduR)	12
Validation	Checks AUTOSAR constraint (constr) rules in real time; clicking a violation jumps to the owning editor	14
AI chat	Create and modify the model in natural language. Five providers (Claude [OPUS], Claude [GLM], Gemini, Codex, Ollama)	15
QuickStart workflow	Pick a domain template (24 templates across 7 domains), fill in the variables, and the whole project is generated step by step	15

1.3 Design Philosophy — the IO-First Architecture

The most important structural characteristic of PAIO is that AUTOSAR is not the original.

                       ┌───────────────────────────┐
   ARXML  ──import──►  │                           │  ──export──►  ARXML (R25-11)
   DBC    ──import──►  │         IO Model          │  ──export──►  DataType ARXML
                       │  Format-neutral · single  │  ──export──►  ECUC ARXML
                       │      source of truth      │
                       └───────────┬───────────────┘
                                   │
                     Every editor, the AI, and validation
                        read and write only this model

• The IO Model is the primary data model. It is saved as human-readable text, so you can put it straight into version control.
• AUTOSAR (ARXML) and DBC are a converter layer laid on top of it. They are not the original.
• The editors, the AI, and validation all look only at this model. You can replace a converter and keep using the editors unchanged.
• Round-trip conversion — import → edit → export → re-import — is supported. This does not mean, however, that an arbitrary ARXML file makes that round trip without loss.

Diagram Coordinates Do Not Leave in the ARXML

Screen layout information such as node position and size stays inside the project. IVC diagram coordinates are stored in the IVC model, and VFB diagram coordinates in design/SWC/Layout/<composition name>.vfb.layout. An exported ARXML contains no coordinates. Reading an exported ARXML back in another tool or another project therefore does not restore the screen layout. Because of this, the following two operations look different.

Situation	Behavior
First import of an ARXML into an empty project	The ARXML holds no coordinates, so the importer lays nodes out automatically on a grid
Re-import into a project that already has a model	On merge, position and size are excluded from the content comparison, so the coordinates you arranged on screen are kept as they are. Simply moving a node is not detected as a conflict

Unlike coordinates, mapping information that has no place in the standard does leave in the ARXML, inside an SDG (Special Data Group) — see 13.3.6.

1.4 Edit History and Multiple Projects

• A single timeline manages the project edit history (undo, redo, and whether changes are saved). Editors do not keep separate undo stacks, so Undo in the Edit menu reverses edits consistently, whichever editor you made them in.
• Editors from several projects can be open in one PAIO window at the same time. In that case undo, redo, and Save All in the menu are limited to the active project. When you quit the application, however, changes in all open projects are saved, so edits in another project are not lost on exit.
• Only the dirty marker (the dot) on a tab is unaffected by project scope. It is calculated per tracked file, whichever project is active, so a tab in an inactive project also shows its unsaved changes.

1.5 AUTOSAR Support Scope

• Classic Platform: ECU instances, communication clusters (CAN / CAN FD / LIN / FlexRay / Ethernet), frames, PDUs and signals, SWCs and compositions, port interfaces, data types, system mappings, ECUC BSW module definitions and configurations, NM, Transport Protocol (CanTp/LinTp), and Global Time.
• Adaptive Platform: Machine Design, machine configuration (Function Group, Process, 10 modules), Adaptive Application (Executable/Process), service interfaces and deployment (SOME/IP, DDS), Error Domain, PHM, State Management, Persistency, Crypto, IDSM, UCM, Time Sync, and DLT.
• The 10 modules of machine configuration: LOG (Log and Trace), CM (Communication Management), SM (State Management), NM (Network Management), PHM (Platform Health Management), TS (Time Synchronization), CRY (Cryptography), PER (Persistency), IDS (Intrusion Detection), and UCM (Update and Configuration Management).
• Output schema: output is fixed to the AUTOSAR R25-11 (AUTOSAR_00054.xsd) namespace.

FlexRay is handled in the model and the converter layer, but it does not appear on screen in the IVC editor. The exact conditions are collected in sections 2.5 and 2.12 of 02. Specifications.

1.6 Representative Workflows

The following describes, in order, the flow of four frequently performed tasks.

A. Starting from an Existing ARXML

1. Open a workspace folder with Project ▸ Open Workspace... (Ctrl+O). The project Explorer shows the list of projects under that folder.
2. Create a project with Project ▸ New Project (Ctrl+N). Enter a name, and the project folder, the fixed folders, and the three default models are created.
3. Right-click the project node, select Import, and choose the ARXML (or DBC) files. You can select several files at once. Before the import starts, unsaved edits in open editors are written to disk first.
4. If any item conflicts with the existing model, the conflict resolution dialog opens. Choose which side to keep for each item.
5. Double-click each model node under design to review and adjust the result in the editor.
6. Right-click the project node and select Export. No save-location dialog appears; the ARXML files are created directly in the <project>/export/ folder.
7. Check the result. Expand the export folder to see the generated files, such as <project name>_System.arxml.

B. Starting from Scratch

1. Open a workspace and create a project.
2. In the IVC editor, place ECUs and HPCs, then right-click a node and use Add Connector and Add Controller to attach connectors and controllers. Join two connectors of the same protocol on the canvas and a new communication cluster is created between them. From the third node on, you connect the connector to the existing cluster.
3. In the Signal editor, define frames, PDUs, and signals, and map the signals to the PDUs.
4. In the Interface and DataType editors, define port interfaces and data types.
5. In the VFB editor, place compositions and SWCs, connect the ports, and then map them to ECUs and HPCs.
6. Open the Validation panel and clear the constraint violations. Clicking a violation row opens the editor that owns the element. In most cases the element is also selected and highlighted, but if the element cannot be found, only the editor opens.
7. If you need ECUC, select the ECU node in the IVC editor, choose the modules in the ECUC section of the properties panel on the right, and click Generate ECUC. Note that this button is disabled when the ECU has no CAN connector.
8. Right-click the project node and choose Export to produce the ARXML.

C. Generating a Draft with AI

1. Run Project ▸ Quick Start. The QuickStart screen opens in a new tab.
2. Choose a domain template. There are seven domains — Body, Powertrain, ADAS, Infotainment, Chassis, Gateway, and Diagnostics — and 24 templates in total.
3. Fill in the variables and click Start Generation.
4. When the step-by-step generation finishes, review and adjust the result in each editor.

For the detailed procedure, see 15. AI Assistant.

D. Delivering Only One ECU's Worth of Data to a Supplier

When you need to cut out only one ECU's worth of data and hand it to a supplier, use the Extract feature.

1. Open the IVC editor and right-click the target node on the canvas.
2. Extract ECU appears for an ECU node and Extract Machine for an HPC node. Other kinds of node — connectors, controllers, and clusters — do not have this item.
3. Select the item, and an ARXML cut down to the part reachable by reference from that node is created under <project>/export/<node name>/.

For details, see 13. Import and Export.