agenticempire/axint

 

Axint is the compiler and repair loop for agent-built Apple-native software.

Author in TypeScript, Python, or the preview .axint surface.
Emit ordinary Swift, validate Apple-specific rules, and hand agents a repair packet when something needs work.

Website · Playground · Quick Start · MCP Server · Docs · Registry

---

The loop

Axint exists because Apple-native software is becoming a set of structured system capabilities: App Intents, Siri, Shortcuts, Spotlight, widgets, SwiftUI views, privacy copy, entitlements, and generated metadata.

General coding agents can produce Swift. Axint makes them operate through a smaller contract, validates the Apple-specific parts, and writes a repair artifact the next agent run can use.

feature definition
  → Axint IR
  → Swift + plist + entitlements
  → local or Cloud Check verdict
  → Fix Packet
  → agent repair
  → rerun

The compiler is useful on its own. Registry and Cloud extend the same workflow:

• Compiler — open-source TypeScript/Python/preview .axint to Apple-native Swift.
• Fix Packet — latest.check.* for the quick verdict, latest.* for the full repair contract.
• MCP — agents call compile, validate, fix, schema compile, templates, and packet tools directly.
• Registry — install reusable Apple capabilities with source, compiler metadata, and package details attached.
• Cloud Check — free hosted validation for quick results; signed-in Pro checks add the AI-ready repair prompt, history, and a shareable report.

Read the thesis · Open proof · View Fix Packet

---

License and trademarks

Axint is open-source software licensed under Apache-2.0. The Axint name, wordmark, axis mark, logo, hosted service names, domains, and related Agentic Empire brand assets are not licensed for use by forks or unaffiliated products.

Forks are welcome under the Apache-2.0 license, but they should use distinct names and branding. See NOTICE and TRADEMARKS.md.

---

Why Axint

Apple's API surfaces — App Intents, SwiftUI, WidgetKit — are verbose and contract-heavy. A single widget needs a TimelineEntry, a TimelineProvider, an EntryView, and a Widget struct before you've written a line of business logic. An App Intent needs parameters, metadata, privacy assumptions, and Swift that fits Apple's expectations.

Axint gives agents and developers a smaller authoring surface. One defineIntent() call can replace the intent boilerplate an agent would otherwise regenerate token by token. One defineWidget() can replace the WidgetKit stack. The compiler handles the struct conformances, @Parameter wrappers, LocalizedStringResource literals, plist fragments, entitlements, diagnostics, and repair artifacts around the generated Swift.

Four surfaces, one pipeline:

defineIntent()  →  App Intent for Siri & Shortcuts
defineView()    →  SwiftUI view
defineWidget()  →  WidgetKit widget
defineApp()     →  Full app scaffold

The result: teams and AI tools can author Apple-native features in a smaller surface than hand-written Swift, inspect ordinary generated Swift when it matters, then use Axint Check and Fix Packets to keep the repair loop grounded in the same facts.

---

Quick start

npm install -g @axint/compiler

# compile a single file
axint compile my-intent.ts --out ios/Intents/

# or pipe to stdout
npx -y -p @axint/compiler axint compile my-intent.ts --stdout

Intent

import { defineIntent, param } from "@axint/compiler";

export default defineIntent({
  name: "CreateEvent",
  title: "Create Calendar Event",
  description: "Creates a new event in the user's calendar.",
  domain: "productivity",
  params: {
    title: param.string("Event title"),
    date: param.date("Event date"),
    duration: param.duration("Event duration", { default: "1h" }),
    location: param.string("Location", { required: false }),
  },
});

View

import { defineView, prop, state, view } from "@axint/compiler";

export default defineView({
  name: "EventCard",
  props: {
    title: prop.string(),
    date: prop.date(),
  },
  state: {
    isExpanded: state.boolean(false),
  },
  body: [
    view.vstack({ alignment: "leading", spacing: 8 }, [
      view.text("entry.title"),
      view.conditional("isExpanded", [view.text("entry.date")]),
    ]),
  ],
});

