What's new

Every release of Parallex

Every version, newest first. Parallex keeps itself up to date, so these are for a new Mac or going back a version. Each app archive is signed with the key built into Parallex, and the checksum is what the Terminal installer checks.

Parallex 3.7.2

Parallex is free for now. Everything in Parallex, Pro included, is free on as many Macs as you like, for now. There's no license to buy and no trial to count down.

  • The license screen, Settings › License and parallex license say "Parallex is free for now. Everything is open, Pro included.", with no end date.
  • Buy, Upgrade to Pro and trial prompts are gone while Parallex is free: on the license screen, in Settings, in the sidebar, in first run and beside Pro features. parallex license trial and parallex license upgrade say there's nothing to buy.
  • A new Mac doesn't start a trial while Parallex is free. If it's offline the first time it opens, the trial starts as before, so nothing is ever locked.
  • If you bought a license, it stays valid: activating a Mac, finding your key and your account work as they did.
  • Parallex checks that it's still free every few hours while it's open, sending only its name and version.

Disk image 40.7 MBInstaller package 39.7 MBApp archive 39.7 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KBSBOM 14 KBSBOM manifest 1 KBSBOM signature 1 KB

Parallex 3.7.1

Apps' own updates no longer get stuck behind your instances. Apps like Claude download an update and install it once every copy of the app has quit. An instance that runs the app as it is counts as the app, so while one was open the update never went in, and choosing the app's "Relaunch to update" from inside it did nothing. Parallex now notices an update that's waiting, says so on the instance's page, in the menu bar, in Doctor and in a notification (once per version), and installs it when you ask. Before anything quits, it checks that the download is that app, complete, and signed by the app's own developer, and it won't install anything else. Then it asks the app and its instances to quit (they can ask to save first), puts the new version in place in one step, moves the old one to the Trash, refreshes your copies of the app, and opens what was open again. If something won't quit, it asks before forcing it. If Parallex is interrupted partway, the next start finishes the install or puts the app back as it was. From the command line: parallex vendor-update and parallex vendor-update install Claude.

A copy of Claude no longer says it can't reach the update server. A copy's own updater is kept quiet because Parallex refreshes the copy when the app updates. Claude asks its updater in a way that read that quiet answer as a broken server, so Check for Updates in a copy showed an error. It now hears it's up to date.

Disk image 40.7 MBInstaller package 39.7 MBApp archive 39.7 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KBSBOM 14 KBSBOM manifest 1 KBSBOM signature 1 KB

Parallex 3.7.0

Parallex 3.7 is about accountability: an audit log kept on your Mac, a list of every address Parallex contacts, and a bill of materials with every release.

An audit log, kept on your Mac.

Parallex now keeps a record of what's done with it that matters for security: instances made, removed, rebuilt, imported and exported, changes to how an instance is kept apart, repairs and restores, moves to another Mac, fleets and agent runs (and whether each was sealed), your organization's settings, license changes, updates and backups. It stays on your Mac and is never sent anywhere. It never holds secrets, keys or anything inside an instance.

Each entry is chained to the one before it, so Parallex can tell when an entry was changed, removed or moved, or the log was cut short. Settings › Audit shows the log and whether it's intact, and exports it; in Terminal, parallex audit show, parallex audit verify and parallex audit export --since 7d do the same. Doctor checks it too, and a diagnostics file includes its last entries (without names, unless you include them).

Each entry also goes to macOS's own log, so an organization's device management or security tools can collect it. Organizations can keep the audit log on, or turn it off, with the new AuditLog managed preference. It's on unless you turn it off, and turning it off or on is an entry of its own.

Every address Parallex contacts, in one list.

parallex network lists every address Parallex can contact, what each request carries and how to turn it off. The same list is on parallex.mandip.dev/trust. The privacy page now also names three small requests it had left out, each of which sends only Parallex's name and version: the current prices, whether licensing is paused when a license can't be confirmed, and Doctor's check that the server answers. An old usage report sender that nothing used any more is gone. Parallex's notices about apps now follow update checks: when automatic checks are off, in Settings › About or by your organization, they're fetched only when you choose Check for Updates.

A bill of materials with every release.

Each release now comes with an SBOM (CycloneDX): Parallex's own programs and libraries with each file's checksum, the one open source package it's built with and its license, the third-party material it carries, and the tools that built it. It's signed with the same key as the release. The new page parallex.mandip.dev/trust explains how releases are signed and notarized, how an update proves it's Parallex's before it's installed, and how to check a release yourself.

Disk image 40.1 MBInstaller package 39.1 MBApp archive 39.1 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KBSBOM 14 KBSBOM manifest 1 KBSBOM signature 1 KB

Parallex 3.6.1

Fixes from the second security audit's remaining findings: web copies, links, screen sharing, Describe, Carry and the flight recorder.

  • Fixes.
  • Bringing a workspace over with Carry no longer sends its copies' traffic through the proxy the file names unless you keep it. It's listed with the other settings that share more, off by default (--keep-settings on the command line).
  • The flight recorder's record lives in the copy's own folder, which the copy can write. Parallex now notes how the record was at each check, in its own folder. If the record shrank, was replaced or had lines changed by anything but the recorder, the check says so, shows no green shield and doesn't count as verifying the app. parallex check says so too, and its JSON has recordChangedSince.
  • A copy now counts as running with Parallex's library only when it has loaded Parallex's own library file. Another file with the same name no longer counts.
  • Guard now keeps a copy out of the original app's data however the path is spelled: upper or lower case in any script (not only A to Z), and accented letters composed either way.
  • A new copy no longer takes on the preferences and saved window state left by an earlier copy that had its identifier, such as one removed while it was open. They go to the Trash first.
  • Links that open an instance or a workspace now ask first when they come from Finder (a .webloc file) or are clicked in a terminal, as they already did from a browser. After you cancel twice in a row, such links stop asking for a minute, then longer, up to an hour. The license link waits the same way.
  • Settings › General has a new option to show only the front instance's color in the menu bar, not its name, since the menu bar shows in every screen share.
  • Parallex Links' "Which copy?" question and its error alerts, and Parallex's question before opening a copy from a link, now ask macOS to keep them out of screen sharing and recordings, as the outlines and the switcher do. Some recording tools may not honor this.
  • Web copies: only the page in the copy's own window can post notifications, not a pop-up or a frame inside the page. A notification from a site the copy has wandered off to says which site it's from, and the window shows that site's name while you're there. Page dialogs now appear as sheets on the window, say where they're from when it isn't the copy's own site, never come from an embedded frame of another site, and from the second one on can be stopped for that page. Links into other apps (meetings, mail, calls) from another site ask first.
  • Explain Copy shows the facts from the copy's settings alongside Apple Intelligence's summary, and the copy's name is no longer given to the model, so words in a name can't pass for facts.
  • Describe: a throwaway or own Mac ID applies only to the app your words ask it of. "Slack for work, a throwaway Chrome" no longer makes Slack a throwaway.
  • Building a setup joins only the workspaces its preview showed. If a workspace with the same name was made since, nothing is made until you look at it again, and a name that happens to be another workspace's id never joins that one. parallex setup build --out checks for name clashes in that folder, not /Applications.
  • Parallex's MCP server answers batched requests only for clients on the protocol version that has them, as one reply, and refuses request ids that aren't a string or a number.
  • Decoy credentials for agents point at an endpoint whose name no longer says it's a decoy.
  • Upgrading to Pro from Parallex now shows which license will be upgraded, by the end of its key, before checkout.

Disk image 39.4 MBInstaller package 38.3 MBApp archive 38.3 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KB

Parallex 3.6.0

