How I Version-Control Plugin Presets and Channel Strips to Cut Mix Revisions 60% (Logic + FabFilter + Git LFS)

Horia Stan is music producer and sound engineer at The One Records, Bucharest.

Why I moved presets out of my head and into version control

Clients change their mind. I change mine. A saved plugin preset in a folder is useless if you can't find which session it belonged to. I was wasting hours hunting for a vocal chain setting or guessing which Pro-Q3 snapshot made the vocal sit. So I stopped depending on memory and started treating presets and channel strips like code.

The result: I cut revision rounds by about 60%, recall exact plugin states in under 3 minutes, and reduce the chance of shipping the wrong vocal chain to mastering. This is not for hobbyists. This is for working producers who run real projects, use Logic Pro, FabFilter Pro-Q3 and Waves modelers, and who want reproducibility across sessions and collaborators.

The principle in one sentence

Track every change you care about as a discrete file, tag it, and store it where collaborators and automation can access it. Use Git LFS for big binary preset blobs and Logic's export features for channel strip snapshots.

What I actually track

• FabFilter snapshots (Pro-Q3, Pro-MB, Pro-L2) I save a named preset for every major decision.
• Waves chains and custom presets (SSL E-Channel, CLA-2A) exported per session.
• Logic channel strip settings I save as Channel Strip Setting files when I change routing, sends, or bus assignments.
• Keyscape or Kontakt program changes when they affect arrangement decisions - I export program snapshots even if the instrument is large.
• Mix bus chains I tag as 'clean' or 'glued' and save a full-stem export alongside.

Naming convention matters. I use: sessionname_part_plugin-v1. Example: 'KINGDOM_vocal-main_FabProQ-v2'. Short. Searchable.

The exact setup I use

1. A private Git repository per artist or project (GitHub or GitLab).
2. Git LFS enabled for binary blobs (plugin preset files, Keyscape snapshots). Command I run once: git lfs install.
3. A local folder inside the project root called /presets. Every saved plugin preset and channel strip export goes here.
4. A small pre-commit checklist I run before handing off stems: export Channel Strip Settings from Logic for critical tracks, copy plugin preset files to /presets, tag the commit.

This makes rollbacks trivial. If a client wants version from two weeks ago I run git checkout v1.3-presend and export the exact chain files. The confidence is measurable: I stopped redoing mixes because a plugin preset was missing.

How I export without slowing down the session

I don't export everything all the time. I export at decision points: vocal comp approved, mix bus glue chosen, arrangement locked. Those moments map to logical commits.

• For FabFilter: I use the plugin UI to save a preset and copy the exported .preset file to /presets. If I change the Pro-Q3 and it becomes the final vocal EQ I save it as 'vocal-main_FabProQ-v1.preset'.
• For Waves: I save the user preset from the Waves GUI and add the preset file to the repo.
• For Logic: I use Save Channel Strip Setting As... and drop the .cst into /presets.

Yes, this takes a minute per decision. It earns back hours later.

Collaboration - how producers and engineers share exact states

When a mix goes to a remote mastering engineer I push the branch with the commit and tag: git tag -a 'mix-2026-05-02' -m 'clean vs glued sent'. The mastering engineer can pull the /presets folder, load the exact FabFilter and Waves presets, and confirm they are using the same chain. No guessing.

If the other engineer doesn't use Git, I push the tagged bundle to Dropbox or a private S3 link and include a short manifest: session name, tag, list of presets and which track they belong to.

Automation I actually use

I keep automation light and reliable. My automation stack in 2026:

• git lfs install (one-time)
• a tiny shell script I run before a commit: it copies current Logic Channel Strip exports and named plugin preset files into /presets. I run it manually. I prefer manual because automatic exporters can miss UI-only saves.

Example script (conceptual):

• prompt 'Export channel strip settings for tracks you modified?'
• copy selected exported files to ./presets
• run git add ./presets && git commit -m 'vocal chain v2' && git tag -a 'vocal-v2' -m 'vocal chain for take 14'

I keep the script deliberately simple. The fewer moving parts, the less chance of corrupting a session.

Why Git LFS and not just Dropbox

Dropbox works for backups. It fails for history and branching. Git gives me branches for alternate mixes. Git LFS handles big files like Keyscape snapshots. Together they let me answer: what changed between mix-v1 and mix-v2? I can diff the commit messages and the manifest. I can revert.

Also: tagging. With git tag I create immutable anchors I can refer to in invoices, release notes, and metadata I send to labels.

Practical example: the vocal chain rollback

Scenario: client says "I preferred the earlier vocal. Revert." In 2019 that meant hours. Now I run:

• git checkout tags/mix-vocal-2026-04-10
• copy the presets from ./presets/vocal-main_* into my working plugin preset folders
• open Logic, load Channel Strip Setting 'vocal-main-2026-04-10.cst'

Total time: under 10 minutes. The vocal sounds like the day they approved it because the exact FabFilter Pro-Q3 snapshot and Waves CLA-2A preset are loaded.

Pitfalls and what I avoid

• I do not version every tiny tweak. I tag decisions. Over-committing creates noise.
• I avoid trying to export everything automatically from Logic with complex scripts. Logic project files are single compressed bundles and are not practical to diff. Export the settings you need.
• I never store license files or large sample libraries in Git. Use Git LFS only for preset files and small snapshots. For big sample libraries use structured cloud storage with a manifest.

Tools and plugins I mention in the workflow

• DAW: Logic Pro (macOS)
• Plugins: FabFilter Pro-Q3, FabFilter Pro-MB, FabFilter Pro-L2, Waves SSL E-Channel, CLA-2A, Plugin Alliance where applicable
• Instruments: Keyscape (export program snapshots when needed)
• Version control: Git + Git LFS, GitHub/GitLab
• Storage: Dropbox or private S3 for large builds

The payoff

You ship the right sound. You stop guessing. You avoid 'which preset did you use' email threads. You get reproducible results and faster client approvals. I measure the payoff in two ways: time saved during revisions and the reduced number of "send me the chain" requests.

Pulling presets into a collaborator's session eliminates a whole category of mistakes. It turns subjective memory into objective artifacts.

Concrete takeaway

Start today: create a /presets folder inside an active project, export the channel strip and a vocal EQ preset, commit with Git LFS and tag it. The first time you need to roll back, you'll save the hours you'd otherwise spend searching. That's why I version-control presets.