Widget

import { defineWidget, entry, view } from "@axint/compiler";

export default defineWidget({
  name: "EventCountdown",
  displayName: "Event Countdown",
  description: "Shows time until the next event.",
  families: ["systemSmall", "systemMedium"],
  entry: {
    eventName: entry.string("Untitled"),
    minutesUntil: entry.int(0),
  },
  body: [
    view.vstack({ alignment: "center", spacing: 4 }, [
      view.text("entry.eventName"),
      view.text("entry.minutesUntil"),
    ]),
  ],
});

App

import { defineApp, scene, storage } from "@axint/compiler";

export default defineApp({
  name: "WeatherApp",
  scenes: [
    scene.windowGroup("WeatherDashboard"),
    scene.settings("SettingsView", { platform: "macOS" }),
  ],
  appStorage: {
    useCelsius: storage.boolean("use_celsius", true),
    lastCity: storage.string("last_city", "Cupertino"),
  },
});

Compile any surface the same way:

axint compile my-intent.ts --out ios/Intents/
axint compile my-view.ts --out ios/Views/
axint compile my-widget.ts --out ios/Widgets/
axint compile my-app.ts --out ios/App/

---

Public truth

v0.4.9 · 20 MCP tools + 5 prompts · 182 diagnostic codes · 1098 tests · 14 live packages · 26 bundled templatesPublic proof is generated from `../public-truth/public-truth.json` via `npm --prefix .. run truth:sync`.

If release numbers, diagnostics, package counts, or MCP surfaces change, update the canonical truth layer and re-run the sync instead of editing proof values by hand.

---

Watch mode

Recompiles on every save with 150ms debounce, inline errors, and optional swift build after each successful compile:

axint watch ./intents/ --out ios/Intents/ --emit-info-plist --emit-entitlements
axint watch my-intent.ts --out ios/Intents/ --format --swift-build

---

MCP server

