I brought Arduino systems into the classroom about five years ago. The hardware was fabulous and we built a number of fun robots. After a couple of years, I built some custom Arduino hardware for our needs. Our hardware has screw terminals for the inputs and outputs, a battery pack on the back and high-current motor controllers to animate the robots. Because these platforms are Arduino (with an ATmega 328P processor and a FTDI USB to serial converter) we can use the stock Arduino development tools.

Students struggled with the complex syntax of Arduino C: they found it especially hard to type the obscure punctuation marks and to remember to insert semicolons. I often heard comments like “this takes too much typing” and “why is it so picky about semicolons?” The lack of an interactive mode made experimenting a bit slower than on our Logo systems. In spite of the difficulties, there have been students who have done interesting projects in Arduino robotics:

The hardware was just what we wanted, and a few students used skills learned in the program later on. However, the software was not aimed at young students just starting to write code. Instead of throwing out our existing systems and starting over, I wondered if we couldn’t keep using the same (hand-made) hardware but improve the programming environment.

I searched for a tiny programming language that could run on Arduino and offer an experience more like Lego Logo. I wanted something that students could use as a foundation for further computer education and exploration, something very much like Python.

There is a smaller version of Python, called MicroPython: it is still a fairly large language which takes a few hundred kB of ROM and a significant amount of RAM. The language is also large enough that we couldn’t cover it in any detail in our class time.

I finally decided to just try and write a small Python-inspired language that could fit on our existing Arduino Duemilanove compatible hardware. This machine has:

I believe that shrinking the language to a small Python subset will let the language run on this hardware while also being simple enough to expose students to the whole language in a small amount of class time.

The goals of the Snek language are:

Snek is Python-inspired, but it is not Python. It is possible to write Snek programs that run under a full Python system, but most Python programs will not run under Snek.

A traditional exercise in any new language is to get it to print the words hello, world to the console. Because Snek offers an interactive command line, we can actually do this in several ways.

The first way is to use Snek to echo back what you type at it. Start up Snek on your computer (perhaps by finding Snek in your system menu or by typing snek at the usual command prompt). When it first starts, Snek will introduce itself and then wait for you to type something.

At this `> ` prompt, Snek will print anything you type to it:

Here we see that Snek strings can be enclosed in single quotes. Strings can also be enclosed in double quotes, which can be useful if you want to include single quote marks in them. Snek always prints strings using single quotes, so the output here is the same as before.

Snek is actually doing something a bit more complicated than echoing what you type. What you are typing is called an “expression”, and Snek takes the expression, computes the value that it represents and prints that out. In this case, the value of either 'hello, world' or "hello, world" is 'hello, world'.

Stepping up a notch, instead of inputting 'hello, world' directly, we can write a more complicated expression which computes it:

At this point, we’re using the feature of the interactive environment which prints out the value of expressions entered. Let’s try using the print function instead:

This time, Snek printed the string without quote marks. That’s because the print function displays exactly what it was given without quote marks while the command processor prints values in the same format as they would appear in a program (where you’d need the quote marks).

Variables are Snek’s way of remembering things. Each variable has a name, like moss or tree, and each variable can hold one. You set (or “assign”) the value of a variable using the = operator, and you get the value by using the name elsewhere:

Snek creates a variable whenever you assign a value to it for the first time.

Let’s define a function which uses print to print hello world and call it. To define a new function in Snek, we use the def keyword like this:

There’s lots of stuff going on here. First, we see how to declare a function by using the def keyword, followed by the name of the function, followed by the “arguments” in parentheses. We’ll talk about arguments in the next section, Simple Arithmetic. For now just type (). After the arguments there’s a colon.

Colons appear in several places in Snek and (outside of dictionaries) are used in the same way. After a colon, Snek expects to see a list of statements. The usual way of including a list of statements is to type them, one per line, indented from the line containing the colon by a few spaces. The number of spaces doesn’t matter, but each line has to use the same indentation. When you’re done with the list of statements, you enter a line with the old indentation level.

While entering a list of statements, the command processor will prompt with + instead of > to let you know that it’s still waiting for more input before it does anything. A blank line ends the list of statements for the hello function and gets you back to the regular command prompt.

Finally, we call the new hello function and see the results.

Snek normally ends each print operation by moving to the next line. That’s because the print function has a named parameter called end which is set to a newline ('\n') by default. You can change it to whatever you like, as in:

The first call appends a , to the output, while the second call explicitly appends a newline character, causing the output to move to the next line. There are a few characters that use this backslash notation; those are described in the section on String Constants.

