Verwandle dein Bolt.new-Projekt mit Capacitor in native Mobile Apps

Einführung

Bolt.new ist eine innovative, KI-gestützte Entwicklungsplattform, mit der Full-Stack-Webanwendungen über verschiedene Frameworks wie React, Vue, Svelte und mehr generiert werden können. Aber was, wenn du deine Bolt.new-Kreation auf mobile Geräte bringen willst? In diesem ausführlichen Tutorial zeigen wir dir, wie du dein Bolt.new-Projekt exportierst und mit Capacitor.

Kurzfassung: Die Bolt zu iOS und Android Seite fasst den gesamten Weg auf einem Screen zusammen: Export, Capacitor, Cloud Builds ohne Mac und Live Updates.

Egal, ob dein Bolt.new-Projekt React, Vue oder ein anderes unterstütztes Framework nutzt – dieser Guide hilft dir dabei, native iOS- und Android-Apps zu erstellen, die Zugriff auf Gerätefunktionen wie Kamera, Speicher und Push-Benachrichtigungen haben.

Bevor du startest: Anforderungen & Zeitaufwand

Geschätzte Zeit: 3–5 Stunden für das Setup

Systemanforderungen:

• iOS-Entwicklung: Mac mit macOS 12.0+ (erforderlich, kein Workaround)
• Android-Entwicklung: Beliebiges OS (Windows/Mac/Linux)
• Free Space: 20–30 GB für Dev-Tools
• Memory: Mind. 8 GB RAM, 16 GB empfohlen

Budget erforderlich:

• Apple Developer: 99 $/Jahr (für den iOS App Store)
• Google Play Store: einmalige Gebühr von 25 $
• Cursor Pro: 20 $/Monat (optional, beschleunigt die Entwicklung)

Was wir installieren werden:

• Node.js & npm
• Xcode (nur Mac, für iOS)
• Android Studio (für Android)
• Verschiedene CLI-Tools

Warum deine Bolt.new App mobil machen?

• Plattformübergreifende Reichweite: Veröffentliche deine KI-generierte App in den App Stores
• Nativer Geräte-Zugriff: Nutze Kamera, GPS, Dateisystem und weitere native Features
• Bessere Performance: Der native Container bietet eine bessere Performance als Web Views
• Offline-Funktionen: Offline-Nutzung dank nativer Storage-Lösungen
• Push-Benachrichtigungen: User-Engagement durch native Push-Notifications

Warum Capacitor statt Expo?

Wenn du Optionen für mobile Entwicklung abwägst, bietet Capacitor deutliche Vorteile gegenüber Expo, besonders bei Web-First-Ansätzen:

• Eine Codebase, drei Plattformen: Deine bestehende React-, Next.js- oder Vue.js-Website wird ohne Konvertierungsaufwand zur iOS-, Android- UND Web-App
• Kein Rebuild nötig: Nutze dein Bolt.new-Projekt einfach so, wie es ist – kein Rewrite für ein anderes Framework nötig, wie Expo es verlangt
• Echter Web-First-Ansatz: Im Gegensatz zu Expo, das Mobile-First ist und im Web hakt, behandelt Capacitor das Web als First-Class-Citizen
• Nahtlose Entwicklung: Nutze weiterhin deine gewohnten Web-Dev-Tools und Workflows
• Framework-Freiheit: Funktioniert mit jedem Web-Framework (React, Vue, Svelte, Next.js, etc.) – kein Vendor Lock-in wie bei Expo mit React Native

Der entscheidende Unterschied:

• Mit Capacitor: Website bauen → Mobile Support hinzufügen (gleiche Codebase)
• Mit Expo: Mobile-Build → Versuch, das Web lauffähig zu machen (anderer Ansatz, oft unhandlich)

Da dein Bolt.new Projekt bereits eine Web-App ist, ermöglicht Capacitor die Erweiterung auf Mobile, ohne eine einzige Zeile code zu ändern. Expo würde ein komplettes Rebuild deines Projekts für deren Framework erfordern.

Schritt 1: Entwicklungsumgebung einrichten

Hol dir Cursor – dein KI-gestützter Code Editor

Um effizient mit deinem Bolt.new Projekt zu arbeiten, nutzen wir Cursor, einen intelligenten code Editor, der die Entwicklung vereinfacht:

