utm-dev: Deep Improvement Analysis & Roadmap#

// Use charmbracelet/bubbletea for interactive TUI
type BuildProgress struct {
    Platform    string
    Stage       string  // "Dependencies", "Compilation", "Packaging"
    Progress    float64
    CurrentFile string
    Speed       string  // "15 MB/s"
    ETA         time.Duration
}

// Example output:
// ╭─ Building gio-plugin-webviewer ─────────────────╮
// │ Platform: Android                                │
// │ Stage: Compiling Go code                         │
// │ Progress: [████████████░░░░░░] 65%               │
// │ File: webview_android.go                         │
// │ ETA: 45 seconds                                  │
// ╰──────────────────────────────────────────────────╯

// Use zerolog or similar for structured logging
log.Info().
    Str("platform", "android").
    Str("app", "webviewer").
    Str("stage", "icons").
    Msg("Generating platform icons")

// With --verbose flag, show detailed info
// Without it, show clean progress bars

type BuildError struct {
    Phase       string
    Error       error
    Suggestions []string
    DocsURL     string
}

// Example:
// ❌ Build failed: NDK compiler not found
// 
// Suggestions:
//   1. Install Android NDK: utm-dev install ndk-bundle
//   2. Check SDK path: utm-dev config
//   3. Verify NDK version >= r19c
// 
// More info: https://docs.utm-dev.dev/errors/ndk-not-found

// Hash-based build cache
type BuildCache struct {
    SourceHash  string    // Hash of all .go files
    DepsHash    string    // Hash of go.mod + go.sum
    IconHash    string    // Hash of icon-source.png
    Binary      string    // Path to cached binary
    BuildTime   time.Time
}

// Skip rebuild if hashes match
if cache.IsValid() && !forceRebuild {
    log.Info("Using cached build from", cache.BuildTime)
    return cache.Binary
}

// Build multiple platforms concurrently
func buildAll(platforms []string) error {
    results := make(chan BuildResult, len(platforms))
    
    for _, platform := range platforms {
        go func(p string) {
            results <- buildPlatform(p)
        }(platform)
    }
    
    // Collect results and show progress
    return collectResults(results, len(platforms))
}

// Parallel icon generation
func generateIcons(platform string) error {
    var wg sync.WaitGroup
    sizes := getIconSizes(platform)
    
    for _, size := range sizes {
        wg.Add(1)
        go func(s IconSize) {
            defer wg.Done()
            generateIcon(s)
        }(size)
    }
    
    wg.Wait()
}

# .goup-cache/
#   ├── go-build/     # Go build cache
#   ├── go-mod/       # Module cache
#   ├── binaries/     # Built binaries
#   └── icons/        # Generated icons

# Mount these in Docker builds for consistency
volumes:
  - .goup-cache/go-build:/go/pkg
  - .goup-cache/go-mod:/go/pkg/mod

# goup.yaml (or .utm-dev.yaml)
project:
  name: my-hybrid-app
  version: 1.0.0
  description: "A cross-platform hybrid app"

build:
  # Global build settings
  parallel: true
  cache: true
  verbose: false
  
  # Platform-specific settings
  platforms:
    android:
      package: com.example.myapp
      minSDK: 24
      targetSDK: 34
      permissions:
        - INTERNET
        - ACCESS_NETWORK_STATE
      signing:
        keystore: ./release.keystore
        alias: myapp
    
    ios:
      bundleID: com.example.myapp
      team: ABCDEFG123
      minVersion: 14.0
      capabilities:
        - Push Notifications
        - WebView
    
    macos:
      bundleID: com.example.myapp
      category: public.app-category.productivity
      minVersion: 11.0
    
    windows:
      publisher: "My Company"
      displayName: "My Hybrid App"
      capabilities:
        - internetClient
  
  # Custom build flags
  flags:
    ldflags: "-s -w"  # Strip debug info
    tags: "release"

assets:
  icons:
    source: "./assets/icon.png"
    foreground: "./assets/icon-fg.png"  # Android adaptive
    background: "./assets/icon-bg.png"
  splash:
    source: "./assets/splash.png"

dependencies:
  go: "1.25"
  gio: "v0.8.0"
  gio-plugins: "v0.8.0"

# Override config from command line
utm-dev build android \
  --package com.test.myapp \
  --min-sdk 26 \
  --signing-key ./debug.keystore \
  --verbose

# Profile-based builds
utm-dev build android --profile debug
utm-dev build android --profile release
utm-dev build android --profile staging

# Run on simulators/emulators
utm-dev test ios --simulator "iPhone 15 Pro"
utm-dev test android --emulator "Pixel_8_API_34"

# Screenshot testing
utm-dev test --screenshots ./screenshots/

# Integration with standard Go tests
utm-dev test --platform all --coverage

# Install to connected device
utm-dev deploy ios --device "John's iPhone"
utm-dev deploy android --device adb-device-id

# Upload to stores
utm-dev deploy appstore --testflight
utm-dev deploy playstore --internal-testing

# Generate store assets
utm-dev assets screenshots --platforms ios,android
utm-dev assets store-listing

# .github/workflows/build.yml (generated)
name: Build Multi-Platform
on: [push]
jobs:
  build:
    strategy:
      matrix:
        platform: [ios, android, macos, windows]
    runs-on: ${{ matrix.platform == 'ios' && 'macos-latest' || 'ubuntu-latest' }}
    steps:
      - uses: actions/checkout@v4
      - uses: utm-dev/setup@v1
      - run: utm-dev build ${{ matrix.platform }}
      - uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.platform }}-build
          path: .bin/

