Capture One shortcuts for the terminally curious: part 3 (Final)

We have arrived at the final part of this series: the script!

This is a simplified extract of the full installer application I made, as it is simply far too big to break down into a single tutorial. Instead, I have made a fully functional version of the useful part, which does most of the heavy lifting and annoying bit – adding the shortcuts to a set of installed scripts.


  • Quit C1.
  • Make a folder in ~/Library/Scripts/Capture One/Scripts/
    • (For my example today: ~/Library/Scripts/Capture One/Scripts/Apply Latitude)
  • Copy your scripts into this folder – for this, I am using scripts from another project post to come in the new year – yours will be whatever you make.

My scripts are called:

  • “Apply SB-01.scpt”
  • “Apply SB-02.scpt”
  • “Apply SB-03.scpt”
  • “Apply SB-04.scpt”
  • “Apply SB-05.scpt”
  • “Apply SB-06.scpt”
  • “Apply SB-07.scpt”
  • “Apply SB-08.scpt”
  • “Remove Style.scpt”

You need to decide what the shortcuts will be, and you need as many shortcuts as there are scripts (9).

Next we need to map these together as a “value pair” for the script.

As a reminder on the first post in the series, coding shortcuts requires a bit of symbology to equate user facing stuff: Modifier keys are represented as: @ for Command, $ for Shift, ~ for ⌥ and ^ for ⌃.

So the string “@$~^t” represents ⌘+⇧+⌥+⌃+T

Im going to set these up as the full ⌘+⇧+⌥+⌃ + [key]. This is obviously impractical for a users, but it serves as a technical demonstration (and actually doesn’t matter in the other project). You might decide to use something else:

  • “@$~^A”
  • “@$~^B”
  • “@$~^C”
  • “@$~^D”
  • “@$~^E”
  • “@$~^F”
  • “@$~^G”
  • “@$~^H”
  • “@$~^I”

Now you have the list of file names, and the list of shortcuts, we have to combine this into an object the script will parse into the shell command.

The simplest way (IMO) to do this (and there are many methods) is to make a list. As we have to make many value pairs, we could go one step further and make a list containing the smaller lists.

A list in apple script is defined with curly brackets:

To define the first value pair, combine the script name and the shortcut (“” makes them text values) and then split with a comma.

We could add more pairs to a single list, but this would be suboptimal. Instead we create a list of lists (a list containing several smaller lists) by puting the another pair of brackets around the first. This gives you a main list, containing each of the value pairs as addressable items within it.

When completed, it should look like this:

Which is basically a list containing a number of text value pairs, each as their own little lists of 2 items.

TIP: You can line break long lines of code by placing the cursor and using ⌥+[return] – this makes reading and editing long lines easier.

When testing, you can now ask for a value pair from the list easily:

Which returns the 3rd item – {"Apply SB-03", "@$~^C"}

The script also needs to know the name of the folder you made your scripts in (seeing as we are using the full path approach to the shortcuts).

Create a new variable and assign the name:

Next we have to make some logic that will chop the value pairs for each row, and then run the shell command with those bits. A repeat loop can be used to cycle through the list, and extract the name and the shortcut from each pair by creating new varibles from the indexed position. Comments have been added to the code below explaingin each line (those lines starting –)

There are again, a few ways to do this. I used this approach:

The last part is the shell command, and is fairly advanced if you have no experince in scripting shell in AppleScript, requiring skills like string concatination, charcter escaping… and massive patience. I do conceed, I should maybe have started this this blog with a gentler slope, but what can you do. Stuff tumbles out when it does.

The shell command from part 2 was:

You can type this into terminal and it will work – but it wont if run from within AppleScript.

Shell commands from an AppleScript are invoked from the “Do shell script” command – this recieves a single text paramater between “”. Because our command has several ” between the first and last ” the script interprets the code inncorrectly. To stop this from happening we need to escape certain characters so the script ignores them, but will still pass them to the command line. To do this, charcters we want, but want AppleScript to interpret as just text, are proceeded with “\”.

