PET 2001 Emulator Guide

Topics:

• Keyboard Input
• Emulator Controls
• Saving Files
• Loading Files
• BASIC Source Files
• Loading Programs from URL-Parameters
• URL-Parameters
• Utilities and Export Options
• Copy & Paste
• PET Manuals, Trivia, Etc

Keyboard Input

There are two major methods of input, the real keyboard on your computer and the virtual keyboard of the emulator.

Computer Keyboard

The support of real keyboards is set up so that you may type as natural as possible. Special characters are generally what they are on your keyboard. E.g., the double quote is still how you type it normally, probably a shifted key, while it is no a shifted key on the PET 2001. Hitting a normal letter key will produce this letter as normal, even if it appears in upper case on the PET. Shifted variants of PET characters are available for all of the alphabetic characters, allowing you to enter the common Commodore BASIC abbreviations naturally as on a real PET. However, shifted variants are probably not available in combination with special characters or punctuations. In this case, please resort to the virtual keyboard (see below). The shift key on your keyboard will still work, so you may shift-click a key on the virtual keyboard to access a graphics character.

The emulator works best with a full-size keyboard featuring a numeric keypad, which generally mirrors the layout of the PET 2001’s chicklet keyboard. This is especially true for games, which freequently make use of the numeric keypad for directional input. Cursor keys and editing keys, like HOME, DEL, etc, are supported as well and mapped to their PET equivalent, including support of shift keys. In order to mirror the PET 2001 keyboard layout even closer, the ENTER key on the numeric keypad is mapped to “=” and the decimal key is always mapped to a dot (“.”), even if it is a comma on your particular keyboard.

However, not all PETSCII characters have a direct equivalenant on modern keyboards. Therefore, a few special mappings are used:

STOP

is mapped to ESC.

↑

is mapped to the caret (“^”) and to TAB, as well,
SHIFT+TAB to Pi (π).

←

is mapped to the underscore (“_”) and to ALT+TAB,
ALT+SHIFT+TAB is mapped to “◥”

RVS

is mapped to “®”, which should be ALT+R on most keyboards.
The shifted variant, “RVS OFF“ should be also available by holding the SHIFT key. (May be subject to the type of keyboard used.)

The Virtual Keyboard

The virtual keyboard, depicted below the screen, is ideal for touch screens and also complements the real keyboard for the input of graphics characters. Simply tap or click a key on the keyboard image (visual feedbak is provided). To input a shifted character, first click/tap one of the two SHIFT keys and then click/tap the actual key. If you have a real keyboard, shift-clicking a key will work as well.

Touch Cursor Controls

The “touch cursor” allows you to freely position the cursor anywhere on the screen, by simply clicking or tapping onto the emulated screen. Repositioning the cursor will also force the editor out of quote/insert mode and reset any active RVS ON mode.

To use this feature, please activate the checkbox “Touch Cursor” below the emulated screen. Be aware that accidential clicks/taps may interfere with input statements. So, while this is helpful for editing and sketching up things on the screen, it may be best to leave this option off while running programs.

Keyboard Modes

The PET 2001 doesn’t feature key repeat. To the opposite, its operating system actively inhibits it. In order to facilitate natural keyboard input and fluent cursor movements, the emulator adds a key repeat of its own, both for the real keyboard and for the virtual keyboard. However, this usually isn’t best for games, which often implement a keyboard repeat of their own. Games will also benefit from the more immediate reaction of the unmodified keyboard input. Therefore, the emulator features a a special menu to switch between “Editing” (virtual key repeat on) and “Games” (virtual key repeat off) modes. This menu is found, like all other emulator controls, directly below the virtual screen.

Character Sets

The PET 2001 features, like all the Commodore 8-bit computers that followed, two character sets, one for upper case letters and graphics characters (default), and one for upper-case / lower case text and just a limited range of graphics characters. Mind that the original PET 2001, unlike later models, displayed unshifted characters in upper-case in both modes and displayed lower-case letters for shifted characters!

This is how you change the character set on the PET 2001 (by a POKE to a hardware address, the PCR of the VIA):

• POKE 59468,12 … switch to upper case / graphics.
• POKE 59468,14 … switch to upper case / lower case.

There’s also an item “Switch Character Set” in the “Utils/Export” menu (see below) and a respective item in the context menu for the virtual screen that will do the same for you.

Emulator Controls

