autokey.github.io

"Sourcing" AutoKey settings on a new computer means copying your existing AutoKey configuration — phrases, scripts, and global settings — from the old machine into the location AutoKey reads on the new one, then pointing AutoKey at that data. The AutoKey 0.96.0 documentation lists "How to 'source' settings on a new computer?" as a core introductory topic, but the page excerpt available here does not include the step-by-step procedure or the exact storage paths. The steps below reflect the general approach for transferring a desktop application's user data; verify the precise folder names against the documentation or your installed version before relying on them.

What "sourcing" involves

AutoKey stores your user data (abbreviations/phrases, scripts, and settings) in a user configuration directory, separate from the application itself. Sourcing on a new computer therefore has two parts:

1. Copy the configuration directory from the old machine.
2. Place it where the new installation expects it, so AutoKey loads it on startup.

Because the documentation excerpt does not state the exact directory, treat the location as something to confirm rather than assume. A practical way to find it: on the old machine, check AutoKey's settings/preferences for a stated data or configuration folder, or search your home directory for a folder named after AutoKey.

Step-by-step transfer

1. Locate the configuration on the old computer

• Open AutoKey's settings or preferences and look for the configuration/data folder path.
• If none is shown, search your home directory for an AutoKey-named folder (commonly under a hidden configuration directory in your home folder).
• Note the full path before copying.

2. Copy the folder

• Close AutoKey on the old machine first so files aren't mid-write.
• Copy the entire configuration folder to removable media or a network location. Copy the whole folder rather than individual files, so phrases, scripts, and settings stay together.

3. Install AutoKey on the new computer

• Install AutoKey 0.96.0 (or your matching version) first, then launch it once so it creates its default configuration location. This gives you a known target path.

4. Replace or merge the configuration

• Close AutoKey on the new machine.
• Put the copied folder where the new installation reads its configuration. If a default folder already exists, either replace it or merge the contents — merging preserves any new-machine defaults while adding your old data.
• Reopen AutoKey.

5. Verify

• Check that your phrases/abbreviations appear and that a test abbreviation expands correctly.
• Open a script you rely on and confirm it is present.
• Confirm global settings (hotkeys, send mode) match what you expect.

Common snags

Keeping settings consistent across computers

• Keep a single master copy of the configuration folder and update it deliberately, rather than editing on both machines independently.
• After any major change on one machine, re-copy the folder to the other to avoid drift.
• Note that scripts depending on absolute paths or installed programs will need those dependencies present on each machine.

For the exact folder names and any version-specific instructions, consult the "How to 'source' settings on a new computer?" section of the AutoKey 0.96.0 documentation directly, since the available excerpt does not reproduce those details.

To add an abbreviation in AutoKey, you create a new text-type entry in a folder and assign it an abbreviation as its trigger; when you later type that abbreviation and press a word boundary key, AutoKey replaces it with the entry's content. The AutoKey 0.96.0 documentation lists "Adding Abbreviations" under Common actions, and the API reference documents the keyboard and clipboard machinery that performs the substitution. The exact menu path and dialog fields are not reproduced in the documentation excerpt, so follow the labels in your installed version.

What an abbreviation does

An abbreviation is a short trigger string tied to a longer piece of text. AutoKey watches what you type and, when the trigger is matched, substitutes the configured content. This is the same mechanism behind the "some examples" the documentation introduces on its welcome page.

Two practical consequences follow:

• The trigger must be unambiguous. If your abbreviation is a string you also type normally, it will fire when you don't want it to. Choose something you would not otherwise type, or one that ends in a character you rarely use.
• The match happens on typing, not on a hotkey. Unlike a script bound to a keyboard shortcut, an abbreviation needs no key combination — you just type it.

Steps to create one

1. Open the AutoKey main window and select the folder that should hold the abbreviation. Folders keep related entries together; the documentation's "How are things organized?" section explains this structure.
2. Create a new entry of the text type. In AutoKey, abbreviations are a kind of text entry — the content you supply is what gets inserted.
3. Set the abbreviation field to your trigger string. This is the text AutoKey will watch for.
4. Set the contents field to the replacement text — the phrase, signature, snippet, or code fragment you want inserted.
5. Save the entry. The abbreviation becomes active for the folders/phrases currently enabled in AutoKey.
6. Test it in a plain text editor: type the trigger, then a space or other word-ending key, and confirm the replacement appears.

If nothing happens, check that the phrase folder containing the entry is enabled and that AutoKey itself is running — an entry in a disabled folder will not trigger.

How the substitution is performed

The API reference shows the machinery AutoKey uses to insert text. Keyboard.send_keys() sends a string as keystrokes, while Keyboard.SendMode selects the delivery method:

This matters when an abbreviation misbehaves in a particular application. Some programs ignore synthetic keystrokes but accept a clipboard paste, so switching the send mode is the usual fix for an expansion that types nothing or types only part of the text. The Keyboard API also exposes fake_keypress(), press_key(), release_key(), send_key(), wait_for_keyevent(), and wait_for_keypress() for finer control, and the Key constants (for example Key.ENTER, Key.TAB, Key.BACKSPACE) let a script send the boundary key that completes a trigger.

