Version Control

Replicator Redux keeps a git repository that mirrors your EVE settings. Not a metaphor for one, but an actual repository you can cd into and run git log against.

This exists because settings get destroyed in ways that have nothing to do with this app: a patch resets your window layout, a client crash truncates a file, or you copy the wrong direction and flatten the profile you meant to keep. A snapshot from before the mistake fixes all three.

Turning it on

Open the Version Control tab and initialise the mirror. From then on the app commits a snapshot when you make changes, and the tab shows the history.

Each commit carries a message and a timestamp, and you can add your own message when taking a snapshot manually, which is worth doing before anything drastic.

Restoring

Pick a commit from the history and restore it. The files in that commit are written back over your live settings, and you get a report of exactly what changed.

Restoring is itself a mutation, so the same rule applies: EVE has to be closed.

Because the restore is a normal write, the state you were in before it is still in the history. Restoring to the wrong commit is recoverable: restore again to the one you wanted.

Syncing to a remote

Push the mirror to a private repository and your settings exist somewhere that is not your hard drive. That is what makes them survive a dead disk or a clean reinstall.

Use a private repository. Your settings files are not secret in a security sense, but they are yours, and there is no reason to publish them.

Create the repository

On GitHub, create a new repository and leave it completely empty. Do not add a README, a .gitignore or a licence.

This matters. Replicator Redux pushes its own main branch. If GitHub has already put a commit on main, the two histories are unrelated, the push is rejected as a non-fast-forward, and there is no force option in the app. An empty repository has nothing to conflict with.

Create a GitHub token

Pushing over HTTPS needs a credential. Replicator Redux uses a personal access token, which it stores in your operating system's keychain: Keychain on macOS, Credential Manager on Windows, the Secret Service on Linux. It is never written to the app's database or into the repository.

Fine-grained token (recommended, because you can scope it to one repo):

1. Go to GitHub then Settings then Developer settings then Personal access tokens then Fine-grained tokens.
2. Generate new token.
3. Give it a name you will recognise in a year, such as replicator-redux-settings.
4. Set an expiry. Longer is more convenient, shorter is safer. Whatever you pick, the push will start failing on that date and you will need a new token.
5. Under Repository access, choose Only select repositories and pick the repository you just made.
6. Under Permissions then Repository permissions, set Contents to Read and write. That is the only permission needed. Leave the rest alone.
7. Generate the token and copy it. GitHub shows it exactly once.

Classic token, if you prefer: create one with the repo scope. That is much broader access than this app needs, which is why the fine-grained token is the better option.

Point the app at it

1. Open the Version Control tab and initialise the mirror if you have not already.
2. Paste the token.
3. Set the remote URL. It must be the HTTPS URL, the https://github.com/you/your-repo.git one. SSH remotes will not work, because the stored token is sent as an HTTPS credential.
4. Push.

The app only ever tells you whether a token is present, never what it is. Clear it whenever you like; clearing removes it from the keychain.

Restoring onto a new machine

This is the reason to set any of it up.

Right now the app pushes but does not clone, so putting the repository back is a manual step:

1. Install Replicator Redux on the new machine and launch it once. That creates the mirror directory.
2. Quit the app.
3. Delete the mirror directory it just made, or move it aside.
4. Clone your repository into that exact path:

git clone https://github.com/you/your-repo.git "<mirror directory>"

5. Launch the app again. The Version Control tab will show your whole history.
6. Close EVE, pick the commit you want, and restore.

The mirror lives in the app's own data directory. Open the folder for your platform, then the Replicator Redux folder inside it, then mirror:

After that first clone, the app pushes to the same remote as before, so the new machine picks up where the old one left off.

Working with the repository directly

Nothing stops you. It is an ordinary git repository containing your .dat files, so git log, git diff --stat and git checkout all behave.

One caveat: the files are binary, so diffs tell you that a profile changed and not what changed inside it. The commit history and timestamps are what make it useful.

Next: Troubleshooting.