Multitui

What is Multitui?

Multitui is a macOS "app factory" that lets you wrap any terminal-based or TUI (text user interface) program into a standalone native macOS application. Instead of running powerful tools and untrusted code directly in your main terminal, you can generate individual .app bundles that behave like first-class Mac apps—with their own icons, windows, recent documents, and integrations—while benefiting from fine‑grained filesystem sandboxing.

Designed for power users, developers, and anyone who relies on command‑line tools, Multitui helps you keep your existing workflow and terminal setup intact. It acts like a general shell with access to your CLI tools, but adds a protective layer around what code can read, write, or delete on your machine. This makes it ideal for running AI coding agents, utilities, and focused TUI apps without compromising your dev environment or personal files.

Key Features

• Custom macOS apps for any terminal tool
  Turn TUI and command‑line programs into dedicated macOS apps, each with its own .app bundle. Give tools like lazygit, htop, or AI coding agents their own window and icon instead of yet another terminal tab.

• Filesystem sandboxing with macOS sandbox-exec
  Multitui uses the built‑in sandbox-exec framework to constrain what your apps can access:

  • Default deny for delete operations everywhere
  • Default deny for read and write access in your user folder (~)
  • Targeted allow rules for specific paths or project folders
  • Optional full read/write for trusted project directories
  • Logging of denied actions so you can see what was blocked and selectively allow it
  • A "--dangerously-skip-permissions" mode when you consciously want to bypass restrictions

• Folder‑based & file‑based apps
  Build apps tailored to how you work:

  • Folder-based apps: Open and work inside project directories (ideal for tools like AI code agents, lazygit, dua, etc.)
  • File-based apps: Double‑click documents in Finder to open them with your custom app (perfect for nano, SQLite tools, JSON viewers, hex editors, and more)

• First‑class macOS integration
  Each generated app behaves like a native Mac app:

  • Dock icon and Spotlight discoverability
  • Native window management support (works great with Rectangle, Magnet, and similar tools)
  • Recent documents menu and document‑based workflows
  • Native tabs and configurable toolbars, including seamless minimal toolbars