Axint ships an MCP server for Claude Desktop, Claude Code, Cursor, Codex, VS Code, Windsurf, Xcode, and any MCP client.```json

{ "mcpServers": { "axint": { "command": "npx", "args": [ "-y", "-p", "@axint/compiler", "axint-mcp" ] } } }

MCP tools and built-in prompts:

| Tool | What it does |
| --- | --- |
| `axint.status` | Report the running MCP server version, package path, uptime, and Xcode restart/update instructions |
| `axint.doctor` | Audit version truth, Node/npm/npx paths, project MCP wiring, and agent start-pack files |
| `axint.session.start` | Start an enforced agent session, refresh `.axint/AXINT_REHYDRATE.md`, write `.axint/session/current.json`, and return the token required by workflow gates |
| `axint.compile` | Full pipeline: TypeScript → Swift + plist + entitlements |
| `axint.schema.compile` | Minimal JSON → Swift (token-saving mode for agents) |
| `axint.validate` | Dry-run validation with diagnostics |
| `axint.feature` | Generate an editable feature package: intents, views, widgets, components, app shells, stores, tests, and support fragments |
| `axint.project.pack` | Generate `.mcp.json`, `AGENTS.md`, `CLAUDE.md`, `.axint` rehydration/memory/docs/project files, and the session-first workflow for first-try agent setup |
| `axint.context.memory` | Return the compact Axint operating memory for new chats and context-compaction recovery |
| `axint.context.docs` | Return the project-local Axint docs context so agents can reload docs after compaction |
| `axint.suggest` | Suggest app-specific Apple-native features, reusable components, and shared stores from a product description |
| `axint.workflow.check` | Check whether an agent rehydrated Axint after compaction, has an active session token, and used suggest, feature, swift.validate, cloud.check, and Xcode proof before moving on |
| `axint.scaffold` | Generate a starter TypeScript intent from a description |
| `axint.swift.validate` | Validate existing Swift against build-time rules |
| `axint.swift.fix` | Auto-fix mechanical Swift errors (concurrency, Live Activities) |
| `axint.fix-packet` | Read the latest AI-ready repair packet from a local compile or watch run |
| `axint.cloud.check` | Run an agent-callable Cloud Check report against Swift or TypeScript source |
| `axint.tokens.ingest` | Convert design tokens into SwiftUI token enums for generated views |
| `axint.templates.list` | List bundled reference templates |
| `axint.templates.get` | Return the source of a specific template |

Built-in prompts:

| Prompt | What it does |
| --- | --- |
| `axint.project-start` | Start an Xcode/Apple project by reading the docs, verifying MCP, and establishing the check/fix loop |
| `axint.context-recovery` | Recover Axint after a new chat, context compaction, or long coding drift |
| `axint.quick-start` | Get a quick-start guide |
| `axint.create-intent` | Start a new intent from guided parameters |
| `axint.create-widget` | Start a new widget from guided parameters |

`axint.schema.compile` is the key optimization — agents send ~20 tokens of JSON and get compiled Swift back directly, skipping TypeScript entirely.

<!-- truth:readme-discovery-links:start -->Need a working repo instead of a raw snippet? Browse **[axint-examples](https://github.com/agenticempire/axint-examples)**. Still seeing older package names like `@axintai/compiler`? Use the current package identity: `@axint/compiler`.<!-- truth:readme-discovery-links:end -->

---

## Diagnostics

Diagnostic codes across the validator surface with fix suggestions and color-coded output:

| Range | Domain |
| --- | --- |
| `AX000`–`AX023` | Compiler / Parser |
| `AX100`–`AX113` | Intent |
| `AX200`–`AX202` | Swift output |
| `AX300`–`AX322` | View |
| `AX400`–`AX422` | Widget |
| `AX500`–`AX522` | App |
| `AX700`–`AX750` | Swift build rules |
| `AX720`–`AX737` | Swift 6, SwiftUI, and accessibility checks |
| `AX740`–`AX749` | Live Activities |

```text
error[AX100]: Intent name "sendMessage" must be PascalCase
  --> src/intents/messaging.ts:5:9
   = help: rename to "SendMessage"

Full reference: docs/ERRORS.md

---

Type mappings

TypeScript	Swift	Default value
string	String	✓
int	Int	✓
double	Double	✓
float	Float	✓
boolean	Bool	✓
date	Date	—
duration	Measurement<UnitDuration>	✓ ("1h")
url	URL	—
optional<T>	T?	✓

---

Playground

No install required — axint.ai/#playground runs the same compiler in a server-backed playground, returning Swift live without a local install.

---

Editor extensions

Extensions for Claude Code, Claude Desktop, Codex, VS Code / Cursor, Windsurf, JetBrains, Neovim, and Xcode.

---

Project structure

axint/
├── src/
│   ├── core/        # Parser, validator, generator, compiler, IR
│   ├── sdk/         # defineIntent(), defineView(), defineWidget(), defineApp()
│   ├── mcp/         # MCP server and prompt surface
│   ├── cli/         # CLI (compile, watch, validate, eject, init, xcode)
│   └── templates/   # Bundled reference templates
├── python/          # Python SDK
├── extensions/      # Editor extensions (9 editors)
├── spm-plugin/      # Xcode SPM build plugin
├── tests/           # Compiler, CLI, SDK, MCP, and Python coverage
├── examples/        # Example definitions
└── docs/            # Error reference, assets

---

What's next

Current priorities — full roadmap in ROADMAP.md:

• IntentDialog + richer Apple parameter types
• Swift → TypeScript round-trip for existing Apple projects
• More surface templates in the registry (Control Widgets, App Shortcuts catalog)

---

Contributing

PRs reviewed within 48 hours. Browse good first issue to get started, or see CONTRIBUTING.md.

Apache 2.0, no CLA.

---

Requirements

• Node.js 22+
• Any OS (macOS, Linux, Windows)
• Xcode 15+ to ship the generated Swift

---

License

Apache 2.0 — fork it, extend it, ship it.

---