Open Beta — Free to try

Your React app → Native iOS.
In seconds.

Name: Morphkit
Author: AshlrAI

Morphkit analyzes your TypeScript/React web app and generates a native SwiftUI Xcode project — complete with typed models, async networking, and native navigation. You customize the last 20%.

Get Started View on GitHub

Star on GitHub MIT Licensed & Open Source

Morphkit

ResearchView.tsx TSX

export default function ResearchView() {
  const [query, setQuery] = useState('')
  const { agents, status } = useResearch()
  return (
    <div className="research-grid">
      <SearchBar value={query} />
      <AgentGrid agents={agents} />
      <ReportStream status={status} />
    </div>
  )

ResearchView.swift Swift

struct ResearchView: View {
  @State private var query = ""
  @Observable var research = ResearchModel()
  var body: some View {
    VStack {
      SearchBar(text: $query)
      AgentGridView(agents: research.agents)
      ReportStreamView(status: research.status)
    }
  }

Terminal

$ npx morphkit generate ./probe-web --output ./probe-ios

Analyzing tryprobe.io codebase...

✓ Found 24 components, 6 routes, 8 API endpoints

✓ Mapped navigation: TabView + NavigationStack

✓ Generated Swift Package → ./probe-ios/Package.swift

✓ Generated CLAUDE.md + .claude/commands/ for AI-assisted completion

How It Works

Four steps to native

Morphkit reads your codebase like a senior developer would, then writes the Swift code you'd want to write yourself.

Analyze

Morphkit scans your TypeScript codebase, extracting components, routes, state management, and API calls using deep AST analysis. It understands your app's architecture, not just its syntax.

Transform

AI-powered semantic understanding maps web patterns to their native iOS equivalents — TabView, NavigationStack, @Observable — preserving intent and user experience.

Generate

Output a complete SwiftUI Xcode project with typed Codable models, an async networking layer, native navigation, and an organized project structure ready for the App Store.

Complete with AI

Morphkit generates a CLAUDE.md guide, slash commands, and an MCP server. Open in Claude Code and run /complete-all to wire up every screen using structured TODO markers, reference implementations, and the API contract.

What's Included

A real Xcode project, not a prototype

Every conversion generates these files — ready to open in Xcode and customize.

SwiftUI views for every screen

Typed Codable models from your TypeScript types

Async URLSession networking layer

TabView + NavigationStack routing

@Observable state management

Xcode Asset Catalog with your colors

Package.swift (iOS 17+, SwiftUI)

Info.plist and app entry point

CLAUDE.md implementation guide

.claude/commands/ slash commands

MCP server integration

morphkit verify completion tracking

You'll want to configure your API endpoints, add an app icon, and customize the UI to match your brand.

Features

Everything maps cleanly

Web patterns have native equivalents. Morphkit knows them all.

TypeScript → Swift Types

Your Product interface becomes a Codable struct. Generics, optionals, and enums all map correctly.

Tab + Stack Navigation

File-based routes and nested layouts become TabView and NavigationStack with type-safe paths.

Async API Client

Fetch calls and Axios requests become a typed Swift API client using async/await and URLSession.

State → @Observable

Zustand stores and Redux slices become clean @Observable classes with SwiftUI's native reactivity.

Tailwind → Asset Catalog

Your Tailwind color palette is extracted and generated as a native Xcode asset catalog with semantic names.

AI Provider Support

Claude, OpenAI, or Grok for intent extraction and component mapping. Or run fully offline with heuristics.

Claude Code Integration

MCP server, slash commands, and structured CLAUDE.md let Claude Code complete your generated app screen-by-screen with full context.

See It In Action

React in, SwiftUI out

A real component transformation. Your logic, rewritten natively.

          ProductList.tsx
          TypeScript
        
interface Product {
  id: string;
  name: string;
  price: number;
}

export default function ProductList() {
  const [products, setProducts] =
    useState<Product[]>([]);

  useEffect(() => {
    fetch("/api/products")
      .then(r => r.json())
      .then(setProducts)
  }, []);

  return (
    <ul>
      {products.map(p => (
        <li key={p.id}>
          {p.name} - ${p.price}
        </li>
      ))}
    </ul>
  );
}

→

          ProductListView.swift
          SwiftUI
        
struct Product: Codable, Identifiable {
  let id: String
  let name: String
  let price: Double
}

struct ProductListView: View {
  @State private var products:
    [Product] = []

  var body: some View {
    List(products) { p in
      HStack {
        Text(p.name)
        Spacer()
        Text("$\(p.price, specifier: "%.2f")")
          .foregroundStyle(.secondary)
      }
    }
    .task {
      products = await
        APIClient.fetch("/products")
    }
  }
}

Use Cases

Built for developers who ship fast

Whether you're an indie dev, a startup founder, or an agency — Morphkit gets you from web app to App Store.

🚀

SaaS Founder

You have a web app and users keep asking for a mobile version. Run morphkit generate and ship an iOS companion app in a day, not months.

🤖

AI-Native Developer

Use Claude Code with Morphkit's 9 MCP tools. Generate the scaffold, then /complete-all to have AI wire every screen. The fastest path to iOS.

🏢

Agency / Freelancer

Client has a React web app and wants iOS? Generate a production-quality Swift project in minutes. Focus your time on polish, not boilerplate.

Pricing

Start free, scale when ready

No credit card required. Convert your first app in under two minutes.

Free

For trying Morphkit on personal projects

20 conversions / month
Full SwiftUI output
All React patterns
Community support

Get Free API Key

Up and running in one command

Point Morphkit at any Next.js, React, or TypeScript project and get a native iOS app.

$ npx morphkit generate ./my-nextjs-app --output ./ios-app

$ bun install -g morphkit

$ morphkit generate ./my-nextjs-app --output ./ios-app

$ npx morphkit generate ./my-nextjs-app --output ./ios-app

$ cd ios-app

$ npx morphkit setup # Registers MCP server in Claude Code

# Open in Claude Code → run /complete-all

FAQ

Common questions

What developers ask before converting their first app.

Can Morphkit convert any React app to iOS?

Morphkit works best with React and Next.js apps built with TypeScript. It analyzes your components, routes, state management (useState, Zustand, Redux), and API calls to generate equivalent SwiftUI code. Complex third-party libraries with native DOM dependencies may require manual adaptation, but standard React patterns map cleanly to native iOS equivalents.

Do I need to know Swift to use Morphkit?

No. Morphkit generates production-quality SwiftUI code automatically. The output is clean, idiomatic Swift that follows Apple's conventions — but you don't need Swift expertise to generate it. Familiarity with Xcode helps for building and deploying the final app to the App Store.

How is Morphkit different from React Native?

React Native runs JavaScript in a bridge layer at runtime. Morphkit generates actual native SwiftUI code — no bridge, no runtime overhead. You get a real Xcode project with native Swift files, native performance, and full access to iOS APIs. It's not a cross-platform runtime; it's a code generation tool that outputs the same code a senior iOS developer would write.

What React patterns does Morphkit support?

TypeScript interfaces and types become Codable structs. File-based and nested routes become TabView + NavigationStack. useState and Zustand/Redux state become @Observable classes. Fetch and Axios API calls become async/await URLSession requests. Tailwind color palettes become Xcode Asset Catalogs. React component composition becomes SwiftUI view hierarchies.

Is Morphkit free?

Morphkit has a generous free tier — convert up to 20 projects per month at no cost. The Pro plan ($19/month) unlocks unlimited conversions, team features, and priority support. Enterprise plans are available for larger teams.

What does the generated iOS project include?

A complete Xcode project with SwiftUI views for each component, Codable model structs from your TypeScript types, an async networking layer using URLSession, TabView and NavigationStack navigation derived from your routes, an Xcode Asset Catalog from your design tokens, and a clean project structure organized for App Store submission.

Can Claude Code complete the generated app automatically?

Yes. Morphkit generates a CLAUDE.md implementation guide, .claude/commands/ with slash commands, and structured MORPHKIT-TODO markers in every generated Swift file. Run /complete-all in Claude Code and it will wire up API calls, complete data models, and implement auth flows screen-by-screen using the API contract and reference implementations as context.

What is the MCP server?

The MCP (Model Context Protocol) server exposes 6 tools that Claude Code can call directly: morphkit_analyze, morphkit_generate, morphkit_plan, morphkit_screen_context, morphkit_verify, and morphkit_next_task. Run morphkit setup to register the server. Claude Code then has structured access to your project’s semantic model, completion status, and implementation context without you needing to copy-paste anything.

Your React app → Native iOS.In seconds.

We dogfood Morphkit on our own apps