Open-source project
VeriorPies/ParrelSync avatar
VeriorPies/ParrelSync

ParrelSync clones your Unity project instead of building it again

(Unity3D) Test multiplayer without building

6,137 stars400 forksC#MIT

At a glance

What is it?
ParrelSync is a Unity editor extension that opens a second editor on a copy of your project so two instances can run multiplayer without a build. It symbolic links three folders back to the original and lets the rest stay independent, which is fast to set up and costs disk per clone.
Who is it for?
Anyone testing Unity multiplayer in the editor should adopt ParrelSync and its git path install; teams that validate against built players should not, because the project never produces a build. Check the editor version against the tested list of 2022.3.56f1 LTS, 2021.3.29f1 LTS and 2020.3.1f1 LTS, and commit the project before importing the .unitypackage.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 153 days ago.
What is it written in?
Mainly C#, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • VeriorPies/ParrelSync6,137 ★ · +37
Star history
Repository2026-09-232026-11-15
VeriorPies/ParrelSync6.1k6.1k

37 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Clones are project copies with three folders linked back to the original

ParrelSync answers one editor problem: a multiplayer session needs two live copies of the same project, and rebuilding a player after every change does not keep up. Its answer is a second Unity editor window opened on a copy of the project folder. For each clone instance, ParrelSync copies the original project folder and points the `Asset`, `Packages` and `ProjectSettings` folders back at the original with a symbolic link, the same mechanism the project documents through Microsoft's `mklink` reference. `Library`, `Temp` and `obj` stay independent per clone, which is what keeps two editors from writing over one import cache.

Clone directories sit right beside the original with a numeric suffix, so the folder hierarchy looks like this:

code
/ProjectName
/ProjectName_clone_0
/ProjectName_clone_1
...

The repository root also carries a `.gitignore`, a `VERSION.txt` and the `ParrelSync/` package folder where the C# editor code sits.

The git path install needs a Package Manager that understands ?path=

Two install routes exist, and the newer one depends on the editor version. The manual route has three steps: back up the project folder or use a version control system such as Git or SVN, download the .unitypackage from the latest release and import it into the project. After import, ParrelSync appears in the menu item bar. Nothing gets typed in that route.

The Package Manager route needs a git package path query parameter, which the installation notes tie to Unity 2019.3.4f1 and Unity 2020.1a21. Add this URL in the Package Manager:

bash
https://github.com/VeriorPies/ParrelSync.git?path=/ParrelSync

Or write the dependency into `Packages/manifest.json` yourself:

json
"com.veriorpies.parrelsync": "https://github.com/VeriorPies/ParrelSync.git?path=/ParrelSync"

The `?path=/ParrelSync` suffix is what points the package manager at the `ParrelSync` subfolder instead of the repository root. An editor older than the two named versions has no path parameter to pass, so the .unitypackage route is the only one on offer there.

ClonesManager.IsClone is what separates the server window from the client window

A working host setup turns on one API. `ClonesManager.IsClone()` reports whether the editor running the script is a clone, so a single script can start the server in the original window and connect to the local host in the clone:

csharp
if (ClonesManager.IsClone()) {
  // Automatically connect to local host if this is the clone editor
}else{
  // Automatically start server if this is the original editor
}

Without that branch both windows try to do the same job, which is the failure this API exists to prevent. The project's List of APIs wiki page holds the full set of these calls, and `Examples/CustomArgumentExample.cs` in the repository is a further example, on custom arguments.

Every clone duplicates Library, Temp and obj on the same disk

A clone is a full folder copy, and the three folders that are not symbolic links stay separate per clone. `Library` is the one that grows with imported assets, so three clones means three import caches, each owned by a different editor window. Nothing in the project states a ceiling on how many clones can be opened, so the practical limit on a given machine is disk space and how many Unity windows stay responsive.

A leftover clone keeps holding its own `Library` until someone removes it, and because the folder name pattern `_clone_0` and `_clone_1` is predictable, a stale directory is easy to recognise next to the original project.

