Thursday, March 1, 2012

Ultimate List of Propeller Languages

The Ultimate
Propeller Programming Languages
(for the BIG BRAIN)

A List Created & Maintained by Humanoido
The most comprehensive source of programming languages for the Parallax Propeller Chip on the Planet! - Total: OVER 250 Languages & Versions (May include languages and their versions with variations as noted, authors, source URLs, information and download sites.)

Propeller Chip Language List
Language Links
Language Notes & Comments
Programming Language Converters
Debug Programming Methods
New Visual Languages!

Ultimate List of Big Brain Languages (Big Brain Blog Site) Current List!
The Ultimate List of Propeller Languages (Old thread no longer updated - Parallax 

List of Big Brain Installed Languages (Propeller P8X32A-D40 Chip) Documents many more languages that were installed into the Big Brain.

Showing languages in blocks of ten and indexed/counted for reference and study

10 ------------------------------------------------------------------------ 


 Propeller/Spin Tool Software v 1.2.6

Supports Win2K (and newer) and IE7 (and newer). Includes software, USB driver, Propeller Manual, PE Kit Labs text and example code, schematics, quick reference, Propeller Help and tutorial examples.


Everything is open source under the MIT open source license. I'll add the notice in the next update. The attached zip file contains a first cut at the simulator. I've implemented most of the Spin bytecodes, except for the cogxxx and lockxxx ones. Also the value for cnt is always zero. I'll transate the system time into a cnt value at some point. Pin-related operations don't really do anything. I also haven't implemented the bit read and write functions. The simulator runs in a DOS window on a Windows machine. Also, the basic I/O drivers are different. Instead of using FullDuplexSerial and FSRW the simulator uses conio and fileio. These drivers provide the same basic methods such as rx, tx, popen, pread, etc. You can use the Parallax Prop Tool, BST or homespun to compile the spin code and generate a binary file. spinsim loads the binary file and executes it.

Learn spin code with the Spin Stamp and the Board of Education BOT. The first three chapters of Andy Lindsay’s “Robotics with the Boe-Bot” plus objects from his PEK Labs 

(Not fully open source)
This is a command-line Spin compiler that reads .spin files and outputs .eeprom files. It is written in C# and runs on Windows with the .Net framework and on Linux with Mono. It generates output that is identical to Proptool's (except the occasional least-significant bit in floating-point constants), which was the original goal. It takes Spin source and generates a .eeprom file.


The bst suite of tools comprises : # bstl - The command line loader. This little application simply allows you to load pre-compiled .binary and .eeprom files into your propeller. It is a command line application that takes optional parameters and a file name. # bstc - The command line compiler. bstc is a completely Parallax syntax compatible SPIN and PASM compiler and linker.


This is a command-line assembler for the Parallax Propeller.
PLASMA by Linus 
The Propeller Low-level Assembly Aggregator (lft), Assembly Language Complier: Plasma is a small (637 lines of source code) tool for compiling and concatenating propeller assembly language (PASM) and binary data. It extends PASM with some new features, most notably ARM-like constant pools.

LAS: Largos LMM Assembler
 by Bill Henning 
Assembly Language Complier, Las Supports: * full Propeller instruction set * all Propeller condition prefixes * all Propeller effect codes * Pasm compatible storage allocation * Parallax “.binary” output format * Generating “COG” cog-only code * “LMM” code for HUB or XMM * hosted on Windows, Extensions: * native support for LMM instruction set extensions * automatically translates following ops to correct kernel calls and in-line constants in LMM mode * JMP * CALL * RET * LDI * PUSHI * PUSH * POP * YIELD * HALT * SYS * LIBCALL * additional pseudo operations for easier programming * CACHE/ENDCACHE block generated FCACHE and long count * Largos relocatable LMM executable format

This is a simple Basic interpreter for the Propeller. It supports a keyboard and either a VGA or TV display as well as an optional SD card with PC compatible FAT file system. It runs on the Propeller Demo Board, Protoboard, and Hydra. On the Hydra, the VGA version doesn't work with the SD card because the I/O pins involved conflict. An extended version with support for the IR Buddy is included as an example of extending the interpreter. Fix: SD card turned off when unmounted (thanks Cluso99). 

20 ---------------------------------------------------------------------- 

Continued modification of Michael Green's FemtoBASIC, which incorporates the AiGenericCF_Text_Driver for 40x23 color text. Changes with this update.. *Friendly, flashing cursor *Limited string variable support, A,B, & C can now store/manipulate a string type data. {Added commands, <PRINT A> <IFA="STRING"> <A="STRING"><INPUT"QUERY";A}

This modification of FemtoBASIC is geared toward minimal Propeller configurations (like a bare Protoboard or PEkit) allowing the use of FemtoBASIC with a connected PC running Propterminal. The Step-by-Step Tutorial for Protoboard New Users contains instructions for getting started with Propterminal and this revision of FemtoBASIC.

An adaption created for use with the BoeBot, supporting PING, IR,. and an HM55B compass,
This is a modified version of FemtoBasic designed to run on a Protoboard on a BOE-BOT chassis. It supports the wheel servos and a PING bracket servo, a PING sensor, an IR emitter/detector/distance sensor, and an HM55B compass. It uses a serial console via either an xBee wireless link or the USB programming port. Some sample programs are included. Like FemtoBasic, programs and data can be stored on an attached SD card.

An adaption created for use with Hitt Consulting's Propeller Dongle. This is a modified version of FemtoBasic intended for use with Hitt Consulting's Propeller Dongle or any other minimal Propeller board like the PropStick or PropStickUSB. It requires only the serial port used for programming, but will use an SD card on I/O pins 8-11 if present. Like FemtoBasic, it provides access to the I/O pins and counters and can use any EEPROM present for programs or data.

This is a modified version of FemtoBasic designed for the 4D Systems uOLED-96-Prop display with an integrated Propeller controller and uSD card socket. In addition to the usual FemtoBasic features including SD card support, this has a series of statements for controlling the display. The console is serial port because of the small size of the display and the absence of a standard keyboard interface. The archive includes a Basic version of 4D Systems' demo program.

The 8080 emulation for the Propeller will run MITS Altair Basic. You can now enter, edit and run programs written in one of Microsoft's first basics on your Prop Demo board! This is mostly the same as the CP/M for the Prop package (2.1) but: 1. Altair extended basic v4 is loaded into memory instead of CP/M. 2. Added emulation of the 8080 RST instructions as the BASICS use them even if CP/M does not. 3. Added emulation of the Altair's front panel switch register which is used by BASICS to determine serial port configuration. This build still includes disk emulation on an sd card but will run with no sd card present.
RGW_JTC_TinyBasic_010.spin by JT COOK
in folder JT_Cook/T_Basic_Mod_08_06_07 HYDRA CD
a tiny basic modified version

In folder Robert_Woodring/ RGW_HTBasic_08_03_06 HYDRA CD
Hydra Tiny Basic (HT Basic) is based on Dr. Dobb’s Journal’s various implementations of Tiny Basic. My version is loosely based on the work of Li Chen Wang’s Palo Alto tiny Basic and more so the version by Gordon Brandly’s 68000. The language is rather simple but should implement most statements and function to make a surprisingly useful implementation.

In folder Robert_Woodring/T_Basic_Mod_08_06_07 HYDRA CD
a tiny basic modified version

in folder Robert_Woodring/ RGW_HTBasic_08_20_06 HYDRA CD
a tiny basic modified version 

30 ------------------------------------------------------------------------ 

By popular request (humanoido) here is PropAltair running the tiny basic version called MINOL. This makes the HUB RAM look huge! As it happens there is a MINOL on the altairz80 simulator site. -heater. Tiny Basic was implemented on the Intel 8080/8085 and the original archived discussion page, reconstructed (with help from Volume 17 of the CP/M User's Group archives), is found here: MINOL-Tiny BASIC with Strings in 1.75K Bytes. Note the letter by Erik T. Mueller. Erik T. Mueller said... Dear Mr. Warren: May 1, 1976. I have a Tiny BASIC program running on my Altair that I think you might be interested in. I call it MINOL. It fits in 1.75K memory. Unlike the other Tiny BASIC's, MINOL has a string-handling capability, but only single-byte, integer arithmetic and left-to-right expression evaluation. Additions to TB include CALL machine-language sub- routines, multiple statements on a line (like TBX), and optional "LET" in variable assignments. Memory locations of the form (H,L) can be used interchangably with variables, permitting DIM-like operations. Sincerely, Erik T. Mueller... This information was updated 27 times. While the original posting from "Dr. Dobb's Journal of Computer Calisthenics and Orthodontia" no longer links the Tiny Basic listing or file, just scroll down farther on the page and provided is a listing of the 8080/8085 Tiny Basic code manually typed which can be copied and pasted from the html page! You can consult the more recent versions as archived links here (as I chose the oldest link from Jul 02, 1998)
The newest link is here, from Sep 28, 2007
Thanks to the Internet Archive WayBack Machine
At originally only 1.75K, a working version on the Prop would be absolutely remarkable. -humanoido (thanks to heater for making this possible!)
 General PBASIC functionality library, written in Spin, that mimics and extends many popular BS2 functions: COUNT, DEBUG, DEBUGIN, FREQOUT, PAUSE, PULSOUT, PULSIN, PWM, RCTIME, SEROUT, SERIN, SHIFTOUT, SHIFTIN. Version 1.5.0 adds methods for HIGH/LOW/IN, and continuous methods for FREQOUT, PWM and COUNT. It also add EEPROM access for code and high memory access using READ and WRITE methods. Don't forget to start -Needed for timing: BS2.Start(31,30)

This is a FREE ANSI C compiler for the Propeller, based on LCC.(Catalina shells out to Homespun and Homespun is not fully open source.) There are versions available for Windows and Linux. There is a tutorial to get you started, as well as a technical description of various aspects of Catalina. It includes Documents and demos. Binaries and sources for Win32 and Linux are also in posts.

(beta release )
will eventually be a substantially complete GWBASIC clone. Compiles under Catalina using the large memory model (requires 512KB XMM RAM). While not complete, this release (0.3) can be used to execute complete basic programs, such as Star Trek and the classic ELIZA psychoanalyst program - albeit slowly (e.g. it can take 20-30 seconds for Eliza to respond to each line of input). Dumbo BASIC is based on "Mini Basic" by Malcolm McLean, but is heavily modified to add many common basic statements that Mini Basic lacks, new types, and also some tweaks to support GWBASIC style syntax. It currently executes basic programs about 100 lines per second - about 10 times faster than Bywater BASIC. The ELIZA basic program and several versions of Star Trek are included, along with Dumbo BASIC binaries for the TriBladeProp and the HYDRA. There is also a DOS executable (the DOS version requires MinGW and GCC to compile).

GCC C compiler
Somewhere along the line it has been forgotten that the Prop can be programmed with the GCC C compiler. That is, there is a version of GCC that compiles for the 6809 and the resulting binaries are runnable under MoCog. MoCog is not perfected yet so perhaps this is a bit premature but early test programs for MoCog were created with GCC. - heater. The GNU Compiler Collection includes front ends for C, C++, Objective-C, Fortran, Java, and Ada, as well as libraries for these languages (libstdc++, libgcj,...). Some people have suggested porting one of the existing open source GPL C compilers: GCC (Gnu C Compiler) or SDCC (Small Device C Compiler). Both these were written to be retargetable, so a back end for the Propeller should be possible, again probably using the LMM. - "The home of GCC for 6809 is here MoCog can be found in the MoCog thread. Getting the compiled binary into a form ready load into MoCog with say a Spin "file" statement is a bit of a trick with objdump and or hexdump under Linux . I'd probably need to provide some instructions when MoCog is a bit more mature." - heater

BDS C COMPILER by Leor Zolman, runs under the z80 emulator
8080/Z80 C Compiler: Now Open Source and Public Domain! In 1979, I wrote a compiler for a subset of the pre-Standard ("K&R Classic") C Programming Language. The package was developed on, and targeted for, CP/M-80 floppy-based systems with as little as 32K of available system RAM. Originally intending to publish the source code in BYTE, I was eventually persuaded to turn the project into a retail product. Now BDS C's commercial potential is well in the past. Until recently, I had not been aware of the continuing international interest in 8-bit CP/M (and derivative) systems... upon this discovery, I found no reason not to render BDS C, along with all of its source code (including the 8080 assembly language compiler/linker sources), free to the public.

TINY.C by Les Hancock
a tiny interpreter which was published in Dr. Dobb's #41 (January 1980), pages 21-8. It was implemented using BDS C by Lee Bradley. A library file of this is at

MOUSE by Peter Grogono in 1979, thanks to LEE BRADLEY
Runs under the Z80 CPU emulator. Has a single character command set. Includes Mouse interpreter and sample Mouse programs. Lee Bradley revised a Mouse tutorial that he wrote some time back and he had an interest in not only putting the latest version on the web but also in making sure that everything was in the Public Domain. Simeon Cran's MYZ80 Z80 CPU emulator has a Public Domain version so it, along with a Mouse interpreter and sample Mouse programs.

C IMAGECRAFT ICCV 7.04 (not open source)
for Propeller Demo, Free fully functional ICCV7 45-day trial version. After 45 days, code-size limited 10 K for non-commercial use. Purchase either a non-commercial or standard license from Parallax. The ICC website has a good description of what you get with the Demo version as well as the Non-Commercial vs. Standard versions. You only get floating point with the Standard version. The Demo version works like the Non-Commercial version for 45 days, then will only compile programs up to 1/3 of the size of the Propeller's memory. You have to refer to ICCs documentation on any C programming questions including multi-cog programming.

PROPTINY - Jack Crenshaw's TINY language by HEATER
Runs on the demo board. Some time ago I worked my way through Jack Crenshaw's famous series of articles "Let's Build a Compiler." For those who know a little about programming but nothing about creating compilers, this is a fabulous introduction to that black art. Even if creating a compiler is not your goal, the simple parsing techniques described are worth a look at as they have many uses elsewhere. As I worked through the series, I worked the examples in C rather than Pascal as used by Jack and generated code for the Propeller rather than the original target, Motorola 68000. The result is an implementation of the TINY language defined in the series that generates PASM code for the Prop to be run under a Large Memory Model (LMM) virtual machine. TINY is a very simple block structured language in the style of Pascal and all. See the README.txt for instructions on building the compiler and compiling/asembling/downloading TINY programs. A simple example program with most TINY features implemented so far is included. 

40 ------------------------------------------------------------------------ 

HYDRA LOGO 1.41 by DREAMWRITER!! (old links)
Updated download link here and new thread here - now ported - works with Parallax Propeller Proto Board and Parallax Demo Board. Thank you Oldbitcollector! With this programming language you can draw neat things and stuff without using any sort of compiler/editor, just type commands and watch them happen. Here's a fun program you can type to get you started:
to spiral :ln
fd :ln
rt 92
fd :ln+1
rt 92
spiral :ln+2
Then just enter
spiral 4
and watch the fun!

LISP - for HYDRA, written in C. Takes 96K., by ROSSH
Added super trivial garbage collection to make it possible to execute more than just a couple of lines of lisp before running out of space! New version uses short pointers instead of long pointers - allows for over 3 times as many lisp nodes.

JAVA JVM BY Peter Verkaik
Run Java(TM) 1.1 code on Propeller. Allows lower cost hardware like Spin Stamp. Supports Propeller Proto Board hardware. Supports any minimalist Propeller hardware. Flexibile MIT licensed open source JVM. Leverages the extensive Javelin class library. Twice performance of Javelin in some tests

PropJavelin is a project to implement the functionality of the Javelin Stamp on the Propeller Chip. This is the implementation of a JVM which runs on the Propeller to allow Java(TM) programming of the Propeller. Java program development is undertaken using a modified version of the Javelin Stamp IDE.

 by Sal Sanci
PropForth 2.7 has several changes: fixed the error in the "saveforth" word, updates to documentation, instructions to generate new propforth.spin code. Additional updates to the documentation will be posted in the next week or so, currently enough is present to get up and running. Questions and comments are welcome. Please point out anything that needs clarification. Notice: PropForth is separate from propellerforth, which unfortunately has not been updated since 2008 and does not have any source available. PropForth has the spin source posted and can be modified in the source in addition to or in combination with modifying the forth dictionary. prof_braino notes that PropFORTH' author is Sal Sanci, same guy that made SPIN FORTH. PropForth is actually version 2 of Sal's SPIN FORTH. Instead of running out of the ROM based spin, it is completely run out of ram, the dictionary, tasker, and primatives are written in assembler. (prof_braino only does code reviews and posting of notifications).
The new version of PropForth is available on Google code
The PropForth version 3.2 file set is a single archive download. This version uses descriptive names and a (hopefully) clearer naming convention. The README.txt file included in the archive includes a list of the name changes to help bring forward any existing code.


Cliffe Biffle has created an open source complete Forth development system for the Propeller, called PropellerForth. If you are not familiar with what Forth is about, its basically a programming language and development environment that runs entirely on the Propeller. You do not need a PC to program your Propeller board (Prop Demo, Hydra supported) anymore. Once you use the Propeller Tool to upload the single binary image all your other development tasks are performed on the Propeller directly. Simply plug in a keyboard, hook up a TV, and off you go! I was a little confused a while back about what Forth is really about, so the best analogy I can give would be: It's like an open programmable dynamic "operating system" that can be modified on the fly, in real-time, while the system is running. Your best bet is to go download this rather amazing peice of work, and install it on your Propeller system. More information and links to file downloads available on the PropellerForth homepage.

Interactive ANS-subset Forth for the Parallax Propeller microcontroller.VERSION for Parallax HYDRA pf801-hydra.binary v8.01 for HYDRA (bugfix release) Jan 2008 10.0 KB

JDFORTH FORTH to SPIN Compiler by Carl Jacobs,
Not open source
Demo or pay. JDForth - the first compiler(?) that takes an input source file and generates a Spin object! • Input Files: Forth source files + PASM kernel. • Output File: A Spin object that requires only a single cog. • Easy interface allows Spin access to Forth words. • The resultant object may be instantiated multiple times for multiple Forth systems. • Unused forth and kernel words are optimised out for a minimal memory footprint. • Editor has syntax highlighting for forth (*.jd4) as well as kernel (*.pasm) files...

Under General Public License

A forth for the propeller chip, written in spin and assembler, includes an assembler. 2008-Jan-24 Version 1.1 - fixed one outstanding bug "if else else then" bug, and changed console handling so you can write an IO device on a cog and use it as the console. One minor change to avariable to support smoother assembler operation which will be documented in the next 60 - 90 days. 2007-Dec-19 Here it is, rev 1.0 and for lack of any plan, It is under GPL. If anyone wants something else, let's talk offline. All this has only been tested with the propeller protoboard, and teraterm pro v4.51
as a terminal program. I run teraterm at 115.2 kb with 8 bits, no parity, 1 stop bit, no flow control, 1ms delay per line. Tested with prop clip, and RS232 port on Toshiba laptop.

Proof of Concept Thumb VM implementation attached. Not comprehensively tested but it runs the embedded Thumb VM Program which proves the most common functionality, including branch and subroutine call and return. It increments a value in a fixed location in hub memory, Tv_Text displays it. Currently uses an in-Cog subroutine call stack but external stack is easy enough to add and it shouldn't have too much impact on speed. A casual stopwatch test suggests it's delivering just under 1MIPS at 80MHz. That gives PASM around a 20:1 speed advantage. For "mov a,b" and similar PASM has around a 12:1 advantage. Thumb VM is approximately three times slower than LMM, but there's no reason Thumb VM cannot support native 32-bit instructions LMM-style... 

50 ------------------------------------------------------------------------ 

For those of you with experience in compiler writing ... Here's a little work-in-progress. This is a compiler-compiler that runs on a Propeller (5MHz xtal, 128K EEPROM, attached SD card, programming port as console). It reads a source program from a file on the SD card and compiles it into Spin in another file on the SD card. The language involved is a simple compiler writing language called Meta2 that dates back to the 1960's and has been used to bootstrap several compilers including a Pascal compiler. It needs a little work before I consider it suitable for compiling anything other than itself, particularly the addition of a simple symbol dictionary, but I thought it might be interesting for others to see it now that it can compile itself. The support library (object) may also be generally useful since it has routines to scan Spin and C type comments, convert Spin constant formats to binary, and recognize identifiers and string constants. The actual input and output files are 32K areas in the EEPROM. The EEPROM writing is buffered to minimize the amount of writing.

web site by mparkSphinx is a Spin compiler—written in Spin—that runs on the Parallax Propeller. Although memory constraints prevent Sphinx from compiling the full gamut of Spin programs (see Limitations at url), it is not a toy compiler. It can compile many complex and substantial programs, including those containing Propeller assembly language, such as the Parallax tv and graphics objects. Sphinx can also compile itself. Hardware requirements: Sphinx requires a Propeller system with the following peripherals: * SD card interface (fsrw-compatible) and SD card. * NTSC video interface and NTSC display device. * PS/2 keyboard interface and PS/2 keyboard.

Introducing MoCog an emulation of the Motorola 6809 microprocessor for the Propeller. In the few slack moments I have nowadays I have been converting the ZiCog Z80 emulator into a 6809 emulator. As usual with me this is a very unfinished early release. There is a lot of code in place but very little is tested. So far it just about single steps its way through a short loop of
ADDA $01
JMP $0000
No flag setting is in place. This should compile with BST or homespun for the Prop Demo Board if the following defines are set: "PropDemoBoard" and "SingleStep". Just compile, download and watch the output in the terminal window of BST or ProTerminal or whatever. Hit any key to take single steps through the loop.

Bean's pasm based compiler - The PropBASIC compiler will compile BASIC code into Propeller assembly language (PASM). The compiler is based on the SX/B compiler that was written for the SX processor. The compiler does a "compile in place". In other words each line is translated directly into PASM code. This results in very fast code. PropBASIC is still in development, but some example programs are posted in this thread

LMM basic compiler

There's also Clojure, a Lisp variant whose compiler targets the Java
Virtual Machine, for which there's, apparently, a port to the Propeller


This is "Bywater BASIC" for the Propeller - a complete BASIC development system. Bywater BASIC provides a self-contained BASIC development environment with floating point and real-time clock support, plus file system support which can be used to load and save BASIC programs, as well as read and write arbitrary data files. Full source code and documentation is included

an Infocom game interpreter from the grand old days of text-based computer games. With this interpreter, and suitable game files, you can play all the Infocom greats - Zork, Deadline, Suspended, Witness, Hitchhikers Guide to the Galaxy, A Mind Forever Voyaging, Starcrossed ... etc


The P4 compiler is open-source so can be modified and tailored to make it more Propeller Chip friendly and useful. It's not a complete Standard / ISO 7185 Pascal but a reasonable implementation. 

60 ------------------------------------------------------------------------ 

A Motorola 6809 emulator for the Propeller. This should compile with BST or homespun for the Prop Demo Board if the following defines are set: "PropDemoBoard" and "SingleStep".

 - Basic Compiler
Ouroboros and ouroboros1 are left-overs from a project to make a Basic to LMM compiler for the Propeller. I forgot to delete them from the archive for the Winbond/SRAM driver. They're not in the Object Exchange version of the driver. Here's my long ignored working directory, comes with no guarantees, no documentation or explanation other than that Ouroboros.spin is an attempt to create an editor front end, never quite worked. I think there was a problem with the SD card I/O routines. ExOuroboros.spin is the beginning of a compiler. It can process declarations and allocate storage and some of the code generation for expressions and simple flow of control seemed to work.

Basic Compiler. Ouroboros and Ouroboros1 are left-overs from a project to make a Basic to LMM compiler for the Propeller. I forgot to delete them from the archive for the Winbond/SRAM driver. They're not in the Object Exchange version of the driver.

 , contributions by BAGGERS

 The obvious first step was to code up a 6502 core, keeping in mind the requirements for use in a 2600 emulator. Attached is my first attempt at a 6502 core.

ClusoInterpreter (v260C_007F) - high speed SPIN by CLUSO99
 Chip's Interpreter 
executes 4114 PASM instructions for 100 spin instructions. My RamInterpreter executes 3889 PASM for the same code. I have 3 versions of the Interpreter now running simultaneously (executing the same spin code), Cog 5 runs the Rom Interpreter, Cog 6 runs the Ram Interpreter (basically the Rom Interpreter in Ram with a couple of mods), Cog 7 runs the Cluso Interpreter (the faster modified version under test in Ram). This allows me to compare the results and debug the ClusoInterpreter.

A toolchain which will allow the free LCC compiler to be used for C programming of the Propeller. The toolchain will create self-contained executables for download into the Propeller chip or C programmed objects to be incorporated within and used by a Spin program. It is a command line toolchain but designed to be easily callable by GUI front-ends or IDE's. Primary goal is creating small executables rather than delivering high speed of execution. Proof of concept and prototype working. Components are currently being re-written, improved and enhanced ( Sep 2008 ).

Specification for a Large Memory Model with access up to 512 klongs of code and 512kbytes of data. LMM Kernel Specification v1.0 - pacito version. The purpose of this specification is to serve as basis for a large memory model (LMM) for the Parallax Propeller. This would extend the usable memory area beyond the 2kbytes of COG's memory. This specification requiers the following hardware support: - A parallax propeller v 1.0 - Am external RAM (DRAM or SRAM) for more than 32 kbytes of code.

PROPBS1 Basic Stamp Propeller by HIPPY 
A downloadable software emulator which will allow a developer to program in PBASIC, use the Basic Stamp development tools and use the Propeller as if it were a Basic Stamp. Will emulate the BS1 and, hopefully, BS2, but requires further R&D in that direction. Proof of concept and prototype working. Project queued behind others. Spin, PASM plus LMM. Deliverables to be decided; downloadable .binary will be provided but the project may not be 'open source' in whole or part. Licensing to be decided.

Urban Müller's Brainf*** BF IMPLEMENTATION BY JAZZED"BF is a programmer's toy; it is an incredibly obscure "write only language" (this means "once you write it, you may as well forget about reading and understanding it after just a few hours" :) The BF interpreter is implemented in less than 120 PASM instructions. Various trivial demo program strings such as "Hello World!" are included. The "99 Bottles" demo is default. The PASM interpreter has an interface to serial input/output provided by the demo code; the interface should be easily changed to a keyboard/TV with a little work. The _XINFREQ is set to 6MHz (PLL16), so watch out." (Steve) "I'm not so sure that BF, or something similar, is totally bereft of practicality. It may well be an appropriate language for adaptive programming via a genetic algorithm. It has a small alphabet and is much more DNA-like than typical procedural languages. Moreover, once a program is optimized, there is no reason it couldn't be translated back into something that runs more quickly."

70 ------------------------------------------------------------------------ 

12BLOCKS (formerly SPINNER) by HANNO
Easily create programs by dragging blocks together. The library of ~100 blocks makes it easy to build games, robots and more. All the complexity of cogs, objects, memory and variables is handled for you- leaving you free to focus on your code. Comes with ~10 sample programs, a 20 page tutorial, a 30 page manual, videos, and a wiki illustrating what others have accomplished. Perfect complement for the "Parallax Demo Board" for beginners - but powerful and extensible enough for anyone.


runs CPM2.2, CPM3, programs, development tools and languages

This OS now runs on the simulated Z80 processor, emulator on Prop For many languages supported under CPM2

Microsoft BASIC with CP/M 2.2

CP/M Version 1.4

Personal CP/M
Operating system, Customized BIOS, Sources for CCP, BDOS and BIOS

CP/M Version 3 with banked memory
Operating system, Altair BIOS source, Support for various CP/M disk formats including Apple II CP/M

MP/M II with banked memory
 Operating system with support for 8 banks, Multi terminal support for 4 terminals via Telnet, Multi user and multi programming, Altair XIOS source.

PropDOS 1.6
 released by Oldbitcollector
Installing PropDOS as the single program on your EEPROM allows you to display and choose what programs you want to start just as you would have with DOS on a PC. PropDOS has the following requirements for operation: 1. An SD interface with installed SD media  (Storage for all your other spin programs), 2. Composite (TV) Video, 3. A PC keyboard. All additional programs you chose to run are simply added to your SD card as binaries using your PC.

80 ------------------------------------------------------------------------

Operating system, CP/M compatible replacement for both CCP and BDOS, All sources for system generation, Original sources are on C. B. Falconer's site


CP/M 2.2 with NovaDOS as BDOS replacement, All sources for system generation

CP/M 2.2 with P2DOS as BDOS replacement, All sources for system generation

a complete CP/M compatible replacement for CCP and BDOS from MICROCode Consulting featuring time/date stamping. Includes the source of the modified BIOS, documentation, LinkZ and DebugZ. QP/M, LinkZ and DebugZ are free for non-commercial use but see the restrictions. Download at

 , CP/M 2.2 with SuperDOS as BDOS replacement. All sources for system generation

, CP/M 2.2 with Z80DOS as BDOS replacement, all sources for system generation

CP/M 2.2 with ZSDOS as BDOS replacement, all sources for system generation

full release of Z-System based on CP/M 2.2, All sources included, user manual in PDF format, see also the MaxZ80 tutorial by Lee Bradley

Full release of Z-System based on CP/M 3, All sources included, User manual in PDF format.

TurboDOS in single user mode, AltairZ80 specific sources included, For more information visit Bill Buckels' The TurboDOS Museum 

90 ------------------------------------------------------------------------

 , 86-DOS version 1.00 by Seattle Computer Products 
See also Howard's web site on 86-DOS

 , 56K IMDOS VERS 2.05, CP/M 2 compatible operating system

CP/NET 1.2
 Server based on MP/M
Client based on CP/M 2.2, All customized sources on disks, CP/NET server can serve one or two CP/NET or CPNOS clients, Works on all platforms supported by SIMH


Altair DOS Version 1.0

100 ------------------------------------------------------------------------

MITS Disk Extended BASIC Version 4.1

Altair Disk Extended Basic Version 300-5-C available by Scott LaBombard]h.../cpm/intro.php

Altair Disk Extended Basic Version 5.0
from Andrew Kessel's site

MINOL based on documents retyped by Emmanuel ROCHE]h.../cpm/intro.php

