DaVinci Shortcuts: Master Keyboard Tricks for Resolve

Learn practical DaVinci shortcuts to speed editing in DaVinci Resolve. This guide covers core keys for Windows and macOS, scripting basics, and tips for building your own shortcut map.

Shortcuts Lib Team

April 12, 2026·5 min read

Keyboard Shortcuts Windows Shortcuts Mac Shortcuts

DaVinci Shortcuts Mastery - Shortcuts Lib — Photo by Anna Pou via Pexels

Quick AnswerDefinition

DaVinci shortcuts unlock faster editing and scripting workflows in DaVinci Resolve. This guide covers essential Windows and macOS keys, plus how to customize mappings and automate repetitive tasks. Mastering these shortcuts reduces hand movement, minimizes context switching, and boosts consistency across projects for editors and hobbyists alike.

What are DaVinci Shortcuts and Why They Matter

DaVinci shortcuts refer to keyboard commands and quick-access mappings that speed up editing, color, and delivery tasks in DaVinci Resolve. They apply on Windows and macOS, often mirroring common OS shortcuts while adding Resolve-specific actions like blade edits, ripple deletes, and timeline navigation. According to Shortcuts Lib, mastering a compact, consistent shortcut set reduces hand movement, minimizes context switching, and improves consistency across projects. You can treat these shortcuts as both built-in keys and external mappings from macro tools to tailor Resolve to your workflow.

JSON

{
  "shortcuts": [
    {"name": "Save Project", "key": "Ctrl+S / Cmd+S"},
    {"name": "Play/Pause", "key": "Space"},
    {"name": "Undo", "key": "Ctrl+Z / Cmd+Z"},
    {"name": "Blade/Cut", "key": "B"}
  ]
}

Python

# Python pseudo-code: load a custom keymap (illustrative)
import json
with open("davinci_shortcuts.json") as f:
    keymap = json.load(f)

# Apply to your macro tool (pseudo)
def apply_mapping(keymap):
    for item in keymap["shortcuts"]:
        print(f"Map {item['name']} -> {item['key']}")

if __name__ == "__main__":
    apply_mapping(keymap)

These examples show a data-driven approach to shortcut maps: you maintain a single source of truth and feed it to your macro tool (AutoHotkey on Windows or Keyboard Maestro on macOS). The aim is to align Resolve actions with your most-used keystrokes while keeping the map portable across projects.

Core Windows/macOS shortcuts you should know

Across platforms, some shortcuts stay constant, while others switch from Ctrl to Cmd. Below is a compact reference you can start using today, with a JSON mapping to view both sides at a glance.

JSON

{
  "Play/Pause": {"windows": "Space", "macos": "Space"},
  "Save Project": {"windows": "Ctrl+S", "macos": "Cmd+S"},
  "Undo": {"Windows": "Ctrl+Z", "macOS": "Cmd+Z"},
  "Redo": {"windows": "Ctrl+Shift+Z", "macos": "Cmd+Shift+Z"},
  "Blade/Cut": {"windows": "B", "macos": "B"},
  "Select All": {"windows": "Ctrl+A", "macos": "Cmd+A"},
  "Copy": {"windows": "Ctrl+C", "macos": "Cmd+C"},
  "Paste": {"windows": "Ctrl+V", "macos": "Cmd+V"}
}

Here are quick notes to avoid conflicts:

Space toggles playback in the timeline on both Windows and macOS.
Save, Undo, and Copy/Paste map to the familiar system shortcuts that you already use in other apps.
The Blade tool (B) is a fast way to cut clips on the timeline; switch back to selection with the A key.

Bash

# Example: generate a simple keymap file for review (bash)
echo '{"Play/Pause":"Space","Save":"Ctrl+S"}' > davinci_keymap.json
cat davinci_keymap.json

These patterns help you build consistency across your editing sessions and reduce the mental load of remembering Resolve-specific actions. The code blocks demonstrate a portable approach to mapping: a simple JSON file can power your macro tool while keeping the truth centralized.

Scripting and automation with the DaVinci API

Beyond keyboard shortcuts, DaVinci Resolve exposes a scripting interface that can be used to automate repetitive tasks and batch operations. While scripting is optional for quick edits, it unlocks repeatable workflows on large timelines or color stacks. Below is a minimal Python example that demonstrates connecting to Resolve and listing timelines. Replace with actual API calls relevant to your version.

Python

# DaVinci Resolve scripting (illustrative example)
import DaVinciResolveScript as dvr
resolve = dvr.scriptapp("Resolve")
pm = resolve.GetProjectManager()
project = pm.GetCurrentProject()
# Hypothetical: list timelines in the current project
try:
    timelines = project.GetTimelineList()
    print("Timelines:", timelines)
except Exception as e:
    print("Scripting not available or API changed:", e)

If you want to integrate macros with scripting, consider a two-layer approach: a keyboard shortcut maps to a scripting command, and a Python script orchestrates a batch of Resolve API calls. This separation keeps your human-oriented shortcuts simple while enabling powerful automation for advanced workflows. You should verify the exact API names for your Resolve version and environment since they evolve with updates.

Practical workflow: building and maintaining a personal shortcut map

A robust shortcut map starts with core actions you perform daily. Start with a minimal set: play/pause, save, undo/redo, cut, copy/paste, and select-all. Then expand to timeline navigation, trimming, and color-grading actions you routinely apply. Create a JSON file that represents this map, and use a macro tool to read and apply it. Document each mapping so others can reproduce your setup if needed.

JSON

