[[Plover software|Plover]] reads three different dictionary file types by default and uses a unique '''dictionary format''' to encode extra information or commands into translations for outlines.
[[Plover software|Plover]] reads three different dictionary file types by default and uses a unique '''dictionary format''' or '''translation language''' to encode extra information or commands into translations for outlines.
==Dictionary File Formats==
==Dictionary File Types==
By default, Plover uses .json (preferred), .rtf, and .modal dictionaries.
By default, Plover can interpret <code>.json</code> (recommended), <code>.rtf</code>, and <code>.modal</code> dictionaries.
With the installation of the [[plover-python-dictionary]] [[Plugins|plugin]], Python also supports programmatic dictionaries in .py file format. After installing the plugin, Plover must be restarted before it loads Python dictionaries.
With the installation of the [[plover-python-dictionary]] [[Plugins|plugin]], Python also supports programmatic dictionaries in <code>.py</code> file format. After installing the plugin, Plover must be restarted before it loads Python dictionaries.
Currently, Plover does not support dictionary file formats from other CAT programs such as .dct or .sgdct formats. Plugins were previously authored to allow support in Plover, but as of April 2025, are not in working order.
Currently, Plover does not support [[CAT Dictionary File Types|dictionary file formats from other CAT programs]] such as <code>.dct</code> or <code>.sgdct</code> formats. Plugins were previously authored to allow support in Plover, but as of March 2026, are not in working order.
=== json ===
=== JSON ===
The standard Plover format. These dictionaries contain a single JSON dictionary containing outlines mapped to translations.
The standard Plover format. These dictionaries contain a single JSON dictionary containing outlines mapped to translations.
Line 16:
Line 17:
Unicode is supported in JSON format dictionaries since Plover 3.0.0.
Unicode is supported in JSON format dictionaries since Plover 3.0.0.
=== rtf (aka CRE) ===
=== RTF (aka CRE) ===
RTF dictionaries tend to cause Plover to take longer to start up and don't have Unicode support.
RTF dictionaries tend to cause Plover to take longer to start up and do not support Unicode.
A standard interchange format. Described at http://www.legalxml.org/workgroups/substantive/transcripts/cre-spec.htm .
A standard interchange format. Described at http://www.legalxml.org/workgroups/substantive/transcripts/cre-spec.htm .
Line 23:
Line 24:
RTF/CRE is an import/export format used by proprietary steno software. This means Plover can work with exported dictionaries from Eclipse, ProCAT, Case CATalyst, and other steno software applications.
RTF/CRE is an import/export format used by proprietary steno software. This means Plover can work with exported dictionaries from Eclipse, ProCAT, Case CATalyst, and other steno software applications.
===py===
===Python===
{{See also|Programmatic dictionary}}
{{See also|Programmatic dictionary}}
Within a Python dictionary, a function called <code>lookup()</code> is used to process input and determine if the dictionary will create an output.
Within a Python dictionary, a function called <code>lookup()</code> is used to process input and determine if the dictionary will create an output.
==Other CAT File Formats==
==Translation Language (JSON)==
=== dct (aka Stentura, Jet, MDB, Microsoft Access) ===
.dct file format is used by the software DigitalCAT.
Since the default <code>.json</code> Plover dictionary format only contains two pieces of data for each entry—an outline and a translation—most of the extra information concerning prefix, suffix, glue, and capitalization behavior must be included within the translation field.
add photo here later
These are standard Microsoft Access databases (otherwise known as Microsoft Jet databases, or MDB files. They contain a single table named "Steno", which has columns named "Steno", "English", and "Flags". Each row represents a translation.
"Steno" is a text column containing the stroke, encoded as a concatenated sequence of six-digit hex strings representing bitmasks; each bit represents a key in the standard steno order
"English" is a text column giving the text translation of that stroke.
"Flags" is an integer bitmap. Within the dictionary editor, flags are selected for prefixes, suffixes, capitalizing the next stroke, glue, and more using checkboxes. The combination of all flags is stored in this column.
.dct also stores info about the date an entry was created, as well as the number of times it has been used within DigitalCAT.
A limited number of functions are added within the English field such as indications for switching paragraph type {Q} and {A}. Otherwise, the English field is mainly treated as plaintext.
=== sgdct (CaseCat) ===
CaseCATalyst dictionaries have the extension ".sgdct". There is often a corresponding ".sgxml" file, but this contains no dictionary data.
Much of the detail of the file format remains unknown.
The files begin with a 640-byte header, which begins with the magic number SGCAT32. Nothing is known about header fields at present.
One or more records follow the header. Each record gives a single translation from steno to text.
The record header is 21 bytes. header[18] contains the number of strokes, and header[19] gives the number of letters in the text. Each is an unsigned byte. The purpose of all other fields in the record header is unknown at present.
The stroke follows, as a sequence of four-byte unsigned integers. Each integer is a bitmap of keys in the standard steno order, with the first "S" as the most significant bit.
Then the text follows, as ordinary ASCII text. Nothing is currently known about coding of text outside the ASCII range. Various non-ASCII characters crop up, apparently as control codes.
Finally, there are zero to three padding bytes, in order to bring us up to a four-byte boundary.
===.dix (Eclipse)===
==Translation Language==
Since the default .json Plover dictionary format only contains two pieces of data for each entry—an outline and a translation—most of the extra information concerning prefix, suffix, glue, and capitalization behavior must be included within the translation field.
Other dictionary formats contain more than two pieces of data per entry in order to separate out this information out.
Other dictionary formats contain more than two pieces of data per entry in order to separate out this information out.
Line 72:
Line 37:
In order to distinguish such information from the translation itself, Plover has a translation language that dictates how to encode it. Most of these commands utilize curly braces <code>{}</code>.
In order to distinguish such information from the translation itself, Plover has a translation language that dictates how to encode it. Most of these commands utilize curly braces <code>{}</code>.
For a complete documentation of the Plover translation, refer to the Plover Documentation: https://plover.readthedocs.io/en/latest/translation_language.html
For the definitive documentation of the Plover translation, refer to the Plover Documentation: https://plover.readthedocs.io/en/latest/translation_language.html
Following is a summary of its functions:
== Plover Control Commands ==
You can control some aspects of Plover's function using certain translations, such as adding a translation, enabling or disabling output, using lookup, suggestions, opening [[Configuration]], focusing, quitting, and modifying Plover config.
Plover's default dictionary (<code>commands.json</code>) contains some of these commands on default outlines.
== Prefix strokes ==
It's possible to select the translation for a stroke depends on whether the previous word is finished.
Given the dictionary:
<code>{
"S": "word",
"/S": "{prefix^}"
}</code>
with a stroke <code>S</code>, the translation <code>"/S": "{prefix^}"</code> is chosen; unless the previous word is not finished (for example if the previous translation is <code>{con^}</code>), then the translation <code>"S": "word"</code> is chosen.
It's possible to explicitly mark a translation as "finished" with <code>{$}</code> (or equivalently <code>{:word_end}</code>).
[https://github.com/openstenoproject/plover/blob/df65bf1c6e2e6e7f958f635f0a3922b0b7b80c63/test/test_blackbox.py#L1597-L1604 See this blackbox test for an example.]
== Text Formatting ==
=== Prefixes, Infixes, and Suffixes ===
Following is a summary of a few aspects:
Strokes can be attached at the beginning and/or end using the "attach" operator. You can also use some of the built-in orthographic rules that Plover uses for creating intelligent strokes.
* <code>{^}</code> is the attach operator.
=== Affixes ===
* <code>{^ish}</code> is an orthographic-aware suffix that will add "ish" to the end of the previous word. E.g. <code>RED/EURB</code> will output <code>reddish</code>. Note: addition of a second "d" caused by Plover's understanding of English orthography.
In English stenography, spaces are output by default before each translation. To indicate that a certain translation should stick to either the previous or following translation as a prefix or suffix, the <code>^</code> symbol is used. Depending on the formatting, you can also control whether Plover attaches these translations as-is, or according to orthography rules.
* <code>{^}ish</code> is a suffix with the text outside the operator—this means that the text will simply be attached without grammar rules. Using this stroke in the previous example would give instead <code>redish</code>.
* <code>{^-to-^}</code> is an infix, e.g. <code>day-to-day</code>.
* <code>{in^}</code> is a prefix, e.g. <code>influx</code>.
* Most custom punctuation entries will take advantage of the attach operator, e.g. <code>{^—^}</code> for an emdash.
=== Glue Operator (Numbers, Fingerspelling) ===
=== Glue ===
Glue is sort of like the [[Dictionary Format#Prefixes, Infixes, and Suffixes|attach operator]] above, except that "glued" strokes only attach to neighboring "glue" strokes.
Glue is similar to affixes above, except that "glued" strokes only attach to neighboring "glue" strokes. To indicate a glue stroke, the <code>&</code> symbol is used. This is most frequently used for writing [[numbers]] and [[fingerspelling]].
Translations containing ''only'' digits are glued, allowing you to output multiple number strokes to make a large number.
Translations containing ''only'' digits are glued, allowing you to output multiple number strokes to make a large number.
* <code>{&}</code> is the glue operator.
=== Keyboard Shortcuts ===
* <code>{&a}</code>, <code>{&b}</code>, <code>{&c}</code>, etc. are how the fingerspelling alphabet is made.
{{See also|https://plover.readthedocs.io/en/latest/translation_language.html#keyboard-shortcuts Plover Docs: Translation Language - Keyboard Shortcuts|external}}
* <code>{&th}</code> is a multiletter glue stroke, which can be useful (<code>TH*</code> in the default dictionary)
You can use Plover to type common keyboard shortcuts. For example, you may use the arrow keys to navigate. You may know <code>Ctrl+C</code> and <code>Ctrl+V</code> to copy and paste, or <code>Alt+Tab</code> to switch windows. You can encode these shortcuts as translations for steno outlines, using Plover translation language.
Because glued translations only glue to other glued translations, they won't attach to regular words. This gives us some power because you can write:
In contrast with text output, keyboard shortcuts cannot be "undone" with the <code>*</code> outline, similar to how you cannot backspace a shortcut on your keyboard.
<code>THR/-R/#H/#A/KATS</code> to get "there are 45 cats" and only <code>#H</code> (4) and <code>#A</code> (5) are "glued" to each other.
Read the Plover source code to find the [https://github.com/openstenoproject/plover/blob/master/plover/key_combo.py#L21 complete list of supported keyboard shortcut keys].
=== Capitalizing ===
=== Plover Control Commands ===
Capitalizing a word means turning the first letter into a capital, e.g. proper nouns and in titles. Usually your dictionary has capitals pre-defined, but there are times when you need to capitalize a word on the go.
You can control some aspects of Plover's function using certain translations, such as adding a translation, enabling or disabling output, using lookup, suggestions, opening [[Configuration]], focusing, quitting, and modifying Plover config.
==== Capitalize Next Word ====
* <code>{-|}</code>
The next word will have a capitalized first letter. In the default dictionary, we have <code>"KPA": "{-|}"</code>, which will capitalize the next word; and <code>"KPA*": "{^}{-|}"</code> which omits a space and capitalizes the next word. That last stroke would let you writeLikeThis. This formatting style is called "camel case', which some programmers use in their work.
Capitalize next word can also be used in name titles, like <code>Ms. {-|}</code>.
The last stroke word will have a capitalized first letter. This is useful in case you realize that a word should be capitalized after you've written it. It can also be used in a stroke, like in <code>{*-|}{^ville}</code>. This would capitalize the last word and attach to it. This would be useful for town names on the fly, such as <code>Catville</code>.
'''Suggested stroke:''' <code>KA*PD</code>
=== Uncapitalizing ===
==== Uncapitalize Next Word ====
* <code>{>}</code>
Forces the next letter to be lowercase, e.g. <code>{>}Plover</code> → <code>plover</code>
* <code>{~|text}</code> or <code>{^~|text^}</code> where the attach operator is optional and the text can be changed.
In English, we have punctuation that doesn't get capitalized, but instead the next letter gets the capitalization. For example, if you end a sentence in quotes, the next sentence still starts with a capital letter! <code>"You can't eat that!" The baby ate on.</code>
In order to support this, there is a special pre/in/suffix syntax that will "pass on" or "carry" the capitalized state. You might find this useful with quotes, parentheses, and words like <code>'til</code> or <code>'cause</code>.
The default dictionary for Plover should use these operators where appropriate.
{
"KW-GS": "{~|\"^}",
"KR-GS": "{^~|\"}",
"KA*US": "{~|'^}cause",
"PREPB": "{~|(^}",
"PR*EPB": "{^~|)}"
}
For a newline, the syntax would be <code>{^~|\n^}</code>.
=== Uppercasing (CAPS) ===
See [[Dictionary Format#Output Modes|Output Modes]] for CAPS mode, which acts like CAPS lock on a regular keyboard. Alternatively, you can use a [[Dictionary Format#Keyboard Shortcuts|Keyboard Shortcut]] set to <code>{#Caps_Lock}</code> to activate the system CAPS lock like you can on your keyboard.
The most notable translation in this category is the function of undoing the last stroke typed, which is the default way of "backspacing" in stenography and is assigned to the outline <code>*</code> in nearly every theory.
This is a special case of an infix. See also [[Dictionary Format#Prefixes, Infixes, and Suffixes|Prefixes, Infixes, and Suffixes]].
==== Conditional translation ====
Plover can output a conditional translation that depends on the following text. The following text is compared to a RegEx expression to determine what to output.
=== Canceling Formatting of Next Word ===
For example, this function can be used to make a single outline output "a" or "an" based on the text that follows.
In order to cancel formatting of the next word, use the empty meta tag as your definition:
* <code>{}</code>
=== Casing Modes ===
You can use certain translations to put Plover in a certain "mode", such as CAPS LOCK and Title Case. The mode can be changed or reset with another translation.
Using <code>{}</code> in front of a arrow key commands, as in <code>{}{#Left}</code>, is useful if the arrow key commands are used to move cursor to edit text. Canceling formatting actions for cursor movement prevents Plover from, for instance, capitalizing words in middle of a sentence if cursor is moved back when the last stroke, such as <code>{.}</code>, includes action to capitalize next word.
There are some built-in modes:
See also the [[Dictionary Format#"Do Nothing" Translation|"do nothing" translation]]
=== Format Currency ===
There is a built-in meta in Plover that allows you to format the last-written number as currency. The format is <code>{*($c)}</code> where <code>$</code> is any currency symbol you'd like, and <code>c</code> is the amount, formatted in standard currency format, with either no decimals or two. Commas are added every 3 numbers before the decimal automatically.
* <code>{*($c)}</code>: Standard English dollars
** <code>23{*($c)}</code> → $23
** <code>2000.5{*($c)}</code> → $2,000.50
* <code>{*($c CAD)}</code>: You can include other text, e.g. when specifying a currency's country
** <code>100{*($c CAD)}</code> → $100 CAD
* <code>{*(c円)}</code>: The symbol can be placed on either side of the number, which often happens in languages other than English and in certain regions.
** <code>2345{*(c円)}</code>: 2,345円
Here are some other currency symbols, in case you need to copy-paste them into your entries: £, ¥, €, $, ₩, ¢
Conditional translation depending on the following text. Outputs <code>text_if_match</code> if the following text matches the regex, otherwise outputs <code>text_if_no_match</code>. Regex is case-sensitive. For example, <code>{=[AEIOUaeiou]/an/a}</code> outputs "a" unless the next word starts with a vowel, in which case it outputs "an".
== Friendly Command Names ==
In a sufficiently-new Plover version, it's possible to use friendly names for some commands/metas.
For detailed descriptions of the commands, see the other sections.
{| class="wikitable"
!Command/macro/meta
!Equivalent
|-
|<code>{*}</code>
|<code>=retrospective_toggle_asterisk</code>
|-
|<code>{*!}</code>
|<code>=retrospective_delete_space</code>
|-
|<code>{*?}</code>
|<code>=retrospective_insert_space</code>
|-
|<code>{*+}</code>
|<code>=repeat_last_stroke</code>
|-
|<code>{^}</code>
|<code>{:attach}</code>
|-
|<code>{^word}</code>
|<code>{:attach:^word}</code>
|-
|<code>{word^}</code>
|<code>{:attach:word^}</code>
|-
|<code>{^word^}</code>
|<code>{:attach:word}</code>
|-
|<code>{&a}</code>
|<code>{:glue:a}</code>
|-
|<code><nowiki>{-\|}</nowiki></code>
|<code>{:case:cap_first_word}</code>
|-
|<code><nowiki>{*-\|}</nowiki></code>
|<code>{:retro_case:cap_first_word}</code>
|-
|<code><nowiki>{~\|word}</nowiki></code>
|<code>{:carry_capitalize:word}</code>
|-
|<code>{<}</code>
|<code>{:case:upper_first_word}</code>
|-
|<code>{*<}</code>
|<code>{:retro_case:upper_first_word}</code>
|-
|<code>{>}</code>
|<code>{:case:lower_first_char}</code>
|-
|<code>{*>}</code>
|<code>{:retro_case:lower_first_char}</code>
|-
|<code>{*($c)}</code>
|<code>{:retro_currency:$c}</code>
|-
|<code>{#shift(a)}</code>
|<code>{:key_combo:shift(a)}</code>
|-
|<code>{PLOVER:LOOKUP}</code>
|<code>{:command:LOOKUP}</code>
|-
|<code>{MODE:CAPS}</code>
|<code>{:mode:CAPS}</code>
|-
|<code>{.}</code>
|<code>{:stop:.}</code>
|-
|<code>{,}</code>
|<code>{:comma:,}</code>
|-
|<code>{$}</code>
|<code>{:word_end}</code>
|}
Note that currently the <code>{#a}</code> form will be interpreted literally in the "Strokes" text box of the Plover "Add Translation" dialog box, however entering a stroke mapped to <code>{:key_combo:a}</code> will enter the raw stroke into the text box.
== Undoable Line Breaks and Tabs ==
When you use [[Dictionary Format#Keyboard Shortcuts|keyboard shortcuts]], the asterisk/undo command on Plover will not have any effect. This is a limitation imposed by the fact that most commands will not have a meaningful undo. For example, you wouldn't "undo" a "copy" command. For this reason, <code>{#return}</code> and <code>{#tab}</code> don't work how many users would expect.
Instead, we must use special characters that can be undone by Plover for new paragraphs and erasable tabs. Specifically:
* <code>\n</code> or <code>\r</code> for line breaks.
* <code>\t</code> for tabs.
For example:
* <code>{^\n^}{-|}</code> This translation would create a line break without spacing and then capitalize the next word. It can be removed with the asterisk key.
* <code>{^\t^}</code> This translation presses the tab key without any other spacing. It can be undone with the asterisk key.
== Macros ==
Macros can be mapped from a stroke and perform operations on the stroke-level. This means that it can perform actions based on previous strokes, not necessarily on previous words or translations.
=== Undo / Delete Last Stroke ===
* <code>=undo</code>
The built-in "undo" macro is assigned to the asterisk key <code>*</code>. You can map other strokes to "undo" or "delete last stroke" by creating a stroke where the translation is <code>=undo</code>
=== Repeat Last Stroke ===
* <code>{*+}</code> A stroke mapping to this macro will send the last stroke entered. A common stroke to map to repeat-last is the bare number bar; <code>"#": "{*+}"</code>; causing <code>KAT/#/#</code> to behave like <code>KAT/KAT/KAT</code>. Repeat last stroke <code>{*+}</code> is very useful for keys that you repeat. For example, when you are moving around text in a document.
'''Suggested stroke:''' <code>#</code>
=== Toggle asterisk ===
* <code>{*}</code> A stroke mapping to this macro will toggle the asterisk key on the last stroke entered. For example, if you had this stroke in your dictionary as Number Bar + Asterisk, <code>"#*": "{*}"</code>, when you write <code>KAT/#*</code> it will behave as if you wrote <code>KA*T</code>. Toggle asterisk <code>{*}</code> is useful for when you notice that you should have included an asterisk in your last stroke. For example, you wanted to write the name "Mark" (a person's name), but you wrote "mark" (the noun/verb). At this point, you can use Toggle asterisk <code>{*}</code> to correct it. You wouldn't have to erase the word and re-stroke it (this time, with you including the missing the asterisk).
'''Suggested stroke:''' <code>#*</code>
=== Retroactively Add Space ===
* <code>{*?}</code> A stroke mapping to this macro will add a space between your last stroke and the one before that, splitting apart the two strokes. For example, if your dictionary contained <code>PER</code> as "Perfect", <code>SWAEUGS</code> as "Situation" and <code>PER/SWAEUGS</code> as "Persuasion". If you meant to write "Perfect situation", but saw your output was "Persuasion", you could force these two strokes to be split apart by using the <code>{*?}</code> stroke. This means your output would change on the screen from "Persuasion" to "Perfect situation".
* <code>{*!}</code> A stroke mapping to this macro will delete the space between your last stroke and the one before that. If you wrote "Basket ball" but wanted it to be "Basketball", you could force these strokes together by using the {*!} stroke. Plover will go back and remove the space before your last stroke; As a result, your output would become "Basketball".
Most Plover strokes are just text and formatting operators. Plover handles standard strokes really well. This allows it to handle "undoing" with the asterisk key, as well as automatically handling case and spacing. However, Plover's text and formatting strokes can't send arbitrary key strokes, such as sending keyboard shortcuts.
'''Note:''' Plover 3.1 introduces new rules for commands that differ slightly from the previous implementation. Before Plover 3.1, commands were used to send symbols because Plover didn't have full Unicode support. ''It used to be possible to send "+" by writing <code>{#plus}</code>, but the system has been updated.''
* <code>{#}</code> is the command operator.
Inside of a command block, you write in what keys you want Plover to simulate. The keys hit in command blocks won't be "undone" when using the asterisk (because you can't backspace a keyboard shortcut). You select the keys by their name. All key names will only refer to the base key. For example, to use letter keys, you just use the corresponding letter (case insensitive) separated by spaces:
* <code>{#a b c d}</code> will send "abcd" and will not affect Plover's text formatting or asterisk undo-buffer.
You can also use key names, which is needed when you are accessing a symbol key. For example, on the QWERTY layout there is an equal/plus key in the top right, which you can access by either of its names:
* <code>{#equal plus}</code> will send "==". Plover doesn't send modifiers. It just hits the key based on the name.
If you want to send symbols, though, don't use commands. Commands should be used for keyboard shortcuts only. Instead, use the symbol in your dictionary entry.
=== Modifier Names ===
If you want to use a modifier, use it by name (e.g. <code>Shift_L</code>). For convenience, all key names are case insensitive and you can optionally default to the left modifier by dropping the side selector:
'''Windows''': <code>Back</code>, <code>Forward</code>, <code>Refresh</code>'''Linux''': XF86 key names are supported, for example <code>XF86_MonBrightnessUp</code> - refer to the [https://github.com/python-xlib/python-xlib/blob/master/Xlib/keysymdef/xf86.py definition file in <code>python-xlib</code>] for the key names.
|}
Consult the code for the [https://github.com/openstenoproject/plover/blob/master/plover/key_combo.py#L21 full list of supported keyboard shortcut keys].
'''Note:''' a key name will determine a key to emulate with '''no modifiers''' based on your keyboard layout. For example, let's say we want to make a keyboard shortcut to hit shift-2 which is "@" in QWERTY: <code>{#at}</code> will only press the <code>2</code> key. To get the <code>@</code> symbol, we need to add the shift key: <code>{#shift(at)}</code>, which is functionally the same as <code>{#shift(2)}</code>.
=== Example Shortcuts ===
Here are some shortcuts. They are in JSON format:
* <code>"STPH-G": "{#right}"</code> — right arrow on the keyboard, for moving the cursor to the right once
* <code>"SKWR-G": "{#shift(right)}"</code> — shift and right arrow on the keyboard, for selecting one character
* <code>"SKWR-BG": "{#control(shift(right))}"</code> — shift, control, and right arrow on the keyboard, for selecting one word to the right on Windows/Linux
* <code>"SKWR-BG": "{#option(shift(right))}"</code> — option (alt), control, and right arrow on the keyboard, for selecting one word to the right on Mac
These next strokes are not particularly useful, but they show you what you can do with the command syntax:
* <code>"TKAO*UP": "{#control(c v v v)}"</code> — copy, then paste 3 times
* <code>"SKPH-Z": "{#control(z shift(z))"</code> — program-dependent, but possibly "undo/redo". Notice how the first z has only the control operator, and the second has both the control and the shift operator.
Commands are case insensitive - adding capitals will not affect the output. <code>{#control(z shift(z))</code> is the same as <code>"{#CONTROL_L(Z SHIFT(Z))}"</code>
=== Escaping Special Characters ===
Most symbols (e.g. <code>+, =, ~, r</code>) can just be included directly in the definition. But some symbols are part of the dictionary syntax and so need to be escaped:
{| class="wikitable"
!Symbol
!Escaped Form
|-
|<code>\</code>
|<code>\\</code>
|-
|<code>{</code>
|<code>\{</code>
|-
|<code>}</code>
|<code>\}</code>
|}
<code>\</code> is a special case. It must be escaped only if there's any possible ambiguity.
Special case: <code>=content</code> might be interpreted as the invocation of a macro named <code>content</code>. Use <code>{#}=content</code> instead.
If you edit the JSON file directly rather than with Plover's built-in editor/ [[File:Translation add.svg|link=|32px]][[Built-in_Tools#Add_translation_dialog|Add translation feature]], you need to escape those characters in addition, according to JSON syntax:
{| class="wikitable"
!Symbol
!Escaped Form
|-
|<code>\</code>
|<code>\\</code>
|-
|<code>"</code>
|<code>\"</code>
|}
Example:
{| class="wikitable"
!JSON
!Plover show
!Plover input
!Plover output
|-
|<code>"ab"</code>
|<code>ab</code>
|<code>ab</code>
|<code><nowiki><a> <b></nowiki></code>
|-
|<code>"\\{"</code>
|<code>\{</code>
|<code>\{</code>
|<code><{></code>
|-
|<code>"\\\\{"</code>
|<code>\\{</code>
|<code>\\{</code>
|<code><\> <{></code>
|-
|<code>"\""</code>
|<code>"</code>
|<code>"</code>
|<code><"></code>
|-
|<code>"\\"</code>
|<code>\</code>
|<code>\</code>
|<code><\></code>
|-
|<code>"\\\\"</code>
|<code>\\</code>
|<code>\\</code>
|<code><\> <\></code>
|-
|<code>"\\\\\\"</code>
|<code>\\\</code>
|<code>\\\</code>
|<code><\> <\> <\></code>
|-
|<code>"\n"</code>
|<code>\n</code>
|<code>\n</code>
|<code><\n></code>
|-
|<code>"\\n"</code>
|<code>\\n</code>
|<code>\\n</code>
|<code><\> <n></code>
|-
|<code>"\\x"</code>
|<code>\x</code>
|<code>\x</code>
|<code><\> <x></code>
|-
|<code>"\\\n"</code>
|<code>\\n</code>
|(none)
|<code><\> <\n></code>
|-
|<code>"\\\\n"</code>
|<code>\\\n</code>
|<code>\\\n</code>
|<code><\> <\> <n></code>
|}
Column explanation:
; '''JSON:'''
:how the entry is stored in the JSON file.
; '''Plover show:'''
:how the entry is displayed in Plover [[File:Translation add.svg|link=|32px]] "[[Built-in_Tools#Add_translation_dialog|Add translation]]" dialog. (version 4)
; '''Plover input:'''
:how the entry can be added to the dictionary using Plover "[[Built-in_Tools#Add_translation_dialog|Add translation]]" dialog. <code>(none)</code> means it's only possible to obtain the entry by editing the JSON in an external editor.
; '''Plover output:'''
:what Plover will send to the emulated keyboard when that stroke is pressed.
=== "Do Nothing" Translation ===
You can use the keyboard shortcut syntax (<code>{#}</code>) if you want a stroke that effectively does nothing. For example: a null or canceled stroke, which doesn't affect formatting, doesn't output anything, and cannot be "undone" with the asterisk key. A stroke mapped to <code>{#}</code> will effectively do nothing but show up in your logs.
* <code>{#}</code> an effective "null" stroke.
See also: [[Dictionary Format#Canceling Formatting of Next Word|Canceling Formatting of Next Word]]
== Output Modes ==
* <code>{MODE:}</code> is the mode operator
Plover supports special character casing, such as CAPS LOCK and Title Case. It also supports replacing its implicit space with other characters. This is useful for when you want to write_in_snake_case.
'''Output modes''' are activated with a special syntax in your dictionary. They can be a stroke or just part of a stroke. They can then be turned off with a special reset command.
An example flow for CAPS LOCK might be:
# Turn on CAPS LOCK.
# Write in capital letters.
# Turn off CAPS LOCK.
However, there's nothing stopping you from building in output modes into your strokes. For example, you might want your new paragraph stroke to reset the case mode, no matter what.
=== Reset Command ===
You can reset the output mode to its default with <code>{MODE:RESET}</code>.<blockquote>'''Important''': We recommended you have a reset output mode command, so that you can always reset Plover's output mode. This is in case you change it by accident.</blockquote>
* <code>{MODE:RESET}</code>: Reset the case and space character. We recommended this for getting out of any custom output mode. For example: <code>"R-R": "{^~|\n^}{MODE:RESET}"</code> and <code>"TPEFBG": "{#escape}{MODE:RESET}"</code>
* <code>{MODE:RESET_CASE}</code>: Exit caps, lower, or title case.
* <code>{MODE:RESET_SPACE}</code>: Use spaces as normal.
=== Modes ===
There are some built-in modes you can use:
{| class="wikitable"
{| class="wikitable"
!Dictionary Syntax
!Dictionary Syntax
Line 621:
Line 97:
|}
|}
=== Custom Modes ===
You can also define your own custom modes on the fly using additional translations.
You can define your own custom modes with the <code>SET_SPACE:</code> operator. This allows you to replace the space that Plover outputs with anything. Plover's snake-mode is the same as <code>SET_SPACE:_</code>.
Here are some other examples:
{| class="wikitable"
!Dictionary Syntax
!Sample Output
|-
|<code>{MODE:SET_SPACE:}</code>
|Thequickbrownfoxjumpsoverthelazydog.
|-
|<code>{MODE:SET_SPACE:-}</code>
|The-quick-brown-fox-jumps-over-the-lazy-dog.
|-
|<code>{MODE:SET_SPACE:😁}</code>
|The😁quick😁brown😁fox😁jumps😁over😁the😁lazy😁dog.
|}
== Summary of suggested commands you can cut and paste into your dictionary ==
Here is a summary of the suggested commands you can cut and paste into your personal dictionary:
<code>{
"PHR*UP":"{PLOVER:LOOKUP}",
"PHROFG":"{PLOVER:CONFIGURE}",
"PHROFBGS":"{PLOVER:FOCUS}",
"PHROBGT":"{PLOVER:QUIT}",
"KA*PD":"{*-|}",
"KA*PS":"{MODE:CAPS}",
"KPA*L":"{<}",
"*UPD":"{*<}",
"HRO*ER":"{>}",
"HRO*ERD":"{*>}",
"#":"{*+}",
"#*":"{*}",
"AFPS":"{*?}",
"TK-FPS":"{*!}"
}</code>
<blockquote>{{Info-Info|text=''Note:'' The final entry '''must not''' have a trailing comma.}}</blockquote>
[[Category:Plover]]
[[Category:Plover]]
Latest revision as of 08:32, 20 March 2026
format=frameless
This page needs clean-up. The information may be complete, but help revise the page by removing first-person speech, breaking up large blocks of text, adding inter-wiki links, and making information more concise and easy-to-read.
Plover reads three different dictionary file types by default and uses a unique dictionary format or translation language to encode extra information or commands into translations for outlines.
By default, Plover can interpret .json (recommended), .rtf, and .modal dictionaries.
With the installation of the plover-python-dictionaryplugin, Python also supports programmatic dictionaries in .py file format. After installing the plugin, Plover must be restarted before it loads Python dictionaries.
Currently, Plover does not support dictionary file formats from other CAT programs such as .dct or .sgdct formats. Plugins were previously authored to allow support in Plover, but as of March 2026, are not in working order.
JSON
The standard Plover format. These dictionaries contain a single JSON dictionary containing outlines mapped to translations.
The JSON format that Plover uses is not used or supported by other steno applications. If you want to move or copy your Plover JSON formatted dictionary to another steno software application, you must convert it to RTF. This is a default function in Plover, which can be found by right clicking highlighted dictionaries, and choosing "Save dictionaries as..." and then "Create a copy of each dictionary". This process may fail if the dictionary contains any unicode characters.
Unicode is supported in JSON format dictionaries since Plover 3.0.0.
RTF (aka CRE)
RTF dictionaries tend to cause Plover to take longer to start up and do not support Unicode.
RTF/CRE is an import/export format used by proprietary steno software. This means Plover can work with exported dictionaries from Eclipse, ProCAT, Case CATalyst, and other steno software applications.
Since the default .json Plover dictionary format only contains two pieces of data for each entry—an outline and a translation—most of the extra information concerning prefix, suffix, glue, and capitalization behavior must be included within the translation field.
Other dictionary formats contain more than two pieces of data per entry in order to separate out this information out.
In order to distinguish such information from the translation itself, Plover has a translation language that dictates how to encode it. Most of these commands utilize curly braces {}.
In English stenography, spaces are output by default before each translation. To indicate that a certain translation should stick to either the previous or following translation as a prefix or suffix, the ^ symbol is used. Depending on the formatting, you can also control whether Plover attaches these translations as-is, or according to orthography rules.
Glue
Glue is similar to affixes above, except that "glued" strokes only attach to neighboring "glue" strokes. To indicate a glue stroke, the & symbol is used. This is most frequently used for writing numbers and fingerspelling.
Translations containing only digits are glued, allowing you to output multiple number strokes to make a large number.
You can use Plover to type common keyboard shortcuts. For example, you may use the arrow keys to navigate. You may know Ctrl+C and Ctrl+V to copy and paste, or Alt+Tab to switch windows. You can encode these shortcuts as translations for steno outlines, using Plover translation language.
In contrast with text output, keyboard shortcuts cannot be "undone" with the * outline, similar to how you cannot backspace a shortcut on your keyboard.
You can control some aspects of Plover's function using certain translations, such as adding a translation, enabling or disabling output, using lookup, suggestions, opening Configuration, focusing, quitting, and modifying Plover config.
Plover's default dictionary commands.json contains some of these commands on default outlines.
Dynamic Functions
Modifying previous strokes
You can use Plover's translation language to repeat the last stroke, toggle the asterisk in the last stroke, and more.
The most notable translation in this category is the function of undoing the last stroke typed, which is the default way of "backspacing" in stenography and is assigned to the outline * in nearly every theory.
Conditional translation
Plover can output a conditional translation that depends on the following text. The following text is compared to a RegEx expression to determine what to output.
For example, this function can be used to make a single outline output "a" or "an" based on the text that follows.
Casing Modes
You can use certain translations to put Plover in a certain "mode", such as CAPS LOCK and Title Case. The mode can be changed or reset with another translation.
There are some built-in modes:
Dictionary Syntax
Sample Output
{MODE:CAPS}
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
{MODE:TITLE}
The Quick Brown Fox Jumps Over The Lazy Dog.
{MODE:LOWER}
the quick brown fox jumps over the lazy dog.
{MODE:CAMEL}
theQuickBrownFoxJumpsOverTheLazyDog.
{MODE:SNAKE}
The_quick_brown_fox_jumps_over_the_lazy_dog.
You can also define your own custom modes on the fly using additional translations.