We also – and at the same time (bloody hell) – have to inject our variables into the text. This requires replaceing stanadrd text with the varibles and then concatenation of the various elements together with “&”.

So with all 3 variables, escaping and the new command, our script looks like this:

Our script is now complete. Running the script will add the shortcuts to (in this case) Capture One 20.

The script from this post is below in full, if you want to copy paste this to your own IDE and start breaking stuff, go nuts.

If you screw up your C1 plist you can reset the custom shortcuts entry by using the following terminal command:

I hope this has been an interesting series – we have tonnes lined up, but I wonder what should be next?

Leave a comment after the break.


How to make a script applet

Making a script applet is not much harder than actually making a script – from the outside the extension changes to .app, and the app when clicked will “run” rather than open in script editor. Mostly useful.

I use Script Debugger for all my AppleScript work. It’s a billion times better than Script Editor. Specifically for applet design, it makes life simpler for adding and removing resources, and you can also add your icons and developer ID easily. You can do this in Apples’ Script Editor but for the uninitiated, it is a journey of questions, throwing things and swearing.

Start a new script from File > New Script and choose Application> Applet in the Script Template tab:

Once open you will see the following:

You can add script resources (files, icons, libraries and other scaffolding) using the “+” icon within the bundle tab (suitcase icon in the toolbar). Make sure to save your applet before you add, as it can get squirrely adding resources when its still in memory.

In the example here I’ve made an .icns file (a new icon for the applet) and added a folder containing a text file, and a snippet of code for demo.

Once added you can choose the .icns file as an alternative to “applet”. This gives the script a nice custom look so it looks nice and shiny on the mac.

The code in my applet is very simple – this just demonstrates some syntax to get the path of x resource, then show it on screen for the user. The standard additions command “path to resource” is important, as we will want to use the paths in the final project for copying the resource from the bundle, to the destination Mac.

For the final project in Capture One shortcuts for the terminally curious I want to build an applet that will install the scripts for my guy, plus add shortcuts to them. An applet is perfect for this as I can bundle all the resources I need in the applet (making it super easy to distribute). Another goal was to have the project reusable for other clients/projects so I don’t have to spend hours changing key value pairs in xml or escaping super long shell scripts because the clients use spaces in all their naming.

Capture One shortcuts for the terminally curious: part 2.5ish

I was just about to conclude the the shortcuts series and getting to the point, when I realised I may have approached the flow of this project ass-backwards, as there are a lot of other moving parts that make this whole endeavour more relevant if understood first. So, if you have never done this stuff before I should probably ALSO write about these other things.

So, to frame this properly and hopefully make this a more, rounded and useful experience, there are two other topics to dig into. Each of these is now its own post, and you can find the links below:

How to install and use scripts with Capture One

How to make an applet

The ultimate point (of the Capture One shortcuts series) was this: part of what I make for my clients ends up as “script bundles”. That is, I create a number of scripts, each designed for different actions.

If you don’t know, “scripts” in Capture One is as to Actions in Photoshop – they are designed to cut time from repetitive tasks.

Stuff I have written for Capture One includes:

  • Barcode scanning extensions
  • Renaming macros
  • Case dependent processing
  • Metrics and reports
  • Notifications
  • Excel integrations
  • Workspace and session templating
  • Specialised workflow design
  • Metadata manipulation

Most of these interact with Capture One in some way or another, and usually will need to be executed on demand.

In nearly all cases, the best way to do this is with a shortcut to run the specific workflow – and you sometimes need many of these. As per the shortcuts post, Capture One itself does not (and why not is a mystery) offer the user the ability to shortcut scripts, styles, or indeed any other user generated menus. The work around does work for scripts (and this is the method I use to help my clients) but it’s not scalable to install multiple machines without automation – or when I have to build new applications for new clients and all the menus change.

This requires a solution to package the scripts in an “installer” and somehow add the shortcuts to said scripts when they are installed to the users workstation…

Have I arrived at the fucking point? I hear you ask. Well, sort of.

