convez.ai
AgenteDesign & UIAvançado
arvindchellapondy

Interface.ai - Pipeline Figma para Apps Nativos com IA

arvindchellapondy/interface-ai

Do Figma ao iOS/Android nativo com IA e sync em tempo real

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent que converte designs do Figma em aplicativos nativos iOS e Android através de um protocolo A2UI universal. Integra plugin Figma, dashboard Next.js com chat Claude para personalização em tempo real, e renderizadores nativos que recebem atualizações via WebSocket.

Instalação

$npx convez-ai arvindchellapondy/interface-ai

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 9 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Gerar interfaces iOS em SwiftUI a partir de designs Figma
  • Personalizar conteúdo de apps em produção via chat com IA
  • Converter layouts Figma para Kotlin ou React Native automaticamente
  • Atualizar UIs em dispositivos conectados sem redeploy

Veredito

Ferramenta robusta e bem arquitetada que automatiza o fluxo designer → código nativo, com diferencial real de IA para personalização dinâmica. Exige domínio técnico (TypeScript, swiftUI, Kotlin) mas elimina handoff manual entre equipes.

README

A tradução para o português deste README ainda está na fila.

An AI-powered pipeline that takes UI designs from Figma to native iOS and Android apps. Extract components with a Figma plugin, preview and personalize with Claude in a live dashboard, and push updates to devices over WebSocket — instantly.

Highlights

  • AI Chat — Ask Claude to select and personalize widgets in natural language, auto-pushed to connected devices
  • AI Personalization — Provide user context and Claude rewrites data-bound fields with personalized content
  • Real-Time Push — Dashboard and AI edits broadcast instantly to iOS/Android via WebSocket
  • Figma-to-Native — Extract designs from Figma, preview on web, render natively, or generate SwiftUI/Kotlin/React Native code
  • Universal A2UI Protocol — One JSON format drives web preview, native rendering, and code generation across all platforms

Architecture

                              Interface.ai Pipeline
 ┌─────────────────────────────────────────────────────────────────────────┐
 │                                                                         │
 │   ┌──────────┐     ┌────────────┐     ┌──────────────┐                  │
 │   │  Figma   │────▶│   Figma    │────▶│  A2UI JSON   │                  │
 │   │  Design  │     │   Plugin   │     │  (.a2ui.json) │                  │
 │   └──────────┘     └────────────┘     └──────┬───────┘                  │
 │                                              │                          │
 │                    ┌─────────────────────────┼─────────────────────┐     │
 │                    │                         │                     │     │
 │                    ▼                         ▼                     ▼     │
 │           ┌────────────────┐     ┌───────────────────┐   ┌────────────┐ │
 │           │  Web Dashboard │     │  Code Generators  │   │    CLI     │ │
 │           │  (Next.js)     │     │  (mobile-codegen)  │   │            │ │
 │           └───────┬────────┘     └───────────────────┘   └────────────┘ │
 │                   │                  │       │       │                   │
 │                   │ WebSocket        ▼       ▼       ▼                   │
 │                   │              SwiftUI  Kotlin   React                 │
 │            ┌──────┴──────┐       (.swift) (.kt)   Native                │
 │            │             │                (.tsx)                         │
 │            ▼             ▼                                               │
 │     ┌────────────┐ ┌──────────────┐                                     │
 │     │    iOS     │ │   Android    │                                     │
 │     │  Renderer  │ │   Renderer   │                                     │
 │     │  (SwiftUI) │ │  (Compose)   │                                     │
 │     └────────────┘ └──────────────┘                                     │
 │                                                                         │
 └─────────────────────────────────────────────────────────────────────────┘

How It Works

 1. DESIGN                 2. EXTRACT               3. REPRESENT
 ┌───────────────┐        ┌───────────────┐        ┌───────────────┐
 │               │        │               │        │ createSurface │
 │    Figma      │───────▶│  Figma Plugin │───────▶│ updateComps   │
 │    Canvas     │        │  extracts     │        │ updateData    │
 │               │        │  nodes        │        │               │
 └───────────────┘        └───────────────┘        └───────┬───────┘
                                                           │
         ┌─────────────────────────────────────────────────┘
         │
         ▼
 4. PREVIEW & PERSONALIZE         5. RENDER NATIVELY
 ┌──────────────────────┐        ┌───────────────────────────────┐
 │                      │        │                               │
 │  Web Dashboard       │──WS──▶│  iOS (SwiftUI)                │
 │  - Live preview      │       │  - MessageProcessor           │
 │  - Edit data model   │       │  - DataBindingResolver        │
 │  - AI personalization│       │  - ComponentNodeView          │
 │  - Push to devices   │       │                               │
 │                      │       │  Android (Jetpack Compose)    │
 │                      │       │  - MessageProcessor           │
 │                      │       │  - DataBindingResolver        │
 │                      │       │  - ComponentNodeView          │
 └──────────────────────┘       └───────────────────────────────┘

Quick Start

Prerequisites

RequirementPurposeInstall
Node.js 18+Dashboard, CLI, codegennodejs.org
Xcode 15+iOS renderer (optional)Mac App Store
XcodeGeniOS project generation (optional)brew install xcodegen
Android StudioAndroid renderer (optional)developer.android.com

One-Command Setup

git clone https://github.com/arvindchellapondy/interface-ai.git
cd interface-ai
./setup.sh

This installs all dependencies (root workspaces, dashboard, CLI), creates the .env file, and generates the iOS Xcode project if XcodeGen is available.

Or Step by Step

# 1. Install all dependencies
npm run setup

# 2. Configure AI (optional — needed for AI chat features)
cp dashboard/.env.example dashboard/.env
# Edit dashboard/.env and add your ANTHROPIC_API_KEY

# 3. Start the dashboard
npm run dev
# Dashboard:  http://localhost:3001
# WebSocket:  ws://localhost:3001/ws

# 4. Run iOS app (optional — requires Xcode + XcodeGen)
npm run ios:setup
open ios-renderer/Examples/A2UIDemoApp/InterfaceAI.xcodeproj
# Build and run on simulator (Cmd+R)

5. Push a design to mobile

Open the dashboard, select a design, and click Push to Devices — or use the AI chat to select and personalize widgets automatically.

Available npm Scripts

CommandDescription
npm run setupInstall all dependencies (root + dashboard + CLI)
npm run devStart dashboard with WebSocket server on port 3001
npm run buildBuild all workspace packages
npm run build:dashboardBuild the Next.js dashboard for production
npm run ios:setupGenerate iOS Xcode project from project.yml

Project Structure

interface/
├── README.md                  # This file
├── A2UI-SPEC.md               # A2UI format specification
├── package.json               # Monorepo root (npm workspaces)
│
├── figma-plugin/              # Figma plugin — extracts designs to A2UI
│   ├── src/code.ts            #   Plugin entry point
│   ├── src/extractor.ts       #   Figma node property extraction
│   ├── src/converter.ts       #   Convert extracted data → A2UI JSON
│   └── ui/index.html          #   Plugin UI panel
│
├── a2ui-parser/               # A2UI schema library
│   └── src/
│       ├── schema.ts          #   TypeScript interfaces
│       ├── validator.ts       #   Validation logic
│       └── index.ts           #   Parser entry point
│
├── dashboard/                 # Next.js web dashboard
│   ├── server.ts              #   Custom HTTP + WebSocket server
│   ├── src/app/               #   Pages (home, chat, design detail)
│   ├── src/components/        #   React components
│   └── src/lib/               #   A2UI types, WS server, AI client
│
├── ios-renderer/              # Swift Package — native iOS renderer
│   ├── Package.swift          #   SPM manifest
│   ├── Sources/A2UIRenderer/  #   Library source
│   │   ├── Models/            #     A2UI schema, Surface
│   │   ├── Processing/        #     Message processor, resolvers
│   │   ├── Rendering/         #     SwiftUI views & style modifiers
│   │   └── Transport/         #     WebSocket client
│   └── Examples/              #   Demo app (InterfaceAI)
│
├── android-renderer/          # Kotlin library — native Android renderer
│   ├── lib/                   #   Library module (Jetpack Compose)
│   │   └── src/main/kotlin/   #     Models, processing, rendering
│   └── demo/                  #   Demo app
│
├── mobile-codegen/            # Static code generators
│   └── src/
│       ├── swiftui/           #   SwiftUI generator
│       ├── kotlin-compose/    #   Kotlin Compose generator
│       └── react-native/      #   React Native generator
│
├── cli/                       # Command-line interface
│   └── src/cli.ts             #   Parse A2UI → generate native code
│
└── examples/                  # Sample A2UI design files
    ├── widget_hello.a2ui.json
    ├── widget_weather.a2ui.json
    └── ...

Key Concepts

A2UI Protocol (v0.9)

A2UI is a message-based protocol for describing UI declaratively. A design is represented as a sequence of three messages:

MessagePurpose
createSurfaceInitialize a surface with an ID and design tokens
updateComponentsDefine the component tree (Card, Text, Button, etc.)
updateDataModelBind dynamic data to components via ${/path/to/value}

Design Tokens

Styles reference design tokens using {TokenName} syntax:

{ "backgroundColor": "{Accents.Indigo}" }

Tokens are resolved at render time from the createSurface.designTokens map.

Data Bindings

Text and labels use ${/path} bindings:

{ "text": "${/greeting/text}" }

Values are resolved from the data model, enabling runtime personalization.

Real-Time Push

The dashboard connects to mobile devices via WebSocket (ws://localhost:3001/ws). When you edit a data model or the AI selects a widget, the full design is pushed to all connected devices instantly.

 Dashboard                    WebSocket Server              iOS / Android
 ┌──────────┐                ┌──────────────┐              ┌────────────┐
 │ Edit data │───POST /api──▶│  push-design │──WS push───▶│ Renderer   │
 │ model     │               │  endpoint    │              │ updates    │
 └──────────┘                └──────────────┘              └────────────┘

AI-Powered Personalization

The dashboard includes an AI chat interface powered by Claude. You can ask it to:

  • Select widgets: "Show me a weather widget for NYC"
  • Personalize content: "Change the greeting to say Good Morning"
  • Auto-push: Selected widgets are automatically pushed to connected devices

The AI sees the full widget catalog and intelligently maps your request to the right design with appropriate data model values.


Tech Stack

LayerTechnology
Design ToolFigma + custom plugin
Interchange FormatA2UI JSON (v0.9)
Web DashboardNext.js 14, React 18, Tailwind CSS
AIAnthropic Claude API
Real-timeWebSocket (ws)
iOS RendererSwiftUI (iOS 17+), Swift Package Manager
Android RendererJetpack Compose, Kotlin, Gradle
Code GenerationTypeScript (SwiftUI, Kotlin, React Native)
CLINode.js, TypeScript
Monoreponpm workspaces

Sub-Project Documentation

Each sub-project has its own README with detailed setup and API documentation:

License

Private — Interface.ai

Ver o original no GitHub

Bom para

Relacionados