Where abbreviations live and how matching works

Abbreviations are stored as entries inside phrase folders, and the folder structure is what the documentation's "How are things organized?" section describes. Matching is against the text you type in the focused application; the trigger fires when the typed sequence matches an active entry. Because the trigger is plain typed text, the same abbreviation can be used across applications — but it also means a trigger that collides with ordinary typing will fire unexpectedly, which is why distinctive triggers are worth the extra keystrokes.

Related actions worth knowing

The documentation groups abbreviations with other common actions, and the API reference covers the surrounding capabilities:

• Keyboard control — Keyboard.send_keys() and the send modes above, plus the Key constants for special keys.
• Mouse control — the Mouse API (click_absolute(), click_relative(), move_cursor(), select_area(), wait_for_click(), and others) for entries that need to click or select rather than just type.
• Persistent values — the Store API (get_value(), set_value(), get_global_value(), set_global_value(), has_key(), remove_value(), remove_global_value()) for entries that remember state between triggers.
• Dialogs — the QtDialog API, including calendar() and choose_* methods, for entries that prompt for input.

For a first abbreviation, the text-entry route above is enough; reach for the API when the expansion needs to press special keys, paste into an application that rejects synthetic typing, or vary its output based on stored values.

AutoKey is a desktop automation utility for Linux and X11 that watches what you type and what hotkeys you press, then responds by expanding abbreviations or running scripts. You would use it when you retype the same phrases, addresses, or command sequences and want a short trigger to produce the full result. The official documentation at autokey.github.io covers version 0.96.0 and is the reference for the behavior described here.

The two mechanisms behind everything

AutoKey's feature set reduces to two triggers and two responses:

• Text trigger (abbreviation): you type a short string, and AutoKey replaces it with a longer phrase or runs a script.
• Hotkey trigger: you press a key combination, and AutoKey runs a script or inserts text.

The responses are either plain text expansion or a Python script that can call AutoKey's APIs. That is the whole model, and the documentation is organized around it: an introduction, a glossary of terms, common actions, and then the API reference.

What the APIs let a script do

The API reference is the clearest statement of AutoKey's scope. The documented modules are:

Two details are worth knowing before you plan anything:

• Send modes matter. Keyboard.SendMode includes KEYBOARD, CB_CTRL_V, CB_CTRL_SHIFT_V, CB_SHIFT_INSERT, and SELECTION. These are different ways of delivering text, and which one works depends on the target application. If expansion lands in the wrong place or does nothing, the send mode is the first thing to change.
• Keys are named constants. The Key class enumerates everything from Key.LEFT and Key.ENTER through Key.F1–Key.F35, modifier keys like Key.CONTROL and Key.SUPER, and numpad keys like Key.NP_5. Scripts refer to these names rather than raw codes.

Concrete things you can automate

Using only documented capabilities, a typical setup looks like this:

• Phrase expansion. Type a short abbreviation and get a full signature block, a canned reply, or a shell command. The documentation's "Common actions" section starts with adding abbreviations, which is the entry point most users need.
• Hotkey-driven scripts. Bind a combination and have it type a string, press a sequence of keys, or click at a stored location.
• Form and field filling. Combine Keyboard.send_keys() with Key.TAB presses to move between fields.
• Mouse-position work. Use Mouse.get_location() to capture a position and Mouse.click_absolute() to return to it later.
• Small stateful helpers. Use the Store API to keep a value between runs, for example a counter or a last-used path.

Where the documentation helps and where it stops

The site is an API and concepts reference, not a tutorial series. It explains terms, how things are organized, and how to "source" your settings onto a new computer — useful if you are moving a working configuration to a second machine. It does not describe installation, and the page evidence contains no pricing or licensing information, so treat availability and cost as things to confirm on the project itself rather than assume.

If you are deciding whether AutoKey fits: it does if you are on Linux with X11 and your repetitive work is typing, key presses, and mouse clicks. It does not if you need automation outside that environment, since the documented scope is desktop input on X11.

The AutoKey 0.96.0 documentation at autokey.github.io is the official reference site for AutoKey version 0.96.0. It explains what AutoKey is, how its features are organized, and how to automate keyboard and mouse actions through its scripting API. It is a documentation resource, not a download page or a tutorial series, so it is most useful when you already have AutoKey installed and need to look up a concept, an API method, or a concrete example.

What the site covers

The documentation is organized into three main areas, plus a short introduction.

Introduction to AutoKey

This section answers the basic questions a new user has before writing any script:

• A glossary of AutoKey terms, so the rest of the documentation is readable
• How things are organized in the application
• How to "source" your settings on a new computer, which matters if you move between machines
• Why you would use AutoKey and what it does for you, illustrated with examples
• A plain explanation of what AutoKey is and how it works

If you are evaluating whether AutoKey fits your workflow, this is the section to read first. The examples show the kind of repetitive typing and clicking that AutoKey is meant to remove.

Common actions