The last piece of the puzzle is the “installer applet” and the point of all this effort, will conclude with a “How to” post on how to make it (when I’ve finished it).

Watch this space.

How to install and use scripts with Capture One

There are a few ways to have a script execute and “do its thing” with Capture One. From easiest to hardest:


Copy the script to the CO scripts folder.

Simple scripts can be run straight from Capture One’s application script folder. Once installed, these will appear as a menu item in Capture One and is executed by selecting it like any other menu item (this method works well if you want to shortcut your scripts, as per the shortcuts article here).

To use this framework:

Open the scripts folder from inside Capture One (or navigate to ~/Library/Scripts/Capture One Scripts/)

Finder view:

Copy your scripts into this folder. If you copy in sub-folders containing scripts, then these will automatically be represented as drill down menus in Capture One.

Once added, choose, “update scripts menu” from inside Capture One to make sure the scripts are loaded.

Scripts should now show as menu items. You can add shortcuts to these manually as per the How to shortcut almost anything in Capture One


Save the script as an “app”

This can be run from applications (and can be added to, and launches like, any other app from the dock).
Script Applets are effectively an encapsulated script plus all the necessary bits and bobs. If your script requires to be self contained – like an installer containing all you resources, uses other libraries or even app artwork like icons etc, then this is the solution. This is in effect a very simple version of what real developers ship in commercial software.

Script applets can also be saved in the CO menu and run just like a script, so this is the best solution for commercialising scripts. We will use this method for the shortcut installer project.

See the article on making applets here.


Set it as an event.

Capture One has a number of events: things like capture did happen, processing finished, etc. You can utilize these to trigger your script: e.g. Processing finished, email Roger in retouch to say his images are ready on the server. This happens sudo-magically, at least, once set. Capture One will just call your script automatically every time the specific event occurs. But there is a bit more work to get to that point… perhaps this is an article for for another day.

Capture One shortcuts for the terminally curious: part 2

In part 1 I ended with the idea of using this in to some AppleScript routines but hit a number of design issues with the syntax:

  1. Writing everything as a single list is not ideal for scalable or re-useable code.
  2. The syntax doesn’t really lend itself to scripting routines
  3. The big list was a LOT of escaped text and a pain to edit
  4. The main problem – the methodology if run again (say for another project) would replace any existing shortcuts, rather than appending. Less than ideal for building or adding to a set of shortcuts.

Fortunately I recently found a second approach which solved all of the above.

This changes the syntax a bit, but most of the existing work can be reused (for the specific menu drill down using \033) and the shortcut notations (like \UF70D for F10)

To break down the improved syntax:

  1. The command and domain remains (defaults write com.captureone.captureone13 NSUserKeyEquivalents)
  2. This is followed by the specifier for add new key/value pairs to the dictionary (-dict-add)
  3. Then this is followed by the value pairs of menu title and shortcut (in quotes, separated with space)
    e.g. “\\033Scripts\\033My Folder Name\\033My Script” “\\UF70D”

A full command (including escaping) now reads:

This new approach means you can chop up this command line in a “do shell script” with some injected variables, and each and every invocation will add the shortcut to the dictionary.

Still a bit to do for the working script but will try to make that the next post!

Remote controlling Capture One – Automation routines from a distance

I’ve had this idea for ages to remote control more of Capture One from the iPhone/iPad – more specifically have my scripting run when I call it from the phone. With COVID in full force, more remoting options are good things and so I thought I’d write this up!

I was messing around for ages with an app called Entangler. This let you make launcher-widgets on the phone, which fired AppleScripts on a target mac through one’s iCloud account. I used this to run session setups remotely and get reports on the number of shots in each folders etc to my inbox. It’s sadly become unreliable of late (another victim of Catalina’s “security theatre” perhaps) but either way, I needed an alternative.

iOS 13 shortcuts app came with an interesting new action – Run Script over SSH. As Applescripts can be run from the command line using the command “osascript” I thought this could be a solution.

What is SSH?

SSH – or Secure Shell – is an admin tool used to access and remote manage machines over the network. You can log in to the machine and execute command line as if you are sitting at the machine.