Let’s write a function to convert from Fahrenheit temperatures to Celsius. If you recall, that’s:

Snek can’t use the ° sign in variable names, so we’ll just use C and F:

The # character introduces a comment, which extends to the end of the line. Anything within a comment is ignored by Snek.

The f_to_c function takes one “argument” called F. Inside the function, F is a variable which is set to the value you place inside the parentheses when you call f_to_c. In this example, we’re calling f_to_c with the value 38. Snek gets the value 38 from F whenever Snek finds it in the function:

Snek requires an explicit multiplication operator, *, as it doesn’t understand the mathematical convention that adjacent values should be multiplied. The return statement is how we tell Snek that this function computes a value that should be given back to the caller.

Numbers in Snek may be written using _ as a separator, which is especially useful when writing large numbers.

Now that we have a function to do this conversion, we can print a handy reference table for offline use:

We see a new statement here: the for statement. This walks over a range of values, assigning the control variable (F, in this case) to each of the values in the range and then evaluating the list of statements within it. The range function creates the list of values for F by starting at the first value and stepping to just before the second value. If you give range only two arguments, Snek will step by 1. If you give range only one argument, Snek will use 0 as the starting point.

We need to insert the numeric values into the string shown by print. Many languages use a special formatted-printing function to accomplish this. In Snek, there’s a more general-purpose mechanism called “string interpolation”. String interpolation uses the % operator. Snek walks over the string on the left and inserts values from the list of values enclosed in parenthesis on the right wherever there is a % followed by a character. The result of string interpolation is another string which is then passed to print, which displays it.

How the values are formatted depends on the character following the % mark; that’s discussed in the String Interpolation section. How to make that set of values on the right is discussed in the next section, Lists and Tuples

Lists and Tuples in Snek are closely related data types. Both represent an ordered set of objects. The only difference is that Lists can be modified after creation while Tuples cannot. We call Lists “mutable” and Tuples “immutable”. Lists are input as objects separated by commas and enclosed in square brackets, Tuples are input as objects separated by commas and enclosed in parentheses:

Let’s assign these to variables so we can explore them in more detail:

As mentioned earlier, Lists and Tuples are ordered. That means that each element in a List or Tuple can be referenced by number. This number is called the index of the element, in Snek, indices start at 0:

Lists can be modified, Tuples cannot:

That last output is Snek telling us that the value ('hello', ' world') cannot be modified.

We can use another form of the for statement to iterate over the values in a List or Tuple:

Similar to the form described in the Loops, Ranges and Printing Two Values section, this for statement assigns the control variable (e in this case) to each of the elements of the list in turn and evaluates the statements within it.

Lists and Tuples can be concatenated (joined into a single thing) with the + operator:

Tuples of one element have a slightly odd syntax, to distinguish them from expressions enclosed in parentheses: the value within the Tuple is followed by a comma:

Dictionaries are the fanciest data structure in Snek. Like Lists and Tuples, Dictionaries hold multiple values. Unlike Lists and Tuples, Dictionaries are not indexed by numbers. Instead, Dictionaries are indexed by another Snek value. The only requirement is that the index value be immutable, so that it can never change. Lists and Dictionaries are the only mutable data structures in Snek: anything else can be used as a Dictionary index.

The indexing value in a Dictionary is called the “key”, the indexed value is called the “value”. Dictionaries are input by enclosing key/value pairs, separated by commas, inside curly braces:

Note that Snek re-ordered our dictionary. That’s because Dictionaries are always stored in sorted order, and that sorting includes the type of the keys. Dictionaries can contain only one element with a given key: you’re free to specify dictionaries with duplicate keys, but only the last value will occur in the resulting Dictionary.

Let’s assign our Dictionary to a variable and play with it a bit:

This example shows creating the Dictionary and assigning it to d, then fetching elements of the dictionary and assigning new values. You can add elements to a dictionary by using an index that is not already present. When you ask for an element which isn’t present, you get an error message.

You can also iterate over the keys in a Dictionary using the same for syntax used above. Let’s try our print_list function on d:

You can test to see if an element is in a Dictionary using the in operator:

The for statement is useful when iterating over a range of values. Sometimes we want to use more general control flow. We can rewrite our temperature conversion chart program using a while loop as follows:

This does exactly what the for loop did in the Loops, Ranges and Printing Two Values section: it first assigns 0 to F, then iterates over the statements until F is no longer less than 100.