The emulator features a set of basic controls, which are found below the virtual screen in two rows.

First row:

Reset

Resets the virtual PET in its current configuration. SHIFT-clicking or CTRL-clicking this button will reset the machine to default values (the same configuration the machine is using, when the page is initially loaded). If the page was loaded with a special configuration, like a link to a program to load (see below), the latter option will also create a new entry in the browser history.

Pause

Pauses and resumes the virtual machine, toggling between the respective states.
(The virtual machine will also be implictely paused, while a dialog is displayed or when the emulator is in a hidden browser tab.)

Utils/Export

A menu with various export options and some helpful utilities. This will be covered more extensively below.

Screen Color

PET 2001s came both with white screens and green phosphor screens. Select your favorite screen color here.

Keyboard Mode

Controls the virtual key repeat added by the emulator. Choose between “Editing” (repeat on) and “Games” (repeat off — unmodified input).

ROM Version

Choose between “ROM2”, also known as “new ROM”, the most common configuration, and “ROM1”, the version the very first PET 2001s came with. (However, since this had a few quirks and was missing some functions, like the built-in monitor, most of the early PETs were upgraded to the new ROM.)
ROM2 will be generally the best option. However, some old programs require ROM1.
Additionally, there is also an option for “ROM4”, but the emulator currently doesn’t support any of the additional disk commands that came with Commodore Basic 4.0. So this is practically identical to ROM2, as it uses the same zero page addresses and memory layout.
Changing the ROM version will reset the virtual machine.

RAM Size

Chosse between 8K, 16K and 36K of RAM.
While 8K was the standard configuration, some programs will require an extra amount of RAM.
Changing the RAM size will reset the virtual machine.

Second row:

Touch Cursor

This option allows you to freely position the cursor on the virtual screen by simply clicking/tapping on the desired location. Repositioning the cursor will also force the editor out of quote/insert mode and reset any active RVS ON mode. (Since this may interfere with input statements, this option may be best left off while running programs.)

Prg Library

Displays a list of programs in an overlay. Use the “run” or “online” links to try them in the emulator without reloading. (Shift-clicking such a link will create a new entry in your browser history.)
Shift-click or ctrl-click the button to open the program library in a new window.

Mount File

Use the file dialog to locate a program file or archive to mount, ready for use. See below for supported formats. Generally, just dragging and dropping a file onto the virtual screen of the emulator will be simpler und do the same job.

Directory

A button to access a directory listing may appear in this place, if you loaded/mounted a disk or tape archive (see below).

File Display

A mounted file will be indicated by a media icon and the file name next to it. Clicking the media icon will trigger the most appropriate action: either load and run a single program or bring up a directory dialog for an archive format.

Saving Files

The emulator has a virtual IEEE-488 device attached at address 8, which can be used to load and save files. To save a program, type “SAVE "NAME",8” (replace “NAME” by your actual choice) and the emulator will generate a binary file in .prg format. What happens next, may depend on your browser and your operating system: you may be prompted with a file dialog and a suggested filename, or the file may be simply downloaded to your normal download folder, or, if there’s no native support for this, the emulator will display a ribbon with a link, which you can right-click (or Cmd-click on Macs) in order to save the file.

There’s also an option “Save BASIC as PRG-File” in the “Utils/Export” menu, which does essentially the same, without requiring an explicit command to be typed into the virtual machine.

(Note that IEEE-488 doesn’t work very well with ROM version 1.)

Loading Files

There are several ways of loading a file into the emulator:

• Mounting a file and typing “LOAD "NAME",8” into the emulated PET. This will load any previously mounted file into the emulator.

  Note on ROM 1.0 (old Rom):
  IEEE-support isn’t great with ROM version 1 and requires pessing the STOP key. However, the emulator will press the STOP key automatically and will, in case the file starts at the usual BASIC start at $0401, attempt to adjust the BASIC system pointers accordingly to the program. If all works well, there shouldn’t be any notable difference in operations.

  Note on binary and BASIC pprogram types:
  Unlike with later Commodore 8-bit computers, files are always loaded absolute on the PET. In order to run BASIC programs from other Commodore machines, the emulator uses drive number 8 to force a program to be loaded to the usual start address of BASIC at $0401, as in “LOAD "8:NAME",8”.