Mac setup

You will need to switch on remote control options in system prefs, and note your network address. You will need this later.

  1. Enable remote login, and the users allowed to perform SSH actions. Note your network address – something like ssh [user]@192.168.0.xx

iOS setup

2. Open the Shortcuts app

3. The three dots menu can be used to rename, customise the icon, set color, and sharing options of the shortcut. For now, press Add action

4. Search for SSH in the search bar. Tap the Action to add it to the workflow.

5. Press the small arrow to add your personal info to the action

6. You will need to add the following fields:

  • Host: The IP address of the target Mac from step 1.
  • User: The user account name (ideally an admin account on the target mac)
  • Password: The users password
  • Script: This is the command-line script you are effectively asking the target machine to run when the action on the phone is run.

7. After setup, the panel should look like this.

The shell script is quite simple: the command “osascript”, followed by the path on disk of the script in question to run. e.g

*Keeping the script in shared is a good idea so the paths to the resources are always absolute, not relative in a particular user account.

8. To finish up, press the “…” icon in the corner and finalise setup. Name, color, icon etc can all be tweaked.

9. All done. Tap the red box w/baby icon to launch the testScript on the target mac!

The testScript.scpt for this post was a simple script (of course saved in shared) and speaks the following string just to let me know the command worked. You can of course put whatever script you have in place of this: reporting, configuration, whatever.

Sending messages is an interesting use case though… perhaps when socially distancing – say when reviewing photos on Pilot from another part of the studio – and want to let the team know the shoot is going great, I can have the computer send them some positive vibes. Daniel sounds like a bit of a sarcastic prick though so maybe I’ll experiment with the voices.

If you have a use case you’d like to this out on, let me know in the comments.

Capture One shortcuts for the terminally curious: part 1

This is a part 2 to my last post like a year ago (sue me I’m busy) where I was looking at short-cutting stuff not supported by C1 – quick access to functions that are missing from C1’s shortcuts capability (like work spaces, scripts, styles).

While the workaround using the OS was fine, the process is a bit shite if you have to set up a lot of shortcuts. As it’s now a year later and nothing had changed from C1 side, I thought I’d look at it again to try to find a better way to set these up. What follows is a bit of a hack through C1 plists to automate the process, but it works and its pretty cool.

I don’t know how useful it is or who even who the hell reads these posts, but if nothing else then it served a sort of expressive anger management because its baffling to me that this basic functionality is not in the application. Leave a comment if this was helpful.

Down the rabbit hole

After an evening of reading/google I found a helpful article in an ancient book (Modding Mac OS) which lead me to a couple of (old) blogs on the topic of “NSUserKeyEquivalents”. You can see those here and here.

For the curious, “NSUserKeyEquivalents” is a dictionary container that all Mac OS apps can use (within the app’s own main plist) that stores the shortcuts you make via the system prefs. These articles were not entirely conclusive but they provided most of the working parts and bread crumbs needed for a working solution, and from the comments some insights into other approaches.

Anyway, the tl;dr of all this research was, it turns out you can use shell commands to set up the shortcuts.

Using the methods described in the first post to set up a sample, I did a simple test via the system prefs with CMD+T for default workspace, then opened the C1 plist in textMate to see how the data was stored.

Screenshot 2020-02-15 at 13.37.14

A new entry NSUserKeyEquivalents is made and now contains the value pairs for the menu item (Window->Workspace->Default) and it’s shortcut (CMD+T).

Note: Modifier keys are represented as: @ for Command, $ for Shift, ~ for Alt and ^ for Ctrl – so the string “@$~^t” represents CMD+SHFT+ALT+CTRL+T
I’d read about issues with Function keys so I made a shortcut using (F10) which resulted in:

Screenshot 2020-02-15 at 12.17.52

The F keys and other functional keys are harder to do using shell. You cant just type “F10” unfortunately. These keystrokes have to be represented by their Unicode values and Unicodes need to be Unicode escaped to work in a shell command. Unicode escaping consists of combining \U followed by the 4 digit unicode for the corresponding value. e.g. F10 is listed as the hex 0xF70D. This, when escaped, is “\UF70D”

