Axint

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, coordinates the project proof loop, and writes a repair artifact the next agent run can use.

feature definition
  → Axint IR
  → Swift + plist + entitlements
  → local or Cloud Check verdict
  → project-aware repair plan
  → 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.
• Repair — axint repair indexes the existing Apple project, ranks likely files, classifies build/UI/runtime evidence, and returns the smallest patch/proof loop.
• 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 + feedback — free hosted validation for quick results; signed-in Pro checks add the AI-ready repair prompt, history, and a shareable report. Privacy-safe feedback packets help Axint learn repeated Apple failure modes without sending source code.

WWDC26 made App Intents, App Schemas, Siri, Shortcuts, Spotlight, and Foundation Models tool calls a single agent-facing execution path. Axint now validates that path with schema continuity, entity freshness, execution-target, model-proof, and security-boundary checks.

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

Create the Apple Day Agent starter

If you want the fastest shareable proof path, start here:

npx -y -p @axint/compiler create-axint-app apple-day-agent
cd apple-day-agent
npm run proof
open share/built-with-axint.html

This creates a premium Apple-native mini app instead of a blank scaffold:

• intents/create-event.ts is the App Intent source contract.
• intents/create-reminder.ts and intents/check-weather.ts add two more Apple capabilities.
• .axint/agent-prompts/ gives Codex, Claude Code, and Cursor the exact proof loop.
• ios/App/DayDashboardView.swift gives the starter a real SwiftUI app shell.
• .axint/run/latest.md starts the durable proof trail.
• share/built-with-axint.html gives you an interactive proof preview with the generated app shell, contracts, Swift, and proof.

The point is to make the first run feel real: agent writes Apple-native contracts, Axint compiles multiple capabilities, validates them, renders a usable app preview, and hands the agent a repair path when something breaks.

npm install -g @axint/compiler
axint activate

# initialize Axint inside an existing Apple/Xcode project
axint init --apple-project /path/to/MyApp --agent codex

# 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/

Repair an existing Apple app

When the Swift already exists and something subtle breaks, use the project-aware repair loop instead of asking an agent to guess from one file:

axint project index --changed Sources/HomeComposer.swift Sources/FeedScreen.swift

axint repair "comment box is visible but cannot be tapped" \
  --source Sources/HomeComposer.swift \
  --platform ios \
  --actual "visible composer no longer accepts focus or typing" \
  --agent codex

axint feedback latest --format markdown
axint feedback status

axint repair writes .axint/repair/latest.* and a privacy-safe .axint/feedback/latest.json packet. The feedback packet includes project shape, diagnostic codes, issue class, redacted evidence, and likely Axint product owner, but not source code.

Axint also queues source-free feedback automatically when Cloud Check, Run, or Repair finds an Axint learning signal. The default endpoint is https://registry.axint.ai/api/v1/feedback; packets declare source_not_included, never include source by default, and can be turned off with axint feedback opt-out, AXINT_FEEDBACK=off, or AXINT_DISABLE_FEEDBACK=1. Use axint feedback list on a maintainer inbox to cluster imported edge cases into the next Axint fixes.

Axint also sends a tiny source-free adoption heartbeat so the project can see which install paths are actually working: CLI command class, MCP tool name, version, coarse host hint, OS family, Node major version, CI flag, and a random anonymous install ID. It never sends source code, prompts, generated Swift, arguments, file names, local paths, credentials, or machine IDs. Inspect it with axint telemetry status, turn it off with axint telemetry opt-out, or disable it per process with AXINT_TELEMETRY=off / AXINT_DISABLE_TELEMETRY=1.

The same senior repair read is shared by axint.suggest, axint.feature, axint.cloud.check, and axint.repair. If a prompt describes a broken existing SwiftUI flow, Axint routes toward the smallest repair/proof loop instead of generating a replacement screen. New-component prompts can still reference existing app types as context without being blocked.

When MCP transport is stale or closed, use axint suggest <app-description> as the CLI fallback, then continue the same workflow check with --ran-suggest.

Public truth

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 b

…