macOS app: PyInstaller bundle, Application Support paths, loading UI, fixes

- Build: align local_build.sh with CI, verify deps, icon generation (Pillow)
- PyInstaller: bundle groovy, gradio, torch; hook torch bin/ and datas
- App paths: app_paths.py for App Support/logs; use in core, rvc, tabs
- Launcher: single instance, loading page then Gradio redirect, TeeOutput.isatty()
- Prerequisites: offline-safe; restart in bundle shows manual-restart message
- Console tab: gr.Info + single output for clear; gr.Timer for auto-refresh

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 2 people

.github/workflows/build-macos-release.yml

@@ -51,15 +51,24 @@ jobs:
     - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -r requirements_macos.txt
-        # Verify critical dependencies for PyInstaller
-        pip show webrtcvad-wheels || echo "Warning: webrtcvad-wheels not installed"
-        pip show pyinstaller || echo "Warning: pyinstaller not installed"
+        python -m pip install -r requirements_macos.txt
+        # Verify critical dependencies (same checks as local_build.sh; fail early on missing packages)
+        MISSING=""
+        for pkg in webrtcvad-wheels pyinstaller torch gradio pywebview; do
+          if ! python -m pip show "$pkg" &>/dev/null; then
+            MISSING="${MISSING} ${pkg}"
+          fi
+        done
+        if [ -n "$MISSING" ]; then
+          echo "::error::Missing package(s):$MISSING"
+          exit 1
+        fi
+        echo "Critical packages present (webrtcvad-wheels, pyinstaller, torch, gradio, pywebview)"
 
     - name: Generate app icon
       run: |
         chmod +x build/macos/generate_icon.sh
-        ./build/macos/generate_icon.sh
+        PYTHON=python ./build/macos/generate_icon.sh
 
     - name: Check build/macos assets (icon, codesign, DMG README)
       run: |

Applio.spec

@@ -13,6 +13,20 @@ app_name = 'Applio'
 datas = []
 datas += collect_data_files('gradio')
 datas += collect_data_files('gradio_client')
+# Gradio reads .py source files at runtime (e.g. component_meta.create_or_modify_pyi);
+# include full package tree so Path(__file__).parent / "*.py" exists in the bundle
+try:
+    import gradio as _gr
+    datas += [(os.path.dirname(_gr.__file__), 'gradio')]
+except ImportError:
+    pass
+datas += collect_data_files('groovy')  # gradio dependency; needs version.txt at runtime
+# Torch uses inspect.getsource() at import; include package tree so source is available
+try:
+    import torch as _torch
+    datas += [(os.path.dirname(_torch.__file__), 'torch')]
+except ImportError:
+    pass
 datas += collect_data_files('safehttpx')
 datas += collect_data_files('transformers')
 datas += collect_data_files('fairseq')
@@ -32,6 +46,7 @@ datas += [('app.py', '.')]
 hiddenimports = []
 hiddenimports += collect_submodules('gradio')
 hiddenimports += collect_submodules('gradio_client')
+hiddenimports += collect_submodules('groovy')
 hiddenimports += collect_submodules('uvicorn')
 hiddenimports += collect_submodules('transformers')
 hiddenimports += collect_submodules('fairseq')
