Home

artheia

artheia is a host-side DSL for modeling Adaptive-AUTOSAR-style components — atomic nodes with explicit TIPC addresses and typed ports, wired into compositions and clusters — plus the code generators that turn an .art model into C++ scaffolds, .proto wire types, deploy manifests, and netgraphs for the Theia runtime.

It is inspired by ARText (the syntax aesthetic + the structural concepts: atomic components, ports, prototypes, compositions, connectors), but it is its own thing — not AUTOSAR-tool-compatible.

Install

artheia 0.1.0 is on PyPI:

pip install artheia

That gives you three console scripts:

script	what it is
artheia	the CLI — parse, check-addresses, and the gen-* generators (Generators)
artheia-lsp	the language server for the VS Code / Emacs editor integrations (Editor Support)
artheia-mcp	the generator surface exposed as an MCP server for Claude Code (Editor Support)

From a source checkout: pip install -e . (or, against a wheel cache, pip install --find-links /opt/theia/wheels artheia).

The three primitives

The grammar has three structural primitives, bottom to top:

Primitive	Is a	Owns
node	one thread	one TIPC type/instance, typed ports, a behavior class (GenServer / GenStateM / GenRunnable)
composition	one process / executable	node prototypes + in-process wiring (connect)
cluster	a distribution / deploy bundle	compositions + inter-process wiring; the installable unit

Around them: message / enum (proto3-equivalent data), interface (senderReceiver for streams, clientServer for request/reply), import across packages, and the AUTOSAR-PSP extras bus / gateway_route. See Grammar for the full reference.

A model in one breath

package system.demo

enum Mode { IDLE = 0  RUN = 1 }

message Tick    { uint32 seq }
message SetMode { Mode mode }

interface senderReceiver TickStream { }          // a stream of Tick
interface clientServer   ModeCtl {
    operation Set(in r:SetMode) returns Tick
}

// a node: one thread, one TIPC endpoint
node atomic Counter {
    tipc type=0x80020001 instance=0
    ports {
        receiver ticks_in requires TickStream     // inbound stream
        server   ctl      provides ModeCtl        // request/reply surface
    }
}

node atomic Driver {
    tipc type=0x80020002 instance=0
    ports {
        sender ticks_out provides TickStream
        client mode_call requires ModeCtl
    }
}

// a composition: the process, wiring prototypes together
composition DemoProc {
    prototype Counter counter
    prototype Driver  driver

    connect driver.ticks_out to counter.ticks_in
    connect driver.mode_call to counter.ctl
}

// a cluster: the deploy / package unit
cluster Demo {
    composition DemoProc proc
}

What you do with a model

artheia parse           system/system.art                 # resolve + validate the tree
artheia check-addresses system/system.art                 # assert TIPC addresses unique
artheia gen-app --kind fc <component>.art --out services/<fc>/   # C++ scaffold (lib/main/impl)
artheia gen-proto       <component>.art --out platform/proto
artheia gen-netgraph    <component>.art --out netgraph.json
artheia gen-manifest    <component>.art services/manifest/service.py

artheia --help lists the full command set (~30 generators incl. DBC/FIBEX import, config-schema migration, and the rig/manifest pipeline). The gen_server shape follows OTP — handle_call / handle_cast / handle_info per node.

Pages

• Grammar — the .art language in depth: packages, messages, interfaces, nodes, compositions, clusters, state machines, the keyword reference.
• Generators — the gen-* command surface (verified catalog), what each emits, and the gen-app lib/main/impl split.
• Editor Support — the artheia-lsp language server, the VS Code + Emacs clients, and the artheia-mcp server.

Related

• Theia wiki — the full system: the actor runtime, the supervisor, the Functional Clusters, deploy.
• perotheia organization — all repos.

License

Apache-2.0.