# New project wizard
$ utm-dev init

Welcome to utm-dev! Let's create your hybrid app.

? Project name: my-awesome-app
? Description: A cross-platform hybrid application
? Target platforms: (use space to select)
  [x] iOS
  [x] Android
  [x] macOS
  [ ] Windows
  [ ] Linux
  [x] Web

? Use webview for content? Yes
? Include example code? Yes
? Initialize git repository? Yes

✓ Created project structure
✓ Generated goup.yaml
✓ Created example code
✓ Initialized git repository

Next steps:
  cd my-awesome-app
  utm-dev build ios
  utm-dev dev  # Start development server

# Smart suggestions
$ utm-dev buidl ios  # typo
Did you mean: build ios?

# Contextual help
$ utm-dev build
Error: missing platform argument

Available platforms:
  ios              Build for iOS devices
  android          Build for Android
  macos            Build for macOS
  windows          Build for Windows
  all              Build for all platforms

Examples:
  utm-dev build ios ./my-app
  utm-dev build android --release
  
Run 'utm-dev build --help' for more information.

// Expose Go functions to JavaScript
bridge := webview.NewBridge()

// Type-safe function exposure
bridge.Expose("getUserProfile", func(userID string) (*UserProfile, error) {
    return db.GetUser(userID)
})

bridge.Expose("saveData", func(data map[string]interface{}) error {
    return db.Save(data)
})

// JavaScript can now call:
// const profile = await window.goup.getUserProfile("user123")
// await window.goup.saveData({foo: "bar"})

# Generate TypeScript definitions from Go code
$ utm-dev bridge generate-types

# Generates: ./web/src/goup-bridge.d.ts
declare namespace Goup {
  function getUserProfile(userID: string): Promise<UserProfile>
  function saveData(data: Record<string, any>): Promise<void>
  
  interface UserProfile {
    id: string
    name: string
    email: string
  }
}

// Enable Chrome DevTools for webview
if debug {
    webview.EnableDevTools(true)
    webview.EnableNetworkInspection(true)
    webview.EnableConsoleForwarding(true)
}

// Forward console.log to Go logger
webview.OnConsoleMessage(func(level, message string) {
    log.Debug().Str("source", "webview").Str("level", level).Msg(message)
})

# Development mode with hot reload
$ utm-dev dev --platform macos

✓ Building app...
✓ Starting file watcher...
✓ App launched
✓ Web content server running on http://localhost:3000

# When HTML/CSS/JS changes:
✓ Detected change: index.html
✓ Reloading webview...

# Build in Docker for consistent environment
utm-dev build linux --docker
utm-dev build windows --docker

# Uses official build containers:
# - golang:1.25-bullseye for Linux
# - golang:1.25-windowsservercore for Windows

# Use cloud builders for platforms you don't have
utm-dev build ios --remote
utm-dev build windows --remote

# Uses:
# - GitHub Actions
# - CircleCI
# - Or self-hosted build farm

# Detect CGo issues early
utm-dev check --platform linux

⚠ Warning: Cross-compiling to Linux from macOS requires Docker
  Reason: CGo dependencies cannot be cross-compiled
  
  Options:
    1. Use Docker: utm-dev build linux --docker
    2. Build on Linux: Use CI/CD or remote build
    3. Disable CGo: Set CGO_ENABLED=0 (may lose some features)

// ~/.utm-dev/plugins/my-plugin/plugin.go
package main

import "github.com/joeblew999/utm-dev/sdk/plugin"

type MyPlugin struct{}

func (p *MyPlugin) Commands() []plugin.Command {
    return []plugin.Command{
        {
            Name: "deploy-firebase",
            Run: func(args []string) error {
                // Custom deployment logic
            },
        },
    }
}

func (p *MyPlugin) Hooks() []plugin.Hook {
    return []plugin.Hook{
        {
            Event: "post-build",
            Run: func(ctx plugin.Context) error {
                // Run after every build
            },
        },
    }
}

func main() {
    plugin.Serve(&MyPlugin{})
}

# Opt-in to anonymous usage analytics
utm-dev telemetry enable

# Helps us understand:
# - Which platforms are most used
# - Build times and failure rates
# - Feature usage
# - Error patterns

# Always opt-in, always anonymous
utm-dev telemetry status
utm-dev telemetry disable

// Replace silent builds with rich output
import "github.com/charmbracelet/bubbletea"
import "github.com/schollz/progressbar/v3"

// Show download progress with size, speed, ETA
bar := progressbar.NewOptions(downloadSize,
    progressbar.OptionSetDescription("Downloading NDK"),
    progressbar.OptionShowBytes(true),
    progressbar.OptionShowCount(),
    progressbar.OptionSetPredictTime(true),
)

// Add goup.yaml support
type Config struct {
    Project ProjectConfig
    Build   BuildConfig
    Assets  AssetsConfig
}

// Read and merge with CLI flags
config := LoadConfig("goup.yaml")
config = MergeWithFlags(config, cliFlags)

// Structured errors with context
type BuildError struct {
    Phase       string
    Platform    string
    Error       error
    Suggestions []string
    DocsURL     string
}

// User sees:
// ❌ Build failed during: Compilation
// Platform: android
// Error: NDK compiler not found
// 
// Try:
//   utm-dev install ndk-bundle
//   utm-dev config  # verify SDK path

// Build icons in parallel
var wg sync.WaitGroup
for _, size := range iconSizes {
    wg.Add(1)
    go generateIcon(size, &wg)
}
wg.Wait()

// 5-10x faster icon generation