@@ -57,6 +72,7 @@ hiddenimports += [
     'uvicorn.protocols.websockets.auto', 
     'uvicorn.lifespan', 
     'uvicorn.lifespan.on',
+    'app_paths',
     'rvc.lib.platform',
     'rvc.lib.zluda',
     'assets.i18n.i18n',

app.py

@@ -39,14 +39,17 @@
 from tabs.realtime.realtime import realtime_tab
 from tabs.console.console import console_tab
 
-# Run prerequisites
+# Run prerequisites (non-blocking: if offline/unreachable, app still starts; user can retry from Train tab)
 from core import run_prerequisites_script
 
-run_prerequisites_script(
-    pretraineds_hifigan=True,
-    models=True,
-    exe=True,
-)
+try:
+    run_prerequisites_script(
+        pretraineds_hifigan=True,
+        models=True,
+        exe=True,
+    )
+except Exception as e:
+    print(f"Prerequisites check/download skipped (will retry when online): {e}")
 
 # Initialize i18n
 from assets.i18n.i18n import I18nAuto

app_paths.py

@@ -0,0 +1,28 @@
+"""
+Central definition of user data root for Applio.
+All downloaded models, trained models, and reusable data should live under
+this directory so they persist across app updates and rebuilds.
+
+- macOS (bundled): ~/Library/Application Support/Applio
+- Otherwise: APPLIO_APP_SUPPORT env var, or current working directory (dev/script)
+"""
+import os
+
+
+def get_app_support_dir():
+    """
+    Return the root directory for user data (models, downloads, logs, etc.).
+    When running as the macOS app, the launcher sets APPLIO_APP_SUPPORT to
+    ~/Library/Application Support/Applio so data is reused across builds/versions.
+    """
+    return os.environ.get("APPLIO_APP_SUPPORT", os.getcwd())
+
+
+def get_models_dir():
+    """Trained models (RVC .pth, etc.) - e.g. AppSupport/logs."""
+    return os.path.join(get_app_support_dir(), "logs")
+
+
+def get_rvc_models_dir():
+    """Pretraineds, embedders, predictors - e.g. AppSupport/rvc/models."""
+    return os.path.join(get_app_support_dir(), "rvc", "models")

build/macos/generate_icon.sh

@@ -46,9 +46,10 @@ else
 fi
 
 # Fallback: Generate icon using Python if conversion failed
+# Use PYTHON if set (e.g. by local_build.sh) so the same interpreter with deps is used
 if [ ! -f "$TEMP_PNG" ]; then
     echo "⚠ Icon conversion failed, generating fallback icon..."
-    python3 build/macos/generate_fallback_icon.py "$TEMP_PNG"
+    "${PYTHON:-python3}" build/macos/generate_fallback_icon.py "$TEMP_PNG"
 fi
 
 # Verify temp icon exists

build/macos/hooks/hook-torch.py

@@ -1,6 +1,7 @@
 # PyInstaller hook for torch with Apple MPS support
 # This ensures torch MPS backend and necessary libraries are included
 
+import os
 from PyInstaller.utils.hooks import collect_submodules, collect_dynamic_libs
 
 # Collect all torch submodules including MPS backend
@@ -16,3 +17,12 @@
 
 # Collect dynamic libraries
 binaries = collect_dynamic_libs('torch')
+
+# torch.__init__ looks for torch/bin/torch_shm_manager at runtime; include it
+_torch_dir = os.path.dirname(__import__('torch').__file__)
+_torch_bin = os.path.join(_torch_dir, 'bin')
+if os.path.isdir(_torch_bin):
+    for name in os.listdir(_torch_bin):
+        path = os.path.join(_torch_bin, name)
+        if os.path.isfile(path):
+            binaries.append((path, 'torch/bin'))

core.py

@@ -9,8 +9,10 @@
 now_dir = os.getcwd()
 sys.path.append(now_dir)
 
+from app_paths import get_app_support_dir
+
 current_script_directory = os.path.dirname(os.path.realpath(__file__))
-logs_path = os.path.join(current_script_directory, "logs")
+logs_path = os.path.join(get_app_support_dir(), "logs")
 
 from rvc.lib.tools.prerequisites_download import prequisites_download_pipeline
 from rvc.train.process.model_blender import model_blender

launcher.py

@@ -41,11 +41,14 @@ def setup_environment():
     app_support_dir = home_dir / "Library" / "Application Support" / "Applio"
     logs_dir = home_dir / "Library" / "Logs" / "Applio"
 
-    # Create directories
+    # Create directories (user data root so models/data persist across builds/versions)
+    (app_support_dir / "logs").mkdir(parents=True, exist_ok=True)
     for directory in [app_support_dir, logs_dir]:
         directory.mkdir(parents=True, exist_ok=True)
         print(f"Created/verified directory: {directory}")
 
+    os.environ["APPLIO_APP_SUPPORT"] = str(app_support_dir)
+    
     # IMPORTANT: Set environment variables for Apple MPS optimization
     # These settings optimize for Apple's unified memory architecture
     os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"  # Enable Metal Performance Shaders with CPU fallback
@@ -116,21 +119,46 @@ def cleanup():
     print("Goodbye!")
 
 def wait_for_server(url='http://127.0.0.1:6969', timeout=30):
-    """Wait for the server to be ready by polling the endpoint."""
-    print("Waiting for Applio server to start...")
+    """Wait for the server to be ready by polling. Returns True when ready."""
     start_time = time.time()
     while time.time() - start_time < timeout:
         try:
             response = urllib.request.urlopen(url, timeout=1)
             if response.getcode() == 200:
-                print("Applio server is ready!")
                 return True
         except (urllib.error.URLError, ConnectionError, OSError):
-            # Server not ready yet, wait a bit
             time.sleep(0.5)
-    print(f"Warning: Server did not respond within {timeout} seconds")
     return False
 
+# Shown immediately so user sees progress; we redirect to the real UI when server is up (no second instance).
+LOADING_HTML = '''<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Applio - Starting</title>
+<style>
+  * { box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: #1a1a1a; color: #e5e5e5; margin: 0; padding: 2rem; min-height: 100vh; display: flex; flex-direction: column; align-items: center; justify-content: center; }
+  .box { max-width: 520px; text-align: center; }
+  h1 { font-size: 1.5rem; margin-bottom: 1rem; }
+  p { color: #a3a3a3; line-height: 1.6; margin: 0.5rem 0; }
+  .spinner { width: 40px; height: 40px; border: 3px solid #333; border-top-color: #0ea5e9; border-radius: 50%; animation: spin 0.8s linear infinite; margin: 0 auto 1.5rem; }
+  @keyframes spin { to { transform: rotate(360deg); } }
+  .log-path { font-size: 0.85rem; word-break: break-all; color: #737373; margin-top: 1.5rem; }
+</style>
+</head>
+<body>
+  <div class="box">
+    <div class="spinner"></div>
+    <h1>Applio is starting</h1>
+    <p>Checking and downloading prerequisites if needed. This may take several minutes on first run.</p>
+    <p>You will be switched to the main interface when ready.</p>
+    <p class="log-path">Log: ~/Library/Logs/Applio/console.log</p>
+  </div>
+</body>
+</html>'''
+
 def launch_gradio(app_dir, logs_dir):
     """Launch the Gradio app."""
     global _gradio_thread
@@ -180,6 +208,10 @@ def flush(self):
                     self.original_stream.flush()
                 except Exception:
                     pass
+        
+        def isatty(self):
+            """Required by uvicorn/logging when configuring formatters; we are not a TTY."""
+            return False
 
     # Redirect stdout and stderr to our tee
     sys.stdout = TeeOutput(log_file_path, sys.stdout)
@@ -191,63 +223,65 @@ def flush(self):
     print(f"All output will be captured to the Console tab in the UI")
     print("=" * 60)
 
-    # Run the Gradio app in a thread so pywebview can take control of main thread
-    def run_gradio():
+    # Single background thread: import app (runs prerequisites) then start Gradio server.
+    # We never start a second Applio process.
+    def run_app_and_server():
         try:
-            # Import the app module which will launch Gradio
             import app
+            app.launch_gradio("127.0.0.1", 6969)
         except Exception as e:
             print(f"ERROR: Failed to start Applio: {e}")
             import traceback
             traceback.print_exc()
 
-    _gradio_thread = threading.Thread(target=run_gradio, daemon=True)
+    _gradio_thread = threading.Thread(target=run_app_and_server, daemon=True)
     _gradio_thread.start()
 
-    # Wait for server to be ready
-    wait_for_server()
-    
-    # Launch pywebview window
     try:
         import webview
-        print("Opening Applio window...")
-        
-        # Create window and keep reference so we can treat close-as-quit
+        print("Opening Applio window (loading page first)...")
+        # Show loading page immediately; redirect to real UI when server is ready (no second instance).
         window = webview.create_window(
             'Applio',
-            'http://127.0.0.1:6969',
+            html=LOADING_HTML,
             width=1400,
             height=900,
             resizable=True,
             fullscreen=False,
             min_size=(800, 600),
             background_color='#1a1a1a',
             text_select=True,
-            on_top=False,  # Keep in foreground but not always on top
-            focus=True     # Get focus on creation
+            on_top=False,
+            focus=True,
         )
 
-        # On macOS, closing the window (red X) does not quit the app by default;
-        # the Cocoa run loop keeps running and the app can "reopen". Treat window
-        # close as an explicit quit: cleanup and exit so we don't respawn.
+        # Redirect this same window when server is up (long timeout for first-run download).
+        def redirect_when_ready():
+            print("Waiting for Applio server (prerequisites may be downloading)...")
+            if wait_for_server(timeout=600):
+                print("Applio server is ready — switching to main interface.")
+                try:
+                    window.load_url("http://127.0.0.1:6969")
+                except Exception as e:
+                    print(f"Redirect failed: {e}")
+            else:
+                print("Server did not start in time. Check ~/Library/Logs/Applio/console.log")
+        
+        threading.Thread(target=redirect_when_ready, daemon=True).start()
+        
+        # Quit fully on close so macOS does not reopen the app.
         if window is not None:
             def on_window_closed():
-                print("\nWindow closed by user — quitting.")
+                print("\nWindow closed — quitting.")
                 cleanup()
                 os._exit(0)
             try:
                 window.events.closed += on_window_closed
             except Exception:
-                pass  # older pywebview may not have events.closed
+                pass
 
-        # Register cleanup handler for graceful shutdown (e.g. Dock Quit, SIGTERM)
         atexit.register(cleanup)
-        
-        # Start the webview - this blocks until the GUI run loop exits
-        # When window is closed, on_window_closed() runs and we os._exit(0)
-        webview.start(gui='cocoa')  # Explicitly use Cocoa for macOS
-        
-        # If start() returns without on_window_closed firing (e.g. other backends)
+        webview.start(gui='cocoa')
         print("\nWindow closed by user")
 
     except ImportError: