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 19. 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 in one project window and one data model. One window holds one project: the folder the window opens is the project itself.
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 side views, 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 19. 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 | System |
| 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 or HPC | System (node menu SW Mapping) or VFB (composition menu ECU/HPC Mapping) |
| Hold the diagnostic data of the vehicle (diagnostic extract, DEXT) | Diagnostic |
| 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.
Design editors open from the EDITOR view, which the first icon (Design) of the icon rail
at the far left of the window shows. Its DESIGN section lists System, VFB,
Interface, DataType, and Diagnostic, and its MODULE section lists Definition
and Configuration. Click a row once and its editor opens in a tab named <project>:<row>, for
example <project>:System. Signal has no row: it opens from the Signal icon, the upper
icon of the strip along the left edge of the System editor canvas.
| Editor | What it edits | Saved to | Document |
|---|---|---|---|
| System (formerly the IVC editor) | The vehicle network topology — ECUs, HPCs, Ethernet switches, connectors, controllers, communication clusters, physical channels | IVC model (design/IVC.io.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 |
| Diagnostic | Diagnostic data (diagnostic extract, DEXT) | Diagnostic model | Not covered in this manual |
| Module Definition | ECUC module definitions (the schema) | Module definitions | 12 |
| Module Configuration | ECUC BSW module configuration values | Module configurations | 12 |
The system-level information has no editor of its own. The System button (PAIO logo) on the right edge of the System editor canvas and of the VFB editor canvas opens the SYSTEM panel: NAME, VERSION, and DESCRIPTION of the system, plus ECU MAPPING in the System editor or ROOT COMPOSITION and COMPOSITIONS in the VFB editor. See 11. SYSTEM Panel.
Beyond these eight, more viewers and editors open files: code files, Markdown documents (with live preview), images, plain text, HTML preview, and the Workflow editor. For how to use them, see 16. Code Editing, Build, Terminal and Documents and 15. AI Assistant. The Explorer (the icon at the bottom of the rail) shows the project folder as a plain file tree; open the design editors from the EDITOR view, not from the Explorer.
When Each Model Is Created
When you create a new project, its design folder holds only three model files:
IVC.io.model, SYSTEM.io.model, and VFB.io.model. The files for Signal, Interface,
DataType, Diagnostic, Service, and IDS, and everything under design/Module/, appear the first
time you save in the matching editor or when an import produces that content. The DESIGN list
shows its five rows either way, so a missing file in a new project is 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
design/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, and container exec | 16 |
| Document editing | Markdown editor with live preview, and Mermaid, PlantUML, Draw.io, and ZenUML diagrams | 16 |
| Remote development | SSH / Docker Dev Container connections, with automatic LSP deployment to the remote | 17 |
| vECU | The vECU view of the icon rail, for the PRTE and PARA vECU containers in which ECU software is built and run | — |
Conversion · Validation · Automation
These are the features you use to exchange models with external formats, to check a model against rules, or to generate code and drafts.
| 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 |
| PRTE / PARA code generation | The PRTE Code Generation and PARA Code Generation icons on the DESIGN header generate code from the model | — |
| 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 |
| Workflow editor | Opens the project's workflow document (workflow/WORKFLOW.io.workflow) from the Workflow icon of the rail | — |
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. System editor
diagram coordinates are stored in the IVC model (design/IVC.io.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 One Project per Window
- 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.
- A PAIO window holds exactly one project, and its title bar reads
PAIO [<project>]. Undo, redo, and Save All therefore always act on that one project. - Creating or opening another project in a window that already holds one does not add it to that
window: the other project opens in a window of its own, and the current window closes.
PROJECT ▸ New Window(Ctrl+Shift+N) opens an additional empty window.
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), Global Time, and the diagnostic extract (DEXT).
- Adaptive Platform: Machine Design, machine configuration (Function Group, Process, 11 modules), Adaptive Application (Executable/Process), service interfaces and deployment (SOME/IP, DDS), Error Domain, PHM, State Management, Persistency, Crypto, IDSM, UCM, Time Sync, DLT, Software Cluster and Vehicle Package, and ECU resources (hardware).
- The 11 modules of machine configuration: LOG (Log and Trace), CM (Communication Management), SM (State Management), DM (Diagnostic 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 System 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
- Create a project: click New Project on the Welcome tab, or choose
PROJECT ▸ New Project...(it has no shortcut). In the New Project dialog, enter Name, set Location (type a path or click Browse…), and click Create. The project opens and the title bar readsPAIO [<project name>]. To work in a folder that already holds a project, usePROJECT ▸ Open Project...(Ctrl+O) instead. - In the EDITOR view, click Import, the first icon on the DESIGN header, 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.
- If any item conflicts with the existing model, the conflict resolution dialog opens. Choose which side to keep for each item.
- Click each row under DESIGN to review and adjust the result in its editor.
- Click Export, the second icon on the DESIGN header. No save-location dialog appears; the
ARXML files are created directly in the
<project>/export/folder. - Check the result. Expand EXPORT in the EDITOR view to see the generated files, such as
<project name>_System.arxml.
B. Starting from Scratch
- Create a project as in step 1 of A.
- Click System under DESIGN to open the System editor. Right-click the empty canvas and use Add ECU / Add HPC to place nodes, then right-click a node and use Add Connector and Add Controller to attach connectors and controllers. From the menu of a bus connector, Create CommunicationCluster [<protocol>] creates a new communication cluster; further connectors are joined to it.
- Click the Signal icon at the left edge of the System editor canvas to open the Signal editor. Define frames, PDUs, and signals, and map the signals to the PDUs.
- In the Interface and DataType editors, define port interfaces and data types.
- In the VFB editor, place compositions and SWCs and connect the ports. Then map each composition to an ECU or HPC with ECU/HPC Mapping on the composition in the VFB editor, or with SW Mapping on the node in the System editor.
- Click the V icon in the status bar to 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.
- Click Export on the DESIGN header to produce the ARXML.
C. Generating a Draft with AI
- Open the AI chat and describe in natural language the model you want to create or change.
- Review and adjust the result in each editor.
The QuickStart workflow, which generated a whole project from a domain template, has no menu entry in this version. For the detailed procedure of the AI chat, 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.
- Open the System editor (DESIGN ▸ System) and right-click the target node on the canvas.
- 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.
- 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.