Serenade is freely available for macOS, Windows, and Linux. To download Serenade, head to https://serenade.ai/download.

After installation, Serenade will walk you through installing plugins for supported applications, like VS Code, Chrome, and Hyper. Serenade will then guide you through interactive tutorials to practice voice coding.

Serenade can be configured to use cloud-based speech recognition or local speech recognition. To change this setting, just head to Settings > Server. If you're using Windows, the local server requires WSL with Ubuntu. Regardless of your setting, you can also opt into sharing your data with Serenade in order to help improve Serenade's speech-to-code machine learning models.

Serenade floats above all your other windows, so you can keep it side-by-side with other applications, like your code editor. You can toggle Serenade by clicking the Listening switch or pressing Alt+Space. Then, as you speak, you'll see a list of transcripts in the Serenade window.

Sometimes, Serenade isn't sure what you said, so you'll see a few different options. The first one will be used automatically, but to use a different option (and undo the first one), just say the number you want to use instead. For instance, to use the second option, just say two. If none of the options are right, you can just say undo.

As you'll see throughout these docs, most Serenade voice commands have the same form:

<action> <selector>

The action is something you want to do to your code. Common actions include add to add a new line of code, change to edit code, and delete to remove code.

A selector is a block of code to operate on. Some selectors are text-based, like line or word. Even more powerful selectors are code-based, which enable you to reference parts of your code, including function, class, and return value. For a complete list of selectors, see the Reference section.

Serenade commands simply combine an action and a selector: add function hello, change parameter to number, and copy lines five to ten.

You can also chain commands together without pausing. For instance, you can say save focus terminal to save your current file and then focus your terminal, or start of class add method hello to add a new method at the start of a class.

Finally, you can also specify how many times a command should be executed. For instance indent three times will run the indent command three times.

Below is a compact list of commonly-used Serenade commands that you can use as a reference or cheat sheet as you're learning voice coding.

go to <selector>

add <code>

insert <code>

change <old> to <new>

delete <selector>

copy/paste <selector>

indent/dedent

save

undo

open <text>

(next | previous) tab

focus <text>

The insert command will insert code at the current cursor position. insert is useful for appending text to an existing line of code or inserting text into the middle of a line.

insert commands look like:

insert (above | below)? <code>

hello world

two

one
two

add is used for writing new lines or blocks of code. This command will intelligently position your cursor and handle boilerplate for you. For instance, add parameter foo will move your cursor to the nearest parameter list, and then create a new parameter.

Below are just some examples of add commands—you can use any selector. All add commands have the same form:

add <selector> <code>

def factorial() -> int:
  pass

class Page:
  pass

return say("hello")

if x > 3:
  return
elif x < 3:
  pass

import numpy as np

capitalize(word[0])

# fix later

@app.route
def index():
  pass

class Colors(enum.Enum):
  pass

if not error:
  pass

callback = lambda e: pass

class Person:
  def name(self) -> str:
    pass

class Circle:
  radius = 3.5

while i != 0:
  pass

system inserts text wherever your cursor has focus, even if no Serenade plugin is present. For instance, you can use system to type into VS Code's "Find" dialog box rather than the main text editor. system also doesn't do much formatting for you, which can be useful if you want to drop down to a lower-level and manually specify all formatting, spacing, etc.

simple text

The change command selects the nearest match to the cursor and replaces it with some text.

change <selector> to <code>

set_color("foreground", "blue")

set_color("background", "blue")

def fly(height: int):
  pass

def fly(speed: int):
  pass

class Install:
  pass

class Setup:
  pass

You can also copy, cut, and paste code.

all too well

this is a long line of text

shake it off

You can delete code with the delete command. Below are just some examples of delete commands—you can use any selector. All delete commands have the same form:

delete <selector>

class Bird:
  def fly(self):
    // TODO
    return

class Bird:
  def fly(self):
    // TODO
    return