1. Gehe auf cursor.sh und lade den Installer für dein OS herunter
2. Führe die Installation durch
3. Cursor starten, sobald es bereit ist

Cursor für maximale Produktivität konfigurieren

Um das Beste aus Cursor herauszuholen, ist ein kurzes Setup nötig:

1. Consider Getting Cursor Pro - Die kostenlose Version funktioniert, aber Pro ($20/Monat) bietet:

   • Unbegrenzte KI-Unterstützung
   • Premium-Modelle (GPT-4, Claude)
   • Sofortige Antworten
   • Premium-Support

2. Einstellungen öffnen mit Command+, (Mac) oder Ctrl+, (Windows)

3. KI-Features aktivieren - Ensure AI assistance is turned on:

4. Wähle dein KI-Modell - Wir empfehlen Claude oder GPT-4:

5. Befehlsausführung aktivieren - Erlaube Cursor, Befehle automatisch auszuführen:

Schritt 2: Dein Bolt.new Projekt exportieren

Jetzt bringen wir dein Bolt.new Projekt in Cursor.

Projekt herunterladen

1. Navigiere zu deinem Bolt.new Projekt im Browser
2. Suche nach Download oder Exportieren Button in der Bolt-Oberfläche

3. Lade die ZIP-Datei mit deinem Projekt herunter
4. Entpacke sie in einen Ordner auf deinem Computer

In Cursor öffnen

Nach dem Entpacken das Projekt in Cursor öffnen:

1. Nutzt File > Open Folder in Cursor
2. Wähle deinen entpackten Bolt.new Projektordner aus
3. Cursor lädt dein Projekt

Alternative: Klonen von GitHub

Falls du Bolt.new mit GitHub verbunden hast:

1. Drücken Shift+Command+P (Mac) oder Shift+Ctrl+P (Windows)
2. Suche nach „Git: Clone“
3. Gib deine Repository-URL ein
4. Wähle einen Speicherort aus

Schritt 2: Projekt-Framework identifizieren

Bolt.new kann Projekte mit verschiedenen Frameworks erstellen. So findest du heraus, welches du nutzt:

package.json prüfen

Öffne package.json um das Framework deines Projekts zu sehen:

Gängige Bolt.new Projekttypen:

• React + Vite: Häufigstes Setup
• Vue + Vite: Vue.js-Anwendungen
• Svelte: Svelte-Anwendungen
• Next.js: Full-Stack-React-Apps
• Vanilla JS: Reine JavaScript-Apps

Schritt 3: Dev-Tools installieren

Option A: Cursor AI alles erledigen lassen

1. Drücken Command+K (Mac) oder Ctrl+K (Windows) in Cursor
2. Gib diesen Prompt ein:

   Install all necessary development tools including Node.js, then install project dependencies and start the dev server

Cursor AI wird automatisch:

• Installiere Node.js und npm, falls nötig
• Richte Homebrew auf macOS ein
• Installiere alle Projektabhängigkeiten
• Starte deinen Development-Server

Option B: Manuelle Installation

Falls du manuelle Kontrolle bevorzugst oder der KI-Ansatz Probleme macht:

Öffne zuerst das Terminal in Cursor mit Shift+Command+T (Mac) oder Shift+Ctrl+T (Windows)

Für macOS-Nutzer:

# Get Homebrew package manager
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Node.js via Homebrew
brew install node

# Move to your project folder
cd your-bolt-project

# Install project packages
npm install

# Launch development server
npm run dev

Für Windows-Nutzer:

1. Node.js Installer herunterladen von nodejs.org
2. Installationsassistenten abschließen
3. Im Cursor-Terminal:

cd your-bolt-project
npm install
npm run dev

Deine Bolt.new App sollte nun laufen (meist unter http://localhost:5173 für Vite-Projekte).

Schritt 4: Build für Mobile konfigurieren

Deine Konfiguration hängt von deinem Projekt-Framework ab.

Option A: Automatische Konfiguration mit Cursor AI

Lass Cursor AI die Konfiguration übernehmen:

Configure my Bolt.new project for mobile deployment with proper build settings

Cursor erkennt dein Framework und wendet die passende Konfiguration an.

Option B: Manuelle Konfiguration nach Framework

Für React + Vite-Projekte:

Bearbeiten vite.config.js:

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  base: './',
  build: {
    outDir: 'dist',
    assetsDir: 'assets',
    rollupOptions: {
      output: {
        manualChunks: undefined,
      },
    },
  },
})