If statements provide a way of selecting one of many paths of execution. Each block of statements is preceded by an expression: if the expression evaluates to True, then the following statements are executed. Otherwise, the next test is tried until the end of the if is reached. Here’s a function which measures how many upper case letters, lower case letters and digits are in a string:

The elif statements try other alternatives if previous if tests have not worked. The else statement is executed if all previous if and elif tests have not worked.

This example also introduces the less-than-or-equal comparison operator <= and demonstrates that for v in a also works on strings.

General-purpose IO pins, or “GPIOs”, are pins on an embedded processor which can be controlled by a program running on that processor.

When Snek runs on embedded devices like the Duemilanove or the Metro M0 Express, it provides functions to directly manipulate these GPIO pins. You can use either of these, or any other device which uses the standard Arduino pin numbers, for these examples.

Snek supports 32-bit floating point numbers and understands the usual floating point number format:

All parts are optional, although the number must include at least one digit in either the integer part or the fraction.

Floating point values (represented internally in IEEE 854 32-bit format) range from approximately -1.70141e+38 to 1.70141e+38. There is 1 sign bit, 8 bits of exponent and 23 stored/24 effective bits of significand (often referred to as the mantissa). There are two values of infinity (positive and negative) and a “Not a Number” (NaN) value indicating a failed computation. Computations using integer values will generate an error for values which cannot be represented as a 24-bit integer. That includes values that are too large and values with fractional components.

Names in Snek are used to refer to variables, both global and local to a particular function. Names consist of an initial letter or underscore, followed by a sequence of letters, digits, underscore and period. Here are some valid names:

And here are some invalid names:

Keywords look like regular Snek names, but they are handled specially by the language and thus cannot be used as names. Here is the list of Snek keywords:

Snek uses many special characters to make programs more readable; separating out names and keywords from operators and other syntax.

Snek uses indentation to identify program structure. Snek does not permit tabs to be used for indentation; tabs are invalid characters in Snek programs. Statements in the same block (list of statements) are indented the same amount; statements in deeper blocks are indented more, statements in shallower blocks less.

When typing Snek directly at the Snek prompt blank lines become significant, as Snek cannot know what you will type next. You can see this in the Tutorial, where Snek finishes an indented block at the blank line.

When loading Snek from a file, blank lines (and lines which contain only a comment) are entirely ignored; indentation of those lines doesn’t affect the block indentation level. Only lines with Snek tokens matter in this case.

Spaces in the middle of the line are only significant if they are necessary to separate tokens; you can insert as many or as few as you like in other places.

String constants in Snek are enclosed in either single or double quotes. Use single quotes to easily include double quotes in the string, and vice-versa. Strings cannot span multiple lines, but you can input multiple strings adjacent to one another and they will be merged into a single string constant in the program.

Anything else following the backslash is just that character. In particular:

List and Tuple constants in Snek are values separated by commas and enclosed in brackets: square brackets for Lists, parentheses for Tuples.

Here are some valid Lists:

Here are some valid Tuples:

Note the last case — to distinguish between a value in parentheses and Tuple with one value, the Tuple needs to have a trailing comma. Only single-valued Tuples are represented with a trailing comma.

Dictionaries in Snek are key/value pairs separated by commas and enclosed in curly braces. Keys are separated from values with a colon.

Here are some valid Dictionaries:

You can include entries with duplicate keys: the resulting Dictionary will contain only the last entry. The order of the entries does not matter otherwise: the resulting dictionary will always be the same:

When Snek prints dictionaries, they are always printed in the same order, so two equal dictionaries will have the same string representation.

The ``=`` operator works a bit different on Lists than any other type — it appends to the existing list rather than creating a new list. This can be seen in the following example:(((=)))

Compare this with Tuples, which (as they are immutable) cannot be appended to. In this example, b retains the original Tuple value. a gets a new Tuple consisting of (3,) appended to the original value.

The Slice operator, value [ base : bound : stride ], extracts a sequence of values from Strings, Lists and Tuples. It creates a new object with the specified subset of values from the original. The new object matches the type of the original.

All three values are optional. The default value for stride is one. If stride is positive, the default value for base is 0 and the default for bound is the length of the array. If stride is negative, the default value for base is the index of the last element in value (which is len(value) – 1) and the default value for bound is –1. A slice with a single colon is taken as indicating base and bound. Here are some examples:

String interpolation in Snek can be confused with formatted printing in other languages. In Snek, the print function prints any arguments as they are given, separating them with spaces on the line. String interpolation produces a new String from a format specification String and a List or Tuple of parameters: this new String can be used for printing or for anything else one might want a String for.

