Muxy is a native macOS terminal emulator that stands out by combining a battle-tested terminal emulation backend with a modern SwiftUI interface. Instead of reinventing terminal emulation from scratch in Swift, it wraps the C library libghostty for rendering terminals and builds a declarative UI on top. This approach enables features like project-based workspace persistence, drag-and-drop split panes, and vertical tabs — all integrated into a native macOS experience.
what muxy does and how it’s built
Muxy targets macOS 14+ and is written in Swift 6.0+, using SwiftUI for its UI layer. The core terminal emulation engine is libghostty, a library that handles terminal rendering and input processing. By separating terminal logic (libghostty) from UI management (SwiftUI), Muxy can offer a flexible and modern interface while relying on a proven terminal backend.
The app supports project-based workspace management, meaning you can organize terminal tabs and split panes tied to specific projects, with their state preserved across app restarts. Tabs are arranged vertically for easier navigation, and panes can be split and rearranged via drag-and-drop.
Under the hood, Muxy integrates libghostty by creating Swift bindings or wrappers around the C library, allowing the SwiftUI app to manage terminal output and user input seamlessly. This architecture lets the UI layer focus on declarative rendering and state management, while libghostty handles the complex terminal emulation details.
Additional features include a lightweight text editor with syntax highlighting embedded in the app, built-in git diff viewing, and support for over 200 terminal color themes. Updates are managed via Sparkle, a popular macOS auto-update framework.
Beyond macOS, Muxy offers iOS and Android companion apps that do not emulate terminals themselves but act as remote clients connecting to the Mac app over the network. This design choice favors a consistent, powerful terminal experience on the Mac, with mobile devices serving as remote control terminals rather than standalone emulators.
architecture and technical strengths
Muxy’s main architectural strength lies in its clean separation between terminal emulation and UI. Terminal emulation is a complex domain, full of edge cases and obscure behaviors inherited from decades of terminal history. By relying on libghostty, Muxy reuses a battle-tested C library designed specifically for terminal rendering and input handling.
The SwiftUI layer then acts as a declarative wrapper that manages the layout, user interaction, and workspace state. This means the UI is responsive, modern, and highly customizable without having to reimplement terminal parsing or rendering logic.
This separation also means the app can evolve the UI independently of the emulation engine. For example, adding vertical tabs or drag-and-drop split panes is mostly SwiftUI work, while terminal correctness remains solid thanks to libghostty.
The project-based workspace concept is another highlight. Tabs and splits are tied to projects with persistent state, which is a real productivity boost for developers managing multiple terminals and codebases.
The remote pairing with mobile apps is a thoughtful feature. Instead of building a full terminal emulator on iOS or Android, which comes with performance and UX challenges, Muxy treats mobile apps as remote terminals connecting to the Mac. This keeps the heavy lifting on macOS and provides a consistent, native terminal experience.
Limitations include the requirement for macOS 14 and Swift 6, which restricts usage to the latest Apple OS versions. The mobile apps are still in closed or test phases, so the remote terminal feature is not yet fully polished or widely available.
quick start with muxy
requirements
- macOS 14+
- Swift 6.0+
- Optional: Ghostty installed for themes
- Optional:
ghCLI installed for pull request management
install via Homebrew
brew tap muxy-app/tap
brew install --cask muxy
manual install
Download the latest release from the GitHub releases page.
mobile apps setup
The iOS app is available via TestFlight. To connect:
- Install the iOS app via TestFlight
- Open Muxy on your Mac
- Go to Settings (Cmd +
,) - Navigate to the Mobile tab
- Toggle “Allow mobile device connection”
- Open the iOS app and enter your Mac’s IP and port
- Approve the connection on your Mac
The Android app is in closed testing with a similar setup process through Google Play Store.
verdict
Muxy is a solid example of building a native macOS terminal emulator that balances leveraging existing, battle-tested terminal emulation code with a modern declarative UI built in SwiftUI. The project-based workspace persistence and split pane management demonstrate practical, developer-focused features.
Its architecture is instructive for anyone looking to integrate C libraries into SwiftUI apps and maintain a clean separation between backend logic and UI. The remote mobile terminal pairing is a clever tradeoff, keeping terminal emulation on macOS and using mobile devices as remote clients.
That said, it’s targeted at users on the latest macOS and Swift versions, so its adoption is limited by platform requirements. The mobile companion apps are still experimental, so the full remote experience is not yet mature.
If you’re a macOS developer interested in terminal app internals, SwiftUI integration with C libraries, or project workspace management in terminal emulators, Muxy is worth exploring. It’s a practical, well-structured repo with a clear focus and some neat UI/UX features that set it apart from typical terminal apps.
→ GitHub Repo: muxy-app/muxy ⭐ 656 · Swift