{
  "shortcuts": [
    {"name":"Play/Pause","key":"Space"},
    {"name":"Save Project","key":"Ctrl+S / Cmd+S"},
    {"name":"Undo","key":"Ctrl+Z / Cmd+Z"},
    {"name":"Blade","key":"B"},
    {"name":"Select All","key":"Ctrl+A / Cmd+A"}
  ]
}

To apply this map: create a small script that reads the file and pushes the mapping into your macro tool. Test on a short timeline first to ensure there are no conflicts with OS shortcuts or other active macros. Finally, keep a changelog and cycle through a monthly review to refine mappings based on your evolving workflow.

Troubleshooting and best practices

Common issues include conflicts with OS shortcuts, conflicting mappings across different apps, and mapping a non-existent Resolve action. Use a single source of truth for shortcuts, and test each mapping in a controlled project before expanding. When you add new mappings, export the keymap as JSON and share it with teammates to maintain consistency. Regularly review your map after major Resolve updates, since new actions may warrant new shortcuts.

JSON

{
  "shortcuts": [
    {"name":"Ripple Delete","key":"Shift+Backspace"},
    {"name":"Split Clip","key":"Ctrl+\| Cmd+\|"}
  ]
}

To verify mappings, you can run a quick check script that prints each action with its assigned key and checks for duplicates. If duplicates exist, you can reassign one of the conflicting actions to preserve unambiguous behavior.

Steps

Estimated time: 1-2 hours

1
Audit current workflow
List daily tasks you perform in Resolve and identify bottlenecks where shortcuts could save time. Create a draft map focusing on high-frequency actions.
Tip: Start with 3-5 core shortcuts and expand later.
2
Create a base keymap file
Build a JSON file to represent your shortcut map. Include at least Play/Pause, Save, Undo, and Blade actions.
Tip: Label each action clearly to avoid confusion.
3
Bind to a macro tool
Load the keymap into your macro tool (AutoHotkey on Windows, Keyboard Maestro on macOS) and assign platform-specific bindings.
Tip: Avoid overlapping OS shortcuts to prevent conflicts.
4
Test with real edits
Run through a sample project to verify every mapping behaves as expected, then adjust as needed.
Tip: Keep a quick rollback plan in case a shortcut disrupts your flow.
5
Document and share
Publish a concise cheat sheet for teammates or collaborators and store the source JSON in version control.
Tip: Version control helps track changes over time.
6
Review and iterate
Set a monthly review to refine shortcuts as your workflow evolves and Resolve adds new features.
Tip: Continuous improvement is key.

Pro Tip: Start with the core actions you use daily and map them first for quick wins.

Warning: Avoid reusing OS-level shortcuts on your primary mapping to prevent conflicts.

Note: Keep a single source of truth (the JSON keymap) and version it.

Pro Tip: Test mappings on a small project before applying to larger ones.

Prerequisites

Required

DaVinci Resolve 18+ installed↗
Required
Command Line access (Terminal on macOS, PowerShell on Windows)
Required

Optional

A code editor (VS Code recommended)↗
Optional
Python 3.8+ for scripting (optional)↗
Optional
JSON editing basics↗
Optional

Keyboard Shortcuts

Action	Shortcut
Play/PauseTimeline playback toggle	`␣`
Save ProjectSaves current project	`Ctrl`+`S`
UndoUndo last action	`Ctrl`+`Z`
RedoRedo last undone action	`Ctrl`+`⇧`+`Z`
Blade/CutSwitch to blade tool for cutting clips	`B`
Select AllSelect all clips or timeline content	`Ctrl`+`A`
CopyCopy selection to clipboard	`Ctrl`+`C`
PastePaste from clipboard	`Ctrl`+`V`

Questions & Answers

What are davinci shortcuts?

DaVinci shortcuts are keyboard commands that accelerate common actions in DaVinci Resolve, including edits, playback, and navigation. They can be built-in or customized via external tools to fit your workflow.

How do I customize shortcuts in DaVinci Resolve?

You can customize shortcuts by using a keymap JSON file and a macro tool. Create actions named for clarity, assign platform-specific keys (Windows vs. macOS), and test in a short project before broader use.

Do shortcuts work on both Windows and macOS?

Most core shortcuts work on both platforms, with Windows using Ctrl equivalents and macOS using Cmd equivalents. Certain Resolve actions may differ slightly in key names or availability between OS versions.

Can I automate mapping shortcuts with scripting?

Yes. Resolve supports scripting (Python, Lua) to automate tasks, including setting up and validating shortcut maps. Ensure you refer to the exact API for your Resolve version.

What are best practices for shortcut layouts?

Start with a small, core set, keep OS conflicts to a minimum, and keep a public cheat sheet. Use consistent naming in your maps and document changes.

Should I share my shortcut map with teammates?

Sharing a map helps teams stay consistent across projects. Store the keymap in version control and provide a short guide on how to apply it.

Main Points

Use a centralized keymap to boost consistency
Windows and macOS mappings should mirror where possible
Blade tool (B) speeds cutting in Resolve
Regularly review mappings after updates
Document and share your shortcut map with your team

← More in Custom and Advanced Shortcuts

What are DaVinci Shortcuts and Why They Matter

Core Windows/macOS shortcuts you should know

Scripting and automation with the DaVinci API

Practical workflow: building and maintaining a personal shortcut map

Troubleshooting and best practices

Steps

Audit current workflow

Create a base keymap file

Bind to a macro tool

Test with real edits

Document and share

Review and iterate

Prerequisites

Keyboard Shortcuts

Questions & Answers

Main Points

Related Articles