It never produces a build, so player only behaviour stays untested

ParrelSync tests what runs inside the editor and stops there. No part of the project outputs a player, so code that behaves differently in a built executable, or anything gated behind a build time define, is outside what this setup can check. That is the trade the tool makes: give up build coverage and get play mode within seconds.

The arrangement also fixes both instances to one machine. A clone reaches the original through filesystem symbolic links, and the clone folders live side by side on the same disk, so running a clone on a second computer is not something the project describes. Work that has to be verified across separate machines or on devices falls back to built players.

Protected assets are a narrow guard, not a sandbox around the clone

One listed feature is protected assets, described as guarding them from being modified by other clone instances. Read precisely, it protects assets, and it does not turn a clone into an isolated copy. A clone shares the original `Asset` folder through a link rather than holding a snapshot, so a script change made inside a clone is an edit to the original project. The install steps put backing up the folder, or Git or SVN, first.

For a team this means ParrelSync assumes version control discipline around it. Who changed a script inside a clone, and when, is answered by your own history, not by anything the extension records.

Tested against the 2022.3 LTS line while tags arrive years apart

Platform coverage is Windows, macOS and Linux editors. The versions the project says it has been tested with are 2022.3.56f1 LTS, 2021.3.29f1 LTS and 2020.3.1f1 LTS, with a note that other versions should also work as well. That list ends at the 2022.3 line, so an editor newer than the three named sits outside what has been checked.

Releases and commits move at different speeds. Tags come at long intervals: 1.5.1 on 2021-07-03, 1.5.2 on 2023-04-30, 1.5.3 on 2024-06-16. The last push to the default branch was on 2026-06-16. Anyone upgrading should read `VERSION.txt` at the repository root rather than assume a newer tag exists, because the newest published tag is more than two years old while the branch itself has moved since.

Two editor windows instead of two builds

The alternative is what ParrelSync is built to avoid: build a player for each instance and run two builds. That route costs a build after every change, and it is the only one of the two that exercises your real player pipeline. ParrelSync inverts the cost profile. Play mode starts immediately, there is no build step in the loop, and what you get back is editor behaviour rather than player behaviour.

The project itself is descended from hwaet's UnityProjectCloner, which its README credits as the origin. Beyond it, the project's own feature list covers a GUI for managing clones, the asset protection and the APIs around `ClonesManager`.

Editorial conclusion

Anyone testing Unity multiplayer in the editor should adopt ParrelSync and its git path install; teams that validate against built players should not, because the project never produces a build. Check the editor version against the tested list of 2022.3.56f1 LTS, 2021.3.29f1 LTS and 2020.3.1f1 LTS, and commit the project before importing the .unitypackage.

Frequently asked questions

How do I use ParrelSync in Unity?

Back up the project folder or use Git or SVN, then download the .unitypackage from the latest release and import it. After the import, ParrelSync shows up in the menu item bar.

Can I install ParrelSync through the Unity Package Manager?

Yes, on editors that support the git package path query parameter, which the project ties to Unity 2019.3.4f1 and Unity 2020.1a21. Add the repository URL ending in ?path=/ParrelSync in the Package Manager, or add the com.veriorpies.parrelsync entry to Packages/manifest.json.

What does ParrelSync do to my project folder?

For each clone it copies the original project folder and links Asset, Packages and ProjectSettings back to the original with a symbolic link. Library, Temp and obj stay independent per clone, so every clone carries its own import cache on disk.

Which Unity versions and operating systems does ParrelSync support?

Windows, macOS and Linux editors. The tested Unity versions named by the project are 2022.3.56f1 LTS, 2021.3.29f1 LTS and 2020.3.1f1 LTS, and it states that other versions should also work.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. Releases
  5. VeriorPies/ParrelSync on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/veriorpies-parrelsync.svg)](https://hysenlabs.com/projects/veriorpies-parrelsync)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/veriorpies-parrelsync.svg)](https://hysenlabs.com/projects/veriorpies-parrelsync)

Was this useful?