Releases

Notarized by Apple. Parallex is now signed with a Developer ID and notarized, so a downloaded copy opens without a trip to System Settings › Privacy & Security. Copies Parallex makes are still signed on your Mac, as before.

Downloads from parallex.mandip.dev. The app's updates, the Terminal installer and the download button now come straight from parallex.mandip.dev, and every release is listed at https://parallex.mandip.dev/releases. Compatibility reports go to https://github.com/mandipadk/parallex-community.

Homebrew. The cask has its own tap now. New installs: brew install --cask mandipadk/parallex/parallex. If you tapped the old way, move the tap over once (Parallex stays installed):

brew tap --custom-remote mandipadk/parallex https://github.com/mandipadk/homebrew-parallex git -C "$(brew --repository mandipadk/parallex)" reset --hard origin/main

No second Arc, for now. The nightly lab, now testing the profile instance Parallex makes for each browser, found that Arc ignores the separate profile folder it's started with: an Arc instance opens your own Arc data, cookies included. A copy of Arc with Own identity closes at launch, because Arc needs iCloud. So Parallex no longer makes new Arc instances, from New Instance, links, Duplicate or the command line, until a second Arc can be kept apart. If you already have an Arc instance, it shares your Arc's profile: remove it, or use another browser for a second account.

Also: programs a copy starts from outside itself (macOS's own tools, a shell) no longer inherit Parallex's injected libraries, which could make one of them abort.

Two Microsoft Teams. Copies of Teams now open, and sign in to another account beside your own. Teams' web view used to refuse the copy's own signature and close right away; copies now sign every piece without the flags an app asks for in its Info.plist. Word and PowerPoint ask for them the same way.

Also: tools a sandboxed copy starts from outside itself no longer inherit its app-group mapping, which could make one of them abort.

Outlines keep up. A window's colored outline now follows it as you drag or resize it (it used to trail by up to a third of a second), and is never left broken after a resize.

Parallex 1.9 makes a second copy quicker to get, and adds a window that forgets.

Another one of that. The menu bar now offers Another <app>… for the app or website you were last in (from a copy, its original app), and opens New Instance with it already picked.

Open in a Clean Window. Select a web address in any app, then choose Services › Open in a Clean Window (also in the right-click menu). It opens in a window of its own, with none of your cookies, history or sign-ins. Closing the window quits it, and everything it kept goes to the Trash. Good for a link you don't trust, or a site you want to see signed out.

A better first instance. The first-run setup now suggests the apps people most often run twice (Claude, ChatGPT, WhatsApp, Slack, Discord, Chrome…), when you have them.

Firefox and Thunderbird copies. With Own identity on, their crash reporter no longer crashes as the copy starts.

Throwaways start clean. Each throwaway now gets an identity of its own, so it never inherits notification or privacy choices from an earlier one with the same name.

Also: notices for Microsoft Teams (copies close right after opening, so Parallex points to Teams on the web), and for Arc and Edge with Own identity on. There's a Parallex extension for Raycast in the repository (integrations/raycast), and a page for each app at https://parallex.mandip.dev/apps, now 25 of them.

Parallex 1.8.1 is a small one.

Something's off with this one. An instance's ⋯ menu, and its right-click menu in the sidebar, now have Something's Off…, with that instance already picked, so the note says which copy you mean.

The right GitHub account, every push. Git finds a GitHub sign-in in the keychain by host, so two workspaces signed in to two GitHub accounts could push as the wrong one. In a workspace with its own identity, git is now told the account the workspace's gh is signed in to, and finds that account's own sign-in. Your own git settings aren't touched.

Also: every app Parallex is often used with now has a page of its own at https://parallex.mandip.dev/apps.

Parallex 1.8 gives you a way to say when something's off, and a way to hear sooner when an app update breaks copies.

Something's Off. In the menu bar, the Help menu and Settings › About: write what happened in your own words and it goes straight to Parallex's maker, read by a person. Pick the instance it's about and a few facts go with it: its kind, its app if that's a well-known one, and how it has been doing (whether it has quit at launch, what its isolation check found). Never its name, paths or contents. See What's Sent shows the whole note before Send, and an email address goes only if you type one, deleted once your note is dealt with.

Heads-ups sooner. When an app update starts breaking copies, it's spotted from the anonymous reports and your notes, and a notice can reach every Parallex within hours, before a fix does.

Telegram copies work. They closed a few seconds after opening: Telegram reads the update address Parallex had taken out of its copies (so Telegram's own updater can't replace them), and stopped when it was missing. Copies now get an address that never has an update instead. Existing copies are rebuilt on their own while they're not running.

Everything that leaves your Mac: https://parallex.mandip.dev/privacy

Parallex 1.7 makes updates safer to put out and easier to catch up on.

Everything you missed. If you update past a few releases at once, you now see what came in each of them, in the update window and in What's New afterwards, not only in the newest. (The update window does this for Macs on older versions too, starting today.)

Releases that can stop themselves. Parallex's server can now send a new release to a few Macs first, then to more each day it stays healthy, and stop it on its own if it starts crashing Parallex, failing to update, or breaking copies, judged on the anonymous reports from Macs that share them. It will be turned on once enough Macs share reports for the judgment to mean something.

Settings comes forward. Settings… in the menu bar opens Settings in front of your other windows, instead of behind them; so does Update from the menu bar.

Each Mac counted once. The daily update check now carries a random number picked once on your Mac, so Parallex's server can count each Mac once rather than each check. It isn't derived from anything about you or your Mac, it's never tied to the usage report, and it's forgotten 90 days after your Mac last checks. With automatic checks off (Settings › About), it goes only when you choose Check for Updates.

Everything that leaves your Mac: https://parallex.mandip.dev/privacy

Parallex 1.6 can tell its maker what's working, if you'll let it.

A daily anonymous report. Parallex is free and changes every week, and until now a release that broke copies of an app only showed up once someone wrote in. From 1.6, Parallex can send a short report once a day, with its update check: which well-known apps you copy and on which versions, what happened (an instance made, a copy that quit at launch, a refresh or update that didn't finish, and at which step), which features you use, and Parallex's own crashes and hangs, by where in its own code they happened. It goes under a random number made on your Mac and renewed every 180 days. Never instance names, file names, paths, contents, your own sites, or apps that aren't well-known (those are only counted). The server takes only the names and values Parallex sends, checked against fixed lists and patterns, and keeps what a Mac reported for 90 days.

New installs choose in the first-run setup; if you used Parallex before, it asks once, even if you had the old weekly report on, since this one says more. If you had turned that off, it stays off, and nothing is recorded before you've said yes. Settings › About › See What's Sent, and parallex usage in Terminal, show the whole report before it goes; parallex usage --no-share turns it off and deletes what was waiting.

Why it matters for you. Each release is now judged against the one before it on crashes, updates, refreshes and copies quitting at launch, and an app version whose copies start failing is flagged the day it happens, so a bad release can be paused, and a notice sent, before most people ever see it.

Also: the Terminal installer works again in a UTF-8 locale (it stopped with "unbound variable").

Everything that leaves your Mac: https://parallex.mandip.dev/privacy

Parallex 1.5 lets an editor copy share what should be shared, and keep what shouldn't.

Settings, not accounts. An editor copy (VS Code, VS Code Insiders, VSCodium, Cursor, Windsurf, Zed) can use the original's settings, keybindings, snippets and extensions: turn on Share settings in its Isolation section, or parallex edit <name> --share-settings. The copy's home links those to yours, so a change in either shows in both, while its sign-ins, open projects, history and everything else stay its own. What the copy had there waits beside the link and comes back when sharing stops, even if it stops while the copy runs. Guard lets the copy use exactly those, and the isolation check lists them as shared on purpose. Keep Settings Sync off in a copy that shares.

Also:

• parallex health: every instance at once, with the version of its app it runs (and whether it's staying on one), how its isolation has held since its record began, what Guard kept out, its snapshots, and what needs doing.
• The compatibility page shows what last night's lab run found.

How it works, including the trade-offs: https://parallex.mandip.dev/how-it-works

Parallex 1.4 fills in the workspace as an identity, keeps a week of days for any instance, and lets Parallex learn about apps between releases.

Who you are, at a glance. A workspace with its own identity for your tools now shows who git, the GitHub CLI, AWS, Kubernetes, Google Cloud and npm think you are there, beside who they think you are everywhere else. It's read from their settings files: nothing is run and nothing goes over the network, and tokens are never shown. On the workspace's page, and in parallex workspace persona.

A network per workspace. A workspace can have a proxy, a client's or a tunnel of your own. Chromium and Electron apps in it go through it, what its instances start gets HTTP_PROXY, HTTPS_PROXY and ALL_PROXY, and so does parallex run. Your other apps don't. Network on the workspace's page, or parallex workspace proxy.

Daily snapshots. Turn on Take one every day in an instance's Snapshots (or parallex edit <name> --daily-snapshots), and Parallex takes one a day while the instance isn't running, keeping the last seven.

Fixes for apps between releases. Parallex's signed notices can now carry what it knows about an app: where it keeps its data, the hidden folders that are its own, the ports it finds itself on. A fix for one app reaches the isolation check, Guard and copies without waiting for a release. It only ever adds, within limits (never your shared folders, Parallex's or macOS's), and it's signed like updates.

Tested every night. The compatibility lab now runs every night on GitHub against current versions of popular apps, and parallex.mandip.dev/compatibility shows what it found.

How it works, including the trade-offs: https://parallex.mandip.dev/how-it-works

Parallex 1.3 gives copies a way back from a bad update, and makes a workspace an identity for your command-line tools too.

Go back a version. A copy is built from its app, so Parallex now keeps the version it was built from: a clone, free until the app in /Applications updates, and then the only copy of that version. If an update gets in the way, the copy can go back to the version it was on and stay there while the app moves on, and move forward again when you're ready. From the new Versions section on the instance's page, or parallex versions. Staying on an old version means going without its fixes, security ones included, so it's meant for getting past a bad update.

With its data as it was. Before a copy moves to another version of its app, Parallex takes a snapshot of its data as that version left it, whether Parallex puts the refresh in place or the copy's own launcher does. Going back can take the data back too.

Workspaces as identities. Turn on a workspace's persona (Identity on its page, or parallex workspace persona <name> on) and it gets a home of its own for your command-line tools: yours, shared through links, except for what says who you are to them (.gitconfig, .config/gh, .aws, .kube, .config/gcloud, .npmrc, .netrc, and anything you add). Its git settings start as yours, so only what you set differs.

• parallex run "Client A" -- git push and parallex shell "Client A" work as the workspace, without variables like GH_TOKEN or AWS_PROFILE that would point back at you.
• Terminal and editor copies in the workspace hand its home to the shells and tools they start, so they commit and push as the workspace while your own terminal stays you.
• "Open Terminal as …" on the workspace's page opens a shell as it.
• The README covers what gh, SSH and git over HTTPS keep outside your home.

Also:

• New Instance recommends a copy for Electron apps and editors too (Slack, Discord, Obsidian, VS Code, Cursor, Claude, …): their own Dock icon, sign-in, keychain and data, beside the original. Browsers keep their profiles. A lighter instance is still one switch away.
• parallex edit --[no-]keep-previous-version, and Storage counts kept versions apart.
• A compatibility lab (Support/compat-lab.sh) makes fresh copies of apps, opens them and reports whether they run, crash or leak; it runs every night against popular apps.

How it works, including the trade-offs: https://parallex.mandip.dev/how-it-works

Parallex 1.2 turns isolation from something you check into something that's kept, and gives you a way back when an instance's data goes wrong.

Guard. A copy with its own Library can no longer open the original app's data, even by its full path: its Application Support folder, container, preferences, caches and cookies, and the hidden folders the copy keeps its own. A path saved in data copied from the original, or one the app works out for itself, now fails the way a sandbox would refuse it, and the attempt shows up in Verify Isolation under Kept out by Guard. It's on for copies built or refreshed by 1.2; turn it off in Isolation, or with parallex edit <name> --no-guard.

A record of everything a copy touches. Copies keep a record, from their first launch on, of every file of yours outside the instance that they open, create or rename (access.log in the instance folder). Verify Isolation and parallex check read it, so a check covers a copy's whole life, not only what it has open at that moment, and works while it isn't running.

Snapshots. Keep an instance's data, its own keychain included, as it is now, and go back to it later: after a sign-out you didn't want, an app update that changed your setup, or an experiment. Taking one is instant and takes no space until the data moves on (APFS clones). Restoring one keeps what the instance had as a snapshot too, so a restore can be undone. On the instance page, or parallex snapshot.

Sign-ins land in the right copy. With Parallex Links on, a sign-in started in one copy finishes in that copy, whatever you switched to in between: the copy notes the sign-in it opened, and the link coming back goes to it.

Folders a copy writes to, offered to keep. When a copy writes to a hidden folder you share (say ~/.config/acme), Isolation offers to keep that folder to the copy, and parallex check names it. parallex edit <name> --private <item> does the same.

Zed copies run beside Zed. Zed makes sure only one of it runs by listening on a fixed port on your Mac, so a copy found the original, handed over to it and quit. In a copy, that port is now one of its own. Parallex knows which apps do this, and more can be added.

Also:

• Duplicates and exports leave a copy's record, sign-in notes and snapshots behind.
• parallex storage counts snapshots apart from the instance's data.

How it works, including the trade-offs: https://parallex.mandip.dev/how-it-works

Parallex 1.1 makes own-identity copies hold up over time: they keep what you allowed them, they keep their sign-ins to themselves, and they stay current without asking you to quit.

Copies keep your permissions. Parallex now signs copies with a certificate it makes on your Mac the first time you make one, kept in a keychain of its own (not your login keychain) and locked except while signing. macOS remembers camera, microphone, screen recording and files and folders access by an app's signature, so a copy keeps them when it's refreshed after its app updates. Copies made before 1.1 ask once more after their next refresh.

A keychain of their own. New copies keep the sign-ins they store in the keychain, and their own encryption key, in a keychain of their own in their instance folder, so they never find or replace the original's, and keep them through updates. Apps that use the newer data protection keychain now work as copies too. If a copy's keychain can't be opened, the copy doesn't open rather than use yours. Copies made before 1.1 keep using your keychain until you turn on Separate keychain (Isolation, or parallex edit <name> --separate-keychain), which signs them out of what they kept there.

Refreshed even while in use. When an app updates, its copy is refreshed in the background and takes over the moment the copy quits, or the next time it opens. Settings you change in the meantime stay as you set them. parallex repair on a running copy prepares the refresh instead of refusing.

The app's own updater can't replace a copy. Sparkle could install the developer's build over a copy (giving it the original's identity and data back), and Electron apps downloaded every update in full only to reject it. Copies now have no Sparkle feed and their updaters stay off. If something replaces a copy anyway, Parallex notices, won't open it, and makes it a copy again.

Also:

• A copy's code loads the library that keeps its Library separate by itself, so it keeps working even if macOS changes how libraries can be inserted.
• Two launches at the same moment start an instance once, and an app that reuses an instance's old process number is no longer mistaken for it.
• Proxy passwords in your keychain still reach copies.

How it works, including the trade-offs: https://parallex.mandip.dev/how-it-works

Parallex 1.0: run separate instances of any Mac app side by side, each with its own accounts, settings and Dock icon. Free and open source.

New in 1.0

• How it works, in plain words. parallex.mandip.dev/how-it-works explains what Parallex does to an app so it can run twice, and what that costs you. It's also in Settings › About.
• Homebrew. You can now install with: `` brew tap mandipadk/parallex https://github.com/mandipadk/parallex brew install --cask parallex ``
• VoiceOver now reads color swatches, notices and warnings properly.

What's in Parallex

• Copies that each have their own identity, plus lightweight launchers for apps that can run with their own data folder
• Workspaces, link routing to the right instance, websites as apps, throwaway instances
• Shortcuts actions, a Focus filter, and a menu bar switcher
• Signed updates with staged rollouts, and signed notices about apps that stop working in copies
• Opt-in anonymous usage, which you can only turn on in Settings. What leaves your Mac

Parallex isn't notarized yet. The installer and the Homebrew cask handle this for you. If you download the zip yourself, run xattr -dr com.apple.quarantine /Applications/Parallex.app once.

If Parallex is useful to you, Ko-fi or GitHub Sponsors help pay for notarization.

How apps work for others. parallex.mandip.dev/compatibility lists how apps do as Parallex instances, from reports people write and anonymous usage. It's linked from New Instance.

Heads-ups from Parallex. When an app update breaks copies, Parallex can say so where you create or open an instance of it, and offer its website instead, without an update to Parallex itself. The notices are signed with Parallex's release key and checked against the key built into the app, so no one else can send them. Fetching them sends nothing about you. parallex notices shows the current ones.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Safer updates. New versions can now reach a small share of Macs first, and a bad one can be paused or pulled before most people get it. Each Mac picks a random number from 0 to 99 once, for this and nothing else; about one Mac in a hundred shares each number.

Help spot broken apps early, if you like. Settings › About › Share anonymous usage sends a short report once a week: which apps you copy and how those copies are doing, and which features you use. See What's Sent shows the whole report first (so does parallex usage). Apps are named only if they're Apple's, from the App Store or well-known; anything else is only counted. It's off unless you turn it on. What leaves your Mac

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

What leaves your Mac, in plain words. Parallex's daily update check now goes to parallex.mandip.dev instead of straight to GitHub. It says only which Parallex, which macOS and which chip, and whether it's the first check today, this week or this month. That lets active Macs be counted without knowing whose they are: there's no identifier, and addresses aren't stored. Updates are still verified against the key built into Parallex, and if the server doesn't answer, Parallex asks GitHub directly. Settings › About and the privacy page list everything that's sent, and the server's code is in the repository.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Quit when unused. An instance can quit itself, as ⌘Q would, after 15 minutes, an hour or four hours of not being in front, freeing its memory. It won't quit while playing sound, and the clock stops while your screen is locked or your Mac is asleep. Set it in an instance's Launch section, or run parallex edit <name> --quit-when-unused 60. Needs macOS 14.4 or later.

Claude instances can share MCP servers. Turn on Share MCP servers in a Claude instance's Isolation section and it uses the MCP servers set up in your other Claude, updated each time it opens. Sign-ins, chats and settings stay separate. If the instance had servers of its own, they're kept in a dated backup next to its config.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Parallex in Shortcuts. New actions: Open Instance, Quit Instance, Is Instance Running, Open Workspace and Quit Workspace, with your instances and workspaces to pick from. Siri knows "Open a workspace in Parallex".

A workspace for each Focus. In System Settings › Focus, choose a Focus, then Focus Filters › Add Filter › Parallex. Turning on Work opens your Work workspace, and can quit the instances of your other workspaces.

Quieter scroll bars. Parallex's scroll bars are the thin overlay kind now, shown only while you scroll, even with a mouse connected.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

The main window fits your screen again. In 0.16.1 and 0.17.0, once the "Enjoying Parallex?" card appeared in the sidebar, the window could grow taller than the screen and wouldn't shrink, so its bottom and the New Instance sheet went off screen. Fixed.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Throwaway instances. For a one-off client sign-in or a quick test: a throwaway goes to the Trash with its data once it has been opened and quits. Use an instance's ⋯ menu › New Throwaway Copy (it opens right away), turn on Throwaway in its Launch section, or run parallex create <app> --throwaway. Only a real run counts: an instance that fails to start, or one being restarted, stays.

Memory at a glance. Each running instance shows how much memory it uses, helpers included (for websites, WebKit's page processes too). You'll see it in the sidebar, the instance's header, the menu bar panel, and a workspace's total.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Hide a copy from the Dock. For copies you keep running in the background, like a second chat app: no Dock icon or ⌘-Tab entry. Open it from its menu bar icon or shortcut. Turn it on in an instance's Launch section, or run parallex edit <name> --hide-from-dock.

Bringing a copy forward reopens its window. The menu bar icon, shortcut and Open button now act like clicking the app in the Dock, so an app whose window you closed opens one again.

Memory at a glance, from Terminal. parallex list shows how much memory each running instance uses, helpers included.

Support Parallex. Parallex is free and made by a student. If it helps you, there's GitHub Sponsors and Ko-fi. The first goal is signing Parallex with Apple, so it opens without "Open Anyway".

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Websites as apps. Teams, Outlook, a second WhatsApp or Gmail account: any site becomes an app of its own, with its own Dock icon, sign-in, cookies and notifications. Its unread count shows on the Dock icon, sign-in pop-ups stay in the app, and links to other sites open in your browser. Choose New Instance › A website, or run parallex create --web teams.microsoft.com.

Careful with what a page can do. A website app hands links to other apps (mail, calls, meetings) only from the page itself. It asks before opening unfamiliar kinds of links, and never opens files, network shares or system settings. The camera and microphone go to the site itself; anything embedded in the page has to ask.

Say how an app works. An instance's ⋯ menu › Report How It Works… (or parallex report <name>) opens a GitHub report with the app, its version and how the instance was made already filled in, so the next person knows what to expect. It never includes instance names or paths, and nothing is sent until you submit it.

Copies stay current. Own-identity copies now record which Parallex built them, so improvements to how copies start reach existing copies too. Each is rebuilt once, the next time it isn't running.

Download Parallex.dmg below, update from Parallex › Check for Updates, or run curl -fsSL https://parallex.mandip.dev/install | sh.

Clearer menu bar panel. Hovering the arrow next to an instance now says what it does: it opens the original app (for example, the real Claude while Claude Work is running).

Install from Terminal. curl -fsSL https://parallex.mandip.dev/install | sh installs the latest Parallex with no "Open Anyway" step. It checks the download against the checksum published with each release.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Instances in the menu bar. Turn on Show in the menu bar in an instance's Launch section to get its icon up top. A click opens it, brings it forward, or hides it when it's in front, just like its shortcut. Right-click for Open, Quit and Show in Parallex.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

A whole workspace at once. New Workspace (⇧⌘N) now makes everything in one go. Name it, pick a color, tick the instances you already have and the apps you want new copies of. Parallex makes each copy the way that app works best, in the workspace's color, and groups them.

Workspaces have a color. A workspace can have a color, and Color Its Instances gives it to their window outlines and badges, so Work looks like Work everywhere.

To open a workspace with a Focus, add a Shortcuts automation for that Focus that opens its parallex://workspace/… link. The link is shown at the bottom of each workspace.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Links follow you. A link you click in a work instance can now open in your work browser, and a client's instance in the client's. Choose a browser for each workspace: an app like Safari, a Chrome, Brave or Edge profile, or a browser instance. Then turn on Open web links in the right browser in Settings › Links.

Sites that always open in one place. Rules send a site, and its subdomains, to the browser you pick: northwind.com to the client's browser, github.com to Chrome.

Everything else opens in the browser you had before, exactly as it did. To do this, Parallex Links becomes your default browser; macOS asks you to confirm, and turning it off gives links straight back.

From the command line: parallex links web on, parallex workspace browser Work "Chrome/Work", parallex links rule add northwind.com "Brave Browser".

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Hidden folders stay separate. Apps like VS Code, Cursor and Zed keep things in your home folder too (~/.vscode, ~/.config/zed). New copies now keep those folders to themselves, while everything else in your home still looks like your own. The terminal and tools inside a copy keep your real home.

Its own key. A new copy of an Electron or Chromium app (Obsidian, Slack, Discord and others) keeps its own encryption key in your keychain, instead of asking for the original's or clashing with it.

An honest catalog. Before you make a copy, Parallex says what it can't do (iCloud, push notifications, Sign in with Apple, universal links). Apps whose system extension (VPN, driver) only works in the original get their own section. Apps whose instance passed an isolation check on this Mac are marked Verified here.

Fixes

• VS Code-family instances with longer names start again.
• Zoom can be copied.
• Removing a copy also clears its helper apps from macOS.
• Storage never offers a copy's own data as "unused".
• parallex create Code finds Visual Studio Code by the name the catalog shows.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

A copy never quietly uses the original's data. Before opening a copy with its own Library, Parallex now checks, in a few milliseconds, that macOS will let it keep that Library separate. If a future macOS stops allowing it, the copy doesn't open. You get told why, and Parallex offers Try Again or Use as Plain Copy (sharing the original's data, only if you choose it).

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Separation you can trust. The isolation check now also confirms that the part of Parallex that keeps a copy's data its own actually loaded into it. If macOS ever stops loading it, Parallex tells you, with a Restart button, instead of letting the copy quietly use the original's data.

Removed copies are really gone. Removing or renaming an instance now also removes the old app from Launch Services, so it doesn't keep showing up in Open With menus or catch sign-in links.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Isolation checked for you. About 45 seconds after an instance opens, Parallex looks at the files it has open. If a copy is using the original app's data, you get a notification and a banner on the instance with Check Again. It runs once per launch, at low priority. You can turn it off in Settings › General.

Download Parallex.dmg below, or update from Parallex › Check for Updates.

Improvements

• Copies that won't run are called out. Some App Store apps check their purchase receipt, or refuse a changed signature, and quit the moment they open as their own copy. Parallex now notices when that happens and explains it on the instance, with Open Again and the fix (turn off Own identity). It also remembers the app, so the New Instance list warns you before you make another copy of it.
• Finishing a removal. macOS leaves an app's sandbox containers for you to delete. When you remove a copy, Parallex now says so and shows them in Finder.

Two WhatsApps, two accounts

App Store apps like WhatsApp keep their sign-in and messages in "shared containers", which are keyed by the app's group rather than by the app itself. Until now, an own-identity copy still shared those with the original. Now:

• The copy gets its own shared containers.
• The copy's helper services get identities of their own.
• A WhatsApp copy starts at the welcome screen, signed out, while your original keeps its account. Nothing from the original's containers is opened.

This is on by default for new copies ("Separate shared data" in the instance). Copies you made earlier keep working as they did until you turn it on.

Also

• Removing a copy lists every sandbox container macOS leaves for you to delete (its own and its services').

A calmer window

• The sidebar, the main area and the toolbar are now one frosted surface, instead of three different shades of gray.
• The classic full-height sidebar is back. 0.11.1's floating sidebar is gone.
• The toolbar shows the Parallex wordmark instead of empty space.
• Content no longer scrolls underneath the toolbar.

Fixes

• The Liquid Glass look is back on macOS 26. The app had been built with a mark that made macOS draw it in its older style. You'd see an opaque sidebar and toolbar in mismatched shades. It now gets the floating glass sidebar and toolbar again.
• The sidebar's New Instance bar no longer overlaps the list; rows fade under it as you scroll.

Start from the original's data

A copy with its own Library starts empty. Now it can start as a copy of the original app instead:

• It copies the original's settings, library, cookies and web storage, config folder and preferences, all as instant APFS clones.
• From there, the two go their own ways.
• Find it as Start from <App>'s data in the instance's Isolation section, or run parallex copy-data <name>.

Export and import

• Export… in an instance's menu, or parallex export <name>, saves its settings and data as one .parallex file.
• Double-click the file, or run parallex import, to recreate the instance on any Mac that has the app.
• Imported files are treated as untrusted. The app comes from your Mac, and extra launch arguments and environment are left out unless you ask for them.

Install

Parallex updates itself: choose Update when it offers this version. For a new install, download Parallex.dmg below.

Workspaces

• Group the instances you use together, like Work with Claude, Slack and a browser, and Personal with the rest.
• Open a whole workspace with one click, from the menu bar or the switcher, or with its own keyboard shortcut.
• It can optionally hide the instances that aren't part of it.
• From Terminal: parallex workspace create Work --add "Claude Work", then parallex workspace open Work.

Open from anywhere

parallex:// links open an instance or a workspace from Shortcuts, Raycast, scripts or a bookmark:

• parallex://open/Claude%20Work
• parallex://workspace/Work

Copy Link in an instance's menu gives you its link.

Duplicate

• Make another instance with the same settings.
• It can start fresh, or begin with a copy of the original instance's data (an APFS clone, so it's instant).

Install

Parallex updates itself: choose Update when it offers this version. For a new install, download Parallex.dmg below.

Every copy gets its own Library

On macOS, native apps keep their data in ~/Library: sign-ins, Application Support, caches, cookies and web storage. Until now, a copy of a native app could still share some of that with the original.

• Own-identity copies of apps that aren't sandboxed now keep their entire Library inside the instance. Examples are Spotify, Zed, IINA, VLC, Ghostty and Obsidian.
• Your documents, desktop, downloads and dotfiles stay shared, just as they are now.
• It's on by default for new copies. Copies you made before 0.9 keep working as they did; turn on Separate Library in the instance whenever you like.
• Verify Isolation now flags anything such a copy leaves in your real Library.

We tested this on Spotify, Zed, IINA, VLC, Obsidian and Ghostty: none of them wrote anything to the original app's data.

Also in this release

• Removing a copy takes its preferences and saved window state with it to the Trash.
• Parallex won't rebuild an instance app that belongs to a different Parallex library.
• parallex edit <name> --separate-library / --no-separate-library.

Install

Parallex 0.8 updates itself: choose Update when it offers this version. For a new install, download Parallex.dmg below.

A shortcut for every instance

• Give any instance its own global keyboard shortcut in its Launch settings, or with parallex edit <name> --shortcut ctrl+opt+1.
• Press it to open the instance, bring it forward, or hide it when it's already in front.
• In the switcher (⌃⌥Space), ⌘1 to ⌘9 jump straight to an instance.

Notifications only when they matter

• A running own-identity copy whose app has updated, with Restart Now.
• An instance whose app is gone, and an automatic repair that didn't work.
• Each arrives once per change. You can turn them off in Settings › General.

Updates, built in

• Parallex checks for new versions once a day and updates itself in one click.
• Updates are verified against the Parallex release key before they're installed.
• What's New shows once after each update.
• The parallex command now ships inside the app. Settings › About › Install links it onto your PATH.

Sturdier

• Instances can be named in any language: 日本語, Русский, and emoji all work.
• Two instances whose names differ only in punctuation no longer collide.
• Creating several instances at once, from the app and the command line together, is safe.
• The sidebar shows "Not opened yet" for new instances instead of a tiny size.

Install

Download Parallex.dmg below and drag Parallex to Applications. Releases aren't notarized yet, so the first time you open it, go to System Settings › Privacy & Security and choose Open Anyway.