Why Parall exists, how its shortcut bundles work, and the technical choices behind its local, privacy-first design.
Original macOS engineering
Parall's core could not be assembled from public documentation because the app behavior it depends on is undocumented. It grew from years of reverse engineering macOS app architecture, testing individual apps, and refining an engine around what actually works.
Parall's compatibility profiles come from observing how each target app launches, stores data, handles separate processes, and interacts with the Dock. The same reverse-engineering work makes shortcuts function correctly when opened through Spotlight, Raycast, and Alfred. That work continues as macOS and apps change.
A script can sometimes start another process. Parall solves the harder problem of giving supported instances their own usable identity, Dock behavior, and, where the target app allows it, separate data, accounts, profiles, and settings while keeping them connected to the original app.
Parall never edits or freezes the target app. Every shortcut continues to launch the original installed app, preserving its code signature and allowing its built-in updater to keep working. After an update, all shortcuts use the new version when restarted. That matters because app updates often patch security vulnerabilities.
The research determines how Parall configures standard macOS launch mechanisms. Parall does not use private APIs, inject or patch code, or modify macOS or the original app.
The result is original, human-led engineering. Parall's engine is designed, coded, tested, and maintained by Ihor July rather than generated from an AI prompt or copied from a public recipe.
A different architecture
Many multi-instance workarounds duplicate the target app bundle, change its identity, and re-sign it. Parall instead launches the original installed app through a separate shortcut. It never modifies, repackages, or re-signs the target bundle.
| Comparison topic | Common copy-and-repack approach | Parall |
|---|---|---|
| Target app bundle | Creates a second copy, changes its contents or bundle identity, and may package it again. | Leaves the installed target app untouched and launches its original executable through a separate shortcut. |
| Signing and security | Changing a signed bundle invalidates the developer's original signature. Re-signing creates a differently signed copy and can change or remove entitlements, sandbox behavior, and other protections. | Preserves the target app's developer signature, sandbox, entitlements, and security measures because the target bundle is never changed. |
| Native app services | Changes to identity, signing, or entitlements can disrupt services tied to them, including Keychain groups, passkeys, push notification identity, authorization callbacks, and updater assumptions. | Avoids stripping the target app's original capabilities by continuing to launch its signed bundle. Individual services still depend on the target app and macOS, and known multi-instance limitations are documented in the FAQ. |
| Updates | A copied or repackaged build can fall outside the original update path and remain on an older version until it is rebuilt or replaced. | Keeps the original update path working. After the target app updates, every Parall shortcut uses the updated app the next time it starts. |
| Dependencies | May rely on scripts, manual signing steps, or helper tools obtained outside the app. | The main Parall app is standalone, sandboxed, and distributed through the Mac App Store. No helper download or background daemon is required. |
Updates frequently patch security vulnerabilities. Fast-moving AI and developer tools such as Codex and Claude may receive important fixes often, while AI-assisted security research is also accelerating vulnerability discovery. Staying current is an essential layer of defense alongside malware protection and other security controls.
Parall's shortcut-generation workflow was engineered so the main app can remain sandboxed and be distributed through the Mac App Store without an external helper. Shortcut creation and launching work locally and offline. The optional Download Compatibility Settings action is the explicit network exception documented in the privacy policy.
There is no public API, complete documentation, or published recipe for the shortcut architecture Parall uses. I developed it through personal reverse engineering and direct testing of native macOS behavior. Public examples and generic AI-generated implementations tend to fall back to scripts, copied bundles, or repackaging. To my knowledge, Parall is the first consumer tool to solve this problem while leaving the target app untouched, and the engine will continue to evolve as I study more macOS behavior.
For more than a decade, I dealt with macOS limitations around running multiple instances of the same app. I built scripted app bundles for myself to work around it, then realized there was no easy, polished way for regular users to create those app-like shortcuts. Parall turns that workflow into the first tool of its kind designed specifically to create app shortcuts for multi-instance support.
Parall supports automatic data separation for supported Chrome-based, Firefox-based, Electron-based, Eclipse-based, and ToDesktop-based apps, including when the target app is sandboxed. The advanced HOME redirection mode also supports many other compatible apps. For the detailed and up-to-date list, visit the compatibility page.
Even when multi-instance mode isn't needed, you can still use Parall to create a website, app, file, folder, or command shortcut with its own identity and launch configuration. App shortcuts can add custom command-line arguments or override environment variables, including HOME, to control behavior, select profiles, or redirect data paths. The HOME override builds a container-like structure while preserving essential macOS links for compatibility.
Define custom environment variables applied only to that shortcut - perfect for fine-grained configuration, debugging, or per-project setups. Parall also supports the Arduino IDE, allowing you to run separate development environments with different toolchains, boards, and libraries side by side.
For educational labs and classrooms, Parall can automatically erase a shortcut's redirected data storage when the shortcut quits. This makes it easy to start each session from a clean state for student experiments, without manual cleanup.
Parall makes it easier than ever to start multiple instances of the same macOS app - each with its own Dock icon and configuration - just as if they were separate apps. Instead of relying on workarounds or complex scripts, Parall creates independent shortcuts that launch multiple instances of apps, allowing you to use multiple profiles or sessions simultaneously.
Each shortcut remains directly connected to the original app bundle, meaning that whenever the original app is updated, all your Parall-created shortcuts automatically use the updated version as well. You never need to recreate or maintain them manually.
Parall includes advanced environment management, giving you fine control over how each app instance stores and separates its data. That also enables advanced workflows such as running multiple separated Philips Hue Sync instances on macOS so different displays can use different dedicated LED setups without instance overlap.
I am Ihor July, and I develop Parall as a cybersecurity expert and reverse engineer focused on building secure and privacy-respecting macOS tools. I am also the developer behind DockLock Pro, a Mac Dock utility for controlling Dock behavior across displays; App Trust Preview, a local-first Mac app inspection tool that translates signing, sandboxing, entitlements, and internal components into plain-language reports before you open an app; and LockLines, a Mac utility for designing, previewing, and copying plain-text lock screen messages that fit macOS.
Parall is designed, coded, and tested by me. I write the app code, test every change, and maintain a reusable Objective-C framework across my apps. AI and online search assist with bug research, edge cases, writing, and translations, but the core engine, app-specific compatibility work, implementation, and testing come from my own reverse engineering and code.
The app is built natively in C++ for performance and sandboxed for maximum safety. Parall reflects years of research and development focused on delivering practical, privacy-first solutions for macOS users.
The shortcuts created by Parall are standalone macOS app bundles that directly execute the target app's binary. These shortcut bundles are not sandboxed - by design - because they must launch the original application directly without additional layers.
Each shortcut is unsigned since any modification to an app bundle removes its original signature. macOS may display a message suggesting the shortcut is "trying to modify another app," but this is a generic system notification triggered by access, not by modification. Parall does not modify any system files or applications.
By design, Parall only creates shortcut bundles that mirror the original app structure and configuration. It never alters, injects, or writes into existing apps or the operating system, ensuring your Mac remains secure and unchanged.