Für Vue + Vite-Projekte:

Ändern vite.config.js:

import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'

export default defineConfig({
  plugins: [vue()],
  base: './',
  build: {
    outDir: 'dist',
    assetsDir: 'assets',
  },
})

Für Next.js-Projekte

Füge zu deinen package.json Scripts hinzu:

{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "static": "next build && next export"
  }
}

Update next.config.js:

/** @type {import('next').NextConfig} */
const nextConfig = {
  output: 'export',
  trailingSlash: true,
  images: {
    unoptimized: true,
  },
}

module.exports = nextConfig

Schritt 5: Dein Projekt builden

Zeit, den Production Build deiner Bolt.new App zu erstellen.

Option A: Build mit Cursor AI

Frag einfach Cursor:

Build my Bolt.new project for production deployment

Cursor führt den passenden Build-Befehl basierend auf deinem Framework aus.

Option B: Manueller Build

Für Vite-basierte Projekte (React/Vue/Svelte):

npm run build

Für Next.js Anwendungen:

npm run static

Build-Erfolg bestätigen

Stelle sicher, dass dein Build den richtigen Output generiert:

• Vite-Projekte: Suche nach einem dist Verzeichnis
• Next.js-Projekte: Prüfe auf einen out Verzeichnis

Schritt 6: Capacitor zu deinem Bolt.new Projekt hinzufügen

Verwandle deine Web-App in native Mobile-Apps.

Option A: Schnelles Setup mit Cursor AI

Drücken Command+K (Mac) oder Ctrl+K (Windows) und der Befehl:

Add Capacitor to my project and set up iOS and Android platforms

Cursor AI übernimmt den gesamten Setup-Prozess.

Option B: Manuelles Schritt-für-Schritt-Setup

Installiere die CLI-Tools von Capacitor:

npm install -D @capacitor/cli

Initialisiere dein Capacitor Projekt:

npx cap init

Du wirst nach Folgendem gefragt:

• App-Name: Dein Bolt.new Projektname
• Bundle-ID: Format wie com.yourcompany.yourapp

Weiter mit der manuellen Einrichtung – essenzielle Pakete installieren:

npm install @capacitor/core @capacitor/ios @capacitor/android

Unterstützung für mobile Plattformen hinzufügen:

npx cap add ios
npx cap add android

Was ist gerade passiert?

Deine Bolt.new-Projektstruktur sieht jetzt so aus:

your-bolt-project/
├── src/           # Your app source (React/Vue/etc)
├── public/        # Static files  
├── dist/          # Build output (Vite)
├── out/           # Build output (Next.js)
├── ios/           # iOS Xcode project (NEW!)
├── android/       # Android Studio project (NEW!)
├── capacitor.config.ts  # Mobile configuration
└── package.json   # Dependencies

Wichtige Hinweise:

• Deine Web-code bleibt in src/ – dort bearbeiten
• ios/ und android/ werden generiert – nicht bearbeiten
• Nach Änderungen immer ausführen npx cap sync
• Jede Plattform hat ihren eigenen Build-Prozess

Schritt 7: Capacitor konfigurieren

Zeit, Capacitor für dein spezifisches Framework zu konfigurieren.

Option A: Auto-Konfiguration mit Cursor

Frag Cursor um Hilfe:

Configure capacitor.config.ts for my Bolt.new project build output

Option B: Manuelle Konfiguration

Für Vite-basierte Anwendungen:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.yourcompany.yourapp',
  appName: 'Your Bolt App',
  webDir: 'dist',
  bundledWebRuntime: false,
  server: {
    androidScheme: 'https'
  }
};

export default config;

Für Next.js Anwendungen:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.yourcompany.yourapp',
  appName: 'Your Bolt App',
  webDir: 'out',
  bundledWebRuntime: false,
  server: {
    androidScheme: 'https'
  }
};

export default config;

Schritt 8: Build und Sync

Bereite deine App für das Mobile Deployment vor.

Option A: Nutzung von Cursor AI

Sag Cursor:

Build my project and sync it with Capacitor for mobile deployment