If only a single value is needed, it need not be enclosed in a List or Tuple. Beware that if this single value is itself a Tuple or List, then String interpolation will get the wrong answer.

Within the format specification String are conversion specifiers which indicate where to insert values from the parameters. These are indicated with a % sign followed by a single character: this character is the format indicator and specifies how to format the value. The first conversion specifier uses the first element from the parameters, etc. The format indicator characters are:

If the parameter value doesn’t match the format indicator requirements, or if any other character is used as a format indicator, then %r will be used instead.

Here are some examples of String interpolation:

And here are a couple of examples showing why a single value may need to be enclosed in a Tuple:

In the first case, String interpolation is using the first element of a as the value instead of using all of a.

An If statement contains an initial if block, any number of elif blocks and then (optionally) an else block in the following structure:

If if_value is true, then if_statements are executed. Otherwise, if elif_value is true, then elif_statements are executed. If none of the if or elif values are true, then the else_statements are executed.

A While statements consists of a while block followed by an optional else block:

While_value is evaluated and if it evaluates as True, the while block is executed. Then the system evaluates while_value again, and if it evaluates as True again, the while block is again executed. This continues until the while_value evaluates as False.

When the while_value evaluates as False, the else: block is executed. If a break statement is executed as a part of the while statements, then the program immediately jumps past the else statements. If a continue statement is executed as a part of the while statements, execution jumps back to the evaluation of while_value. The else: portion (with else statements) is optional.

For each value v in the list of values, the for statement assigns v to name and then executes a block of statements. Value can be specified in two different ways: as a List, Tuple, Dictionary or String values, or as a range expression involving numbers:

In this case, the value must be a List, Tuple, Dictionary or String. For Lists and Tuples, the values are the elements of the object. For Strings, the values are strings made from each separate (ASCII) character in the string. For Dictionaries, the values are the keys in the dictionary.

In this form, the for statement assigns a range of numeric values to name. Starting with start, and going while not beyond stop, name gets step added at each iteration. Start is optional; if not present, 0 will be used. Step is also optional; if not present, 1 will be used.

If a break statement is executed as a part of the for statements, then the program immediately jumps past the else statements. If a continue statement is executed as a part of the for statements, execution jumps back to the assignment of the next value to name. In both forms, the else: portion (with else statements) is optional.

The Return statement causes the currently executing function immediately evaluate to value in the enclosing context.

In this case, the print statement did not execute because the return happened before it.

The Break statement causes the closest enclosing while or for statement to terminate. Any optional else: clause associated with the while or for statement is skipped when the break is executed.

In this case, the first example does not print else due to the break statement execution rules. The second example prints else because the break statement is never executed.

The continue statement causes the closest enclosing while or for statement to jump back to the portion of the loop which evaluates the termination condition. In while statements, that is where the while_value is evaluated. In for statements, that is where the next value in the sequence is computed.

The continue statement skips the execution of other += 1, otherwise other would be 12.

The pass statement is a place-holder that does nothing and can be used any place a statement is needed when no execution is desired.

This example ends up doing nothing as the condition directs execution through the pass statement.

The Import statement is ignored and is part of Snek so that Snek programs can be run using Python.

The From statement is ignored and is part of Snek so that Snek programs can be run using Python.

The Global statement marks the names as non-local; assignment to them will not cause a new variable to be created.

Because set_local does not include global g, the assignment to g creates a new local variable, which is then discarded when the function returns. set_global does include the global g statement, so the assignment to g references the global variable and the change is visible after that function finishes.

The Del statement deletes either variables or elements within a List or Dictionary.

If value is False, the program will print AssertionError and then stop. Otherwise, the program will continue executing. This is useful to add checks inside your program to help catch problems earlier.

def fname ( pos1 [ , posn … ] [ , namen = defaultn … ] ) : block

A def statement declares (or re-declares) a function. The positional and named parameters are all visible as local variables while the function is executing.

Here’s an example of a function with two parameters:

And here’s a function with one positional parameter and two named parameters:

Len returns the number of characters for a String or the number of elements in a Tuple, List or Dictionary

Print writes all of its positional parameters to the console separated by spaces (' ') followed by the end named parameter (default: '\n').

Flush output to the console, in case there is buffering somewhere.

Converts the first character in a string to its ASCII value.

Converts an ASCII value to a one character string.

