Versioning Your Preferences

Let's face it: As artists, we hate version control systems. It's a layer of complexity between you and your desire to make cool paintings, and the interface(either from the command line or a graphical client) feels like it was barely made for human beings.

But there is a lot of value in rolling up your sleeves and *properly* learning a version control system, and in this post I'll share some of my use cases for those systems so let's get moving.

Picture this: you're working on multiple projects with different versions of the same software being used. It will probably handle your preferences files to avoid clashes between the versions saved somewhere locally in your machine, but you'll likely want to backup those preferences from time to time in case something bad happens or you need to hit the ground running in a new machine. This is where using version control systems can really help you on backing up, archiving and or restoring your preferences, brushes, plugins, etc.

I'll use Subversion(SVN) for the following examples because as you can probably tell from previous blog posts, I favor that system as it handles binary data(like art files) better than git, file locking features, sparse repository checkouts and for Windows users, it has TortoiseSVN and its bundled tools, which makes working with it super easy even for non-technical people. But the ideas present here can work with any other version control system.

The first step is deciding what are you going to save in your repository and how to organize it. You can create a repository per program, but because SVN has sparse checkout, you can easily create a monorepository storing a bunch of different program preferences and just checkout what you need. So at the root you would have something like this:

.
├── Blender
├── Unreal
└── Krita

Then, for each program, you would create the standard SVN project folders: branches, tags and trunk.

.
├── Blender/
│   ├── branches
│   ├── tags
│   └── trunk
├── Unreal/
│   ├── branches
│   ├── tags
│   └── trunk
└── Krita/
    ├── branches
    ├── tags
    └── trunk

The idea is using the trunk folder as your "main" version of a given software. In branch, you add any other version that you happen to be using, and maybe beta versions to experiment with new features. Tags work like a "version freeze". When you stop using a version, promote it to a tag to freeze your preferences and plugins in time, in case you need to reopen a project in the future, you'll be able to open it again under the same conditions you originally finished it.

.
└── Blender/
    ├── branches/
    │   └── bforartists4.1
    ├── tags/
    │   ├── Themes/
    │   │   └── MMX_DarkGoldTheme
    │   └── Version/
    │       └── 2.93LTS/
    │           ├── config
    │           ├── scripts
    │           └── ZenUV_3_6_0_1.zip
    └── trunk/
        └── 3.3LTS/
            ├── config
            ├── powerbackup
            ├── scripts
            └── ZenUV_4_1_0_4.zip

So any time you want to switch to another version, use the SVN switch command, available in Tortoise right-click menu as well:

By typing the correct URL of the target branch, you can restore your preferences as their once were, or switch back to the latest release. The directory structure is up to you, In the case of Unreal for example, you can separate your custom engine templates from generic things like plugins documentation or cvars.

.
└── Unreal/
    ├── Etc/
    │   ├── branches
    │   ├── tags
    │   └── trunk/
    │       ├── ue5_git_ignore_master/
    │       └── MRQ_ConsoleVariables.txt
    └── Templates/
        ├── branches/
        │   ├── RnD
        │   └── MF_ThirdPerson
        ├── tags/
        │   └── Version/
        │       ├── 5.2/
        │       │   └── MF_Blank
        │       └── 5.3/
        │           ├── Release/
        │           │   ├── MF_ThirdPerson
        │           │   └── MF_Blank
        │           └── RnD
        └── trunk/
            └── MF_Blank

If you have a new machine and you need your preferences from a specific app, you can do a sparse checkout by providing the URL from your repo in a folder in your machine.

Also, don't sleep on the Checkout Depth options: Read the documentation to fully understand how they help, but they're incredibly useful when adding a new program folder to the root of the repository for example. Paste the URL of your repository root and change the option to "Only this item". This will checkout the root of the repository without any folders, so from there you can add whatever new content you want and it will reside at the root level after committing, great way to avoiding downloading the entire monorepository just to add a folder.

Don't forget that when moving and renaming folders inside a working copy, you have to use SVN functions like *svn move* or Tortoise functions like dragging and dropping with right-click or rename from the context menu.

I'll elaborate more on other utilities useful for artists in production like Tortoise IDiff, which can compare images from different revisions, great for revisions and iterations but this basic setup for storing preferences should be enough to spark some ideas.

See you next mission.