VTL-2 based on documents retyped by Emmanuel ROCHE]h.../cpm/intro.php

 : a compiler for a C-like, Simple Programming Language]h.../cpm/intro.php

PROLOGZ (interactive Prolog development environment)]h.../cpm/intro.php

Pascal MT+ compiler and Pascal pretty printer (Pascal source)]h.../cpm/intro.php

ACT 3.0 Assembler by SORCIM

110 ------------------------------------------------------------------------

 - Version 1.5.0 with sample programs

Algol-M - Version 1.1
 with sample programs

apl/z v1.1
 with some documentation and utility functions

Microsoft BASIC-80 Rev. 5.21

Microsoft BASIC Rev. 5.1

Microsoft BASIC Rev. 4.51

Microsoft Basic Compiler BASCOM 5.30a

Digital Research CBASIC Compiler Version 2.8

Digital Research CBASIC Compiler Version 2.0

CBASIC Compiler Version 2.07

120 ------------------------------------------------------------------------

Xitan Z-80 High Precision Disk BASIC Version 1.06

Softaid MTBASIC Multitasking Basic Compiler V2.6g

PDFS-BASIC Compiler Version 5.4b

S-BASIC Compiler Version 5.4b

Real Time Microsystems TARBELL BASIC

BDS C 1.60 distribution