Integrity. Parallex can now check everything it keeps for you, repair what has drifted, and back up your setup on its own, so a crash, a renamed home folder or an older Parallex can't leave things in a muddle.

  • Check and repair. Each instance's page has a new Integrity section. It checks that the app is there and signed as Parallex built it, with the right identity and launch settings, that macOS knows about it, that its folder is yours and not writable by others, that links in its home don't point into another instance or a home folder that's gone, and that its snapshots and kept versions are whole. Each problem is one plain sentence with a Repair button, and Repair All fixes the safe ones. Doctor (Help › Collect Diagnostics…) runs the same checks across everything, including workspaces, folder bindings and folders left without an instance. From the command line: parallex verify --all, and --repair to fix.
  • Repairs never delete. Before any repair, Parallex backs up its settings. Anything that would remove something, like a half-taken snapshot or a folder with no instance, goes to the Trash or is set aside, and only after you say yes. A repair that's cut short is finished the next time Parallex opens.
  • Backups of your setup. Parallex now keeps backups of its own settings: your instances' records and icons, workspaces, folder bindings, link rules, your choices in Settings, and each terminal identity's git settings. It takes one a day (keeping a week), one before every repair, update of its files and restore, and one whenever you ask. Settings › Backups lists them and restores one, and so does parallex backup. Backups never include an app's data, sign-ins, keychains, your license or tokens; credentials in git settings are taken out first.
  • Safe across versions. Every file Parallex keeps now says which version of its layout it is. A newer Parallex brings older files up to date after backing them up, and an older Parallex, such as one you went back to, reads a newer one's files but never writes over them, and says so.
  • Moved home folders. An instance built before your home folder was renamed, or before your account moved to another Mac, used to fail to repair. It's now noticed and rebuilt for where Parallex's folder is now, and its links are pointed at the right places.
  • Fixes.
  • Doctor no longer says every copy has an older launcher right after it was repaired.
  • Duplicating an instance with its data is finished properly if Parallex quits partway, and the copy can't be opened half made.
  • Making several instances at once no longer waits on each other while they build.
  • Agent runs stopped with Control-C, or before their command started, stop cleanly, and a stopped run's log watcher is ended too.
  • Sealed agent caches are kept under 5 GB, and parallex storage shows them.
  • Damaged agent snapshots are listed and can go to the Trash.

Disk image 39.1 MBInstaller package 38.1 MBApp archive 38.1 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KB

Parallex 3.5.0

Accessible. Parallex now works well with VoiceOver, from the keyboard alone, and with the display settings in System Settings › Accessibility.

  • Text size. macOS doesn't let apps follow a system text size, so Parallex has its own: Settings › General › Text size, with Standard, Larger and Largest. It applies to every window, the switcher and the menu bar panel, and layouts grow with it instead of cutting text off.
  • VoiceOver hears what changes. Steps in New Instance, onboarding, Carry, Describe your setup and the update window are announced as they change, and so are results, errors that appear, "Copied" and the switcher's short confirmations, which now stay up longer while VoiceOver is on.
  • The switcher speaks. It's announced when it opens, the row you move to with the arrows is read with its place in the list, results are read when you stop typing, and ⌘↩ alternatives are in the VoiceOver actions menu. Shortcuts are read as words ("Command-3"), not symbols. Home, End, Control-N and Control-P move too.
  • VoiceOver and ⌃⌥Space. VoiceOver uses Control-Option, so with VoiceOver on, onboarding asks you to choose other keys for the switcher instead of teaching ⌃⌥Space, and Settings says why.
  • Every action within reach. Sidebar rows, menu bar copies and setup plans offer their right-click and hover actions in the VoiceOver actions menu. Buttons that appeared only under the pointer also appear when they have keyboard focus. Repeated buttons say what they're for (a snapshot's Restore names the snapshot, a folder's Remove names the folder). Icon-only buttons have names, and the menu bar icon says which copy is in front.
  • Keyboard. Escape closes or cancels every sheet and window, Return does the main thing, and Import Instance… (⇧⌘I) and What Parallex Can Do (⌘?) have shortcuts. Escape no longer throws away unapplied changes on a copy's page.
  • Reduce Motion turns every slide, spring and bounce into a short fade. Demos in What Parallex Can Do play a few times and then rest; hover to play one again.
  • Reduce Transparency makes the window, the switcher, panels and buttons solid.
  • Increase Contrast firms up the edges of groups, fields and cards, and deepens the accent and the quiet text.
  • Easier to read. Secondary text, the accent and the green, orange and red used for states now read at WCAG AA contrast (4.5:1) in light and dark. Buttons filled with the accent keep white text readable in dark mode too. Name tags on a copy's windows pick black or white text to suit the copy's color.
  • Color is never the only signal. Warnings and problems say so to VoiceOver, diff lines in Fleet say whether they were added or removed, and selected choices are marked as selected.
  • Ready for other languages. The app's words are in a string catalog, with plurals and lists formatted by the system, and numbers, money, percentages, durations and dates by formatters. Parallex is in English only for now, and the parallex command stays in English.

Disk image 37.4 MBInstaller package 36.4 MBApp archive 36.4 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KB

Parallex 3.4.0

Faster, and lighter when idle. Parallex now stays quick with many instances, big data folders and long days. The numbers below are from our tests with 50 and 200 instances on a Mac with an M5 chip and 16 GB of memory; yours depend on your Mac and your apps.

  • Idle really is idle. With the window open behind other windows, Parallex kept playing the little snapshot demo on an instance's page, using a good part of a CPU core. Demos now pause whenever their window can't be seen. With 200 instances and the window in the background, Parallex used about 43% of a core before and now uses under 2%, with about 1 wakeup a second instead of over 100.
  • The window opens sooner. It no longer waits for every instance's icon before it shows. Icons are fetched in the background, and an icon that isn't in yet shows the generic app icon for a moment. With 200 instances, the first opening after a while went from about 3.7 seconds to under 1 second, and later ones are about a third faster.
  • Scrolling the sidebar no longer stalls while icons load: a screenful took up to a second the first time with 200 instances, and now takes well under a tenth of a second.
  • No more pauses when apps open or quit. Parallex used to look at all your instances on its main thread whenever any app on your Mac opened or quit. It now looks in the background, and the look itself is about 8 times quicker: an instance's record or app details that haven't changed aren't read again, and the list of running apps is asked for once rather than once for each copy.
  • The switcher (⌃⌥Space) opens about a third faster with 200 instances.
  • The menu bar panel opens about 5 times faster with a long list of instances, because only the rows you scroll to are drawn.
  • Snapshots of big data folders. Snapshots, restores, kept app versions and new copies of an app are now cloned folder by folder in one step. Taking a snapshot of a folder with 20,000 files (666 MB) went from 2.4 seconds to 0.13 seconds, and restoring it from 5.4 seconds to about 1 second.
  • Making a copy of a big app (Slack, about 550 MB) is about 10% quicker. Most of the rest is macOS signing the copy, which Parallex can't skip.
  • parallex list and parallex doctor are about 4 and 3 times faster with 200 instances.
  • Verify Isolation reads a busy copy's full record (12 MB) about 3 times faster.
  • The usage menu reads large Claude Code and Codex logs about twice as fast the first time (160 MB in under half a second). After that it reads only what's new, as before.
  • Starting an instance takes as long as before: Parallex adds about 9 ms to a wrapper and 25 to 36 ms to a copy with its own Library.

Disk image 36.1 MBInstaller package 35.1 MBApp archive 35.1 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KB

Parallex 3.3.1

Parallex 3.3.1 fixes what a third security audit found, and adds a second, offline check to every update: besides the server's signature, each release now carries a manifest signed with Parallex's release key, so not even a compromised server can offer a different download. It's also the first release with a signed installer package for IT teams.

This release closes what a third review of Parallex found, most of it in Fleet, importing, diagnostics and updates, and finishes a set of smaller fixes from earlier reviews.

Safer by default.

  • Fleet review. What an agent writes (its commands, file names, commit messages, errors) is printed by parallex fleet and parallex agent report with any control characters written out, so it can't change your terminal, set your clipboard or redraw the table. In the Fleet window, characters that change how a line reads without being seen (direction overrides, zero-width ones) are shown as ⟨U+202E⟩ and the file is marked, long lines wrap instead of hiding their end, and links and files made executable are labelled as such. A lane that adds a link leading out of your repository isn't merged unless you say so, and a lane whose work doesn't start from the commit the fleet started from isn't used at all.
  • Updates. Every release now comes with a small manifest of its version, size and checksum, signed with the same key as the app itself when the release is made. Parallex checks the download against it, stops a download that runs past its size, and no longer depends on the update server for any of it. Releases withdrawn later are named in a list signed with that key too, which Parallex remembers, so a withdrawn version is never installed whatever the server offers.
  • Importing an instance file. A file's size and number of files are checked before anything is unpacked, so a small file that would unpack to fill your disk is refused when it's opened. The question before importing names the app the instance would really be made from on this Mac, and shows the file's name cleaned. It no longer says which website a file was downloaded from: that can be set by whoever sends the file. It says only whether the file came from the internet.
  • Diagnostics. The diagnostics file now also takes out secrets written as JSON ("token": "…"), in web addresses (?code=, &sig=, signed storage links), cookies, Slack and Discord webhook addresses, Google, GitLab, Hugging Face and Stripe webhook keys, and variables like PRIVATE_KEY. Instance names are taken out as web addresses write them too, and so is this Mac's network name.
  • Organizations' license keys. A sealed agent can no longer read what an organization's configuration profile sets, its license key included.
  • Upgrades to Pro. The page after paying for an upgrade, and the email that follows, no longer show the license key: the email goes to the license's own address. Signed in, Parallex opens only Stripe's own checkout page.
  • Decoy credentials. Turning them off takes them away only between runs, and never through a link an agent put in their place, so a removal can never reach your own credential files.
  • MCP. Inside an agent run, listing workspaces shows only that agent, and an unknown name no longer lists every other agent. Snapshots taken over MCP are limited per server and their labels are cleaned, and throwaways already open anywhere count toward the limit.