Computes the absolute value of its numeric argument. The absolute value of a number is the number’s distance from 0.

Compute the square root of its numeric argument.

Terminate Snek and return value to the operating system. How that value is interpreted depends on the operating system. On Posix-compatible systems, value should be a number which forms the exit code for the Snek process with zero indicating success and non-zero indicating failure.

Pause for the specified amount of time (which can include a fractional part).

Return the time (in seconds) since some unspecified reference point in the system history. This time always increases, even if the system clock is adjusted (hence the name). Because Snek uses single-precision floating point values for all numbers, the reference point will be close to the starting time of the Snek system, so values may be quite small.

Re-seeds the random number generator with seed. The random number generator will always generate the same sequence of numbers if started with the same seed.

Generates a random value greater than or equal to 0 and less than 1.

Generates a random integer between 0 and max-1 inclusive.

Converts value into a number. value can be either a string or a number.

Prints optional prompt and then waits for the user to enter some text, terminated with a newline. The text, without the trailing newline, is returned.

Set the current output pins. If pin is a number, this sets both the Power and Direction pins. If pin is a List or Tuple, then the first element sets the Power pin and the second sets the Direction pin.

Sets the power level on the current Power pin to power. If the Power pin is currently on, then this is effective immediately. Otherwise, Snek remembers the desired power level and will use it when the pin is turned on. Values less than zero set the power to zero, values greater than one set the power to one.

Turns the current Direction pin on.

Turns the current Direction pin off.

Turns the current Power pin on.

Turns the current Power pin off.

Turns the current Power pin on, delays for seconds and then turns the current Power pin off.

Returns the value of pin. If this is an analog pin, then read returns a value from 0 to 1 (inclusive). If this a digital pin, then read returns either 0 or 1.

Removes any pullup or pulldown settings for pin, leaving the value floating when nothing is connected. Use this setting on analog pins to get continuous values rather than just 0 or 1. This is the default setting for Analog pins.

Assigns a pullup setting for pin, so that the read will return 1 when nothing is connected. When in this mode, analog pins will return only 0 or 1. This is the default setting for Digital pins.

Assigns a pullup setting for pin, so that the read will return 0 when nothing is connected. When in this mode, analog pins will return only 0 or 1. Note that some boards do not support this mode, in which case this function will not be available.

Turns all pins off.

Programs either a set of neopixel devices connected to the current Power pin (when Power and Direction are the same) or a set of APA102 devices connected to the current Power (used for APA102 Data) and Direction (used for APA102 Clock) pins (when Power and Direction are different). pixels is either a list/tuple of three numbers, or a list/tuple, each element of which is a list/tuple of three numbers ranging from 0 to 1 for the desired red, green and blue intensity of the target neopixel.

This example programs a single NeoPixel device, setting it to half-intensity green.

This example programs three NeoPixel devices, the first one is set to one third intensity red, the second to two thirds intensity green and the last to full intensity blue. If there are additional neopixel devices connected, they will not be modified. If there are fewer devices connected than the data provided, the extra values will be ignored.

On devices with an audio output, this sets the output of that pin to a sine wave at frequency Hertz. The amplitude is controlled by the power setting for the pin and whether the pin is turned on.

Sets the audio tone to frequency, turns the current Power pin on, delays for seconds and then turns the current Power pin off.

These provide frequencies commonly used in music, starting with middle C:

Reads characters from the console and writes them to eeprom until a ^D character is read.

Dumps the current contents of eeprom out to the console. If a parameter is passed to this function then a ^B character is sent before the text, and a ^C is sent afterwards. Snekde uses this feature to accurately capture the program text when the Get command is invoked.

Re-parses the current eeprom contents, just as Snek does at boot time.

Erase the eeprom.

Restart the Snek system, erasing all RAM contents. As part of the restart process, Snek will re-read any source code stored in eeprom.

The conversion function is pre-set with the parameters needed to convert from the temperature sensor value to degrees Celsius.

Puts the console into “visual” mode. Disables echo. Makes stdscr.getch() stop waiting for newline.

Resets the console back to “normal” mode. Enables echo. Makes stdscr.getch() wait for newlines.

All four of these functions are no-ops and are part of the API solely to make it more compatible with Python curses.

If nodelay is True, then stdscr.getch() will return -1 if there is no character waiting. If nodelay is False, the stdscr.getch() will block waiting for a character to return.

Erase the screen.

Displays string at row, column. Row 0 is the top row of the screen. Column 0 is the left column. The cursor is left at the end of the string.