Comes with CP/M Version 2.2, Compiler and linker sources, Original sources and documentation are on Leor Zolman's site


AZTECH C Vers. 1.06D 8080 (C) 1982 1983 1984 by Manx Software Systems

Microsoft MS-COBOL Version 4.65 with VT100 support

COMAL-80/z80 rev. CP/M 2.10

130 ------------------------------------------------------------------------


Forth 83 Version 2.1.0

Microsoft FORTRAN-80 Ver. 3.4

Microsoft FORTRAN-80 Ver. 3.33

LISP/80 Version 1.1


Modula 2

MUMPS Version 2.62 with source and version 2.60

muSIMP-80 2.14 Symbolic algebra package

Turbo Pascal Version 3.00A configured for VT100

140 ------------------------------------------------------------------------ 

PILOT to Pascal compiler with…


Digital Research PL/I-80 V1.0

PLM based on ISIS


PLMX by SYSCON (SYStem CONsultants Inc. 1980)

PLMX implements the syntax of PL/M

Simple Programming Language (SPL)

150 ------------------------------------------------------------------------

Atari 2600 with a 6507 processor emulator
 by Michael Kohn
"I was looking for an idea for a cool Parallax Propeller project to work on and I figured I'd try out an Atari 2600 emulator. This chip seems like a good microcontroller to do this on since it has 8 cores running at 80MHz, plus a library for outputting to a TV or VGA monitor. I already had C and Java code (links at web site) I wrote for emulating a 6510 CPU (close enough to the 6507) so I wrote a c2spin program to convert the C code to the built in Spin language of the Propeller.