• Finder integration & file handling
  Launch and open content directly from Finder:

  • Finder toolbar buttons for quick access
  • Right‑click (context menu) support
  • Drag files or folders to the dock icon to open them
  • Register apps as handlers for specific file types or document extensions
  • URL scheme support (e.g. claudecode://open?arg=/path/to/open)

• Command‑line & automation friendly
  Each generated app can be launched programmatically:

  • Run from the command line like MyApp.app /path/to/open
  • Integrate with AppleScript and automation workflows
  • Combine with shell scripts, launchers, or third‑party automation tools

• Isolated shell history & snippets
  Keep your main shell history clean and your tools focused:

  • Each app maintains its own command history, separate from your primary shell
  • Save frequently used commands as app‑specific snippets
  • Reduce noise and avoid mixing experimental commands with your day‑to‑day history

• Optimized for AI coding agents and dev tools
  Run AI agents and code assistants safely:

  • Prebuilt examples for Claude Code, Codex, Gemini, and other coding agents
  • Allow them to work inside a project directory while preventing access to the rest of your system
  • Prevent accidental file deletion or unwanted edits outside sandboxed paths

• Ready‑made example apps
  Multitui showcases a range of example apps to illustrate what you can build:

  • AI & code: Claude Code, Codex, Gemini, OpenCode (open‑source coding agent)
  • Dev tools: lazygit (Git TUI), dua (disk usage explorer)
  • File utilities: nano (text editor), Harlequin (SQLite interface), jqp (JSON viewer with jq), hex viewers, Markdown editors
  • System utilities: top, htop, network monitors, battery usage monitors, Docker management (lazydocker), and more

• Menubar widgets from CLI tools
  Build lightweight menubar apps that periodically run CLI commands and display their output:

  • Show ping latency (e.g., to 1.1.1.1)
  • Display external IP via services like icanhazip.com
  • Track weather or temperature via tools like wttr.in

• Keep your existing terminal workflow
  Multitui is additive—not a replacement. Keep using iTerm2, Ghostty, Alacritty, or Terminal.app for general work while moving your most important tools into dedicated, sandboxed windows.

How to Use Multitui

1. Download and install

   • Download the Multitui app for macOS (native app for macOS 15+).
   • Drag it into your Applications folder and launch it like any other Mac app.

2. Create a new app configuration

   • Open the Multitui "app factory" interface.
   • Click to create a new app profile for the tool you want to wrap (e.g., an AI agent, lazygit, a JSON viewer, or a system utility).
   • Specify the command or executable you want the app to run.

3. Choose app type and behavior

   • Decide whether your app should be folder‑based (operating on project directories) or file‑based (opening specific files).
   • Configure how users will open content: double‑click in Finder, drag‑and‑drop, toolbar button, or via URL schemes.

4. Configure sandbox rules

   • Open the sandbox configuration panel.
   • Start from the secure defaults (deny writes/deletes globally, deny user folder access).
   • Add targeted allow rules for specific paths, such as your project directory or a dedicated workspace.
   • Use the deny log to see what the app tried to access and refine your rules as needed.

5. Customize macOS integration

   • Set the app name, icon, and appearance.
   • Configure document handling, recent documents behavior, and toolbar style.
   • Decide whether the app should support native tabs or a seamless, minimal toolbar look.

6. Build and test your app

   • Click to generate the .app bundle.
   • Launch the new app from Finder, the Dock, or Spotlight.
   • Verify that the underlying TUI/CLI tool runs correctly inside the app window.
   • Confirm that the sandbox is working as expected by trying common operations and checking deny logs.

7. Integrate into your workflow

   • Pin your new app to the Dock for quick access.
   • Add it to the Finder toolbar or context menu for relevant folders and files.
   • Use the command line or URL scheme to open specific targets programmatically.
   • Create and save frequently used commands as snippets inside the app, and rely on the isolated shell history for focused workflows.

Use Cases

1. Safe AI coding agents and assistants
   Run AI coding agents such as Claude Code, Codex, Gemini, or other coding copilots with confidence. Use Multitui to:

   • Allow agents to read and write only within a specific project folder
   • Block access to your home directory, SSH keys, or unrelated repositories
   • Experiment with generated code without worrying about accidental file deletions or edits elsewhere on your system This is ideal for developers who want the power of AI assistance without surrendering full filesystem access.

2. Dedicated TUI apps for focused development
   Convert frequently used TUI tools into standalone apps:

   • Wrap lazygit into its own Git management app
   • Turn dua into a disk usage explorer app
   • Build a Docker management app using lazydocker With each tool in its own window and Dock icon, you can reduce terminal tab clutter while taking advantage of macOS window management and shortcuts.

3. Powerful file and data inspectors
   Create file‑centric apps based on CLI tools to inspect and edit data:

   • Text editors (e.g. nano) as double‑click‑to‑open text file apps
   • SQLite database inspector apps using tools like Harlequin
   • JSON viewers powered by jqp and jq
   • Hex viewers or patch tools for low‑level file inspection Use Finder integration so that double‑clicking or right‑clicking files automatically opens them in your custom Multitui‑built app.

4. System monitoring and diagnostics
   Turn system utilities into always‑available, isolated monitoring apps:

   • Resource monitors (top, htop) in dedicated windows
   • Network connection monitors and traffic inspectors
   • Battery usage or power draw monitors Use global shortcuts or "always on top" options (where supported in your configuration) to keep critical views visible while you work.

5. Menubar status widgets from CLI commands
   Use Multitui to convert simple CLI output into lightweight menubar widgets:

   • Ping a known host (like 1.1.1.1) and show latency in the menubar
   • Display your current public IP address by polling icanhazip.com
   • Fetch and show local weather or temperature via wttr.in These small, focused apps give you real‑time status without needing a browser or full terminal window.

FAQ

1. What platforms does Multitui support?
Multitui is a native macOS application designed for macOS 15 and later. It leverages macOS‑specific technologies such as sandbox-exec, Dock integration, Finder extensions, and native document handling, so it is not available for Windows or Linux.

2. Do I need to change my existing terminal or shell setup?
No. Multitui is built to complement, not replace, your current workflow. You can keep using iTerm2, Ghostty, Alacritty, Terminal.app, or any other terminal for general work. Multitui is best used to give select tools—like AI agents, TUIs, and system utilities—their own dedicated, sandboxed app windows.

3. How does Multitui protect my filesystem?
Multitui uses macOS's sandbox-exec to confine what each generated app can do. By default, it denies delete operations everywhere and blocks read/write access to your user folder (~). You can then add specific allow rules for trusted paths, such as a particular project directory. Any denied operations are logged so you can review them and decide whether to loosen restrictions selectively. There is also an explicit option to bypass these protections when you intentionally want full access.

4. Can I open files and folders directly with my Multitui apps?
Yes. Multitui integrates with Finder and macOS's document handling system. You can:

• Double‑click files to open them with your custom app (if registered as a handler)
• Use Finder toolbar buttons or right‑click context menu entries
• Drag files or folders onto the Dock icon
• Use URL schemes (e.g., claudecode://open?arg=/path/to/open) and command‑line invocations like MyApp.app /path/to/open to open content programmatically.

5. Is Multitui suitable for non‑developers?
Multitui is primarily targeted at technical and power users who are comfortable with command‑line tools. However, once an app has been created, non‑technical users can benefit from the resulting .app bundles—opening files, running tools, and using menubar widgets without touching the terminal. Teams can have advanced users build and configure apps that others can run like any standard macOS application.