Moves the cursor to row, column without displaying anything there.

Flushes any pending screen updates.

Reads a character from the console input. Returns a number indicating the character read, which can be converted to a string using chr(c). If stdscr.nodelay(nodelay) was most recently called with nodelay = True, then stdscr.getch() will immediately return -1 if no characters are pending.

On Windows and Linux, launch snekde from your application menu. On Mac OS X, Snekde is installed along with the other Snek files in the Snek folder inside your personal Applications folder, which is inside your Home folder. Double click on the Snekde icon to launch.

Snekde runs inside a console or terminal window and doesn’t use the mouse at all, instead it is controlled entirely using keyboard commands.

Snekde splits the window into two panes. The upper pane is the ”editor pane” that holds your Snek program. The lower pane is the “console pane” and handles communications with the Snek device.

Across the top of the window you’ll see a list of commands which are bound to function keys. Those are there to remind you how to control Snekde.

If your function keys don’t work, you can use the Esc key along with a number key instead. Press and release the Esc key, then press and release a number key. For instance, to invoke the F1 command, press and release Esc, then press and release '1'.

Between the two panes is a separator line. At the end of that line is the name of the currently connected Snek device, such as /dev/ttyUSB0 on Linux or COM12 on Windows. If there isn’t a device connected, it will say “<no device>”.

The cursor shows which pane you are currently working with. To switch between the editor and console panes, use the F7 key. If you don’t have one of these, or if it doesn’t work, you can also use Esc-7 or Ctrl-o (press and hold the Ctrl key, press the o key and then release both).

You can move around the current pane with the arrow, home, end and page-up/page-down keys. Cut/paste/copy use Ctrl-x, Ctrl-v and Ctrl-c or Esc-x, Esc-v and Esc-c respectively. To mark a section of text for a Cut or Paste command, press Esc-space or Ctrl-space then use regular movement commands. The selected region of text will be highlighted.

To connect to a device running Snek, press the F1 key (usually right next to the ESC key on your keyboard). That will display a dialog box in the middle of the screen listing all of the devices which might be running Snek (if you’ve got a serial modem or other similar device, that will also be listed here). Select the target device and press the ENTER key.

Don’t expect anything to happen in the lower pane just yet; you’ll have to get the attention of the device first.

Switch to the Console pane (F7) and press Ctrl-c to interrupt any currently running Snek program. You should see the Snek prompt (“> ”) appear in the pane.

The Snek device holds one program in non-volatile memory. When it starts up, it will run that program automatically. This lets you set up the device so that it will perform some action when it is turned on without needing to communicate with it first.

The Get command fetches the current program from the connected device and puts it into the Editor pane. The Put command writes the Editor pane contents into non-volatile memory in the target device and then restarts the target device to have it reload the program. Both of these commands will interrupt any running Snek program before doing any work.

You can also save and load programs to the host file system. Both of these commands prompt for a filename using a file dialog. At the top of the dialog is the filename to use. The rest of the dialog contains directories and files within the same directory as the filename. Directories are enclosed in [ ].

Using the arrow keys replaces the filename with the highlighted name. You can also edit the filename using backspace and entering a new name.

Select a filename by pressing enter. If the name is a directory, then the contents of that directory will replace the list of directories and files in the dialog. If the name is a file, then that will be used for the load or save operation.

To quit from the dialog and skip loading or saving a file, press Escape.

Snek nearly fills the ATMega 328P flash, leaving space only for the smaller optiboot loader. This loader is not usually installed on the Duemilanove or Nano, so you’ll need to install it by hand using a programming puck, such as the USBTiny device.

Use the Arduino IDE to install the Optiboot boot loader following instructions found on the Optiboot web site.

To install the regular version, once your board is ready to install snek, you can use avrdude to do that with Optiboot. On Linux, you can use snek-duemilanove-install (for Duemilanove and Nano), snek-uno-install (for Uno), or snek-lilypad-install (for LilyPad).

or

or

On other hosts, you’ll need to run 'avrdude' manually. For Duemilanove or Nano boards:

For Uno boards:

For LilyPad boards:

Replace 'COM1' with the name of the serial port on your computer.

To install the “big” version, you’ll need to use a programming device, such as a usbtiny from Adafruit. Once connected, on Linux you can use snek-duemilanove-big-install (for Duemilanove or Nano), snek-lilypad-big-install (for LilyPad), or snek-uno-big-install (for Uno):

or

or

On other hosts, you’ll need to run 'avrdude' manually:

or

or