For software developers to add support of the Propeller chip to their projects and for users needing command-line driven Propeller chip support.

Augmented Assembly Code (PreSpin ver)
 by Bob Anderson
works in conjunction with PreSpin and the Propeller Tool as an aid for people who write assembly code for the Parallax Propeller© chip. It is a preprocessor to the Propeller Tool.

Augmented Assembly Code (standalone ver)
 by Bob Anderson
This program is meant to help people who write assembly code for the Parallax Propeller© chip. It is designed as a preprocessor to be used in conjunction with the Propeller Tool. It looks for "tagged" lines imbedded in normal PASM files and emits a second file for subsequent processing by the Propeller Tool.

Simple Propeller Assembly Debugger (SPAD)
 by Jim Coleman
"At last, a debugging tool that works exactly like the Basic Stamp. Yes, the old reliable Stamp commands debugChar, debugStr, debugDec, debugBin, debugInChar, debugInDec, debugWatchDog and debugDelay may be inserted directly into your propeller assembly code to provide output to and input from your PC just as you did with Stamp debug commands. Writing and learning assembly language code is very easy when you can control your output/input to your PC directly from your assembly code. Now you can stop your assembly code at any point using a simple debugInChar command.

 developed by Dave Hein
A program to convert from the C programming language to Spin. "The current form of the program has no user interface. One way to use the program is to put your C source files in the cspin directory where the cspin.exe and other files are. From the DOS prompt you would "cd" to the cspin directory and run it there. Another way to run it is to copy cspin.exe to a directory in the DOS path. Type "path" from the DOS prompt to see which directories are used to run executables.

 by Christof Eb.
"I have now made some first experiments with the "small small c compiler for prop" ssp.exe.

The ZPU version of GCC for use with ZOG
 by heater
Well C is C is C to a large extent. But as you are accepting multiple implementations of the same language and already have Catalina C, ICC, BDS C for Z80 emulation and GCC for Motorola 6809 emulation then there must be room for another one.

 by Pullmoll
Runs Basic programs on emulator

Tandy M100 BASIC
 by Pullmoll
Runs Basic programs on emulator

160 ------------------------------------------------------------------------

Colour Genie EG2000 computer BASIC
 by Pullmoll
16KB Colour BASIC ROM, adapted from TRS-80 12KB MS-BASIC

Sinclair ZX Spectrum BASIC
 by Baggers the version I put up last, on the file selection menu, you just press 'B' it will perform a cold start on the ZX Spectrum, and you can write you're own basic programs, there is yet no way to save them though, I will be working on that.

Sinclair ZX81 BASIC
 by Baggers
"Also, you can actually use Sinclair ZX81 BASIC, using the Spectrum emulator, which then runs a ZX81 emulator."

ISO standard P5 Pascal compiler/interpreter
 by Ross
The latest version of Catalina (2.5) includes the ISO standard P5 Pascal compiler/interpreter, and also the Lua scripting language

Lua scripting language
 by Ross
The latest version of Catalina (2.5) includes the ISO standard P5 Pascal compiler/interpreter, and also the Lua scripting language

 by Heater
Heater has found a way to program in C++ on the Prop using GCC and Zog. As delivered it runs a binary, FullDuplexSerialPlus_Test.bin, from HUB Ram. The C++ source of this binary is included along with the Makefile used to build it. Should work on pretty much any Prop platform that can talk to the BST serial terminal.

 by Dave Hein
SpinLMM is an enhancement to the Spin interpreter by integrating an LMM PASM interpreter. This enables PASM routines to be run in the same cog that is executing Spin code. A demo program is included that implements a serial port and basic floating pointer routines in LMM PASM. These routines run in a single cog along with the main program, which is written in Spin.

