The compiler your AI agent needs to ship Apple apps
axint gives AI coding agents the compiler, validator, Fix Packet, MCP tools, and Xcode workflow they need to ship Apple-native software.
Install once. Your AI ships Apple apps that compile on the first build and hold up under Apple's platform rules. Free, open-source, works with every coding agent that speaks MCP.
install
point your AI at the docs · one paste
or install from your terminal
shipping today
field reports from real runs
Send the sharp edge, the win, or the place your agent stopped. Real reports make Axint stricter, faster, and less forgiving of vague success.
the workflow
Every Apple change goes through the same loop. Each stage writes a real artifact your agent reads — no build logs in chat, no parroted error messages.
TypeScript, Python, or .axint
your prompt
Swift + plist + entitlements
axint compile
225 Apple-specific diagnostics
axint validate-swift
verdict, findings, repair prompt
.axint/fix/latest.json
no copy-paste, no log parsing
axint repair
real build, real test, real proof
axint run
ready_to_ship · App Review ready
.axint/run/latest.md
Most dev tools stop at stage 03. They tell the user what failed and leave it there. axint writes the fix packet at stage 04 — verdict, findings, AI-ready repair prompt — so the agent can repair, rerun, and ship without anyone copy-pasting a build log into chat.
prove it in the browser
Paste Apple-facing TypeScript or Python, get a verdict and Fix Packet preview, then create a free GitHub account for five hosted checks each calendar month. No card required.
the fix packet · agent repair contract
The Fix Packet is the repair contract between your coding agent, axint, and Xcode.
When the build fails, your agent doesn't need an Xcode log. It needs a contract: verdict, findings, an AI-ready repair prompt, an Xcode checklist, and the full evidence trail. axint writes that file. The agent reads it. Repair runs without anyone pasting an error message into chat.
axint
.axint/fix/latest.json
for the curious · the file your agent reads
six parts of the contract
One word the agent reads to decide whether to ship, repair, or run more tests. Not a build log, not a vibe.
How certain axint is that the verdict is final. low means runtime evidence is still pending.
Each issue named precisely — the rule that fired, the file it fired in, why it matters, and the suggested direction.
A pre-formatted prompt your agent can act on without any user copy-pasting. It already names the file and the change.
If the user wants to fix it themselves: open this file, go to this line, change this thing, rerun this command.
Build log, .xcresult, generated Swift, any source axint emitted. The full evidence trail, machine-readable.
{
"verdict": "fix_required",
"confidence": "high",
"duration_ms": 142000,
"findings": [
{
"code": "AX764",
"severity": "warning",
"file": "Sources/Composer/HomeComposer.swift",
"line": 142,
"message": "TextField overlay missing .allowsHitTesting(false)",
"why": "Decorative overlays steal hit-testing from the field.",
"fix": "Add .allowsHitTesting(false) to the overlay modifier."
}
],
"ai_repair_prompt": "Open HomeComposer.swift line 142. Add .allowsHitTesting(false) ...",
"xcode_checklist": [
"open HomeComposer.swift in Xcode",
"navigate to line 142",
"add .allowsHitTesting(false) to the .overlay() modifier",
"rerun axint run --only-testing testComposerAcceptsInput"
],
"artifacts": {
"swift": ".axint/run/latest.swift",
"build_log": ".axint/run/logs/build-2026-05-02T14-32.log",
"xcresult": ".axint/run/xcresults/HomeComposerUITests.xcresult"
}
}the loop your agent runs
No copy-paste.No chat back-and-forth.Just the next move.
$ agent reads .axint/fix/latest.json
$ agent reads ai_repair_prompt
$ agent applies edit at line 142
$ agent reruns axint run --only-testing
✓ ready_to_shipWant the full schema, the three verdicts, the four access methods? The deep dive on the Fix Packet artifact is its own page.
read the deep divethe system
axint isn't a transpiler. It's the layer between your AI agent and Apple's contract graph. Three pieces do the work — compiler, validator, Fix Packet. Two pieces let your agent and Xcode talk to it. Two pieces are the ecosystem around it.
01 · core engine
What turns prompts into Apple-native code, what catches what's broken, and what tells your agent how to repair it.
Turns TypeScript, Python, or .axint definitions into validated Swift, plist fragments, and entitlements XML.
53 bundled templates
Catches Apple-specific bugs in your AI's Swift before Xcode does — concurrency, accessibility, modifier order, cross-file types.
225 diagnostics · 33 auto-fix rules
When something breaks, axint hands your agent the verdict, the findings, the AI-ready repair prompt, and the Xcode checklist. Not a build log.
agent-readable repair contract
02 · agent interface
How your coding agent and Xcode actually call the engine. No glue code, no bespoke wiring, no copy-paste.
Lets Claude Code, Cursor, Xcode, and every other MCP-speaking host call axint directly. No glue code.
36 MCP tools · 5 prompts
Notarized Source Editor Extension, project guardrails, drift guard, auto-fix, doctor, packet access — installed in one command.
notarized · 11+ host integrations
03 · ecosystem
Where reusable Apple-native packages live and where hosted validation runs when you can't build locally.
Reusable Apple-native packages — install, publish, and verify. GitHub-backed creator identity, bundle hash, compatibility history.
60 live packages
Hosted validation with verdict, confidence, and coverage. Pro tier ships saved history, AI repair prompts, and team workspaces.
free tier · pro tier · team tier
Click anywhere on the page to copy the install prompt. Your agent reads the docs, installs the npm package, sets up the MCP server, and starts using all seven layers on every Apple change.
sample run
axint normalizes agent-authored logic into Apple-native structures, then validates the output before it reaches Xcode.
Pick TypeScript, Python, or the preview .axint format on the left. axint emits the same production App Intent on the right, and the run loop validates, builds, tests, and writes the verdict.
225 diagnostics · 0 errors
ready_for_build · high confidence
build succeeded · 12.4s
5 passed · 0 failed
ready_to_ship
import { defineIntent, param } from "@axint/compiler";
export default defineIntent({
name: "LogWater",
title: "Log water",
description: "Add a glass to today's hydration log.",
params: {
amount: param.measurement({ unit: "fluid_ounce" }),
},
perform: async ({ amount }) => {
await HealthStore.shared.logWater(amount);
return { logged: true };
},
});axint also emits the Info.plist fragment, the entitlements XML, and the privacy manifest strings — written alongside .axint/run/latest.md for the next agent pass.
pricing
Start with one anonymous check, then get five checks each calendar month with a free GitHub account. Pro includes 50 checks each billing month and the full Fix Packet workflow. Teams includes 500 checks, shared history, and organization controls.
Run one hosted check. Get a verdict and packet preview. Sign in with GitHub and use five checks each calendar month with no card. Upgrade to Pro from the same Cloud app when you want the full repair loop.
$0 · no card
Best for trying hosted validation on a real Apple-facing file.
best for
core value
$29 / month
Best for daily agent repair loops.
best for
core value
$149 / month pilot
Best for shared packet history and team workflows.
best for
core value
No surprise billing. Free Cloud Check requires no card. Pro is $29 per month and the Teams pilot is $149 per month. Paid plans renew monthly through Stripe and can be managed or canceled from Account. The open-source compiler stays Apache-2.0 forever — Cloud is additive, not a paywall around the core.
the necessity
axint is the control layer between them. Without it, your AI ships Swift that compiles, runs, and goes to App Review — and then falls apart in ways you can't see. With it, every Apple change runs the same loop.
without axint · the manual loop
Xcode yells. The user copies the error into chat. The agent guesses a patch. The user pastes it. Build fails again. The loop is human-mediated, slow, and lossy.
with axint · the agent loop
Xcode fails. axint writes the Fix Packet. The agent reads the verdict, applies the change at the named line, and reruns. No copy-paste. No chat. The loop closes itself.
four real failure modes the loop closes for you
Missing NSCameraUsageDescription. Build was green. App worked on your Mac. You don't know what changed.
Your intent declares camera use. axint writes the Info.plist fragment, the entitlement, and the localized usage description.
TimelineProvider returned the wrong reload policy. Widget renders once, then sits frozen. No error in Xcode.
Schema check verifies the provider matches the family, the policy is sane, the entries serialize.
ContentState had a non-Codable field. ActivityKit silently fails to encode. User assumes the app is broken.
AX740-AX749 catch non-Codable types, missing attributes, Dynamic Island sizing — before the activity launches.
Agent claimed ready_to_ship. xcodebuild build returned 0. User opens the app to a blank white screen.
Run loop captures the focused test result. Returns evidence_required if it never executed. Agent reads, retries.
■ install once. let axint do the rest.
225 diagnostics
Eight diagnostics for broken agent-authored Apple code, picked from 225 shipping today. 33 auto-fix. The rest hand your agent a repair packet pointing at the fix — file, line, reason, change.
App launches. Field renders. Won't accept typing or focus.
Auto-fix adds .allowsHitTesting(false) to the decorative overlay.
Build succeeds with deprecation warning. Concurrency hazard waiting for a stack trace.
Repair packet rewrites as Task { @MainActor in }, or strips the wrapper inside SwiftUI lifecycle.
Memory leak. Task holds the view alive after dismissal.
Repair packet adds [weak self] to the closure capture list.
View doesn't update on navigation change. Tabs don't switch. Sheets don't dismiss.
Repair packet removes @ObservationIgnored or routes through a published wrapper.
Activity launches, then disappears in five seconds. ActivityKit fails silently.
Repair packet swaps in a Codable primitive or a struct that conforms.
'Invalid redeclaration of FlowLayout' and 'ambiguous use of init(spacing:).'
Validator names both files. Repair packet renames or merges.
parseHex(brand.primaryColorHex) compiles alone, fails on cross-file unwrap.
Caught before xcodebuild. Repair packet unwraps with if let, ??, or accepts the optional.
Agent claims ready_to_ship. App opens to a blank screen because the test was skipped.
axint refuses ready_to_ship. Returns evidence_required until the focused test passes.
plus 217 more across compiler, validator, Xcode workflow, registry, and Cloud Check
see all 225 ruleswhat it generates
These are the building blocks of every iOS, macOS, watchOS, and visionOS app. Click each one to see what you write — and what axint emits.
surface
How Siri, Shortcuts, and Apple Intelligence call into your app.
"Hey Siri, log a glass of water."
used for · Voice actions · Shortcuts automations · Apple Intelligence suggestions
defineIntent({
name: "LogWater",
title: "Log water",
description: "Add a glass to today's hydration log.",
params: {
amount: param.measurement({ unit: "fluid_ounce" }),
},
perform: async ({ amount }) => {
await HealthStore.shared.logWater(amount);
return { logged: true };
},
});import AppIntents
struct LogWater: AppIntent {
static let title: LocalizedStringResource = "Log water"
@Parameter(title: "Amount")
var amount: Measurement<UnitVolume>
func perform() async throws -> some IntentResult {
try await HealthStore.shared.logWater(amount)
return .result()
}
}plus the Info.plist fragments, entitlements, and privacy strings Apple requires alongside it
the run loop
One command runs the whole pipeline. No build logs to copy into chat. No verdicts pulled out of thin air. Each stage writes a real artifact your agent reads.
225 Apple-specific diagnostics
artifact
axint.swift.validate
Concurrency, accessibility, modifier order, cross-file types. 33 with auto-fix.
static + project context
artifact
.axint/cloud/latest.json
Verdict + confidence + coverage. Repair packet if anything fails.
real build, not a vibe
artifact
build log
Captures every Xcode warning and error. Parses .xcresult bundles.
focused or full suite
artifact
.xcresult
Pulls failing test names and assertions back as repair signals.
ready_to_ship · fix_required · evidence_required
artifact
.axint/run/latest.md
One file the agent reads. No build logs to parse, no guesses.
what your agent reads
Not a build log. Not a wall of warnings. One file — .axint/run/latest.md — written in language the next pass can act on.
# axint run report — 2026-05-02 14:32
result: fix_required
duration: 142s
✓ swift validate pass
✓ cloud check pass · high confidence
✓ xcodebuild build pass
✗ xcodebuild test fail
testComposerAcceptsInput · HomeComposerUITests.swift:42
expected true · got false · element not focusable
next axint action:
axint repair "composer field rejects focus" \
--source HomeComposerUITests.swift --platform ios
likely cause:
AX764 candidate · TextField overlay missing
.allowsHitTesting(false). Validator did not flag it
because the overlay was added after the last validate.install
No config files to copy. No env vars to set. No SDK to scaffold. Tell your agent one thing and it does the rest.
Docs runbook covers activation proof.
Reads docs.axint.ai end to end. Learns the workflow gates, the run loop, the artifact vocabulary, and the host-specific install path.
Runs npm install -g @axint/compiler, then runs axint activate or calls axint.activate so the install proves real compiler use before any code edits.
Validate, Cloud Check, run, repair, coordinate. The agent now writes Swift the way a senior engineer would — with proof artifacts your team can audit.
works with
numbers, not adjectives
Verifiable against the source. If you can find a different number on the repo, file an issue — the number on this page is wrong.
MCP tools
36
diagnostics
225
auto-fix rules
33
tests
1,486
templates
53
live packages
60
editor integrations
11+
license
Apache-2.0
The compiler is open-source on GitHub. The npm package is @axint/compiler. The registry runs at registry.axint.ai. Every count above is reproducible from the source.
release notes
Leave an email and we will send the useful parts: Cloud access, proof updates, and concrete release notes. No list spam.
