Vue NativeVue Native
Guide
Components
Composables
Navigation
Architecture
  • iOS
  • Android
  • macOS
GitHub
Guide
Components
Composables
Navigation
Architecture
  • iOS
  • Android
  • macOS
GitHub
  • Getting Started

    • Introduction
    • Installation
    • Your First App
    • Project Structure
  • Core Concepts

    • Components
    • Styling
    • Theming
    • TypeScript
    • Navigation
    • Navigation Components
    • Native Modules
    • Native Code Blocks
    • Hot Reload
  • UI Patterns

    • Forms and v-model
    • Shared Element Transitions
    • Teleport
    • Custom Native Components (escape hatch)
  • Quality & Debugging

    • Testing
    • Debugging
    • Error Handling
  • Platform Hardening

    • Security
    • Accessibility
    • Performance
  • Integration Guides

    • State Management
    • Deep Linking & Universal Links
    • State Persistence
    • Push Notifications
    • Error Reporting & Monitoring
  • Tooling

    • Managed Workflow
    • VS Code Extension
    • Neovim Plugin
  • Building & Releasing

    • Building Native Apps
    • Deployment & App Store Submission
  • Reference

    • Upgrade Guide
    • Migrating from React Native
    • Known Limitations & Platform Differences
    • Troubleshooting

Managed Workflow

Vue Native's managed workflow provides a low-config development experience similar to Expo. The CLI handles iOS and Android project scaffolding, native project generation, simulator management, and hot reload.

Creating a Project

npx @thelacanians/vue-native-cli create my-app
cd my-app
bun install

Templates

Use --template to start with a pre-configured layout:

# Blank app with a single screen (default)
vue-native create my-app --template blank

# Tab-based navigation with two screens
vue-native create my-app --template tabs

# Drawer navigation with sidebar menu
vue-native create my-app --template drawer

Template contents:

TemplateIncludes
blankSingle Home screen with counter, stack navigation
tabsHome + Settings screens, createTabNavigator, VTabBar
drawerHome + About screens, createDrawerNavigator, sidebar menu

All templates include:

  • Complete iOS Xcode project (ios/) with XcodeGen spec
  • Complete Android Gradle project (android/) with Kotlin
  • Vite configuration with Vue Native plugin
  • TypeScript configuration
  • vue-native.config.ts configuration file
  • .gitignore with common exclusions

macOS

The CLI can run and build an existing macOS Xcode project, but vue-native create does not scaffold a macOS app shell yet. Use the macOS Setup guide to add that target manually.

Project Configuration

Configure your app with vue-native.config.ts in the project root:

import { defineConfig } from '@thelacanians/vue-native-cli'

export default defineConfig({
  name: 'MyApp',
  bundleId: 'com.example.myapp',
  version: '1.0.0',
  ios: {
    deploymentTarget: '16.0',
  },
  android: {
    minSdk: 21,
    targetSdk: 35,
  },
})

The CLI validates this file on dev, run, and build. bundleId, ios.scheme, and android.packageName provide launch/build defaults. Native deployment targets are written into the generated Xcode/Gradle files at scaffold time; if you change those values later, update the native project too.

Configuration Reference

FieldTypeRequiredDescription
namestringYesApp display name
bundleIdstringYesReverse-domain identifier (e.g. com.example.myapp)
versionstringYesSemantic version string
ios.deploymentTargetstringNoMinimum iOS version (default: "16.0")
ios.schemestringNoXcode scheme name (defaults to sanitized name)
android.minSdknumberNoMinimum Android SDK (default: 21)
android.targetSdknumberNoTarget Android SDK (default: 35)
android.packageNamestringNoAndroid package (defaults to bundleId)
pluginsstring[]NoReserved metadata for future plugin automation; plugins are not installed automatically

Development Server

vue-native dev

Starts the Vite build watcher and WebSocket hot reload server. The app on your simulator or device will reload automatically when you save changes.

Options

FlagDescription
-p, --port <port>WebSocket port (default: 8174)
--platform <platform>Compile for ios, android, or macos
--iosAuto-detect and boot iOS Simulator
--androidAuto-detect Android emulator
--simulator <name>Specify iOS Simulator name (e.g. "iPhone 16")

Auto-launching Simulators

# Auto-detect and boot an iOS simulator
vue-native dev --ios

# Boot a specific simulator
vue-native dev --ios --simulator "iPhone 16 Pro"

# Detect Android emulator
vue-native dev --android

# Build a macOS development bundle
vue-native dev --platform macos

Each development bundle has one compile-time platform target. Run separate dev commands when switching targets; --ios --android is rejected. A --platform value must also match any --ios or --android launch flag.

When using --ios, the CLI will:

  1. Query available simulators via xcrun simctl list
  2. Boot an available iPhone simulator (or the specified one)
  3. Open Simulator.app
  4. Start the hot reload server

When using --android, the CLI will check for connected devices/emulators via adb devices.

Building and Running

# Build JS bundle and run on iOS simulator
vue-native run ios

# Build and run on Android emulator
vue-native run android

# Run on a physical device
vue-native run ios --device

Run Options

FlagDescription
--deviceRun on physical device
--scheme <name>Xcode scheme to build
--simulator <name>Simulator name (default: "iPhone 16")
--bundle-id <id>App bundle identifier
--package <name>Android package (default: com.vuenative.app)
--activity <name>Android activity (default: .MainActivity)

Project Structure

After vue-native create, your project looks like:

my-app/
  app/                   # Vue 3 source code
    main.ts              # Entry point
    App.vue              # Root component
    pages/               # Screen components
      Home.vue
  ios/                   # iOS native project
    project.yml          # XcodeGen specification
    Sources/
      AppDelegate.swift
      SceneDelegate.swift
      Info.plist
  android/               # Android native project
    app/
      build.gradle.kts
      src/main/
        AndroidManifest.xml
        kotlin/.../MainActivity.kt
    build.gradle.kts
    settings.gradle.kts
  dist/                  # Built JS bundle (generated)
  vue-native.config.ts   # App configuration
  vite.config.ts         # Vite build config
  package.json
  tsconfig.json

Typical Workflow

  1. Create a project: vue-native create my-app --template tabs
  2. Install dependencies: cd my-app && bun install
  3. Develop with hot reload: vue-native dev --ios
  4. Edit Vue components in app/ -- changes appear instantly
  5. Build for testing: vue-native run ios or vue-native run android
  6. Release via Xcode (iOS) or Gradle (Android)
Edit this page
Last Updated: 7/28/26, 4:10 PM
Contributors: github-actions[bot]
Next
VS Code Extension