VPOS by Humanoido
VPOS has many new aspects and concepts of a running programming language primarily including the multiple processor operating system capabilities for the Propeller. Written in SPIN code, and currently under NDA before full release. VPOS allows the programmer to handle multiple computer processors across a multiplicity of Propellers/Cogs and manage their parameters in exampling small but expandable routines/programs which depend on Cog RAM and HUB RAM memory. Includes VPOS Tools inclusive of a loader, tester, extensions, and additional managing elements for seamless integration. Works on the smallest to the largest machines and is adjustable utilizing available Cogs. Functions down to just one cog or all cogs available. Hybrid functioning built in. VPOS is working and tested in various machines from the smallest up to the Big Brain.
 Sample demonstration code for setup LEDs under a finite number of pins and operating samples for exceeding the number of available pins.

 by Dave Hein
Runs script programs. The thread on porting linux got me thinking about the OS that I've been tinkering with. I originally called it CDOS because I was using it to test out file I/O code that I'm adding to CLIB. However, I thought a more appropriate name would be spinix because it is a unix/linux-like OS that's written in Spin. It is actually more like minix because the drivers are viewed as processes, just like a user program. spinix will support up to 8 processes, basically because there are 8 cogs.

SPINbuilder by Microcontrolled
A GUI controlled SPIN compiler for students and newbies, Behold, the first GUI Spin compiler since 12Blocks. SPINbuilder uses a GUI (Graphical User Interface) to give the spin code a select-and-click feature. All code words are spelled out in plain english, and helpful Info buttons describe each function in detail.

170 ------------------------------------------------------------------------

SPIN SCCuM Version by Epmoyer

The Spin Conditional Compile Manager (SCCuM) utility is designed to support a conditional compilation syntax for SPIN programs. As of this writing, the Propeller IDE does not currently support a native conditional compilation syntax.

Visual Spin
 by Raman
This link describes Rayman's 1st Visual Spin Pre-Alpha1 Debug version.
Just in case anybody is trying it... You can select a form object either by double-clicking on it in left tree-view window, or single-clicking on it in the main view. Then, you can edit it's properties in the Properties window on the right.... running Vista, 64-bit. It's built with the standard MS Visual Studio C++ with no 3rd party

Embedded Basic Interpreter - 
a version of femtoBASIC in PropBasic by Bean
I've been toying around with making a version of femtoBASIC in PropBasic instead of spin for speed. Here is my first crack at it. The hard-coded program has a tight 3 line loop that toggles pin 0. It's pretty fast 300,000 (simple) lines per second. So the pin toggles at 100KHz. I'm sure when I start fleshing it out, I'll need to switch to LMM so that will make it quite a bit slower (about 75,000 lines per second). My goal is to make an on-board BASIC for the S2 robot. Programming will be done by USB cable or hopefully some kind of wireless connection. *I uploaded a new version that uses LMM, speed is about 57,000 (simple) lines per second.

Basic Stamp Emulator on a Prop by Bean
Bean continues to "WOW" us with his spectacular software for the Propeller. Now he's integrated "the love of our life," a BASIC Stamp 2 into the prop and it can directly run PBASIC Stamp 2 programs loaded from the Stamp IDE. You can run 4 stamps at the same time inside the prop cogs in one prop chip. Here's what he had to say: I have posted updated code that allows the "Basic Stamp IDE" to download PBASIC code into the propeller. The propeller emulates a stock BS2. When the propeller is started it waits to recieve a program from the "Basic Stamp IDE", then it runs that program. To download a new PBASIC program, you need to reset the propeller. NOTE: Only a limited number of the PBASIC commands are implemented so far. This is a work in progress...

C3 Sphinx FemtoBasic by Mike Green 2010-12-05/
Version 1.001 for the Propeller C3, 
2010-12-05 Sphinx-only version, doesn't run without Sphinx

PSC Propeller Version by Mike Green, PSC Propeller‎
As part of a talk for UPEW on extending FemtoBasic, I've put together a version of FemtoBasic for the Propeller Servo Controller. Essentially I stripped out all the SD card support and replaced the display/keyboard with a serial console using the built-in USB port much like DongleBasic. I've added a statement to control one or more servos using the same servo routines used in the standard firmware for the Servo Controller. I also added a statement to reinitialize the serial port with a specified Baud. The default Baud is 2400. The serial driver and FemtoBasic have been modified to support a half duplex serial connection on the extra serial port if there's no USB connection.. Content of archive:
Basic_I2C_Driver.spin - I2C Driver from ObEx

FemtoBasic_ObEx.spin FemtoBasic main file from ObEx

FemtoBasic_PSC.spin Current FemtoBasic for the PSC

FemtoBasic_PSC1.spin FemtoBasic with keyboard & display replaced with serial I/O and no SD card

FemtoBasic_PSC2.spin FemtoBasic_PSC1 with a few PSC-specific statements added

180 ------------------------------------------------------------------------

FemtoBasic_PSC_More.spin Small portion of FemtoBasic extracted to illustrate adding statements

FemtoBasic_PSC_Notes.spin Just method headers and their comments for most methods in FemtoBasic_PSC

FullDuplexSerialMG.spin - FullDuplexSerial modified for larger buffers and half duplex option
Servo32_Ramp_v2.spin - Servo32 driver from ObEx
Servo32v7.spin - Servo32 driver from ObEx

FemtoBasic_PSC NV Next Version by Mike Green
Here's the next version that includes an automatic program load capability. The interpreter will do a LOAD:RUN if the SAVEd program's 1st line is "99 REM AUTOEXEC.BAS"
BCX Basic by Dr_Acula
Feature rich Basic programs up to 512k. BCX is a free Basic to C converter that has been around for years and has a huge range of Basic language commands 
Couple this with the Catalina C compiler and it is possible to write programs as small as 900 bytes, or as large as 512k (soon to be 32Mb). Or more complex code, using strings, huge string arrays, serial ports, the VGA display, Keyboard input, sd card file load/save and full floating point maths. You can even add inline C code into your program. A simple led flasher:

      High(0)              ' bit 0 high (pin 1 on physical chip)
      Sleep(1000)          ' sleep this number of milliseconds
      Low(0)               ' bit 0 low
      Sleep(1000)          ' sleep

XBASIC by David Betz

I wrote a simple Basic in C that works with ZOG on the C3. It is also an embedded basic in that you can type in programs on the C3 and run them. It contains an expression parser that generates a parse tree in memory and then generates bytecodes from the parse tree.

fb TandyBasic in Spin by Tomas Rokicki (Extended Color BASIC 1.0 by Tandy) 

Mike Green writes: Tomas Rokicki did an homage to TandyBasic in Spin. It was quite limited in capability with expressions, assignments, IF/THEN, GOTO, PRINT, and some others. I used that as the basis for FemtoBasic, added a lot of statements, and Prop-specific I/O capability.
Chip Gracey wrote: Rokicki, Wow! I wouldn't have believed it if I hadn't run it! For those of you who haven't tried this, it's a fairly functional Tandy Color Computer from 1980! It comes up with a prompt and you can type in programs via keyboard and run them (using the Demo Board). It uses line numbers. I typed in this, and it ran:
10 print "x";
20 goto 10
I never expected to see something like this, especially so early. Rokicki, I think you must have done this enough times on enough systems that you could do it in your sleep now. I can't think of any other explanation for how you would know WHAT to do so quickly to make a Tandy CC like this. Please note the new efficient VGA character display I posted last night. It will free up almost half the RAM your tv_terminal is using now, plus it's WAY faster. With more memory, you could do way more. I can't believe you even packed in an interpreter! This thread is under-viewed!

StickBASIC by Mike Green
This is a slightly modified version of DongleBasic. Whenever it attempts to mount an SD card, the mount routine returns an error without initializing the I/O pins involved (9-11). These should work normally. Don't use any of the statements that make use of a mounted SD card.

Enhanced Simple BASIC by Mike Green
I've been enhancing the "SimpleBasic" which was a variation of the "Tandy Color Basic" copy for the Propeller posted some months ago by Radical Eye Software (Rokicki). It's now at a point where it's quite useful. Extensions include support for Rokicki's SD card FAT file system drivers for saving programs and data.

BasicSph by Mike Green
This version includes all the necessary drivers from Sphinx, so it can be run standalone. If so, you'll have to modify the TV, keyboard, and SD card I/O pins as well as the clock settings in BasicSph.spin. If you run it under Sphinx, it uses the settings in Sphinx.

190 ------------------------------------------------------------------------

PROPBrainFsck by UltraLazer
An Interpreter for Obfuscated Programming - requires the Parallax Serial Terminal. Includes 2 BF demo programs. Program1 outputs some text, program2 outputs arbitrarily many Fibonacci numbers. PropBrainFsck.spin

PTFemtoBasic by Oldbitcollector OBC (Jeff)
FemtoBASIC modified for PropTerminal. Takes advantage of the remote keyboard and graphics commands in Propterminal. "It's another fork that I did a while back.. All I did was add a few commands to make it work with Propterminal." OBC
see Propterminal source at:

PE-Basic by Bean
I've been toying around with making a version of femtoBASIC in PropBasic instead of spin for speed.

BS2Prop by Bean
A BS2 emulator that programs in a special version token subset of BS2 PBASIC written in Spin

