# Modaal Docs

> Modaal is a Mac app that builds native iOS and Android apps. You describe what you want in natural language; an AI coding agent writes the Swift and Kotlin, builds the project in Xcode, and verifies the result against the running simulator.

- Docs cover setup, the agent workflow, project templates, backend integrations, the Duet cross-platform architecture, and design.
- Every page below is also available as raw Markdown by appending `.md` to its URL (e.g. `https://docs.modaal.dev/welcome.md`).

## Overview

- [AI App Builder for Native iOS and Android Apps](https://docs.modaal.dev/welcome): Go from idea to production with Modaal. Describe what you want to build or change in natural language and Modaal will write the Swift and Kotlin for you.
- [Modaal Plans and Pricing: Free and Pro](https://docs.modaal.dev/credits-and-plans): Modaal has two plans: Free, which does not expire and needs no card, and Pro at €9 per user per month billed annually. No credit system, no per-token charge.
- [Modaal Changelog: Releases and Updates](https://docs.modaal.dev/changelog): Every Modaal release in order, newest first: what each version added, changed or fixed, with the download link for the macOS build of each one.

## Guides

- [Build Your First Native App with Modaal (iOS and Android)](https://docs.modaal.dev/guides/quickstart): Install Modaal, connect a coding agent, set up Xcode or the Android SDK, and go from a plain-language idea to a running native iOS or Android app.
- [Set Up Xcode for Modaal: Install, Simulators, Verify](https://docs.modaal.dev/guides/setup-xcode): Install Xcode, open it once to download the iOS simulators, and let Modaal confirm the setup: the three steps before Modaal can build and run your iOS app.
- [Set Up the Android Toolchain](https://docs.modaal.dev/guides/setup-android): What Modaal's install-the-Android-SDK banner means and what its button installs: the pinned SDK components, a user-local JDK, and your first emulator.
- [Connect Claude Code, Cursor, or Codex to Modaal](https://docs.modaal.dev/guides/connect-your-agent): Start with Modaal's built-in free preview, then connect the coding agent you already pay for — Claude Code, Codex, Gemini, Copilot or Cursor — in a click.

## Working with Modaal

- [Starting a New Project and Choosing the Right Template](https://docs.modaal.dev/articles/new-project): How the new-project flow works, what each template scaffolds, and how to choose between an iOS + Android app, a prototype, an iPhone app and a 2D game.
- [Working with Modaal: A Guide to Modes and Prompts](https://docs.modaal.dev/articles/modes-and-prompts): When to turn the Plan toggle on for a feature spec, when to let the agent build directly, and the prompting techniques that improve the result in each mode.
- [How to Add Firebase to an iOS App: Auth, Database, Analytics](https://docs.modaal.dev/articles/firebase): Connect Firebase to your iOS app — authentication, cloud database, file storage, functions, analytics, and crash reporting — in a few clicks from Modaal.
- [Firebase Data Connect: A SQL Backend for Your iOS App](https://docs.modaal.dev/articles/firebase-data-connect): Add a real SQL (PostgreSQL) backend to your iOS app — relational tables, joins, transactions, and a typed Swift SDK — managed from Modaal's Firebase panel.
- [Add In-App Purchases and Subscriptions to an iOS App](https://docs.modaal.dev/articles/storekit-testing): Use a local StoreKit configuration file to test in-app purchases and subscriptions before your products exist in App Store Connect — right from Modaal.
- [Debug Your App by Pointing at the Screen](https://docs.modaal.dev/articles/visual-debugging): Point at the screen and describe the bug: the agent reads screenshots, console logs, and the live view hierarchy to find the cause, fix it, and verify the fix.
- [Building 2D Games with SpriteKit](https://docs.modaal.dev/articles/spritekit-games): The 2D game template scaffolds a running SpriteKit app — scenes, sprites, sound and a sample game — on a RIBs module structure with a SpriteKit view layer.

## Duet framework

- [Duet Framework Documentation Map](https://docs.modaal.dev/duet): Every Duet page in one map: the overview, the tutorials, whether to share code, the framework and architecture comparisons, Android primers and the glossary.
- [The Duet Framework: One Shared Core, Two Native Apps](https://docs.modaal.dev/articles/duet): The Duet framework: feature logic written once, native SwiftUI and Jetpack Compose interfaces, and a CI gate that fails when the two apps behave differently.
- [Should You Share Code Between iOS and Android?](https://docs.modaal.dev/articles/share-code-ios-android): Three ways to ship iOS and Android: write two apps, share everything, or share the logic and keep the UI native — with costs, returns, and who should skip it.
- [Handling Platform-Specific UI on iOS and Android](https://docs.modaal.dev/articles/cross-platform-ui-parity): Duet's five-layer presentation contract, the kind-to-renderer registry, and the ledger that records iOS/Android divergence, with SwiftUI and Compose examples.
- [Migrating a CombineRIBs App to Duet](https://docs.modaal.dev/articles/combineribs-to-duet): How an existing Production app project gains a shared Kotlin core and an Android app, one feature at a time, with no flag-day rewrite and no feature freeze.
- [Duet Glossary: Every Term in the Cross-Platform Framework](https://docs.modaal.dev/articles/duet-glossary): Every Duet term defined in one place — feature, reducer, behavior recording, the checks, the coexistence window — and the name the tools use for each.

## Duet tutorials

- [Kotlin Multiplatform Tutorial Series: Duet in Nine Steps](https://docs.modaal.dev/tutorials/duet): Nine Duet tutorials build one native iOS and Android app, Foyer, from a first Kotlin feature to CI checks, theming, localization and analytics.
- [Duet Tutorial 1: Your First Feature](https://docs.modaal.dev/tutorials/duet-01-first-feature): Write a splash feature in Kotlin as state, actions and effects with a pure reducer, then record its behavior into four fixtures and verify them. No UI yet.
- [Duet Tutorial 2: One Behavior, Two Apps](https://docs.modaal.dev/tutorials/duet-02-two-apps): Build the Kotlin core into an Apple framework, replay the recordings across it, then mount the splash in a SwiftUI app and a Compose app from the same store.
- [Duet Tutorial 3: Composing Features](https://docs.modaal.dev/tutorials/duet-03-composing-features): Write a feature tree in Kotlin, mount children from state in SwiftUI and Compose, receive delegate events as parent actions, and pin each seam with a chain.
- [Duet Tutorial 4: Workers](https://docs.modaal.dev/tutorials/duet-04-workers): Replace mock services with an on-device backend, observe its streams with workers adopted at mount, test them with the harness, and unlock a card from a stream.
- [Duet Tutorial 5: Navigation as State](https://docs.modaal.dev/tutorials/duet-05-navigation-as-state): Add an onboarding gate, an upgrade flow and deep links as route state, restore the tree after process death, and share readiness between sibling steps.
- [Duet Tutorial 6: The Checks in CI](https://docs.modaal.dev/tutorials/duet-06-checks-in-ci): Read the lanes the manifest derives, run every check as one workflow in a repository of your own, and run the mutation drill in both directions.
- [Duet Tutorial 7: Theming with Design Tokens](https://docs.modaal.dev/tutorials/duet-07-theming): Declare a token vocabulary once, generate accessors for SwiftUI and Compose, bind the cards to it, and ship a high-contrast theme that changes no feature code.
- [Duet Tutorial 8: Localizing the App](https://docs.modaal.dev/tutorials/duet-08-localization): Turn every message the logic writes into a value, move every string into catalogs and resources, add German, and see what a translation can no longer change.
- [Duet Tutorial 9: Adding Analytics](https://docs.modaal.dev/tutorials/duet-09-analytics): Mint the app's verb, emit seven events from reducers as effect data, add a console sink worker behind one fan-out per platform, and let recordings check them.

## Duet comparisons

- [The Best Cross-Platform Frameworks in 2026](https://docs.modaal.dev/articles/best-cross-platform-framework): Flutter, React Native, Compose Multiplatform, KMP, MAUI, Ionic, Skip and two native apps compared: who draws the screen, where logic runs, what proves parity.
- [Duet vs Flutter: Native UI vs One Codebase](https://docs.modaal.dev/articles/duet-vs-flutter): Duet and Flutter both ship iOS and Android from shared code. They differ on who draws the screen, what ships in the binary, and what proves the apps agree.
- [Duet vs React Native: Shared Logic, No JS Runtime](https://docs.modaal.dev/articles/duet-vs-react-native): React Native runs shared logic in a shipped JavaScript engine and draws native views. Duet compiles a shared Kotlin core and verifies parity with recordings.
- [Duet vs Compose Multiplatform: Share Logic or Share UI?](https://docs.modaal.dev/articles/duet-vs-compose-multiplatform): Both are Kotlin Multiplatform. Compose Multiplatform also shares the UI, drawn on a canvas on iOS; Duet keeps SwiftUI native and shares the logic only.
- [Best iOS App Architecture: TCA, RIBs, VIPER, MVVM, Clean](https://docs.modaal.dev/articles/best-ios-app-architecture): TCA, RIBs, VIPER, MVVM, MVC and Clean Architecture scored on testability, team size, onboarding, cross-platform reach and AI-agent fit — with cited sources.

## Building for Android

- [How Android Apps Work: Anatomy of a Modern Android App](https://docs.modaal.dev/articles/how-android-apps-work): An Android app is an APK or app bundle: a manifest declaring entry points, Jetpack Compose screens driven by state holders, and a Gradle build behind it.
- [Android API Levels: Versions, Codenames, and Device Coverage](https://docs.modaal.dev/articles/android-api-levels): Every Android version with its API level, VERSION_CODES constant, codename, year, and live device coverage — plus how to choose the right minSdk.
- [The Structure of a Kotlin Multiplatform Android App](https://docs.modaal.dev/articles/duet-android-app-anatomy): A Duet Android app is a thin Compose shell over a shared Kotlin core: one Gradle module per feature, plus recorded fixtures its iOS twin replays too.
- [How to Build Testable Android Apps: What Duet Fixes in Place](https://docs.modaal.dev/articles/testable-android-apps): Make Android apps testable by keeping logic in pure reducers: nondeterminism lives behind effects, and recorded scenarios replay as the regression suite.

## Designing with AI

- [How to Design an App with AI: Screenshots to Design System](https://docs.modaal.dev/ai-design): Turn reference screenshots into a design direction, north-star screens, and a frozen design system the agent applies to every screen it builds.
- [AI Design Prompts for App UI: Spacing, Contrast, and Polish](https://docs.modaal.dev/design-prompts): The vocabulary and copy-paste prompts for polishing your app's design — spacing, contrast, tap targets, consistency, motion, and the full audit.

## FAQ

- [Modaal FAQ: Common Questions About Building Apps with AI](https://docs.modaal.dev/faq): Answers to the questions people ask before building with Modaal: platforms, the generated stack, code ownership, agents, pricing, and how to start.

## Optional

- [Download Modaal for Mac](https://modaal.dev/download): Download the Modaal Mac app.
- [Modaal website](https://modaal.dev): Product site and feature overview.
- [Discord community](https://discord.gg/KyQzDXxgU3): Ask questions and share what you're building.
- [Book a demo](https://calendly.com/modaal): Schedule a walkthrough with the team.