• Dropping a file on the virtual screen of the emulator. An overlay and a glow around the edges will signal the reponse, as soon as you move a file over the virtual screen. Dropping the file onto the screen will either automatically load the program, if it is a single file format, or show a directory, if it is an archive. Drag & drop is probably the simplest option.
• If you have loaded previously an archive file, there will be a button “Disk Directory” or “Tape Directory”. Clicking this button will bring up a dialog to select the program and any options.
• You may load a program or archive by a special URL-link or directly from the Program Library.
• Finally you may click the media acount to the left of the displayed file name. This will trigger the most appropriate action, either reset and load + run a single file or bring up a directory dialog for an archive format.

Mounting Files

You may mount a file either via the “Mount File” button, which will give you access to your normal system file dialog or per drag and drop. Archive formats, like disk images, will bring up a directory dialog. The emulator supports full access via “LOAD”. There’s also full support for disk directories in drive 8 (including wildcards and type selectors). Tape archives (“.t64”) are handled like disks mounted in drive 8.

Supported File Formats

There are a number of file formats supported by the emulator, commonly known by their file extension:

• Program Files (.prg, .pet):
  This is the standard format for program files on Commodore 8-bit machines. It’s the same format the original machines used to save files on tape or on floppy disks.
  These files will be normally run automatically by the emulator. Hold SHIFT while dropping such a file onto the emulator to just load a program without running it automatically.
• D64 Disk Archives (.d64):
  D64 has somewhat become the standard format for floppy disk images for Commodore machines. Loading such a file will bring up a directory listing, where you may chose a prorgam to run and select some options.
  Options are:

  Load as BASIC

  Forces the virtual machine to load this file as a normal BASIC program. Normally, a program will be laoded as a binary file at the address found at the very beginning of the program-file, which is usually what you want (same as “LOAD "NAME",8,1” on later Commodore machines). However, you may want to run a BASIC program which was meant for a different Commodore 8-bit machine, which uses a different start address for BASIC programs. Check this option in order to do so and the PET will adjust the program to the usual start address.

  Reset

  This will reset the virtual machine prior to loading the program.

  Auto-Run

  Automatically run the program after loading. Otherwise, you’ll have to type “RUN” and press ENTER manually. However, you may want to inspect the program by typing “LIST” or using any of the Utilities (see below), in which case this option should be off.

  Min. RAM Size

  Lets you manually choose a RAM configuaration (the file size listed along the file names may provide a hint). Otherwise, the emulator will make a smart guess, which may not be that smart, anyway.

• T64 Tape Archives (.t64):
  T64 is for tape archives what D64 is for disk archives. The Directory Dialog for this has the same options as above.
  (Documentation for this format is somewhat lacking. The implementation has been tested with version $100 files and works, like VICE, for type 1 files, which are programs, only. Other file types, while parsed, will be ignored in the catalog. File sizes are checked to work around a common bug with early T64-files. Mind that T64 tape images are intended for the C64, however, some programs, like the type-in ones from books and magazines, will run on a PET with little adjustment. You probably want to load those programs as BASIC files and LIST them before running to check for POKE-commands, etc.)
• P00 Files (.p00….p99):
  This is a single-file format commonly found on DOS, but it’s also used to store PET programs in some rare cases.
• BASIC Source Files (.txt, .text, .bas, .ba):
  Load BASIC source files in plain text. Edit files in your favorite editor or copy them from type-in listings and simply drop them onto the emulator (or load it by the file-upload dialog). The editor will use the same algorithm as the real machine to transform them into regular, binary Commodore BASIC programs. The source code may be either in lower case or in upper case (or even mixed). The usual abbreviations for commands are recognized (works best in lower case source texts). PETSCII special characters may be escaped in curly brackets (“{…}”), see below for details.

The emulator will accept only files with any of the file extensions listed above and will handle the files based on that extension.

A places to look for program files may be www.zimmers.net/anonftp/pub/cbm/pet/ALLFILES.html (have a look at the sections demos/Cursor/ and games/). Download files to your computer and then drop them onto the emulator.

BASIC Source Files

Editing BASIC source file using your own, favorite text editor and simply dropping them onto the emulator is probably the most comfortable way of programming a PET 2001. (No chiclet keyboard, and, while the BASIC editor was certainly nice for its time, your text editor is probably better at it.) Just be sure to save the file as a plain text-file (Unicode is supported, of course).