PICOPIC source by APStech-Attila, file archive by bsnut
It is a graphical programming language... You can program the Propeller as it was a PLC.

FemtoBASIC PropBoe Version by Mike Green

FemtoBASIC Quickstart Board Version by Mike Green*see note
Just for fun ... I got my QuickStart board running today and thought I'd put together a version of FemtoBasic (actually DongleBasic) for it. The only differences from the DongleBasic in the Object Exchange is that the I/O pins for an optional SD card were changed to 12-15 and a BUTTONS statement was added to allow use of the touch buttons. This just calls the Touch Buttons object from the demo program for the QuickStart board. Look at the description in the included QSBasicDocs file. 

Femtobasic HYDRA version

CrustCrawler Smart Arm BASIC by Steve Norris

Here's a converter to COG PASM or LMM PASM by ersmith
I have created a spin to c++ converter which, combined with propgcc, can produce LMM PASM (or COG PASM for a small enough program) from Spin. It's still very incomplete and buggy, but it's able to successfully convert a few of the objects from the obex.

200 ------------------------------------------------------------------------
spin2cpp translator update by ersmith‎
Handles much more Spin language including floating point. Successfully compiles & runs Float32Full.spin, FloatMath.spin, FloatString.spin, F32.spin. FullDuplexSerial.spin & C3 VGA demos work. Bug fixes to PASM translator. Handles most PASM code correctly.

Propeller Operating System by Mike Green (12 versions)
Contains command line programming

QSBasic by Mike Green
Just for fun ... I got my QuickStart board running today and thought I'd put together a version of FemtoBasic (actually DongleBasic) for it. The only differences from the DongleBasic in the Object Exchange is that the I/O pins for an optional SD card were changed to 12-15 and a BUTTONS statement was added to allow use of the touch buttons. This just calls the Touch Buttons object from the demo program for the QuickStart board. Look at the description in the included QSBasicDocs file.

Propboebasic by Mike Green
In honor of receiving a Propeller Board of Education, I've made some very minor changes to the QSBasic I posted recently to make it work with the Propeller Board of Education. I added I2C statements to allow reading and writing data to I2C devices like the BOE's ADC. I plan to add simple support for the BOE's DAC as well. Note that the micro-SD card driver only handles FAT16, so keep card sizes to 2GB or less and format them as FAT16, preferably with 32K clusters.

Femtobasic Modified by OBC
Femtobasic captured enough of my attention to add some additional commands to it while I'm in the process of learning SPIN. To me it gives the propeller the feel of an early 80's microcomputer, (only with SD/MMC and VGA) so I thought I'd write a game for it. .zip contains a new Femtobasic with a few additional commands, the intro-boot for an animated game, as well as a test program for the addition of an Atari joystick.

FemtoBASIC The original FemtoBASIC, which continues to be improved upon by Mike Green. FemtoBASIC as claimed started out as a joke by Tomas Rokicki, a simple simulation of the Color Computer which could handle a couple simple commands. Mike Green took FemtoBASIC  to the next level incorporating many common BASIC commands as well as support for reading/writing to/from EEPROM and SD media.

PropterminalBASIC (NEW) An adaption created for use with Propterminal, supporting Propterminal graphics commands

FemtoBASICcolor NEW adaption incorporating AiGeneric drivers allowing 40x23, 16 color text

Simple BASIC Enhancement by Mike Green
I've been enhancing the "SimpleBasic" which was a variation of the "Tandy Color Basic" copy for the Propeller posted some months ago by Radical Eye Software (Rokicki). It's now at a point where it's quite useful. Extensions include support for Rokicki's SD card FAT file system drivers for saving programs and data.

Femtobasic for Demo Board AND HYDRA by Mike Green
Attached is a new version of FemtoBasic for the Demo Board and the Hydra. There are some constants at the beginning that have to be set properly and some lines that are different for the Demo Board and the Hydra versions with the opposite lines commented out. I've precompiled versions for the Demo Board and the Hydra. The SD card routines work now on both. 

210 ------------------------------------------------------------------------

SimpleBasicHydraTV.binary‎ by Mike Green
Here's a copy recompiled for the Hydra. The SD card FAT stuff DOESN'T WORK at the moment on the Hydra and will do strange things.

Propeller Color BASIC  by Oldbitcollector (Jeff)

PropCMD by localroger
Now you can do some quick command line programming of your Propeller chip. This is a command line SD card explorer that can run binary files from the SD and automatically run them on startup. Meant as a framework for user development with a current command set geared toward exploring the SD card architecture. Similar to PropDOS, based on the FemtoBasic SD utilities. 

Sphinx / Sphinx OS Conducted by Cluso99

ATTinyISP by Cluso99
Uses the Propeller chip to program in ATTiny language. The program can be easily modified for other ATTiny and similar parts. Currently the hex code must be placed into the object and the spin code modified to program the correct length. Feedback is provided by the FullDuplexSerial object and PST (Parallax Serial Terminal).

CLIB by Dave Hein
Program with Standard C library functions written in Spin. Contains string, formatted I/O and memory allocation routines such as strcpy, strcat, printf, scanf, malloc and free. Includes a serial I/O driver that allows multiple instances and multi-cog access. Also contains routines that convert between floating point and strings without additional floating point objects.

GCC port for the Parallax Propeller P8x32a Microcontroller. View the Propeller GCC Alpha Test forums here.

Morse Code Language by Thomas E. McInnes
Can send morse code messages to a buzzer, piezo speaker, or an LED light, it even supports hexadecimal and binary. Includes demo program. Can also be used in conjunction with my ciphers object to send encoded messages. Now supports BOTH uppercase and lowercase. 

PropBasic TV (NTSC) VERSION  BY Bean
PropBasic Library that creates a 256x192 pixel TV (NTSC) screen. Black and white only.

PropBasic 4 Color VGA Version by Bean
PropBasic library that creates a 320x200 4 color VGA screen. Each 16x8 block of pixels can have a unique palette.

220 ------------------------------------------------------------------------ 

PropBasic 320x200 2 color VGA Version by Bean
PropBasic library that creates a 320x200 pixel 2 color VGA screen. Each block of 8x8 pixels can have 2 unique colors. 

Ciphers by Thomas E. McInnes
Create new language ciphers. Uses substitution to encode or decode any lowercase letters. It can also be used in conjunction with my Morse code object to send encoded messages. Custom ciphers can also be easily inputted with very little difficulty.

HYDRA Morse Code Sender by Larry Jennings
This program uses the Hydra Keyboard to send Morse Code of the letters typed. I have inserted code blocks into Andre Mothe's Keyboard Demo program which does the keyboard conversion and the letter display on the video. The audio (and the debug light) carries the Morse Code. The audio program is one that comes with the Hydra documentation.

Morse Code Demo SOS by Tamas Tosaki
This is the Morse Code SOS demo program. Adapts to full Morse Code language. 

Tiny Logo for the S2 by Michael D.
Tiny Logo implements a lot of Logo commands plus access to all of the S2. It comes with limited string and very limited list support. Since it is large, the archive contains crippled versions of the S2.spin and S2Music.spin objects with songs tables removed.

TACHYON FORTH by Peter Jakacki
Parallax Thread
Google Documents page with formatted source code
(includes code snippets, under development) I have taken another look at my old CogForth since I needed amongst other things more runtime speed without having to resort to assembler. So over the last couple of days CogForth has been completely revamped and I think I'm on a winner with this implementation. It is both fast and very small thanks to the byte codes for each Forth VM operation. Like a tachyon, it is fast and very small (as a hypothetical particle anyway) with emphasis on fast I/O operations and maximizing the Propeller's memory.

COG Forth by Peter Jakacki
Mentioned at the Parallax Forum at: 
Was reworked into Tachyon Forth. Check the Forum to see if Peter is making this available for historical reasons.

spintocpp by ersmith
spin2cpp is a translator from Spin to C++. The resulting C++ code may be compiled with PropGCC. It's an easy way to port objects (including PASM) from Spin to C++.

spintocpp Float Version by ersmith

stoc016 by Dave Hein
...converting Spin to C... I treated constants a bit differently, where I used a #define instead of const. The header file contains a different version of the constant name with the file name prepended. The source code is in stoc.c, spinsubs.c and spinsubs.h. The genereated cpp files include spin.h, which defines some basic Spin functions as macros and static functions.

230 ------------------------------------------------------------------------ 

ebasic by David Betz

pico-basic by David Betz
A small BASIC for microcontrollers.

PICoPLC by APStech-Atilla
I have been working on adopting an old PLC software to support Propeller. (Contact the author for more information)

Fortran 4 on an IBM 1130 emulator by wmosscrop (Walter)
16K bytes of memory, 16 bit integers, no booleans, only arithmetic if statements. But it does have "extended precision" (I believe 48 bit) floating point... 


For Balde number one. This can be used as a simple terminal for Blade #2 and will be used to test and develop a Winbond Flash Memory driver that supports normal file handling. I plan to substitute the Winbond driver for the normal FemtoBasic SD card support and I plan to add VT100 support so this can be used like propComm for a CP/M terminal emulator. 

