# Does Palmier Pro Have a Command-Line Interface? Terminal Launch Guide

> Learn how to launch the Palmier Pro macOS app from your terminal. Discover the Swift executable target for command-line access and streamline your workflow.

- Repository: [Palmier/palmier-pro](https://github.com/palmier-io/palmier-pro)
- Tags: how-to-guide
- Published: 2026-06-22

---

**Palmier Pro does not ship a dedicated command-line tool with sub-commands, but you can launch the graphical macOS application directly from the terminal using its Swift executable target.**

Palmier Pro is distributed as a Swift executable target in the `palmier-io/palmier-pro` repository. While the project produces a standard macOS GUI application, understanding its command-line interface capabilities helps developers integrate it into automated workflows or launch it from shell scripts.

## How Palmier Pro Handles Command-Line Execution

The project structure reveals that Palmier Pro is built as a single binary rather than a traditional `.app` bundle, enabling direct terminal execution.

### The Executable Target Configuration

In [`Package.swift`](https://github.com/palmier-io/palmier-pro/blob/main/Package.swift), the repository declares an executable target named `PalmierPro`:

```swift
.executable(name: "PalmierPro", ...)

```

This configuration tells the Swift compiler to emit a single binary that can be invoked directly from the shell. When you run `swift build`, the compiler produces `.build/release/PalmierPro`, which functions as the command-line entry point.

### Entry Point and Application Lifecycle

The execution flow begins in [`Sources/PalmierPro/App/main.swift`](https://github.com/palmier-io/palmier-pro/blob/main/Sources/PalmierPro/App/main.swift), which instantiates `NSApplication`, assigns the delegate, and calls `app.run()`. This standard macOS UI entry point handles both traditional GUI launches and terminal-based invocations.

The [`Sources/PalmierPro/App/AppDelegate.swift`](https://github.com/palmier-io/palmier-pro/blob/main/Sources/PalmierPro/App/AppDelegate.swift) file contains a critical comment confirming CLI support: "Activate the app (required when launched from CLI, not a .app bundle)". Inside `applicationDidFinishLaunching`, the code calls `NSApp.setActivationPolicy(.regular)` to ensure the UI appears even when the binary is launched from a shell environment.

## Launching Palmier Pro From the Terminal

You can build and run Palmier Pro directly from the command line without generating a `.app` bundle. This requires Swift 6.2 and macOS 26.

### Building the Executable

Compile the release binary using Swift Package Manager:

```bash

# Build the executable

swift build -c release

```

This produces `.build/release/PalmierPro`, which you can execute directly.

### Running the Application

Launch the binary using either the built artifact or Swift's quick-run shortcut:

```bash

# Run the built binary directly

.build/release/PalmierPro

# Or use swift run for development builds

swift run PalmierPro

```

When executed, the binary initializes the full graphical editor. The `AppDelegate` automatically handles activation policies to ensure the menu bar and windows appear correctly, regardless of whether the process originated from Finder or a terminal session.

## Command-Line Arguments and Sub-Commands

Palmier Pro does **not** expose a separate command-line interface with sub-commands (such as `palmier-pro export` or `palmier-pro init`). All functionality—including project creation, AI-driven generation, and editing—must be accessed through the GUI after launch.

The `scripts/` directory (containing files like [`dev.sh`](https://github.com/palmier-io/palmier-pro/blob/main/dev.sh) and [`release.sh`](https://github.com/palmier-io/palmier-pro/blob/main/release.sh)) provides helper utilities for building and packaging the application, but these are development tools rather than user-facing CLI commands. There is no argument parser or help flag implemented in the main executable; the binary expects to launch as a standard macOS application.

## Summary

- Palmier Pro is configured as a Swift **executable target** in [`Package.swift`](https://github.com/palmier-io/palmier-pro/blob/main/Package.swift), producing a binary named `PalmierPro`.
- You can launch the application from the terminal using `swift run PalmierPro` or by executing the built binary at `.build/release/PalmierPro`.
- The [`AppDelegate.swift`](https://github.com/palmier-io/palmier-pro/blob/main/AppDelegate.swift) explicitly handles CLI launches by setting the activation policy, ensuring the GUI appears when started from a shell.
- No dedicated command-line tool exists; the repository does not support sub-commands or headless operation, and all features require the graphical interface.

## Frequently Asked Questions

### Can I run Palmier Pro entirely from the command line without a GUI?

No. While you can launch the binary from the terminal, Palmier Pro always initializes the macOS graphical interface. The `AppDelegate` calls `NSApp.setActivationPolicy(.regular)` and presents the full editor window. There is no headless or CLI-only mode for performing operations like code generation or project management without the GUI.

### How do I build the Palmier Pro executable for terminal use?

Run `swift build -c release` from the repository root. This generates `.build/release/PalmierPro`, which you can move to your PATH or invoke directly. The build requires Swift 6.2 and targets macOS 26. You can also use `swift run PalmierPro` for development and testing without creating a release build.

### Are there any command-line arguments supported by the Palmier Pro binary?

The binary does not implement a command-line argument parser or support flags like `--help` or `--version`. The [`main.swift`](https://github.com/palmier-io/palmier-pro/blob/main/main.swift) entry point immediately initializes the Cocoa application lifecycle without inspecting arguments. Any scripts requiring automation should interact with the GUI using macOS accessibility APIs rather than CLI arguments.

### What is the difference between the executable and a .app bundle?

The raw executable (`.build/release/PalmierPro`) is a single binary that you run directly from the terminal. A `.app` bundle is a directory structure containing the same binary along with resources, Info.plist, and metadata required for Finder integration and Mac App Store distribution. Both launch the same GUI, but the executable requires explicit activation handling in [`AppDelegate.swift`](https://github.com/palmier-io/palmier-pro/blob/main/AppDelegate.swift) to ensure proper UI presentation when launched outside a bundle context.