Option B: Manueller Prozess

Führe diese Befehle nacheinander aus:

npm run build
npx cap sync

Schritt 9: Store-ready Binaries mit Capgo Builder erstellen (Empfohlen)

Du brauchst keinen Mac oder eine lokale Xcode/Android Studio Pipeline, um in den App Store oder Google Play zu veröffentlichen. Capgo Builder kompiliert, signiert und kann iOS- und Android-Builds aus der Cloud submitten – der schnellste Weg für vibe-coded Apps aus Bolt.new.

Warum Capgo Builder?

• Kein Mac für iOS nötig — Build von Windows, Linux oder deiner AI-Coding-Umgebung
• Ein CLI Workflow — einfach zu scripten und an Cursor, Claude Code oder Codex zu übergeben
• Kombinierbar mit Live Updates — JS/UI-Fixes via Live Update ausliefern; Native Build nur bei Plugin- oder Permission-Änderungen neu erstellen

Capgo Builder einrichten

Nachdem dein Production Build und Capacitor Sync lokal funktionieren:

npx @capgo/cli@latest login
npx @capgo/cli@latest init
npx @capgo/cli@latest build init --platform ios
npx @capgo/cli@latest build init --platform android

Signing-Credentials einmalig speichern (Apple-Zertifikate, Provisioning Profiles, Android Keystore). Siehe Credentials verwalten und iOS von Windows aus builden.

Cloud-Build anfordern

npm run build
npx cap sync
npx @capgo/cli@latest build com.yourcompany.yourapp --platform ios --build-mode release
npx @capgo/cli@latest build com.yourcompany.yourapp --platform android --build-mode release

Capgo Builder streamt Build-Logs direkt in dein Terminal. Mit konfiguriertem App Store Connect gehen iOS-Builds direkt an TestFlight.

Lade dein Web-Bundle für OTA-Updates hoch:

npx @capgo/cli@latest bundle upload --channel production

Schritt 10: Native IDEs öffnen (Optional für lokales Testing)

Wenn du einen Mac nutzt oder Emulatoren vor Cloud-Builds testen willst, öffne die nativen Projekte lokal:

Greife auf die nativen Entwicklungsumgebungen deiner App zu.

iOS-Entwicklung

Option A: Mit Cursor AI

Open my iOS project in Xcode

Option B: Terminalbefehl

npx cap open ios

Android-Entwicklung

Option A: Mit Cursor AI

Open my Android project in Android Studio

Option B: Terminalbefehl

npx cap open android

Schritt 11: Lokal builden und ausführen (optional)

Auf iOS ausführen

Xcode zum ersten Mal einrichten

1. Zielgerät auswählen:

   • Klicke neben dem Play-Button auf die Geräteauswahl
   • Zum Testen: Wähle einen beliebigen iPhone-Simulator
   • Für ein echtes Gerät: Verbinde dein iPhone per USB

2. Code Signing konfigurieren:

   • Klicke auf deinen Projektnamen in der Seitenleiste
   • Gehe zum Tab „Signing & Capabilities“
   • Aktiviere „Automatically manage signing“
   • Melde dich mit deiner Apple ID an
   • Hinweis: Für echte Geräte ist das Apple Developer Program ($99/Jahr) nötig

3. Erstelle deine App:

   • Klicke auf den ▶️ Play-Button
   • Erster Build: 5-10 Min. (bitte Geduld haben!)
   • Beobachte den Fortschrittsbalken oben

iOS Troubleshooting:

• „No account found“: Apple ID in Xcode > Settings > Accounts hinzufügen
• „Failed to build“: Build-Ordner leeren (Shift+Command+K) und erneut versuchen
• Simulator-Probleme: Simulator über Device > Restart neu starten

Laufzeit auf Android

Android Studio einrichten (Erstmalig)

1. SDK Setup (automatisch):

   • Android Studio erkennt fehlende Komponenten
   • Klicke bei der Aufforderung auf „SDK installieren“
   • Dies lädt ca. 2-3 GB an Dateien herunter

2. Virtuelles Gerät erstellen:

   • AVD Manager öffnen (Telefon-Icon in der Toolbar)
   • Klicke auf „+ Create Virtual Device“
   • Wähle „Pixel 6“ (guter Standard)
   • System-Image bei Aufforderung herunterladen
   • Setup mit Standardoptionen abschließen

3. App starten:

   • Emulator im Dropdown auswählen
   • Auf den grünen ▶️ Run-Button klicken
   • Erster Build: 10–15 Minuten
   • Emulator startet automatisch

Android Troubleshooting:

• „Gradle sync failed“: Versuche File > Invalidate Caches
• Langsamer Emulator: Hardware-Beschleunigung in den AVD-Settings aktivieren
• Build-Fehler: Gradle über vorgeschlagene Fixes aktualisieren

Checkliste zur Verifizierung

Nach erfolgreichem Build prüfen:

✅ App startet ohne Absturz ✅ Bolt.new-Inhalte werden korrekt angezeigt ✅ Buttons und Interaktionen funktionieren ✅ Konsole zeigt keine roten Fehler

Immer noch Probleme? Die Fehlermeldungen sagen meist genau, was falsch ist – lies sie dir sorgfältig durch!

Schritt 12: Live Reload aktivieren (Development)

Beschleunige deinen Workflow durch Hot Reloading.

Option A: Automatisches Setup mit Cursor

Cursor fragen:

Enable live reload for my Capacitor app development

Cursor konfiguriert alles automatisch.

Option B: Manuelle Konfiguration

1. Ermittle deine lokale IP-Adresse:

# macOS
ipconfig getifaddr en0

# Windows  
ipconfig

2. Aktualisiere dein capacitor.config.ts:

import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.yourcompany.yourapp',
  appName: 'Your Bolt App',
  webDir: 'dist', // or 'out' for Next.js
  bundledWebRuntime: false,
  server: {
    url: 'http://YOUR_IP_ADDRESS:5173', // or 3000 for Next.js
    cleartext: true,
  },
};

export default config;

3. Konfiguration anwenden:

npx cap copy

Schritt 13: Native Features hinzufügen

Erweitere deine Bolt.new-App um gerätespezifische Funktionen.

Option A: KI-gestützte Integration

Anfrage von Cursor:

Add native share, camera, and geolocation features to my Bolt.new app

Cursor wird Plugins installieren und die Integration code erstellen.

Option B: Manuelle Plugin-Installation

Beliebte native Plugins installieren:

npm i @capacitor/share @capacitor/camera @capacitor/geolocation

Erstelle eine Utilities-Datei für React-Projekte:

// utils/capacitor.js
import { Share } from '@capacitor/share';
import { Camera, CameraResultType } from '@capacitor/camera';
import { Geolocation } from '@capacitor/geolocation';

export const shareContent = async (title, text, url) => {
  await Share.share({
    title,
    text,
    url,
    dialogTitle: 'Share with friends',
  });
};

export const takePicture = async () => {
  const image = await Camera.getPhoto({
    quality: 90,
    allowEditing: true,
    resultType: CameraResultType.Uri
  });
  return image;
};

export const getCurrentPosition = async () => {
  const coordinates = await Geolocation.getCurrentPosition();
  return coordinates;
};

In deinen Komponenten nutzen

// For React components
import React from 'react';
import { shareContent, takePicture } from '../utils/capacitor';

function MyComponent() {
  const handleShare = () => {
    shareContent('My Bolt App', 'Check out this amazing app!', 'https://your-app.com');
  };

  const handleCamera = async () => {
    try {
      const photo = await takePicture();
      console.log('Photo taken:', photo);
    } catch (error) {
      console.error('Camera error:', error);
    }
  };

  return (
    <div>
      <button onClick={handleShare}>Share App</button>
      <button onClick={handleCamera}>Take Photo</button>
    </div>
  );
}

export default MyComponent;

Änderungen synchronisieren

Mit Cursor AI:

Sync my native feature changes to all platforms

Manueller Befehl:

npx cap sync

Schritt 14: Für die Produktion optimieren

App-Icons und Splash Screens

Option A: Cursor AI Setup

Prompt:

Create app icons and splash screens for my mobile app

Option B: Manuelle Asset-Erstellung

1. Assets-Tool holen:

npm install -D @capacitor/assets

2. Grafiken vorbereiten:

   • Erstellen assets/icon.png (1024x1024px)
   • Erstellen assets/splash.png (2732x2732px)