TrimSpin by Dave Hein
an idea about speeding up the Spin interpreter by supporting a subset of the Spin bytecodes. This allows the interpreter to be optimized for a smaller number of bytecodes. The TrimSpin interpreter executes random code almost twice as fast as the standard interpreter. Some functions, such as BYTEMOVE or the multiply operator run only slightly faster since they use similar code that the standard interpreter uses. The STRSIZE instruction runs about 2.5 times faster because it uses a dedicated routine instead of sharing it with the STRCOMP code. My motivation in doing this is mostly to see if it's possible to develop a virtual machine on the Prop that runs faster than the current Spin VM and is as compact, or even more compact. This might be useful for improving the peformance of Spin, or maybe it could be used for C. 

Propeller OS v1.034 by Mike Green
With a command interpreter for programming, Propeller OS provides an EEPROM-based OS that stores programs in 32K named units, or 32K units of arbitrary data. It allows up to 512K of EEPROM per I2C bus (4x1024 Bs) and can use any pairs of I/O pins for I2C busses. It can auto-detect 32K vs. 64K EEPROMs. 

Propeller TV OS by Mike Green
with command interpreter for programming 

Hydra TV OS 2006-11-13 by Mike Green
with command interpreter for programming

Tachyon EMIC2 by Brian Riley

240 ------------------------------------------------------------------------

Tachyon EMIC2 2 by Brian Riley

Tachyon Ping))) by Brian Riley