This section walks through practical tasks, starting with adding abbreviations. An abbreviation is the simplest AutoKey feature: you type a short trigger and AutoKey expands it into longer text. The documentation treats this as the entry point before moving on to scripts.

Autokey API

This is the largest part of the site and the reason most people return to it. It is a method-by-method reference, grouped by the kind of input or data you are working with.

The Keyboard API is the most detailed. It documents send modes that control how text is delivered, including KEYBOARD, CB_CTRL_V, CB_CTRL_SHIFT_V, CB_SHIFT_INSERT, and SELECTION. The choice of send mode matters because each one delivers text through a different mechanism, and some applications respond better to one than another. The API also lists the individual key constants, from Key.LEFT and Key.BACKSPACE through the function keys up to Key.F35, plus numpad keys and modifiers such as Key.CONTROL, Key.ALT, and Key.SUPER.

The Mouse API follows the same pattern: button constants (LEFT, MIDDLE, RIGHT, scroll directions, BACKWARD, FORWARD, BUTTON10) and methods for clicking, moving, pressing, releasing, scrolling, and waiting.

How to use the site effectively

The documentation is a reference, so the fastest path depends on what you already know.

• New to AutoKey: read the introduction and the glossary before touching the API pages. The terminology (phrases, scripts, folders) is used consistently throughout, and skipping the glossary makes the API pages harder to follow.
• Setting up a second machine: go straight to the "source settings on a new computer" page in the introduction.
• Writing a script: open the API section for the input type you need. If you are sending text, read the send-mode descriptions before choosing one, since the mode changes how the text arrives in the target application.
• Looking for a specific key or button: the constant lists are exhaustive, so scan them rather than guessing at a name.

A worked example of the reference style

Suppose a script needs to press and release a modifier around a keystroke. The Keyboard API separates press_key(), release_key(), and send_key(), which tells you that holding a key down and sending a complete keystroke are different operations. A script that needs Shift held across several inputs would call press_key() with the Shift constant, perform the inputs, then call release_key(). A script that only needs one combined keystroke would use send_key() instead. The documentation gives you the method names and the key constants; the sequencing is up to you.

What the site does not provide

The documentation is version-specific: it describes AutoKey 0.96.0, so behavior or method names may differ in other releases. It is also a reference rather than a guided course, and the site itself does not present pricing or installation instructions in the material available here. Treat it as the place to confirm how a method or constant works, and rely on the introduction pages when you need the conceptual background first.

AutoKey organizes automation into a small set of building blocks—phrases, scripts, folders, and abbreviations—that you arrange in a tree inside the main window. You create an item, attach a trigger (a hotkey or an abbreviation), and AutoKey runs it in whatever application has focus. The official 0.96.0 documentation covers these concepts in its Introduction and "Glossary of AutoKey Terms" pages, and the API reference shows what scripts can call.

The core terms

The distinction that matters most for new users: a phrase is content, a script is code, and a hotkey or abbreviation is the trigger. A phrase or script can have a hotkey, an abbreviation, or both; the item type and the trigger type are separate choices.

How items are organized

AutoKey presents everything as a tree in its main window:

• Top-level folders hold your items. The documentation's "How are things organized?" section describes this structure, and the "How to 'source' settings on a new computer?" page explains that your configuration lives in a folder you can copy to another machine.
• Phrases and scripts sit inside folders. Folders exist purely for grouping, so you can keep, for example, one folder for email snippets and another for window-management scripts.
• Abbreviations are attached to phrases or scripts rather than living as separate top-level objects.

This means the same phrase can be reached two ways—say, a hotkey for quick insertion and an abbreviation for typing—without duplicating the content.

What scripts can do

Scripts are where AutoKey goes beyond text expansion. The API reference lists the modules available to script authors:

• Keyboard — send_keys(), send_key(), press_key(), release_key(), fake_keypress(), and the wait functions wait_for_keypress() and wait_for_keyevent(). The SendMode values (KEYBOARD, CB_CTRL_V, CB_CTRL_SHIFT_V, CB_SHIFT_INSERT, SELECTION) control how text is delivered—useful when an application ignores simulated keystrokes but accepts paste.
• Mouse — clicking, moving, scrolling, selecting an area, and waiting for a click, with absolute, relative, and "relative to self" variants.
• Store — persistent values via set_value()/get_value() and global values via set_global_value()/get_global_value(), so a script can remember state between runs.
• QtDialog — dialogs such as calendar() and choose_... for asking the user for input mid-script.
• Keys and Buttons — named constants (Key.ENTER, Key.F1 through Key.F35, Mouse.Button.LEFT, and so on) so you don't hard-code key names.

For example, a script triggered by a hotkey could read a stored value, open a dialog to let you pick a date, then type a formatted line into the focused window—combining Store, QtDialog, and Keyboard in one action.

Where to start reading

If you are new, read the Introduction, then the Glossary of AutoKey Terms, then "Common actions" (which includes adding abbreviations). Move to the API pages only when a phrase is not enough and you need a script. The documentation is versioned as 0.96.0, so check that page's version label if you are running a different release.