Download

First, download and install Serenade. Serenade supports macOS, Windows, and Linux—platform-specific installation instructions can be found on the download page.

Setup

After installing Serenade, you'll be prompted to activate the app via an email link. If that link doesn't work, you can use the code provided on the activation page to activate manually.

After activation, Serenade can automatically install plugins for supported editors—Atom and VS Code. Make sure to restart your editor after the plugins are installed (to make sure the Serenade editor plugin is running), and you're ready to go!

You can use Serenade with your laptop microphone, though we recommend using a headset for the best accuracy. You can verify that a headset is being used by clicking , and then Microphone.

Environment

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.

Concepts

As you'll see, many Serenade commands take the same form: an action followed by a selector. An action is something you want to do to code, like a add, change, or delete. A selector is a block of code to operate on, like line, word, function, or class. To quickly reference common actions and selectors, check out the Reference section.

Throughout the documentation, you'll see blocks that look like this:

Good morning, ""

Good morning, "sunshine"

• Text in <angle brackets> is free-form text, like the name of a function or variable.
• Text separated by pipes, like (foo | bar), represents a list of choices (i.e., an or).
• Text in [square brackets] is optional.

Modes

Serenade supports different commnads depending on which application is currently in the foreground (i.e., focused). At the bottom-left of the Serenade window, you can see which application is currently active, along with an icon indicating which commands are available. Here the various modes Serenade can be in:

Code editing mode When your editor is in focus, and a file with a supported language is detected, all commands are available. Hover over the active app indicator to see the detected language.

Text mode When your editor is open to a file with a language that's not supported, a subset of commands are supported.

Global mode When your editor is not in focus, Serenade can still type raw text and run system commands.

The automatic reminder can be turned off in "Settings > Editor > Active app reminder", and it will always be available when the active app indicator is hovered over.

Inserting Code

The insert command will insert code at the current cursor position, handling many formatting details for you. For instance, if you have a variable foo_bar in scope and you say insert foo bar, Serenade will automatically format your code as foo_bar, so you don't have to specify the underscore.

The insert command is useful for appending text to an existing line of code, or inserting text into the middle of a line. When you're writing a new line of code, an add command might be faster, but you can also use insert to write any code, including functions, classes, and so on.

hello world

first = array[0]

value = 

value = "hello, world"

world

hello
world

Functions & Methods

While the insert code inserts text at your cursor, the add is a convenient way to quickly write larger programming constructs, like classes or methods, with voice. With the add command, you don't need to dictate the boilerplate parts of code, like braces after a try or parens around a condition. Unlike insert, the add command will also move your cursor for you. For instance, if you say add parameter, but your cursor isn't in a place where a parameter could logically go, add will automatically move your cursor to the right spot (in this case, to the nearest parameter list).

def compute_factorial():
    pass

class Game:
    def score(self):
        return 5

class Game:
    def players(self):
        pass

    def score(self):
        return 5

class Game:
    pass

class Game:
    def score(self) -> int:
        pass

def run(distance):
    pass

def run(distance, max_speed):
    pass

def say_hello():
    pass

def say_hello(name: str):
    pass

def foo(a):
    pass

def foo(a, foo_bar="baz"):
    pass

def get_name():
    pass

def get_name() -> str:
    pass

def set_limit(limit):
    pass

def set_limit(limit: int):
    pass

A parameter occurs in a function signature/definition, whereas an argument occurs when a function is called.

print("hello")

print("hello", first_name + last_name)

foo(a)

foo(a, b=1)

You can also use lambda within any add command to create an inline anonymous function:

f = lambda x: x

Classes

class DownloadManager:
    pass

class CategoryType(enum.Enum):
    pass

class Dog(Pet):
    pass

class Dog(Pet, Animal):
    pass

class Game:
    pass

class Game:
    players = 4

Conditions & Loops

if count == 10:
    pass

if True:
    pass

if True:
    pass
elif highest_score + 1 < 3:
    pass

if True:
    pass

if True:
    pass
else:
    return False

while i < 3:
    pass

for i in range(5):
    pass

Comments

# fix later

Expressions

import random

import random
import time

import numpy as np

from flask import Flask

try:
    write()
except e:
    pass

try:
    pass
except:
    pass

try:
    pass
except:
    pass
finally:
    pass

try:
    pass
except:
    pass

try:
    pass
except:
    pass
except ValueError:
    pass

age = current_age + 1

@app.route("/")
def index():
    pass

@app.route("/")
@login_required
def index():
    pass

print(value)

def get_random():
    pass

def get_random():
    return random.random()

def get_random():
    return

def get_random():
    return 4

You can also include a preposition after add or insert commands to add code at a particular location.

import random

def random(low, high):
    return 4

import random

def random(low, high):
    return 4


def roll():
    pass

Raw Text

The type command inserts text at the current cursor position, without much formatting done for you. It's the simplest way to add text, and it can be useful if you want to manually specify formatting, spacing, etc.

helloWorld

hello

hello
world

The dictate command inserts text, but doesn't convert coding symbols to their equivalents. This can be useful for writing comments or docs, rather than code.

a plus b greater than not c

Finally, system command inserts text wherever your cursor has focus. For instance, if you're using VS Code and open a "Find" dialog, system will type into that find dialog rather than the main text editor.

hello world

Deleting

You can delete code with the delete command.

In files in supported languages, you can navigate with any selector, and in files in unsupported languages, you can navigate with any text selector.

class Bird:
    def chirp(self):
        print("chirp")

    def fly(self):
        # TODO
        pass

class Bird:
    def chirp(self):
        print("chirp")

    def fly(self):
        pass

class Bird:
    def chirp(self):
        print("chirp")

    def fly(self):
        # TODO
        pass

class Bird:
    pass

class Bird:
    def chirp(self):
        print("chirp")

    def fly(self):
        # TODO
        pass

class Bird:
    def chirp(self):
        print("chirp")

class Bird:
    def chirp(self):
        print("chirp")

    def fly(self):
        # TODO
        pass

class B:
    def chirp(self):
        print("chirp")

    def fly(self):
        # TODO
        pass

Refactoring

Serenade has a number of powerful refactoring commands to edit your code quickly. You can use the comment command to comment out a line or an entire function, the indent command to change indentation levels, and the move command to move a block of code somewhere else in your file.

In files in supported languages, you can navigate with any selector, and in files in unsupported languages, you can navigate with any text selector.

def check(x):
    if x < 3:
        return True
    return False

# def check(x):
#     if x < 3:
#         return True
#     return False

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

url = "https://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)

list = [
  1,
  2,
  3
]

list = [1, 2, 3]

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

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

z = f(x, y)

z = f(y, x)

Common Commands

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

Actions

Add Commands

Selector Modifiers

Code Selectors

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

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:

Selector Syntax

By default, a selector applies to the nearest matching object. You can optionally apply previous or next to each selector, as in previous line or next line. Selectors can also include an ordinal prefix/postfix (like first or one) or a range of objects (like two to five).