3. Alle Größen automatisch generieren:

npx capacitor-assets generate

Build optimieren

Build für Vite-Projekte optimieren:

// vite.config.js
export default defineConfig({
  plugins: [react()], // or vue()
  base: './',
  build: {
    outDir: 'dist',
    minify: 'terser',
    terserOptions: {
      compress: {
        drop_console: true,
        drop_debugger: true,
      },
    },
    rollupOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom'], // adjust for your framework
        },
      },
    },
  },
})

Finaler Build

Option A: Build mit Cursor AI

Create the final production build and prepare for app store deployment

Option B: Manueller Build-Prozess

npm run build
npx cap sync
npx cap copy

Häufige Probleme beheben

Framework-spezifische Probleme

React/Vite-Projekte

• Stelle sicher base: './' ist in der Vite-Config eingestellt
• Prüfen, ob alle Imports relative Pfade nutzen
• Sicherstellen, dass der dist Ordner korrekt generiert wird

Vue-Projekte

• Vue Router auf Hash-Mode für Mobile umstellen
• Prüfen, ob Assets korrekt referenziert werden
• Lazy Loading der Komponenten auf Mobile testen

Next.js Projekte

• Stelle sicher, dass der Static Export korrekt konfiguriert ist
• Prüfen Sie, ob Dynamic Imports im statischen Kontext funktionieren
• Stelle sicher, dass API Routes nicht verwendet (oder korrekt behandelt) werden

Build-Fehler

Falls Build-Fehler auftreten:

1. node_modules löschen und neu installieren:

rm -rf node_modules package-lock.json
npm install

2. Bolt.new Projekt-Dependencies auf Mobile-Kompatibilität prüfen
3. Sicherstellen, dass alle relativen Pfade für das Mobile Deployment korrekt sind

Fehlende Assets

Bei Problemen beim Laden von Assets:

1. Prüfen Sie, ob alle Assets im public-Ordner liegen
2. Verwende relative Pfade für Bilder und Dateien
3. Stelle sicher, dass der Build-Prozess alle Assets kopiert

Fazit

Glückwunsch! Du hast dein Bolt.new Projekt erfolgreich in native mobile Apps verwandelt. Deine KI-generierte Web-App kann nun:

• Nativ auf iOS- und Android-Geräten laufen
• Gerätefunktionen wie Kamera, GPS und Speicher nutzen
• Über App Stores verteilt werden
• Eine optimierte mobile User Experience bieten

Nächste Schritte

• Capgo Builder: Nutze Cloud-native Builds für TestFlight- und Play Store-Releases
• Capgo Live Updates: Implementieren Capgo für sofortige Over-the-Air-Updates
• Analytics: Mobile Analytics hinzufügen, um Nutzerverhalten zu tracken
• Performance: Überwache und optimiere die mobile Performance deiner App
• Testen: Teste deine App auf verschiedenen Geräten und Displaygrößen

Deine mit Bolt.new erstellte App ist jetzt bereit für das mobile Ökosystem!

Ressourcen

• Bolt.new-Plattform
• Capacitor Dokumentation
• Vite Mobile Deployment Guide
• Capgo Builder — Cloud Native Builds
• Capgo - Live Updates für Capacitor Apps
• Base44 auf Mobile

Erfahre, wie Capgo dir dabei hilft, Instant Updates für deine mobile App auszuliefern, Registrieren Sie sich für ein kostenloses Konto noch heute.

Weiterlesen: Transformiere dein Bolt.new Projekt in Native Mobile Apps mit Capacitor

Wenn du es nutzt Verwandle dein Bolt.new-Projekt mit Capacitor in native Mobile Apps Um die Arbeit an nativen Plugins zu planen, verbinde sie mit Capgo Plugin-Verzeichnis für den Produkt-Workflow im Capgo Plugin-Verzeichnis, Capacitor Plugins von Capgo für das Implementierungsdetail in Capacitor Plugins von Capgo, Plugins hinzufügen oder aktualisieren für die Implementierungsdetails unter „Plugins hinzufügen oder aktualisieren“, Ionic Enterprise Plugin-Alternativen für den Produkt-Workflow in Ionic Enterprise Plugin-Alternativen und Capgo Native Builds optimieren für den Produkt-Workflow in Capgo Native Builds.