Introduction

Appling is a declarative language for business applications. You write .appling files that describe what exists, what can happen, how capabilities are organized, how programs reach them and how people use them. Appling parses and links those files into one validated model, and every tool works on that model: the CLI, the IDE with its zoomable graph, the AI assistants and the code generators.

The text is the single source of truth. The graph you see, the edits the AI proposes and the project the generator writes all come from it and go back to it.

module sales {
  export Order

  enum OrderStatus {
    draft
    placed
  }

  entity Order {
    reference: String unique
    status: OrderStatus state default draft
  }

  action PlaceOrder on Order {
    requires { reference != "" }
  }

  machine OrderFlow on Order.status {
    transition draft -> placed via PlaceOrder
  }
}

flowchart TB
  subgraph m0["sales"]
    n0["OrderStatus<br/><small>enum</small>"]:::domain
    n1["Order<br/><small>entity</small>"]:::domain
    n2["PlaceOrder<br/><small>action</small>"]:::behavior
    n3["OrderFlow<br/><small>machine</small>"]:::behavior
  end
  n1 -->|"type, uses"| n0
  n2 -->|"entity, uses"| n1
  n3 -->|"field"| n1
  n3 -->|"action"| n2
  classDef domain fill:#3d2510,stroke:#3d2510,color:#f7f2ea
  classDef behavior fill:#6b3f12,stroke:#6b3f12,color:#f7f2ea
  classDef application fill:#a85f17,stroke:#a85f17,color:#f7f2ea
  classDef interface fill:#d98a1c,stroke:#d98a1c,color:#0c0a08
  classDef experience fill:#f2b632,stroke:#f2b632,color:#0c0a08
  classDef cross fill:#1b1712,stroke:#7a6e5e,color:#f7f2ea

How it fits together

flowchart LR
  text[".appling files"] --> lang["Parse, link, validate"]
  lang --> semantic["Semantic graph"]
  semantic --> cli["CLI: check, fmt, graph, release"]
  semantic --> ide["IDE: text and graph side by side"]
  semantic --> ai["AI: MCP server and chat"]
  semantic --> gen["Code generation: Django, Ash"]
  ide -- "edit operations" --> text
  ai -- "reviewable proposals" --> text

Every change, whether you type it, drag it in the graph or accept it from the AI, is an edit of the text. Edits are validated before they land, so the model never holds an error you did not write yourself.

The model in five layers

Each concept is defined once, in the layer that owns it. References only point down the layers, and modules only see what other modules export.

What you can do with it

• Validate the whole model on every build: references, types, layer rules, exports and migrations. See the CLI.
• Explore and edit it in the IDE: the text with a language server next to the graph, at three zoom levels.
• Work with AI through the MCP server or the IDE chat. AI changes pass the same validation and arrive as reviewable diffs.
• Generate a draft Django or Ash project. What the generator cannot write becomes a task in a registry for you or an AI.
• Evolve it safely: once you cut a release, renames and type changes of stored data are recorded as migration steps and carried into generated projects.

Where to go next