Hydra BASIC by Terry Smith
The only true bad a$$ HYDRA language VERSION: 0.2 (using a modified version of the HEL tile and graphics library by Andre' LaMothe, LAST MODIFIED: 05.07.06 (ts_hydrabasic_002.spin)

PROPFORTH 2.7  by Sal Sanci

PROPFORTH 3.2 by Sal Sanci

PROPFORTH 4.0 by Sal Sanci

PROPFORTH 4.5 by Sal Sanci

PROPFORTH 5.0 by Sal Sanci 

pfth ANS Forth Interpreter for the Prop by Dave Hein
Written in C. It can be compiled to run on almost any platform that has a C compiler. I have run it under Cygwin on a PC and on a Prop C3 board using the XMMC model under PropGCC. pfth currently implements 90 of the ANS Forth core words in the C kernel, and 43 core words in the Forth source file ansi.fth. The design goal for pfth is to allow easy porting of ANS Forth programs. When run on the Prop, pfth also supports a small number of words to read and write the OUTA and DIRA registers.

Here is a PropTerminal FemtoBasic with the Buttons command. I just replaced the KEYCODE command, which was commented out, with the BUTTONS command. All I had to do was including the BB_TouchButtons object in the OBJ section, added the button.start methode in Main, renamed the "KEYCODE" token to "BUTTONS", and then copied the Button-token-code from the QSBasic version to the right token in the "factor" methode. You need the BB_TouchButtons.spin from the ZIP in the first post in addition to the attached Spin file.
File Type: spin FemtoBasic_Propterminal05.spin‎ 44.1 KB

250 ------------------------------------------------------------------------

Spinneret Embedded Basic by Bean
Provides a Telnet interface to BASIC interpreter and command shell. Allows live editing and execution of BASIC scripts, including access to external hardware as well as interaction with a user over the Telnet session.

Suggestions by Mike G
Using the WizNet TCP/UPD devices there are also web based protocols and scripting languages (that run on the Propeller)
RESTful services

PropBASIC for Viewport by Bean
Support for ViewPort Terminal (need viewport 4.6.7 or later) using "VPterminal_lib.pbas"
File Type: zip‎ File Type: pbas VPterminal_lib.pbas‎

HYDRA VGA by Oldbitcollector (Jeff)!?p=1161688&viewfull=1#post1161688

Hydra Logo 1.4 for Proto/Demo Boards by Josh Meeds
File Type: zip‎ 43.2 KB
As posted in the Hydra section. This one has been adjusted for use on the Proto/Demo boards.  

TINY LOGO FOR THE S2 by Freak C. (Michael D)

I have just posted a Tiny Logo implementation for the S2 on the Object Exchange. It has a lot of Logo commands plus all commands necessary to control the S2. You can use a TTY console to program the S2 interactively (TO is supported, so you can define own procedures), or you can download either source code or precompiled programs. It comes with its own versions of the S2 and S2Music objects, where I removed the song tables and the ability to play entire songs in order to save some memory space, because I crammed all I could into that Tiny Logo.
Tiny Logo implements a lot of Logo commands plus access to all of the S2. It comes with limited string and very limited list support. Since it is large, the archive contains crippled versions of the S2.spin and S2Music.spin objects with songs tables removed. Please report any bugs to, and let me know how you like it!

260 ------------------------------------------------------------------------

PopForth Robot Control language for the LittleRobot(TM) project by nglordi (NickL)
PfrcLitbot.txt Updated  File Type: txt PfrcLitbot_1.1.txt‎
The stepper motor driver is much simpler than the bot.f version. Separate cogs are used for the motors, ping and to calculate wheel velocities. Note that there are two sets of motion control commands which use predefined data tables to execute the commands. This index approach is more than adequate to drive the robot. For example, the command 9 F(orward) causes the robot to move forward at the highest velocity (ca. 12 rpm). This motion continues until the user executes the H(alt) command. Execution of G(o) causes the robot to continue its motion. The second group of commands are all prefixed with a G, i.e., GF (go forward). Executing, 9 GF with cause the robot to move forward 30 inches and then stop. Executing 2 GC (GCC, GTR, GTL) will cause the robot to turn 15 degrees in the direction defined by the specific command. Indices in this version are limited to 0 - 9 (10 items). The ping is set to automatically stop the robot if it approaches an obstacle by less than a preset value in inches.

PICO C by Dave Hein
Pico C is an interactive C interpreter. C statements can be entered interactively and executed immediately. I modified the makefile that came with Pico C, and I built it from the command line. It may be possible to build it under SimpleIDE. It has to be built with the XMMC model. Check out the Pico C site at There is a Wiki there with some information on how to use it. File Type: zip‎

YFORTH built by Dave Hein with GCC under Linux
I was able to build it with GCC under Linux by typing make. It complained that it was out of dictionary space, so I disabled the floating point options in config.h and it built it again. This left about 10K of unused space in the dictionary. It appears that he implemented everything in the ANS standard, which is quite impressive.
In honor of receiving a Propeller Board of Education, I've made some very minor changes to the QSBasic I posted recently to make it work with the Propeller Board of Education. I added I2C statements to allow reading and writing data to I2C devices like the BOE's ADC. I plan to add simple support for the BOE's DAC as well. Note that the micro-SD card driver only handles FAT16, so keep card sizes to 2GB or less and format them as FAT16, preferably with 32K clusters.

File Type: zip  BY MIKE GREEN
I've modified PropBOEBasic (see attachment) to support the Activity Board's built-in ADC using the function ADC[<channel>]. The SERVO statement has been changed to properly handle the different I/O pins used on the Activity Board for the servo headers (12-17 instead of 14-19) and the xBee Rx and Tx pins are expected to be connected to I/O pins 10-11 instead of 12-13.

As of March 2019, Parallax’ big language push is for these extra languages

BlocklyProp is a visual programming language (VPL).  Unlike the traditional text-based approach to code, these graphical interfaces allow for an easier understanding of programming basics.  Difficult concepts, such as syntax and proper use of capitalization, are replaced by logical code blocks that simply snap together. Learn programming on the fast track with BlocklyProp! Interlocking blocks with readable text introduce programming concepts in a visual, logical way. BlocklyProp works with the Propeller multicore microcontroller, and lets you peek at the generated code under the hood as a natural progression towards text-based programming. Chromebook, Windows, and Mac OS Compatible.

Propeller C
Beginner-level C programming for the open source, multi-core Propeller microcontroller is supported by our Propeller C Tutorial series, featuring the Propeller Activity Board WX, ActivityBot 360° Robot, and Propeller FLiP microcontroller module.

For the BBC micro:bit
Interface the micro:bit with the Propeller. Self-guided, individual learners should also review the MicroPython tutorials designed for the Mu editor (Windows, OSX and Linux) as published by MicroPython. The micro:bit hardware is a single board computer with enough capability to be used for games and applications. The 5x5 LED matrix, buttons, accelerometer, magnetometer, and Bluetooth radio provide enough sensors and communication devices for a number of projects. Micro:bit modules can be programmed in the MicroPython (text-based coding), the Microsoft Block Editor (drag-and-drop language), and JavaScript.

Microsoft MakeCode for micro:bit

(Currently about 260 languages, versions & variations)
(Extra programming language converters and methods not counted)

Parent Directory
FemtoBasic Binaries/
FemtoBasic IRB Binaries/
FemtoBasic IRB.spin
FemtoBasic Manual.pdf
FemtoBasic Manual.rtf
IR Buddy References and Examples/

Propeller Tool


FemtoBASIC for Propterminal

The Propeller Manual

Language Comparisons Embedded Basic is pretty much the same as FemtoBasic only faster and with different features. It can run stand-alone with a PS/2 keyboard and TV, or using PST or using Telnet (it requires a recompile for the different configurations). Embedded Basic is an interpreter like FemtoBasic. Embedded Basic is written using PropBasic...It's a little confusing. But Embedded Basic is a Basic interpreter that is written in a Basic compiler (PropBasic). PropBasic compiles to assembly.

Language Versions Comment by Mike Green. He notes the same language, FemtoBASIC has a number of reconfigured versions.

Is there a TINY FORTH? REPLY BY PROF_BRAINO: I believe "tiny" is just a redundant adjective when describing forth in general. An exception would be something like FPC which is a PC based forth which has about 3000 zillion functions for every possible thing the guys could think of. Which was really cool, but most of the stuff never gets used, so its kind of a waste. And it was too much for me to keep track. In the case of propforth, the memory foot print keeps getting smaller and resources available to the user for applications keeps increasing. So "tiny" would apply to each kernel compared to the last. Propforth 5.3 will have the smallest memory foot print and most resources available for user applications so far compared to the previous releases. Also, it will be noticeably faster due to optimization of critical functions. The "paged assembler" functions will permit very small optimized functions to be brought in and out of memory on the fly, and is easier to use than previous assembler optimization implementation. So, the short answer is 5.0 for now, and will be 5.3 when it comes out.

PropGCC Comment by erSmith
The PropGCC back end should be able to accommodate any of the languages; we've only had time to test it with C and C++. As Steve mentioned, community input to support additional languages would be very welcome (it would be cool to have a Fortran compiler for the Propeller :-)). 

Don't Like the Programming Language? Design your Own!
Jeff Dege comments, "Maybe I'm an old fart, but I thought that the standard response of a real computer programmer, forced to develop in a programming language that lacked essential features, was to design their own programming language and to write a compiler that accepted that language and output code in the language that one didn't want to work in. It's been standard practice since at least 1976, when Kernighan and Plauger published the source to RatFor in "Software Tools". I did it, once, when I was forced to work on a project in Business Basic. I called it "RatBas", though my co-workers called it "Bas-Ackwards". Does no one do this anymore?"

From One Old Fart to Another by Bruce Bates
Bruce Bates replies, "From one old fart to another, I think I can answer your question. Those of us who once used Lisp, SNOBOL, or SpitBol for making such simple language translators have either been sent into retirement, moved into no-more-fun management positions, now own our own businesses, or are busy trying to teach our grandchildren what fun machine language programming can be. :) 


Fortran to C Converter by Dave Hein

Dave Hein notes this route for getting Fortran programs into the Propeller chip by using a Fortran to C converter.

BASIC TO C Converter by Dr_Acula
I've written my own IDE for this and so have ironed out a lot of bugs.

Spin to C or C++ Converter by ersmith
I've just released a new version (0.96) of the spin2cpp tool for converting spin files to C++. It now also supports conversion to plain C as well, with some restrictions.

Spin to PASM Converter by ersmith
Convert spin to PASM. For very simple spin objects this is now possible using a combination of propgcc and spin2cpp. I timed it and got 16 cycles/toggle in the new version, versus 976 cycles/toggle for the original. So the converted version is about 61x as fast.

PropBasic can produce both LMM and plain PASM code 

PropGCC can produce PASM code 

(Catalina does not produce COG PASM code)

SPIN to BS2 with this Object by Martin Hebel

PBasic-to-Spin by Whit 
version 0.99 by ersmith
This version has a number of bug fixes to compile Spin objects that previously were not working right. It also has a (very preliminary) converter from PASM syntax to GNU GAS syntax. There are two ways to use this: (1) If you specify --gas on the command line while converting to C or C++, instead of a "dat" array spin2cpp will output inline GAS assembly. This makes the resulting C/C++ somewhat closer to readable, since the PASM part is now inline assembly. (2) If you specify --gas --dat then the DAT section is output as a GAS .S file. For ordinary use I would *not* recommend using --gas, since the assembler built in to spin2cpp actually works quite well.

PBASIC-like DEBUG for Spin by Phil
One of the things I've always missed when programming the Propeller is the ability to write something like DEBUG DEC x, CR in my program and, when it executes, have a terminal window open automatically to display the output. So for the past few days, I've been working on a way to do just that in Spin.
Parallax Serial Terminal by Jeff Martin
This object works with the Parallax Serial Terminal; see Propeller Downloads page or install Propeller Tool v1.2.6 (or newer). It includes handy methods for output/input (Char, CharIn, Str, StrIn, Dec, DecIn, Bin, BinIn, Hex, HexIn) and cursor positioning (Home, Position, NewLine, MoveLeft, MoveRight, etc.) as well as control character constants that match the function of the Parallax Serial Terminal.

PASD by Andy
A suite of software components which enable end-users to debug Propeller assembly language code at the source level using a remote (USB attached) Windows PC. PASD supports setting multiple break points, single-step execution, memory inspection/modification of COG RAM, inspection of Main RAM, label recognition, and I/O pin state inspection. The debugger suite consists of a Windows application, a spin object and a short Debug Kernel which must be inserted at the beginning of the code to be debugged. The Debug Kernel is only 12 longs in size, and makes possible communication with the PASD spin driver, which runs into own Cog. The PASD spin driver communicates over the Propeller’s serial programming interface with the PASD Windows application running on an attached PC. Except for pins 30 and 31 (the Propeller’s serial programming interface pins) all Propeller IO pins are freely available during debugging.

GEAR software simulated SPIN

PIPE by Buddha
Simulate all 8 COGs and the HUB. Simulate the I/O bus. Provide real-time disassembly of all of the COG registers, to help debug self-modifying code. Provide a complete view of all of the COG registers, HUB memory, and I/O pin states, in a cycle-accurate manner. Load and execute a ROM file.

Simple Text Editor by mpark's a little full-screen text editor. It's like Notepad (in Windows) with word-wrap off, so typing long lines causes everything to scroll sideways. Requires HYDRA, NTSC TV, PS/2 keyboard, SDMAX SD card interface (conversion to non-HYDRA platforms should be straightforward).

Simple Text Editor with AiGeneric 2.1 by Oldbitcollector (Jeff)
With the ATARI font. You'll now get 40x23 text.

PropEDIT (CGEdit) by Oldbitcollector (Jeff)*fixed*-(and-moving-toward-expansion)?p=723296&viewfull=1#post723296 
will allow you to load 64c fonts from the SD, doesn't support font color.

Winbond-based Text Editor by Mike Green
This is the Winbond flash driver posted earlier and the FemtoBasic variant used with that. There's a text editor (Ouroboros) included that's far enough along so you can edit a 39 line x 80 character display buffer and save (and re-edit) the files. From the text editor, you can run a named program on the flash drive (like FemtoBasic). I plan to continue debugging and improving the text editor, then start on some kind of simple compiler, maybe for a Basic similar to PBasic.

Full Screen Text Editor by Oldbitcollector (Jeff)*fixed*-(and-moving-toward-expansion)?p=714097&viewfull=1#post714097
This is version 1.2 of a text editor for the Propeller, intended as an add-on tool for PropDos users. Launching the Propedit will allow you to create/load/save text files. This version is limited to a single page of text, but that will be increased in later revisions. Think of this as NOTEPAD for PropDOS.

The vi editor supplied by Dave Hein
If you build it with BSTC using the script in the zipfile it's about 22K in size. If you don't need the file I/O you could remove about 5 or 6K from that. Most users aren't familiar with vi, so you would probably need to modify it with a more user-friendly interface.  

PVI Text Editor by LucidGuppy
I've come up with a prototype text editor along the lines of vi - I call it pvi. hjkl for navigation, i to enter insert mode, caps_lock to escape insert mode - back into command mode. Right now it only sort of acts like a vga typewriter. You have to edit vga-text object so it doesn't pop a newline if you are at the last column.

Vi1 Text Editor by Dave Hein
Here's a version without file I/O. I kept the ReadFile and WriteFile routines, but commented out the file I/O code. This way other file storage code could be added to store to something like EEPROM. I also include clib.spin, which is used instead of clibsd.spin. Just copy these to files to the same directory as the other vi files and build vi1.spin.  

Editor by Bean
No scrolling yet, but everything else pretty much. Uses Propeller Demo board, VGA and Keyboard 

ED012 Text Editor by Dave Hein
The ed text editor has been around for 40 years, and it's a standard utility in all Unix and Linux systems. So I decided to write a version of ed for the Prop. I wrote it in C and then ported it to Spin using cspin. spinix contains an early version of ed, but this latest version is more complete and it implements most of the ed commands.

ED019 by Dave Hein
I've implemented the ex version of the line editor, and most of vi. vi currently runs in a dumb terminal mode, where it refreshes the screen after every keypress that causes a change. 
Tiny FORTH Text Editor by Ron Sutcliffe
The Editor is written for PropForth Rev 4.00

LineEdit by Paul Baker 

Note by Mike Green
Download the Propeller OS from the Object Exchange. It has the beginnings of an editor in it including a general purpose line/screen editor that allows one to edit the screen buffer. There are provisions for exiting when other control codes are entered, like for moving from screen to screen. It was never developed further.   


TinyJS by Gordon Williams of Pur3 Ltd U.K

(JavaScript) Now compilable with propgcc for the Propeller. It takes up over 600KBytes so you will need an external RAM solution. You can download original TinyJS here: and a fork here To show what can be done Pur3 have JavaScript running on small ARM MCUs with 128K FLASH and 20K RAM. See the impressive demo video here:

Little C by Herbert Schildt, converted to Propeller by Jazzed

Fast by Dave Hein
A FORTH interpreter for the Propeller, designed to replace the Forth interpreter in pfth with a faster one