BASIC source files maybe in either character case, the emulator will try to figure out the correct case for each of the lines. If a line starts in lower case, it will assume lower-case text. Otherwise, it will assume upper-case text (default). Meaning, you may even mix case between lines, as it may happen with copy & paste. Empty lines will be simple ignored.

The usual rules for BASIC text apply: You may use “?” for PRINT and even the usal Commodore BASIC abbreviation, like “pO” or “poK” for “POKE”. Mind that BASIC only accepts lines of up to 80 bytes length (that is, after tokenizing any BASIC keywords to single bytes). The emulator will abort with an error message, if a line exceeds the maximum length. Also mind that the maximum line number in Commodore BASIC is 63999!

Escapes for PETSCII Characters in BASIC source Files

BASIC source files must be in plain US-ASCII text only, with the notable exception of the PI symbol (π). Hence, any special PETSCII characters must be escaped in a special markup. (Mind that graphics characters may appear in BASIC only inside strings.) The emulator uses curly brackets for this (“{…}”), which may embrace either a PETSCII character code in decimal or hex notation or a label.

{ddd}

Decimal character code escape, like “{147}” (clear screen) or {18} (rvs on).

{$hh}

Character code in hexadecimal notation (with a leading dollar symbol), like “{$93}” (clear screen).

{label}

Most of the common labels for PETSCII screen control characters, like “{HOME}”, and their abbreviations are supported. This should work naturally. Any spaces or dashes are ignored. See below for an extensive list.

{n label}

The emulator even “understands“ markup with leading quantifier, as in {4 SPACES} or {12 DOWN}, as may be found in some listings (but will never export them for compatibility reasons.) This works also with decimal or hexadecimal character codes.

(In case the emulator fails to parse an escaped character code or dosen’t recognize a label, it will simply ignore it.)

Labels for PETSCII Screen Control Characters

The PET 2001 uses fewer control characters than later machines, just 12 in total, of which onl 7 may appear in strings. Here they are are, together with a few extra characters and the labels that may be used for them (spaces, etc in names are ignored, as well as case):

As you may see, there’s an abbreviation for everyone and most of the common abbreviations will be recognized. Just use what ever you are used to or what’s in the type-in listing. (The emulator will use the very first label in each of the lists, when exporting a program using labels, see below. Spaces or π will never be replaced by markup in any of those exports, as these are printable characters.)

Loading Programs from URL-Parameters

The emulator will load any of the programs from the Program Library using special hot-links. For security reasons, this option is restricted to files in this specific server directory and will not work with external resources.