class Bird:
  def fly(self):
    // TODO
    return

Serenade supports a variety of commands for refactoring code. All refactoring commands have the same form:

# def random():
#  return 4

url = "serenade.ai"
// pages = 3
// download(url, pages)

y = f(x)
z = g(y)

    y = f(x)
z = g(y)

    y = f(x)
z = g(y)

y = f(x)
z = g(y)

message = Hello world

message = "Hello world"

value++
print(value);
value++
print(value);

def initialize():
  buffer.reset()
def initialize():
  buffer.reset()

first = "a";
second = "b";

second = "b";
first = "a";

z = f(x, y)

z = f(y, x)

list = [
  1,
  2,
  3
]

list = [1, 2, 3]

Serenade uses a combination of plugins and OS-level accessibility APIs to manipulate text no matter what application you're using. However, some applications don't properly implement accessibility APIs, and so Serenade can't read their text fields. When you're using one of these applications, you can use Serenade's Revision Box to format your text. Inside of the Revision Box, all of Serenade's commands will work properly, and when you're done, Serenade can copy the text in the Revision Box back into the application you had focused.

The Revision Box will open automatically when Serenade can't read the current field (if enabled in settings). You can also say revision box to open the revision box yourself. Or, say edit to copy the current text field into the revision box.

When Revision Box is open, you can say close to close and and ts contents into the field you were editing. You can also say enter to also press enter after inserting (e.g., for sending a message) or copy to copy the text to the clipboard rather than inserting it.

For more information on customizing the behavior of the revision box, see the API docs

Serenade has a few different configurable modes to change how your voice commands are interpreted.

Serenade's default mode is Command Mode. In this mode, if you say something that isn't a valid Serenade command, Serenade will show an x next to the command and won't do anything. To enable command mode, just say command mode.

Sometimes, like when dictating a longer block of text, you want Serenade to simply type out everything you're saying, rather than listen for other commands. Serenade's Dictate Mode does just that. To enable Dictate Mode, just say dictate mode, and then Serenade will type out everything you say, rather than listening for valid commands. Some commands, like undo, repeat, andstop listening, will also be presented as alternatives so you don't have to leave Dictate Mode to use them. To get back to normal mode, just say command mode.

By default, Serenade will auto-detect which programming language is being used based on your editor's filename or active language setting. Sometimes, you might want to override this behavior and specify which language Serenade should use. To do so, simply say python mode, javascript mode, and so on. To get re-enable auto-detection, say auto mode.

When speaking any command, you can also include symbols. Here's a list of all of the symbols supported by Serenade:

You can also enclose text in symbols like braces, brackets, and parens. Here's a list of all of the enclosure symbols supported by Serenade:

If you want to use the literal text representation of a symbol (e.g., the word dash rather than the - character, you can escape it by saying escape.

Below are just a few examples of commands using symbols—you can use any of the symbols above.

this.get(key)

first = array[0]

plus

To specify camel case, underscores, and so on, you can specify a style in any insert, add, etc. command. Below is a list of text styles:

When writing code with add and insert, you can specify text styles:

create(SomeClass)

myAge = your_age + 1

You can also style existing text by describing a style, followed by a selector to change:

foo

Foo

one two three

oneTwo three

Code selectors can be used to describe a block of code you want to reference, like a function, argument, or class. You can use any of these selectors in commands like go to, delete, change, or any command that contains a selector.

The following selectors work for supported languages:

Text selectors can be used to describe a block of text you want to reference, independent of any programming language. You can use any of these selectors in commands like go to, delete, change, or any command that contains a selector.

The following selectors work in any file, regardless of whether or not Serenade supports the language:

Below is a list of common modifiers you can use with any selector above. Modifiers can also be combined (e.g., delete next two words).

next | previous

first | second | ...

one | two | ...

start | end

<number> <objects>

X to Y

to start, to end

<object> <name>

phrase