You can find the list of Mac Function Key Unicode characters here

Creating a shell command

The shell command was a bit of trial and error but uses the following logic:

  • Use the defaults write option to modify the plist
  • I found it best to use approach of the list type syntax in the shell command so you can send the config once. Note, because my method does not use the -dict-add command to add to any existing arrays, every time you run this command, it will overwrite any existing shortcuts.
  • The application bundle identifier is com.phaseone.captureonexx, where xx is the version being worked on. I use 12, so e.g. com.phaseone.captureone12
  • The item to be edited is NSUserKeyEquivalents
  • The arrow notation in the manual process to denote the menu hierarchy is (the one exposed via the testing) represented with “\033” for the arrow, then the name of the menu/s.
  • The menu and the shortcut for it, are separated with “=”

The result example (for) F10 is:

The list approach allows you to add a second combo after the “;” – so a single command with a list of menus and corresponding shortcuts looks like:

This example sets F10 to the default workspace, and F11 to simplified workspace and thus allows you to modify lists/batches of shortcuts – great for styles in-particular.


Around the time of that last post I had also started experimenting with Applescript because I thought the Capture One library might offer a solution to the initial problem (it didn’t). But! Applescript can execute shell commands as part of a routine – and variables from it can be injected into the shell command so now I’m thinking I have everything I need to make a fancy set-up app… This shell command won’t work in Applescript just yet without a bit of tinkering and character escaping. I will (maybe next year?!) do the next post on creating the set up script… but hit me up if you have a use case for this and see what I can make.


The motivation for this post was last years announcement from Instagram that they were adding payments to it’s platform. Between the announcement and drafting this for posting, I got sidetracked with other work.

This is not “that” post about social media and commoditization of photography.

While adding payment infrastructure on Social Media is nothing new (see WeChat) this was a pretty interesting development for Photographers/Professionals making a living from photography – rather than just a way to advertise your work it could be potentially used as a direct revenue stream.

BUT, If you are a traditional kind of guy like me (old and jaded) and prefer images taken with real cameras, getting those images up to Instagram can be fairly arduous process – usually involving an intermediary step to the phone.

While trying to find a workflow of least resistance, I stumbled across which (with Pro add on for $10) allows you to post from the desktop to Instagram – or for my case, directly from my image editor of choice, Capture One Pro.

This week there have been some really nice additions to Flume to streamline the posting workflow – the stand out for me being the meta data conversions (and the reason I decided to finish this post):

  • IPTC Description is converted to the Instagram image caption
  • If you include “@” with the users Instagram name in the description text, these are converted to mentions
  • If images contain Keywords then these are converted to hashtags



Using Flume with Capture One Pro

  • Install Flume 2.8.5 (with Pro add on)
  • Open Capture One Pro and Select images (up to 10)

Just a tip, before the output step note that photos will be compressed to a maximum dimension of 1080px before uploading. If you would like to avoid Flume performing compression of high-resolution photos, or to avoid issues with color profiles, configure your workflow to export photos with a maximum dimension of 1080px.

There are some other limitations and some things to be aware of, but you can read more in the Flume Help:



Open With…

If the image is a format directly accepted by flume or if you want to do the final color/adjustments in Flume:

  • Right click> Open with (and choose Flume as the Open with app)

Note the meta data needs to all ready be embedded in the file, so this is best if using already processed images.

Edit With…

If the image is RAW file (with settings) and you want the look and meta data in Capture One to open in Flume:

  • Right click Edit with…
  • Process the image to e.g. jpeg -this then opens the resulting file in Flume.

Images are now ready for posting!

Want Flume? Like this post? Buy via my referral link! It costs the same but I get small cut to help support this blog… which I’ll probably just spend on WordPress subscription renewals.

How to shortcut almost anything in Capture One Pro (Mac)

Capture One has a pretty decent custom shortcuts feature which I use daily, but it lacks two shortcut-able things which would be really useful: Workspaces and Styles.