Parameters are (either as a query string or as hash/fragment, separated by “&”:

• prg=<filename>, also program=, load=, run=
  Will load a program or BASIC source files. Binary programs will be run automatically, use “run” spefically to auto-run a text file. If there’s no file extension supplied, “.prg” will be assumed.
  Files may be located in disk or tape archives, an individual file inside an archive may be specified using a slash (/) as a path separator. If no file name is found, a directory list dialog will be displayed.
• disk=<filename>, also floppy=, d64=, dsk=
  Will load the specified disk archive and display a director list.
• t64=<filename>
  As above for T64 tape archives.

General URL-Parameters

Generally, default options may be specified in URL parameters, as well.
As above, parameters are (either as a query string or as hash/fragment, separated by “&”.

• keyboard=<option>, also kbd=, kbdmode=
  Configures the keyboard mode (key repeat). Valid options are “repeat”, “edit”, “editing” (key repeat on) and “norepeat”, “games”, “gaming” (key repeat off).
• repeat=<option>
  As above, but uses a truthy value, like “yes”, “no”, “off”, “true”, “false”, “1” or “0” to set the option.
• color=<option>, also clr=, screen=
  Sets the screen color. Valid options are “white” and “green”.
• ram=<size-in-K>
  Sets the RAM size. Valid options are “8” (default), “16” and “32”.
• rom=<version>
  Sets the ROM version. Valid options are “1”, “2” (default) and “4”.
• autorun=<option>
  Explicitely requests a program that may be loaded by an other parameter to be run automatically, regardless of the file type. Valid options are any truthy values (see repeat).
• asbasic=<option>, also isbasic=, basic=
  Explicitely requests a program that may be loaded from a a disk or tape archive (by an other parameter) to be loaded as a BASIC program (to the normal start of BASIC at $0401).

Mind that this allows you to bookmark a preferred configuration, like using the link ?screen=white&ram=32 for a white screen and 32K of RAM.

Programs as URL-Data

Finally, you may load an entire BASIC source text using URL parameters. The source may be either encoded using X-WWW-Form-URL-encoding (AKA form data) or as a base64 string. Again, this me be supplied either as a query string or in hash/fragement. All the above configuration parameters also apply and may be used in conjunction.

• data=<data-string>
  The data in the data string will be extracted, transformed into a binary BASIC program to be loaded into the virtual PET, just as if it came from a disk.
  The data format is assumed to be normal URL-encoded form data, if no format is specified at the immediate start of the data string.
  If a prefix “base64:” or “data:<mime-type>;base64” is found the following stream will be interpreted as base64 encoded data. (Suitable MIME-types are, text/plain, text/basic, application/text, application/basic, or application/octet-stream.)
  A file name to be used and displayd for the load command may be supplied by a parameter “filename=<string>” or “name=<string>”.
• execute=<data-string>, also exec=
  Same as above, however, the supplied data will be auto-typed into the virtual machine and executed in direct mode.

E.g., for a simple hello-world example,
?data=10%20print%22hello%20world%22&autorun=true,
or, using the hash/fragment,
#data=10%20print%22hello%20world%22&autorun=true.
(The difference is here, that a normal query string, strating with “?”, will be sent over the network, while a hash/fragment will be handled inside the browser only.)
And here’s an example for executing a statement in direct mode,
?exec=print(100+20)*5.
All the usual PETSCII escape may be used (see above), also “\pi” may be used to escape Pi (π), e.g.,
?exec=printsin(\pi/6)

The “Utils/Export” menu (see below) includes an option to automatically generate a data URL for the BASIC program currently in memory.

You may also use the Link Console to assemble a data-URL for the emulator.

Utilities and Export Options

The menu “Utils/Export” below the emulated screen provides a number of ways to export your work from the virtual machine or to interact with it in oder ways. As there are:

Options to Export the Screen Contents

• Screen Text as Unicode
  Transforms the screen contents into Unicode text and presents the result in a clipboard ready for copy & paste. Mind that there isn’t a suitable equivalent for every of the PETSCII graphics characters. The emulator will do its best to find a close representation.
• Screen as Image
  Exports the current screen as a PNG-image, which will be presented in a dialog ready for copying, or downloading it by drag & drop or by right-clicking the image.
• Screen as Image, No Margins
  The above option will add a small padding to the image. Use this option to get the smaller image as-is.
• Screen as Printer Hard-Copy
  As above, but transforming the image to resemble the output of a matrix dot printer.
• Screen Memory as Hex-Dump
  Exports the current contents of the video RAM (screen codes) as a hex-dump, ready for use in an assembler program.
• Generate BASIC Program
  Generates a BASIC program to reproduce the current screen, ready to be reused in a program. Think Photoshop in BASIC. A dialog lets you chose line numbers, steps in line numbers, the character case of the generated BASIC source, and the kind of escapes to be used for PETSCII special characters. (You may chose from transforming those to CHR$() statements, which will work everywhere, or any of the special escapes used by the emulator, compare the section on PETSCII escapes above.

Options to Export Memory Ranges

• BASIC as Escaped Listing
  Generates a listing of the BASIC program currently in memory, ready for copy and paste. There are a few options regarding the kind of PETSCII escapes to be used (decimal or hex, and whether or not to use any labeled escapes, like “{HOME}”, where applicable.)
• BASIC as Portable Listing
  As above, but any PETSCII special characters are transformed to CHR$() sequences. This is the most compatible option and should work everywhere. However, mind that there’s a small chance that a line may exceed the maximum length and the source may require some manual editing, because of this.
  The “escaped listing” may be preferable for the purpose of external editing.
• BASIC as Hex-Dump
  Generates a hex dump of the current BASIC program. Helpful, if you want to have a closer look, how BASIC actually encodes things.
• Memory Range as Hex-Dump
  This provides a hex dump of an arbitrary memory range. Start and end addresses default to the range of availbale RAM. If you want to inspect the ROMs, enter a start address of at least 0xC000.
• Memory Range as Disassembly
  As above, but provides a disassembly of the respective meory range.
  This is essentially the same dialog, which can be switched between hex-dump and disassembly modes back and forth in order to allow a convinient inspection of a given memory range using the most adaquate tool.
• BASIC System Pointers
  Shows a dialog with the most important system pointers for BASIC memory partioning by label, address, current contents (the address they are pointing to), along with a short description of their meaning.
  May be useful for debugging.

Other Utilities and Options

• Save BASIC as PRG-File
  Save the current program to your computer as a binary program file. This is essentially the same as entering “SAVE "FILENAME",8” in BASIC.
• BASIC Program as URL
  This exports a Link, which will load the current BASIC program in memory as a source file. There are options to adjust the format and encoding type of the link. — Mail your ten-liner to your friends!
• Renumber BASIC in Memory
  A renumber utility for BASIC. Enter start line number and step, the emulator will do the rest. This includes line numbers in statements like THEN, GOTO, GOSUB, ON … GOTO, and ON … GOSUB.
• Switch Character Set
  Switch between the upper case / graphics set and the upper case / lower case set. A prompt will tell you, what action will be performed and what mode the emulated PET is in currently. (Also, it will tell you, what POKE statement would be used in BASIC for this.)

Some of the screen related options are also available in a context menu of the virtual screen.

Copy & Paste

The implementation of copy & paste may vary with browsers and their specific implementation of security related features.

Copy & Paste via the Screen Context Menu

The first two items of the context menu of the virtual screen expose copy and paste functionality:

• Copy As Text
  This exports the contents of the screen as Unicode.
  If the browser supports clipboard interaction for this feature, the text will be immediately transferred to the system clipboard. Otherwise, a dialog similar to Utils/export > Screen Text As Unicode will be displayed.
• Paste To PET
  If the clipboard feature is supported, this will directly transfer the content of the system clipboard as typed text to the PET. A browser may show an additional button (typically labeled “Paste” or similar) or a permissions dialog (to be acknowledged once) as a security feature to confirm the interaction. If the clipboard interaction is not directly supported by your browser (e.g., Mozilla Firefox or older browsers), selecting the context menu item will bring up a dialog with a text-area for pasting.

Paste via System Commands

If the browser supports the feature and there isn’t a pop-updialog active, pasting is also supported via the system “Paste” menu item and its associated shortcut. (Currently, this is supported by all major browsers, as Google Chrome, Mozilla Firefox, Apple Safariat, at least in the respective desktop versions.)

Notes on Paste

Mind that you may only paste to a PET that is interactive and ready to accept keyboard input, meaning, it must not be paused and there has to be an active cursor.

Pasted text will be evaluated for case before it is transferred to the emulated PET and may contain the usual PETSCII-markup ({ddd}, {$hh}, {label}). To the PET it will appear the same as if the text had been typed in by the keyboard. Pasted text may stretch over multiple lines and may even encompass an entire program. If not present, a closing RETURN will be added to the text in order execute it.

Tip: Paste may be used to supply multiple values to input statements of a program, one line per input statement, which may come handy for testing.
E.g., pasting the following will enter a tiny program, run it, and will pass the values 4 and 5 to the executing program:

10 PRINT "RECTANGLE"
20 INPUT "SIDE A"; A
30 INPUT "SIDE B"; B
40 PRINT "AREA: "; A*B
RUN
4
5

However, mind that transferring a file per drag & drop is still the preferred and also quicker method of loading BASIC source texts.

PET Manuals, Trivia, Etc

PET 2001 Manuals

For more information on PET 2001 operations, you may download some essential references directly from this site:

• PET 2001-8 Personal Computer User Manual (PDF)
  Commodore Business Machines, Inc., October 1978
• Pocket Reference Guide to Commodore's 2001 PET (PDF)
  Leading Edge Computer Products, 1979

Further manuals and references can be found at www.zimmers.net/anonftp/pub/cbm/manuals/pet/ and www.commodore.ca/commodore-manuals/.

Trivia

Did you know that the PET 2001 has a built-in monitor in ROM? (ROM version 2, AKA “new ROM”, and ROM 4.0.) The interrupt vector points to the machine monitor. Therefor, jumping to any memory location containing zero (the 6502 instruction BRK) will give you immediate access to the monitor. Such a location is conveniently found at 0x0400, thus you may enter the monitor from BASIC by executing the command, “SYS 1024”.

Things not supported, but maybe nice to have

• Sound: While the PET doesn’t feature sound output, there was a common hack to hook up a speaker to the PET’s user port, which is supported by several games.
• IEEE support for OPEN and CLOSE for programs that require additional data files.
• A built-in 6502 assembler.

Let’s see…

N. Landsteiner, V.1.5, December 2022