Crash-safe.

  • Carry. A copy that moved to another Mac goes to the Trash only once it has been due for a day with the clock not set back meanwhile, so a clock set a week ahead by mistake sends nothing to the Trash. parallex carry open and parallex carry receive say what a file brings before bringing it over and ask first (add --yes when there's no terminal to ask in). Reading a large Carry file with many small parts is much faster.
  • A refresh of a copy that was put in place just before Parallex or the Mac stopped is picked up properly next time, instead of being built again.
  • An import that fails after its app was built takes that app away too.
  • parallex create --force into another folder takes the instance's old app away, so there's never a second app with its identity.
  • Making an instance waits a limited time for another one being made, then says so, instead of waiting for ever.
  • Usage reports that were taken but whose answer was lost are sent again exactly as they were, and counted once.
  • A fleet another process ended is never put back to running by its supervisor.
  • A snapshot whose record can't be read is listed as damaged by parallex snapshot list and can be deleted. The list of Carry files brought over is never written over when it can't be read.

Fixes.

  • Crash records left in Parallex's folder are read only when they're what Parallex itself writes, so nothing else can put text in Diagnostics or the usage report, and a damaged one can't stall the checkup.
  • A keychain prompt left open no longer holds a sealed agent's sign-in import for ever.
  • A Codex session started days ago and still going counts toward today's use.
  • Instance folder names write letters like Ł, Ø, Æ and ı, and full-width letters, in plain Latin instead of dropping them.
  • What's New remembers the newest version you've seen, even after going back to an older Parallex.

For IT teams. Each release now includes Parallex-<version>.pkg, signed with Parallex's Developer ID Installer certificate and notarized, for deploying with device management.

Disk image 35.9 MBInstaller package 34.9 MBApp archive 34.9 MBChecksum 1 KBSignature 1 KBManifest 1 KBManifest signature 1 KB

Parallex 3.3.0

Parallex 3.3 is about running Parallex for real work: you can see what's going on when something goes wrong, IT teams can deploy and manage it, and your license, Carry and fleets are as crash-safe as instances became in 3.2.

Diagnostics.

  • Diagnostics. Help › Collect Diagnostics… (also in Settings › About) checks how Parallex is doing on this Mac. Anything that needs a look comes first, with what's wrong and the one thing to do, and a button when Parallex can put it right itself: repairing copies with an older launcher, putting back the library copies need for their own Library, finishing work a crash cut short, or starting normally after safe mode.
  • The checkup looks at the signing identity, the launcher and libraries in each copy, wrappers and copies that are missing or behind, settings files that couldn't be read, interrupted work, safe mode, disk space, Parallex's keychains, whether updates can be reached and are signed, the license, sealed agent runs and recent crashes. Looking changes nothing. From Terminal: parallex doctor, and parallex doctor --fix.
  • A diagnostics file to pass on. The same window makes a zip with Parallex's version, your Mac's model and macOS, a summary of your instances (their kinds, settings and health), the last day of Parallex's own log, interrupted work, crashes of Parallex's own processes, the license's state and the checkup. You see every file in full before saving it, and it's never sent. Your home folder's path, email addresses, license keys, tokens and passwords, and your account and computer names are taken out first, and instance names too unless you tick Include instance names. From Terminal: parallex diagnose -o <file.zip>.
  • Crashes of every part of Parallex are noted. The command line, the MCP server, the launcher, Parallex Links and Parallex Web now note their own crashes, not just the app. They're included in the anonymous usage report only while you share it, and always in a diagnostics file you make.
  • Parallex keeps a log. Everything Parallex does is noted in macOS's log under com.parallex.app, with names and paths kept private.
  • Clearer errors. Messages that used to show raw system errors ("The operation couldn't be completed…") now say what happened and what to do, like "The disk is full. Free some space and try again." The alert's title no longer says only "Something went wrong".

For teams and IT.

  • Managed settings. An organization can set Parallex's settings with a configuration profile from its device management, for com.parallex.app. A setting the profile sets wins over the one chosen on the Mac, in the app and in the parallex command, and shows as "Managed by your organization", locked. Settings › About lists everything that's managed, and so does the new parallex policy command.
  • What can be managed: the anonymous usage report; update checks, whether Parallex updates itself at all (for teams that ship updates themselves), and how many days a new release waits before it's offered; which apps copies may be made of, or may not; Carry, Fleet, Describe your setup and setup links; agent workspaces, and whether every agent run must be sealed; a proxy every workspace goes through; and a license key.
  • Licenses for many Macs. With a license key in the profile, Parallex adds the Mac to that license on first launch, without asking, when a seat is free. It never frees another Mac: when every seat is taken it tries again a day later, and Settings › License says so. A Mac with a license of its own keeps it. The key is never written to a log.
  • Scripted installs: parallex license activate --key-file <path> reads the key from a file, so it isn't in the command's arguments, and never prints it.
  • Copies of blocked apps aren't made in any way: New Instance, Duplicate, setup links, Carry or importing an instance file. Copies made before stay.
  • A page for IT teams: Parallex in managed fleets covers deploying Parallex, every managed setting, privacy permissions (Parallex asks for none by default), and, honestly, what copies look like to EDR and Santa: they're re-signed on each Mac and load Parallex's own library, so some security tools flag them. The schema, a Jamf Pro custom schema and a sample profile are there too.

Crash-safe, everywhere.

  • Your license's state is changed by one thing at a time. The app, the parallex command, MCP servers and update checks no longer undo each other's changes.
  • A license refresh that was already on its way when you activated a key, or freed this Mac, no longer brings back the license you just replaced.
  • A locked keychain, or a keychain prompt you turned down, no longer signs this Mac out of its Parallex account. Parallex tries again, then leaves everything as it was. Saving your key replaces it in place, so a failure can't leave you with no key saved. If macOS won't let Parallex keep the key, the license screen says so.
  • Free This Mac no longer forgets your license when a proxy or a captive portal answers instead of Parallex's server.
  • If the license file is lost in a power cut, the one before it is put back. When the license is gone or damaged and your key is saved on this Mac, the license screen offers to use it.
  • A clock set a month ahead by mistake, then put right while you're offline, no longer leaves your license looking expired.
  • Sending a copy with Carry marks it as moved before its data is read, so it can't be opened partway through or end up running on both Macs. A send that fails or is cut short is undone: the copy opens here again and no half-written file is left behind.
  • Bringing a Carry file over is all or nothing. If one copy can't be made, the file can be brought over again. Sign-ins the keychain wouldn't take can be tried again with Try the Sign-Ins Again.
  • A fleet whose supervisor went away can now be finished with Finish in the app, or parallex fleet finish. Its lanes' work is committed, checked and compared as usual. Deleting an agent also clears its key and sign-ins from its fleets' lanes, and fleets that ended over 30 days ago (beyond the newest 20) are tidied away. Their branches stay.
  • An agent run's network log stops growing at 8 MB; the requests after that are still counted by host. Its list of processes stays small, however many a long build starts.
  • The app no longer freezes for a moment every few seconds when you have many instances, an app on a disk that's gone, or agent runs left open. Pausing and resuming agents no longer freezes the window either.
  • Exporting, removing and copying the original app's data wait for a copy that's just opening. An export no longer includes Parallex's own leftovers.
  • A copy whose original app was deleted still opens from Parallex.
  • Rewinding or deleting an agent waits while something one of its runs left running (a dev server, say) is still going.
  • A daily snapshot isn't taken when the disk is nearly full. One that failed isn't tried again every time an app quits.
  • Fixed: a name too long for a file failed late, with a confusing message.
  • Fixed: the app could quit when no screen was connected for a moment.
  • Fixed: the MCP server could crash when its client went away mid-answer.
  • Fixed: picking a fleet lane again after a pick was cut short failed instead of finishing.
  • Fixed: the app could overwrite what the command line had noted in its suggestions file.
  • Fixed: update checks could overlap and count your Mac twice.

Disk image 35.7 MBApp archive 34.6 MBChecksum 1 KBSignature 1 KB

Parallex 3.2.1

Parallex 3.2.1 fixes what a second, independent audit found in 3.0 to 3.2: two serious problems (a Fleet merge check that letter case could fool, and credential files in a received terminal identity that weren't filtered) and a set of smaller ones.

Safer by default.

  • Fleet merges. A lane can no longer slip a git hook, filter or hook-manager file past the merge check by spelling its name differently (.HUSKY/, .GitAttributes), and config files your repository includes count too. A lane whose files would land on top of each other, or on a file you already have, because a Mac doesn't tell letter case or accents apart, isn't merged.
  • Carry's terminal identity. AWS credentials, gh and hub sign-ins, .netrc and git's stored credentials now keep only keys, tokens and who you are. Settings that could start a program, like credential_process or .netrc macros, are dropped, and the review lists exactly what was kept from each file.
  • Bringing copies over. A Carry file or a .parallex file can't plant kept app versions, snapshots, a keychain or markers, however their names are spelled. A copy brought over always gets a keychain of its own with a password made on this Mac. Its add-ons and app preferences come only if you keep them in the review.
  • Updates. Every answer from the update server must be signed, including "nothing to offer", so nothing between your Mac and the server can hold back updates or change what's offered. Answers dated ahead of your clock are refused, and links in release notes open only Parallex's own pages.
  • Links. Among programs that aren't apps, only Parallex's own command line (checked by its signature) opens copies without asking. Parallex Links never passes on a link as trusted, and it never takes over Parallex's own links. The question names the copy or workspace that would actually open, and nothing is asked for one that doesn't exist.
  • Agents and MCP. Text an agent wrote (commands, commit messages, lane status) now reaches your assistant cleaned and clearly marked as data, not instructions.

Crash-safe.

  • A copy whose work was cut short (a restore or a move to another version) doesn't open until Parallex has finished or undone that work. Opening it brings Parallex up to do it.
  • Interrupted work is matched to the exact instance it was about, so it can never remove or change a newer instance that took the same name.
  • A restore that's undone after the copy was opened keeps what the copy made, beside its data, and says where.
  • Work that can't be put right is tried three times, then set aside with a clear message, so it can't stall every start or command. The command line and the MCP server don't redo it while Parallex is starting in safe mode.
  • Finishing an interrupted rebuild waits while the copy is being opened, and a setting saved while a copy installs its refresh is no longer lost.

Fixes.

  • The isolation check reads its record line by line, so one odd byte no longer hides every leak, and very large or sparse files can't slow Parallex down or crash it. Odd spellings of the original app's data (extra slashes, .., different case) are noted and shown as what they are.
  • Command-line lookups no longer guess: an exact name always wins, a name that doesn't exist is never matched to another instance, names that differ only in case are reported as ambiguous, and remove, copy-data, snapshot restore and carry send need the exact name or slug.
  • A very large "quit when unused" value from a file can no longer crash Parallex; it's limited to a week.
  • Very long names get shorter folder names, and a copy always keeps its own encryption-key names. Names are cleaned of invisible and direction-changing characters, and renaming onto another instance's name is refused.
  • A new instance never quietly takes over data kept by remove --keep-data.
  • Daily snapshots carry on after the clock is set back, the monthly recap uses Gregorian months whatever calendar your Mac uses, and Carry's words accept a Turkish dotted capital İ.
  • Smaller hardening: more inherited settings are stripped before a copy starts, a file's language and time-zone settings must look like what they are, parallex check escapes what it prints and quotes the command it suggests, sign-in tracking ignores malformed requests, and a web copy grants the camera and microphone only on its own port, never to other sites on a shared platform or to other names on this Mac.

Disk image 33.4 MBApp archive 32.4 MBChecksum 1 KBSignature 1 KB

Parallex 3.2.0

Parallex 3.2 makes everything it does safe to interrupt. Crashes, quitting, sleep and full disks no longer leave an instance, an agent or your settings half changed, and running the app and the command line at the same time no longer loses changes.

  • If Parallex quits, crashes or your Mac loses power in the middle of making, rebuilding or removing an instance, moving a copy to another version with its data, restoring a snapshot, rewinding an agent or pausing one, it finishes or undoes it the next time it opens (or the next time you use the parallex command).
  • While that kind of work is under way, your Mac doesn't go to sleep on its own, and Parallex asks before it quits. You can still quit right away; it's put right next time.
  • Rebuilding an instance never leaves you without a working app: the new one is built in full first, then swapped in in one step. A wrapper that's gone missing is rebuilt along with the rest of routine upkeep.
  • A copy that's opened while it's being rebuilt is left as it is, instead of being moved out from under itself.
  • Refreshing a copy no longer puts a full copy of the old one in your Trash each time.
  • Changing a setting while an instance is being rebuilt, or from the app and the command line at the same time, no longer loses one of the changes.
  • A settings file Parallex can't read is kept as it is, never written over: an instance whose record is damaged stays in the list (from its last good version), workspaces and folder bindings a newer Parallex wrote are kept, and nothing a newer version added is lost when this one saves.
  • Going back to an earlier version of an app with its data: if the data can't be put back, the copy stays on the version its data is from. A copy also won't move to a new version until its data has been kept to go back to.
  • The agent kill switch stops everything even when the disk is full, and Pause All carries on past an agent that can't be paused.
  • Only one Parallex runs at a time. If Parallex keeps failing as it starts, the next start leaves out the automatic work (rebuilding and opening instances) until it has run cleanly for a minute.
  • Tools Parallex runs can no longer make it hang: one that stops responding is stopped after a while.
  • Fixed: opening a Carry file whose identity settings had a line that was only "=" made Parallex quit.
  • Fixed: sending a copy with Carry could make Parallex quit on a very deeply nested file.
  • Fixed: two fleets started in the same second could get in each other's way.
  • What's unpacked from a Carry file you didn't finish bringing over is removed the next time Parallex opens.

Disk image 33.0 MBApp archive 32.0 MBChecksum 1 KBSignature 1 KB

Parallex 3.1.0

Parallex 3.1 is a security release. It closes the gaps found by two independent audits of the app and the license server, and adds a public security policy. Nothing you use changes how it works.

  • Nothing can be slipped into a copy as it opens. A copy's launcher now drops every inherited DYLD_ variable and the runtime hooks apps honour (NODE_OPTIONS, ELECTRON_RUN_AS_NODE, PYTHONSTARTUP and the like) before the app starts, and passes on only Parallex's own libraries. Programs a copy starts get only Parallex's libraries too.
  • Instance files bring in less on their own. Importing a .parallex file now says when it holds add-ons (extensions, plugins, a browser user.js) or app preferences, which run when the copy opens, and leaves them out unless you tick the box (or pass --keep-code). The dialog says which site the file was downloaded from.
  • An imported copy is as apart as a new one. Settings in the file that make it share more than a new copy go back to a new copy's unless you keep them (--keep-settings), nothing in them can reach outside the copy's own folder, and the copy is always built from the app on this Mac, never from an app version stored in the file.
  • Kept extras are vetted. With --keep-extras, only language, time zone and colour variables come in from a file, each launch option is asked about, and options that open a debugger or load code never come in. The same applies to Carry.
  • Web copies ask before a neighbour uses your camera. A web copy gives the camera and microphone without asking only to its own site and that site's own subdomains. Another site on the same hosting domain (github.io, vercel.app, netlify.app and so on) has to ask.
  • Links from a browser ask first. A parallex:// link that opens a copy or a workspace now asks before acting when it comes from a browser or another app, rather than from Parallex, the command line, Shortcuts, Spotlight, a terminal or a launcher. A page can't keep putting the license question in front of you either.
  • Upgrade to Pro never puts your key in an address. Parallex now asks the license server for a link that works once, for 10 minutes, and opens the upgrade checkout with that, so your key stays out of your browser's history.
  • Signed update answers. The update server now signs what it offers, and Parallex checks it: the release, its download and its notes must match, an answer older than one Parallex already had is refused, and only Parallex's own release page is ever opened from an update.
  • Names stay out of screen shares. The outline and name tag Parallex draws on a copy's windows, the switcher and its messages are now kept out of screen sharing and recordings, so a client's name doesn't show up in a call.
  • The license clock can't be wound back past a token. A license is never judged at a time before its token was issued, even with the clock set back, and a clock that's behind no longer costs you the license; Parallex just checks in with the server.
  • This Mac's signing key is kept closer. Only Apple's command-line tools may use it without asking, its keychain's password must be a file only you can read, and it's kept out of backups. The README now says plainly that anything already running as you can still act as you, a copy included.
  • Smaller fixes. A release build of Parallex ignores the development settings that point it at other binaries or another update server. Links can't name a path outside the instances folder. The bash folder-binding hook no longer uses a guessable file in /tmp when TMPDIR isn't set. Removing a copy only ever moves its own app-group folders to the Trash.

On the server.

  • Founding requests: one that names an email with a founding licence now emails that address a link to confirm the Mac, rather than joining it on the email's say-so.
  • Reports: made-up reports can't pause a release or mark an app as broken; that takes reports from several different networks.
  • Sign-in emails: each kind of sign-in gets its own hourly budget, so a flood of one can't block real customers.
  • Pages: every page on parallex.mandip.dev is served with modern security headers.

Reporting a security problem. There's now a security policy at parallex.mandip.dev/security, and a security.txt for researchers.

Disk image 32.4 MBApp archive 31.3 MBChecksum 1 KBSignature 1 KB

Parallex 3.0.0

Parallex 3.0 is about who you're being on your Mac right now, and everything following from that. You can describe your setup in a sentence, move a signed-in copy to your other Mac, give one task to several sealed agents at once, and share a setup as a link. Every Parallex licence covers 3.0, founding Pro included; Carry and Fleet come with Pro.

Describe your setup. Say what you juggle in a sentence, like "Slack, Chrome and Claude for Acme and Globex, plus my personal WhatsApp", and Parallex suggests the workspaces and copies, using the apps on this Mac. Apple's model reads it on your Mac, and nothing is sent anywhere. The model only decides which apps go in which workspace. Parallex decides how each copy is kept apart, sets AI apps up from their templates, and names and colors everything. You watch the plan fill in, rename or leave out anything, and nothing is made until you press Build Everything. Describe is in New Instance, in the first run's "What do you juggle?", and in the switcher.

The switcher understands requests too. Type "open my acme stuff" or "make another slack for globex" and Ask Parallex turns it into one of the switcher's own actions, shown as a row you run with ↩. It never offers anything that removes, rewinds or stops. A copy's Isolation panel can also explain what it shares in a few plain sentences, worked out from its settings. Describe and Ask Parallex need macOS 26 or later with Apple Intelligence on; elsewhere they aren't shown.

Move a copy to another Mac (Pro). Move to Another Mac… on a copy's page, or a workspace's for all its copies, its settings and its terminal identity, writes it to one encrypted file.

  • Opening it on the other Mac. On the other Mac, File › Receive a Copy… shows a pairing code to paste here (Universal Clipboard carries it across). A file made for that code opens only there, and only once. You can protect the file with 12 words instead, to keep it or move it later.
  • What arrives. The copy is built there from that Mac's own app, with its data and settings and the sign-ins it keeps in its own keychain, which are written again so the copy there can read them.
  • It's a move, not a clone. Once the file is written, the copy here doesn't open. Its data stays seven days in case you change your mind (Bring It Back), then goes to the Trash. A copy's own Mac ID only ever travels with a move.
  • What can't move. Some apps will still ask you to sign in again on the new Mac: sign-ins a server ties to one device, Chrome's device-bound sessions and keys in the Secure Enclave can't move. A workspace's terminal identity brings who you are (your git name and email, and sign-ins for git, GitHub, AWS and npm), not settings that run programs or send your tools elsewhere, and a received copy starts with a new copy's isolation unless you keep what the review lists. Agent workspaces don't move in this version.
  • From the command line: parallex carry send, receive, open and back.

Fleet (Pro). Give one task to several agents at once and keep the best answer.

  • How it runs. A fleet runs the same task in two to six sealed lanes side by side, Claude Code or Codex, from one agent workspace or several. Each lane works in a git worktree and branch of its own, with its own copy of its agent's home and sign-in.
  • While it runs. You see what each lane is doing, its steps, time and turns, and the cost Claude Code reports (an estimate, not a bill).
  • When the lanes finish. Parallex commits each lane's work on its branch and runs your check command (like npm test) inside each lane's seal. It shows the diffs side by side and suggests one: the lane that passed the check, then the smallest diff, then the fastest.
  • Picking one. Pick This One squash-merges that lane into the branch you started from, as one commit of yours. Nothing is merged until you pick. Parallex's own git never runs hooks, filters or drivers on a lane's work, so a lane that changes .gitattributes, .gitmodules, hook settings or a hook tool's config isn't merged until you've looked and said so; in repositories that use Git LFS, a lane's files are LFS pointers.
  • What a lane can reach. Its worktree, its own home and the tools it needs. It can't reach your home, the other lanes, your branches or your git objects. Pause All, Stop and the kill switch cover every lane.
  • Cost and limits. Lanes use your agents' sign-ins, so a real fleet spends from those accounts. A 16 GB Mac runs 3 lanes by default.
  • Getting started. Start one from an agent's page, or with parallex fleet run "<task>" --agent <name> --lanes 3 --check "npm test".

Share a setup as a link. Share Setup… on a workspace or a copy puts a link on the clipboard.

  • What the link carries: which apps get a copy, what each is called, the workspaces and their colors, and how each copy is kept apart.
  • What it never carries: data, sign-ins, paths, environment, launch arguments or scripts.
  • Opening a link. It shows the same preview as Describe. Apps you don't have are marked "Not on this Mac", and nothing is made until you build.
  • On the website. On parallex.mandip.dev/r, the setup stays in the part of the link browsers never send, and the page reads it in your browser.

Also.

  • Safer .parallex imports. Importing a .parallex file now removes any link that would lead outside the copy, including one that passes through another link, and gives the copy a new Mac ID.
  • Third-party notices. Parallex now includes them for the BIP-39 word list and the parts of Codex's sandbox policy it adapts.

Disk image 31.8 MBApp archive 30.9 MBChecksum 1 KBSignature 1 KB

Parallex 2.9.0

Parallex 2.9 is a small polish and reliability release. It makes names you can edit look editable, says problems in fewer words, and checks a report about Firefox copies.

Names you can rename where they are. A copy's name under Appearance, and a workspace's name at the top of its page, show a light rounded outline when you point at them and a firmer one while you type, so it's clear you can change them right there. The outline sits just outside the name in room that's always kept, so nothing moves when it appears.

Problems in fewer words. When a copy has some of the original app's files open, when macOS didn't load what keeps its data separate, or when it quits right after it opens, its page says so in one short sentence, with what to do on the line under it. The buttons are the same as before: Check Again, Restart and Open Again.

A refused shortcut says why in its row. When you record a shortcut that can't be used, because another copy already opens with it or it has no ⌃ or ⌥, the reason now shows in the Keyboard shortcut row's own line, the way every other setting explains itself, instead of under the recorder. This is on a copy's page and on a workspace's.

Firefox copies. A report of Firefox copies crashing in Firefox's crash helper couldn't be reproduced. With Firefox 157.0.1 on macOS 27, a fresh copy, both as an instance and as its own copy, started, reopened and quit cleanly, and when a tab or Firefox itself crashed, the crash helper wrote its crash report as it should. The crash helper problem fixed in 1.9.0 is still fixed. If a Firefox copy still crashes for you, Something's Off… on its page sends what's needed to look into it.

What didn't change. No setting was added or removed, and nothing about how copies are made or kept separate changed.

Disk image 25.6 MBApp archive 24.6 MBChecksum 1 KBSignature 1 KB

Parallex 2.8.0

Parallex 2.8 redesigns the settings pages: a copy's, a workspace's and an agent workspace's. Every setting that was there is still there and works as before; what changed is how they're laid out and explained.

One row per setting. Settings sit in grouped rows on the system's grouped background, in sections. Each row is the setting's name and at most one short line. The whole explanation, word for word as before, is behind an ⓘ that shows when you point at the row or tab to it, and opens beside the row. Launch is rows too: open when Parallex starts, the menu bar icon, the shortcut, quit when unused, Throwaway and Hide from the Dock, each findable on its own.

Why something can't change. A row that can't be changed right now says why in place of its line, for example "Quit Claude Work to reset its Mac ID." A Pro setting your license doesn't include says Pro beside its name and offers Upgrade to Pro (or Get Pro) where the switch would be; one that's already on can still be turned off.

At a glance. A copy's Isolation section opens with two short lists, what it keeps to itself and what it shares with the original app, and the last check of what it really used, with Verify beside it. The lists follow the switches below them, including changes you haven't applied yet. A sealed agent's page shows what its runs can and can't reach the same way, from the same words parallex agent show uses, with its network in one line. On an agent's page, pointing at an item shows its full description.

The rest of the pages, in the same style. Problems with a copy, notices from Parallex, the license note and the Apply bar; the Website section of a web copy; hidden folders a copy writes to, with Keep to This Instance and Share Again; the version a copy is staying on; the empty states that teach; and, on an agent's page, the folders you gave it, what the seal refused in its last run, its browser and decoy, its runs with the pages it asked to open, the MCP commands and the offer to seal an agent made before 2.7.

Plain words for status. Running, Paused and Not running are plain words in the sidebar, on an agent's page and in the menu bar, instead of colored capsules. A throwaway copy says Throwaway the same way.

What didn't change. No setting was added or removed, and none changed what it does. Show Me still points at the same controls, changes that rebuild a copy still wait for Apply, and confirmations ask the same questions.

Disk image 25.5 MBApp archive 24.5 MBChecksum 1 KBSignature 1 KB

Parallex 2.7.0

Parallex 2.7 seals agent workspaces: with Pro, each agent run goes inside a macOS sandbox Parallex writes for that run. It's a macOS sandbox, not a VM, and this release says plainly what that does and doesn't mean.

Sealed agent runs. parallex agent run starts a sealed agent through macOS's own sandbox (/usr/bin/sandbox-exec) with a profile written for the run. It can read and write the folder you run it in and its own home, and read its signing key, the tools it needs (nvm, Claude Code, ~/.local/bin, Bun, cargo and rustup, Go, pyenv, Volta, a Homebrew in your home) and any folder you grant it. It can't read the rest of your home folder (documents, other repositories, dotfiles, ~/.ssh, ~/.aws, ~/.config/gh, ~/.npmrc, cargo's credentials.toml), your keychain, Parallex's own folder or other programs' temporary files, and it can't write anywhere else, your tools, apps and Homebrew included. macOS services are limited to a short allowlist, taken from Codex's own sandbox policy, so it can't open apps, read your clipboard or reach launchd; Apple Events, preferences, and signals to or details of your other programs are refused. Its network goes through its proxy or nowhere: macOS refuses any other connection, and name lookups, except with Local servers on (below). New agents are sealed; an agent made before asks once, on its page, and nothing changes until you say so.

What it can reach. An agent's page lists it in plain rows, with Grant Folder… (read only, or read and write) and a Local servers switch (on unless the agent is offline): with it on, the agent reaches anything listening on your Mac without its proxy, a local proxy that fetches onward included, and servers it starts can be reached from your network unless your firewall blocks them. parallex agent set <name> --sealed on|off --grant <path>[:rw] --ungrant <path> --local-servers on|off does the same, and parallex agent show says what it can and can't reach. After a run, what the seal refused is on its page and in parallex agent report, from the system log while the run went on (best effort: macOS doesn't log every refusal).

Git, sign-ins and its tools. In the folder it works in, .git/hooks and .git/config stay read only (a worktree's shared git folder too, which it's given so it can commit), it can't make or move a .git there, and its own git runs with no hooks. Turning Sealed on copies the agent's own Claude Code sign-in from the keychain into its home (macOS may ask once), and Codex's when it kept one there; never yours. Codex runs with -c sandbox_mode="danger-full-access" and Claude Code with its own /sandbox off, because macOS's sandbox can't be nested; the seal around them is stricter about what can be read. Each run has a temporary folder of its own (removed afterwards), caches of its own, and Parallex's MCP server answers from the run's own status.

Pages it asks to open. A sealed agent's BROWSER never opens anything: your browser isn't behind its proxy and has your sign-ins. The run's terminal says "<agent> asks to open <the whole address>", and the run in Parallex lists it with an Open button, marked when it's outside the agent's network rule. Opening it is your choice; sign-ins that show a link or a code, like Claude Code's /login and codex login --device-auth, work that way.

Its limits. It isn't a VM: it runs as you on your Mac's kernel, so a bug in macOS's sandbox could let it out. Apple marks the sandbox tool deprecated, so Parallex tries it before every sealed run and refuses the run, never runs it unsealed, if it doesn't work. It can read anything you grant it, your installed tools' whole trees (not your credentials), and files outside your home that any program can, and with Local servers on it reaches anything listening on your Mac. What it writes into your repository runs as you when you run it, so review its work before you run it. parallex agent check --sealed starts a real sealed run on your Mac and tries each way out from inside it; it needs no network.

Also. The switcher's answers about the switcher, snapshots, practice, versions, the coach and the recap open the new pages on parallex.mandip.dev. The usage report goes out with the first update check after an update, so a Mac is counted on its new version the same day, and parallex usage answers quickly; started as Parallex.app/Contents/MacOS/parallex, the app now says where the command-line tool is instead of opening a second copy of itself.

Disk image 25.4 MBApp archive 24.3 MBChecksum 1 KBSignature 1 KB

Parallex 2.6.0

Parallex 2.6 lets the switcher do things as well as find them, gives snapshots a safe place to practice, and, if you want it, notices patterns and looks back on the month. All of it is worked out on your Mac.

The switcher does things. Type in ⌃⌥Space and, under the copies it finds, there's a short list of things to do: New Copy of Slack…, Open a workspace, Snapshot or Rewind a copy, Pause Agent Runs, Show Usage, Discover, Settings, Show Welcome Again and Make a Practice Copy. A plain app name still lists its copies first. Questions work too: "how do I bind a folder" opens the Discover entry that answers it. ↩ runs the selected row, and ⌘↩ does the other thing it offers (Show in Parallex for a copy, the site's guide for an answer), shown as you hold ⌘. An action that comes with Pro says so with a quiet "Pro", and on a Mac without Pro it explains what it is and how to get it rather than refusing.

A practice copy. Make a Practice Copy (in the Help menu, the switcher, Discover's Snapshots entry, and any copy's empty Snapshots list) makes a throwaway instance of TextEdit with a short note in its own data. Its page walks through taking a snapshot, changing or deleting the note, rewinding, and opening the note to see it back, and each step ticks itself when it actually happens. Anyone can make one and practice on it, with or without a license; the exception covers the practice copy's own snapshots and nothing else. It never counts as one of your copies, and usage sharing counts it only as "practice". Apple's apps can't be own-identity copies, so it's an instance of TextEdit that opens its note, not a second TextEdit with a Dock icon of its own.

A monthly recap. At the start of each month, a card under the page's header puts last month in plain numbers: "September: 4 copies, 61 switches, 2 rewinds, 3 agent runs." See the Month shows them as a short table. It's counted on this Mac from Parallex's own records (kept in recap.json), it's not part of usage sharing, and it takes the day's place in the tips' budget, so it never comes on top of a tip. Settings › General turns it off or shows it any time.

The coach, if you want it. Off until you turn it on in Settings › General. Then, at most once a week, it may suggest something from a pattern it notices: an app you keep quitting and reopening (a second copy might do), two copies you always open together (a workspace), a busy Claude, ChatGPT, Codex or Cursor copy with no recent snapshot (daily snapshots), a bound folder whose workspace has no Terminal identity, or a copy you haven't opened in a month. Each card says why with the fact it noticed, offers one thing to do, Not Now and Don't Suggest This Again. It looks only at apps that have a copy starting and quitting, and at Parallex's own records; never at windows, other apps' data, what you type or browser history. What the Coach Looks At lists every signal, what it notes is counted by day and kept 30 days in coach.json, and Clear forgets it. It shares the tips' budget and stays quiet in your first day with it, with a full-screen app in front, while your screen is mirrored and during a call.

A Mac ID of a copy's own. A new Pro privacy setting on a copy's page, off until you turn it on: Give this copy its own Mac ID. Apps in the copy that read your Mac's hardware ID see one of its own instead. It's made once, kept with the copy and never changes by itself; Reset makes a new one after saying what that does. Some apps use the ID to recognise devices, so changing it can sign the copy out. It needs a copy with its own Library, and Parallex never applies it to itself.

Also. Discover has entries for the practice copy, the coach, the recap and a copy's own Mac ID, each with its small demo, and What's New shows this release the same way.

Disk image 24.1 MBApp archive 23.0 MBChecksum 1 KBSignature 1 KB

Parallex 2.5.0

Parallex 2.5 shows everything it can do, with your own apps, and mentions a feature only at the moment it would help.

What Parallex can do. Discover, at the top of the sidebar (and in the menu bar panel and the Help menu), lists every feature by the job it does: keeping accounts apart, moving faster, staying safe, AI side by side, and agents. Each has a tiny live demo drawn from the apps on your Mac (your Claude splitting into two, a copy's window being outlined in its color, a snapshot timeline going back a day), a line on what it does, and a plain word for where you stand: "You use this", "Try it", or "Pro". Show Me goes straight to the switch for it and points at it once with a ring that fades. The features that were hard to find have a home here too: clean windows, throwaways, Shortcuts and Focus, the parallex command, the MCP server, Guard and keeping copies up to date. Demos run only while they're on screen, and stay still with Reduce Motion.

A tip when it would help. When something you do suggests a feature, Parallex mentions it once, under the copy or workspace it's about: a shortcut for a copy you open several times a day, a workspace when you have two copies of one app, going back a version right after an app you copied updates, Open Terminal as a workspace with its own identity, and a few more. Tips share one budget with the rest of Parallex's suggestions, at most one a day and three a week, and never appear in the first ten minutes after Parallex opens, while a camera or microphone is in use, with a full-screen app in front, or while your screen is mirrored. Using the feature puts its tip away for good, and Don't Suggest This means it. Settings › General has one switch for all of them. What's been suggested is kept in tips.json in Parallex's folder and never sent anywhere.

What's New, without the window. Parallex no longer opens a window after it updates. A quiet "New in 2.5" line in the menu bar panel and at the foot of the sidebar opens a page where each change has a small demo and a Try It, and the line goes once you've looked. Settings › About and the Help menu open it any time.

The trial, plainly. The license window and Settings › License show the 14 days as a timeline: everything today, one reminder in Parallex on day 11, your choice on day 14, and copies that keep opening after. Nothing is charged automatically. On day 11 a single card at the foot of the sidebar says how many days are left; close it and it's gone. On the last two days, a short card lists the Pro features this Mac actually used, with See Both.

Empty pages that show the way. Snapshots, versions, a workspace with nothing in it yet, bound folders and an agent's runs each say what they're for in a sentence, with a small demo and the one thing to do.

A shorter usage list. With several Claude Code and Codex accounts, the ones with nothing today fold into one line in the menu bar ("3 more, nothing today"); click it to see them.

Disk image 22.3 MBApp archive 21.3 MBChecksum 1 KBSignature 1 KB

Parallex 2.4.0

Parallex 2.4 has a new first run that ends with a real copy of an app you already use, and a short first-week checklist that ticks itself as you go.

A first run in four steps. The app you're likeliest to want twice (Claude, ChatGPT, Slack, WhatsApp, Chrome, then the rest) splits into Work and Personal, with your own icon. One question, "What do you juggle?", is answered for you from the apps on your Mac and picks three first copies put as jobs, like "Claude for work" or "Slack for a client". Make It makes the copy right there. Open Both opens the original and the copy side by side, shows where each keeps its data, and checks while the copy opens that it never touches the original's data. Then you press ⌃⌥Space yourself, and the switcher opens. The last step has a few settings and a plain Share or Don't Share for anonymous counts, with nothing picked for you. The 14-day trial starts on its own, with no button and no card; if you used Parallex before it cost anything, Claim is right there instead. Settings › General › Show Welcome walks through it again.

Your first week. Six things worth doing, picked by your answer (sharing your Claude setup and usage per account for AI accounts, a bound folder and an agent workspace for code), sit at the foot of the sidebar and in the menu bar panel. The first two are already done. They tick on what actually happens, never on a click: a copy opened twice counts as signed in, since Parallex never looks inside your apps. When all six are done, the list becomes a one-line note for a few days, then goes. Closing it is for good. It's kept in first-week.json in Parallex's folder and never sent anywhere.

A next step after every new copy. A copy's last page suggests one thing worth doing next, like sharing your Claude setup, a workspace for two Slacks, or a shortcut of its own.

Another shortcut for the switcher. If ⌃⌥Space is taken (macOS's "Select next source in Input menu" can use it), the first run says so and lets you record another, and Settings › General can change it any time.

Skipping setup still sets things up. Skip, at any step, now leaves Parallex opening at login, sending sign-in links to the right copy (from your first copy on) and outlining copies' windows. Nothing is shared unless you choose Share, What's New no longer appears for someone who just installed Parallex, and the usage question no longer pops up after skipping.

Menu bar check. If the camera notch or macOS's menu bar settings hide Parallex's icon, the first run says where it is and how to bring it back.

Disk image 20.9 MBApp archive 19.8 MBChecksum 1 KBSignature 1 KB

Parallex 2.3.0

Parallex 2.3 gives your AI agents an identity of their own: agent workspaces, and a Parallex MCP server. Both are in Parallex Pro, and the free trial includes them.

Agent workspaces (Pro). parallex agent new reviewer, or New Agent Workspace in the sidebar, makes a workspace an agent runs as. Its commits carry "reviewer (agent)" and the email you give it, signed with an SSH key made for it (parallex agent key prints it, to add on GitHub as a signing key). parallex agent github opens GitHub's new token page filled in as far as GitHub allows, and signs the agent's own gh in with the token you paste; it's kept in the agent's gh config and never sent to Parallex. Its git, gh, Claude Code and Codex use its own identity: its git uses none of your SSH keys, and without a token of its own its tools get a placeholder GitHub refuses. It isn't a sandbox: an agent runs as you, so it can read your files and keychain if it tries, and plain ssh, scp or rsync in a run can still use your keys.

A snapshot before every run, and a report after. parallex agent run reviewer --in ~/code/api -- claude -p "review PR 12" runs as the agent after an APFS snapshot of its own state (never your repositories), and parallex agent rewind puts it back. parallex agent report lists the files its Claude Code and Codex read and edited, the commands they ran, the hosts it asked for and the commits it made, built from its own logs. It isn't a full audit of your Mac.

Network rules. Each agent is online, limited to some hosts, or offline, kept by a proxy Parallex runs on your Mac for each run. git, gh, curl, npm, pip, Claude Code and Codex keep to it, like other tools that use a proxy when told to; a program that ignores it can go around it. HTTPS stays encrypted: the proxy sees host names, not contents.

The kill switch. parallex agent pause --all, the menu bar, or a shortcut you set in Settings stops the processes Parallex has seen an agent's runs start, including ones that detached, and cuts their network. A process started and detached in between, or an app opened through macOS, can slip past it.

Decoy credentials (optional). Fake AWS-style credentials in an agent's home: if its transcript shows it reaching for them, or its proxy sees them used, the report says so and a notification tells you.

A Parallex MCP server (Pro). claude mcp add parallex -- parallex mcp (or Codex's config.toml) lets Claude Code and Codex list your workspaces, open a clean browser or a throwaway copy of an app, snapshot an agent, read its reports and ask who they're running as. Rewinding asks you first in clients that support it. Inside an agent run, browsers and throwaways keep to the agent's network rule, and snapshots and rewinds aren't offered. It redacts the secrets it recognises.

Updates arrive sooner. Parallex now checks for updates every few hours and when your Mac wakes, instead of once a day.

Disk image 20.0 MBApp archive 19.0 MBChecksum 1 KBSignature 1 KB

Parallex 2.2.0

Parallex 2.2 puts your AI apps side by side, and gives Parallex Pro its first features of its own.

Claude, ChatGPT, Codex and Cursor, a second account. New Instance now starts with a template for each of these you have installed. Each makes its own copy, the way that app needs it: its own sign-in, chats and connectors, and notifications under its own name. Make as many as you like. In a Claude copy, Claude Code keeps that account's sign-in too. In Terminal: parallex create --template claude.

One setup, every Claude (Pro). Turn on Share my Claude setup on a Claude or Codex instance, or on a workspace, and that account uses your CLAUDE.md, rules, skills, agents, commands, output styles and plugins (for Codex, your AGENTS.md, prompts and skills). Its sign-in, history, settings and MCP servers stay its own, and Guard keeps the rest of your ~/.claude out of the copy.

Usage for each account (Pro). The menu bar shows today and the 5-hour window for each Claude Code and Codex account, yours and each copy's or workspace's, with when the window resets. It's an estimate from the logs already on this Mac: nothing is sent or fetched, and chats in the desktop apps aren't counted. It never switches accounts for you.

Folders that switch your identity (Pro). parallex bind ~/work Acme, add the shell hook from Settings › Folders, and inside ~/work your git, gh, cloud sign-ins, Claude Code and Codex are Acme's. Leave the folder and yours are back. It works in zsh, bash and fish.

Also: parallex license upgrade opens the upgrade from Terminal, and the trial includes everything in Pro.

Disk image 17.2 MBApp archive 16.1 MBChecksum 1 KBSignature 1 KB

Parallex 2.1.0

Sign in with your email. Bought Parallex? Sign in with the email you bought with, in Settings › License or on the license screen, and type the 6-digit code from the email (or click its link). Your license goes on this Mac without typing a key. With more than one license, you pick which one this Mac uses. It's optional: keys keep working as before, and the trial needs no account. In Terminal, parallex account sign-in --email you@example.com does the same.

Your account page. Find My Key is now your account page, at parallex.mandip.dev/licence/portal. Sign in with a code and see your licenses, show a key, free a Mac, sign out a Mac, or delete the account. Deleting it signs out every Mac and removes the account; your keys keep working, and you can choose to take your email off your licenses too.

Buying while signed in fills your email in at checkout, and the purchase goes on this Mac once it's paid.

Disk image 16.2 MBApp archive 15.1 MBChecksum 1 KBSignature 1 KB

Parallex 2.0.1

Ask for founding Pro in the app. Used Parallex up to October 4, but Parallex can't tell from your Mac (versions before 1.7 never kept what it checks)? Open Settings › License and ask, with your email. It's checked by hand, usually within a day, and Pro turns on by itself once it's approved; the key is emailed to you too. In Terminal, parallex license founding --email you@example.com does the same, and parallex license shows how it stands.

A clearer price. The launch price shows on its own, with the list price beside it, and how many are left underneath.

Fixed. A complimentary license that has reached its last day now says so plainly. Your instances keep opening.

Disk image 15.4 MBApp archive 14.4 MBChecksum 1 KBSignature 1 KB

Parallex 2.0.0

Parallex 2.0 is here. Parallex is now a one-time purchase: $4.99 for up to 3 Macs, or Parallex Pro, $9.99 for up to 5, with every 2.x update included. For launch, Parallex is $2.99 for the first 30 buyers. Each Mac gets 14 days of everything first, with no card and no account. Settings › License shows your license and its Macs.

Pro is free if you were here first. Used Parallex up to October 4? Parallex Pro is yours, free, on up to 5 Macs: open Settings › License and claim it, any time until January 31, 2027. If Parallex can't tell that your Mac used it (versions before 1.7 never sent what it checks), write to hello@mandip.dev and you'll get Pro.

Your copies keep opening. Every instance you've made keeps working, with a license or without one, and nothing is deleted. Without a license you can still open, export and remove them; making and changing them needs the trial or a license.

Notarized. Parallex is signed with a Developer ID and notarized by Apple, and checks its own signature when it opens.

Disk image 15.3 MBApp archive 14.2 MBChecksum 1 KBSignature 1 KB

Parallex 1.9.4

ChatGPT as its own copy. The new ChatGPT app is built with Electron but renames Electron's framework, so Parallex didn't recognise it and made ChatGPT a plain instance. The nightly lab found those reaching the original ChatGPT's data, while a copy of ChatGPT stayed clean. A new ChatGPT instance is now its own copy, with its own sign-in and data. If you made a ChatGPT instance before, turn on Own identity in its settings, or make it again.

Settings links to the community. The GitHub link in Settings now opens https://github.com/mandipadk/parallex-community, where compatibility reports and questions go.

Disk image 13.4 MBApp archive 12.3 MBChecksum 1 KBSignature 1 KB

Parallex 1.9.3

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

Disk image 13.4 MBApp archive 12.3 MBChecksum 1 KBSignature 1 KB

Parallex 1.9.2

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.

Disk image 13.2 MBApp archive 12.2 MBChecksum 1 KBSignature 1 KB

Parallex 1.9.1

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.

Disk image 13.2 MBApp archive 12.2 MBChecksum 1 KBSignature 1 KB

Parallex 1.9.0

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.

Disk image 13.2 MBApp archive 12.2 MBChecksum 1 KBSignature 1 KB

Parallex 1.8.1

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.

Disk image 13.1 MBApp archive 12.1 MBChecksum 1 KBSignature 1 KB

Parallex 1.8.0

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

Disk image 13.1 MBApp archive 12.1 MBChecksum 1 KBSignature 1 KB

Parallex 1.7.0

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

Disk image 12.7 MBApp archive 11.8 MBChecksum 1 KBSignature 1 KB

Parallex 1.6.0

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

Disk image 12.7 MBApp archive 11.8 MBChecksum 1 KBSignature 1 KB

Parallex 1.5.0

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

Disk image 12.4 MBApp archive 11.3 MBChecksum 1 KBSignature 1 KB

Parallex 1.4.0

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

Disk image 12.3 MBApp archive 11.2 MBChecksum 1 KBSignature 1 KB

Parallex 1.3.0

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

Disk image 12.0 MBApp archive 10.9 MBChecksum 1 KBSignature 1 KB

Parallex 1.2.0

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

Disk image 11.5 MBApp archive 10.4 MBChecksum 1 KBSignature 1 KB

Parallex 1.1.0

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

Disk image 10.8 MBApp archive 9.8 MBChecksum 1 KBSignature 1 KB

Parallex 1.0.0

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.

Disk image 10.4 MBApp archive 9.4 MBChecksum 1 KBSignature 1 KB

Parallex 0.22.0

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.

Disk image 10.4 MBApp archive 9.4 MBChecksum 1 KBSignature 1 KB

Parallex 0.21.0

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.

Disk image 10.2 MBApp archive 9.1 MBChecksum 1 KBSignature 1 KB

Parallex 0.20.0

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.

Disk image 10.0 MBApp archive 8.9 MBChecksum 1 KBSignature 1 KB

Parallex 0.19.0

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.

Disk image 9.9 MBApp archive 8.9 MBChecksum 1 KBSignature 1 KB

Parallex 0.18.0

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.

Disk image 9.7 MBApp archive 8.7 MBChecksum 1 KBSignature 1 KB

Parallex 0.17.1

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.

Disk image 9.6 MBApp archive 8.6 MBChecksum 1 KBSignature 1 KB

Parallex 0.17.0

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.

Disk image 9.6 MBApp archive 8.6 MBChecksum 1 KBSignature 1 KB

Parallex 0.16.1

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.

Disk image 9.5 MBApp archive 8.4 MBChecksum 1 KBSignature 1 KB

Parallex 0.16.0

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.

Disk image 9.4 MBApp archive 8.3 MBChecksum 1 KBSignature 1 KB

Parallex 0.15.2

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.

Disk image 8.9 MBApp archive 7.8 MBChecksum 1 KBSignature 1 KB

Parallex 0.15.1

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.

Disk image 8.9 MBApp archive 7.8 MBChecksum 1 KBSignature 1 KB

Parallex 0.15.0

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.

Disk image 8.9 MBApp archive 7.8 MBSignature 1 KB

Parallex 0.14.0

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.

Disk image 8.7 MBApp archive 7.6 MBSignature 1 KB

Parallex 0.13.0

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.

Disk image 8.2 MBApp archive 7.1 MBSignature 1 KB

Parallex 0.12.4

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.

Disk image 7.8 MBApp archive 6.8 MBSignature 1 KB

Parallex 0.12.3

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.

Disk image 7.8 MBApp archive 6.8 MBSignature 1 KB

Parallex 0.12.2

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.

Disk image 7.8 MBApp archive 6.8 MBSignature 1 KB

Parallex 0.12.1

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.

Disk image 7.8 MBApp archive 6.8 MBSignature 1 KB

Parallex 0.12.0

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').

Disk image 7.7 MBApp archive 6.7 MBSignature 1 KB

Parallex 0.11.2

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.

Disk image 7.7 MBApp archive 6.6 MBSignature 1 KB

Parallex 0.11.1

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.

Disk image 7.6 MBApp archive 6.6 MBSignature 1 KB

Parallex 0.11.0

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.

Disk image 7.6 MBApp archive 6.6 MBSignature 1 KB

Parallex 0.10.0

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.

Disk image 7.4 MBApp archive 6.3 MBSignature 1 KB

Parallex 0.9.0

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.

Disk image 6.9 MBApp archive 5.8 MBSignature 1 KB

Parallex 0.8.0

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.

Disk image 5.7 MBApp archive 5.7 MBSignature 1 KB