Fortunately the Mac user can utilize the System keyboard shortcuts to get around this shortcoming.

Go to System Preferences > Keyboard

Screen Shot 2017-08-28 at 21.18.33Click on Shortcuts, then with App Shortcuts selected, press “+”

Screen Shot 2017-08-28 at 21.18.42Set the Application to the installation of Capture One you want to affect.

The menu title needs to be exactly what the Menu is called in Capture One (case sensitve). For this article I made a Workspace called “EditWorkspace” (the names of your Workspaces need to be unique).

Add a shortcut – this also needs to be something unique.

Screen Shot 2017-08-28 at 21.19.46

If the shortcut is truly unique, and everything went to plan, you should now see a shortcut next to the Workspace in question. You can now switch to that Workspace using shortcuts.

Screen Shot 2017-08-28 at 21.21.00

This technique is great for short-cutting almost any menu item in the app. It relies on unique menu names in order to find it and then call it. However, there is one use case where this won’t work – that of shortcuts for Styles.


The problem with Styles is the menu titles for the actual styles names appear first in the “Delete Style” menu – and as this menu is found first, any attempt to add a shortcut to a Style in the manner above will add the shortcut to the function to remove the style. Maybe not what you want.

Fortunately there is a simple solution.

When adding the Menu title to the shortcut, you will need to put the full menu hierarchy to the function, separated with “->” (dash, greater than)

The example below adds a shortcut to the Style BW-01 in one of the Phase One Styles Packs. The full menu title is:

Adjustments->Styles->User Styles->B&W->BW-01

Screen Shot 2017-08-28 at 21.35.05This will add the shortcut (MacOS adds the shortcut to the menu UI) and the Style can now be applied via shortcut when a variant/variants are selected in the app.

Screen Shot 2017-08-28 at 21.36.11

This technique is really awesome when used in conjunction with Tangent button panels, putting 12 Styles under your fingertips to do quick looks on images.


Tethering Over Distance

Tethering (for the uninitiated) is Capture One’s party piece. Connect a supported camera to the computer over the relevant cable and shoot directly to the hard drive instead of the memory card. Instant preview, instant client approval, happy customer.

Tethering is a valuable asset to Capture One users. Once you’ve adopted it into your workflow, it becomes very hard to live without it. If it stops working mid-shoot it can be a serious source of stress.

There are physical demands on the system for this to work well, the main one being power. It’s worth noting that 90% of all tethering issues I’ve ever seen were solved with proper power supply. The other issues we’re either faulty cables, faulty hardware, bugs, and plain old user error (in that order).

To transfer data effectively over distance, the cables need supporting power. As distance increases the requirements for power supply increase. In fact, even with the supported lengths (USB2 – 4.5m, USB 3 – 3m) laptops and cheaper consumer products like iMacs often don’t provide a power supply for the camera to run spec.

This problem of distance has only gotten worse with the retirement of FireWire. While it had its own problems, digital back owners could tether over a single 10m. This was technically never supported by Phase One (official FireWire spec was 4.5m) but it mostly worked (to do it officially, a special repeater was needed).

A repeater or hub solution is a great way to extend effective cable length – or just get a solid power supply. Normally the device sits between camera and computer, and the device is plugged into a mains power source.


Optical USB3


This cable architecture is a fairly new idea but they come with a single awesome feature – cable length is not an issue!

In a nut shell, Optical USB cables do away with copper as a means of transferring signal. Signal from the device is converted in the plug to light and then transmitted over fiber-optic. Once received at the other end, the optical signal is converted back to electronic signal.

All that you need to make it work with your camera is a traditional copper USB adapter (maybe 2-3″ long) to convert the female end of the USB cable to a male type used in the cameras USB socket and you are good to go.

The only downside to Optical (apart from the initial cost), is charging – if you used the ultra modern XF camera and IQ backs from Phase One with the USB charging feature, you will have to turn that off.

Corning optical cables are available in many places, and are available in lengths of 10m, 15m, 30m and 100m.