+ Reply to Thread
Page 1 of 19 1234511 ... LastLast
Results 1 to 20 of 361

Thread: ULTIMATE List of Propeller Languages

  1. #1

    Thumbs up ULTIMATE List of Propeller Languages

    The Ultimate List of Propeller Languages

    A List Created & Maintained by Humanoido

    The list has grown too large to maintain on the Parallax Forum.
    The new updated list is found here.

    The most comprehensive source of programming languages for the Parallax Propeller Chip The list seen below is kept up to date and is the most recent posting of languages. It includes authors, source URLs, information and download sites. Please post directly into this thread if you learn about a new language for the Propeller. New languages appear almost every month on this robust Propeller chip (P8X32A-D40).


    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.


    SIMULATED SPIN by Dave Hein
    Everything is open source under the MIT open source license. I'll add the notice in the next update. I spent a few days writing a Spin simulator. 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. At the moment, I think it will parse anything that Proptool will, and it should generate identical bytecode (except for maybe the least-significant bit in floating-point constants).



    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. In addition to being able to compile and load a Propeller, it has a few additional features often requested by users (like being able to emit a list file, some basic optimization, and zip file generation). # bst - The GUI IDE. bst is a fairly complete Integrated Development Environment that aims (and still falls short) to be eventually comparable and compatible with the Parallax Propeller Tool. bst is structured to be a work-alike to the Parallax Propeller Tool so that new users will find the Parallax documentation familiar enough to be able to start from scratch without being plunged into an unfamiliar environment. Like bstc, bst has several features not found in other Propeller development tools, such as an integrated code listing window, basic serial debug terminal and complete project file management. bst also allows you to associate each editor window to a Propeller to allow easy management of multiple Propeller projects.


    This is a command-line assembler for the Parallax Propeller. Features
    • Supports the same syntax and mnemonics as the Parallax Propeller Tool's built-in assembler.
    • Generates files that can be loaded with the Propeller Tool.
    • Supports input in US-ASCII or UTF-8, and allows the full Unicode character set in labels and identifiers.
    • Runs on any platform and architecture with Java 5 available.
    • Really fast (assembles average-size programs in under 10ms on a MacBook Pro).
    • Extensible architecture allows for future enhancements like macros, alternative mnemonics, or new directives.
    • Modular assembler core and instruction set model also make an excellent code generation stage for compilers.
    • Open-source (GPL).
    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. When I began to work on my Turbulence demo, I soon realized that I was going to have to write my own assembler. The one from Parallax was bulky and inflexibly locked to the spin environment for which it was designed, and had to be run through wine. The open source alternatives weren't stable enough at the time. Consequently, I hacked together some prolog code and a bison parser. I've decided to publish the source code here, as free software, in the hope that somebody will find it useful and inspiring.

    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).


    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.

    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. See the beginning of the BoeBotBasic.spin file for a change log. Fix: SD card turned off when unmounted (thanks Cluso99).

    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. See the beginning of the DongleBasic.spin source file for a change log. Fix: SD card turned off when unmounted (thanks Cluso99).


    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. See the beginning of the uOLED96PropBasic.spin file for a change log. Fix: SD card turned off when unmounted (thanks Cluso99).

    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
    a tiny basic modified version in folder JT_Cook/T_Basic_Mod_08_06_07

    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/ RGW_HTBasic_08_03_06 HYDRA CD

    HYDRA RGW_JTC_TinyBasic_010.spin - by ROBERT WOODRING
    , a tiny basic modified version. In folder Robert_Woodring/T_Basic_Mod_08_06_07 HYDRA CD

    RGW_HTBasic_08_20_06 by ROBERT WOODRING
    a tiny basic modified version in folder Robert_Woodring/ RGW_HTBasic_08_20_06

    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 web.archive.org/web/19980702115208/http://www.signiform.com/erik/pubs/minol.htm
    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). web.archive.org/web/*/http://www.signiform.com/erik/pubs/minol.htm. The newest link is here, from Sep 28, 2007. web.archive.org/web/20070928040139/http://www.signiform.com/erik/pubs/minol.htm. Thanks to the Internet Archive WayBack Machine. www.archive.org/web/web.php. At originally only 1.75K, a working version on the Prop would be absolutely remarkable. -humanoido (thanks to heater for making this possible!) http://forums.parallax.com/forums/default.aspx?f=25&p=1&m=320075

    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 www.oddchange.com/gcc6809/ 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, may now be found at

    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.
    compilers.iecc.com/crenshaw/ 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.


    http://forums.parallax.com/showthrea...er-programming! (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



    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). Also, current version is 3.2, and uses descriptive names (like 'interpreter' instead of '_t1') which should make it more usable. http://forums.parallax.com/forums/de...?f=25&m=468264 The new version of PropForth is available on Google code http://code.google.com/p/propforth/ 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 http://sourceforge.jp/projects/ttssh2/ 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...

    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. There's a very very simple descriptive document included.

    http://www.sphinxcompiler.com/ web site by mpark
    Sphinx 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.

    MOCOG V0.60 (6809 VARIANT) by HEATER
    . 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

    , his 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. -Phil

    - 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.

    - 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 (just started being tested). Ouroboros.zip

    - 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

    6502 CORE by ERICBALL
    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. Without the debugger, I will be able to check the speed differences between the Rom and Cluso versions.

    DIY C
    - 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.
    [url=http://forums.parallax.com/forums/default.aspx?f=25&m=220212]http://forums.parallax.com/forums/default.aspx?f=25&m=220212 </A>

    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." -Phil

    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).
    Download at [url=http://www.schorn.ch/cpm/zip/cpm2.zip]http://www.schorn.ch/cpm/zip/cpm2.zip
    For many languages supported under CPM2, have a look at [url=http://www.schorn.ch/cpm/intro.php]www.schorn.ch/cpm/intro.php

    Microsoft BASIC with CP/M 2.2

    CP/M Version 1.4
    download at [url=http://www.schorn.ch/cpm/zip/cpm1.zip]http://www.schorn.ch/cpm/zip/cpm1.zip

    Personal CP/M
    Operating system, Customized BIOS, Sources for CCP, BDOS and BIOS
    download at [url=http://www.schorn.ch/cpm/zip/pcpm.zip]http://www.schorn.ch/cpm/zip/pcpm.zip

    CP/M Version 3 with banked memory
    download at http://www.schorn.ch/cpm/zip/cpm3.zip
    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. Download at [url=http://www.schorn.ch/cpm/zip/mpm.zip]http://www.schorn.ch/cpm/zip/mpm.zip

    PropDOS 1.6
    released by Oldbitcollector

    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. Download at [url=http://www.schorn.ch/cpm/zip/dosplus.zip]http://www.schorn.ch/cpm/zip/dosplus.zip

    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 [url=http://www.schorn.ch/cpm/zip/qpm.zip]http://www.schorn.ch/cpm/zip/qpm.zip

    , CP/M 2.2 with SuperDOS as BDOS replacement. All sources for system generation. Download at [url=http://www.schorn.ch/cpm/zip/superdos.zip]http://www.schorn.ch/cpm/zip/superdos.zip

    , CP/M 2.2 with Z80DOS as BDOS replacement, all sources for system generation. Download at [url=http://www.schorn.ch/cpm/zip/z80dos.zip]http://www.schorn.ch/cpm/zip/z80dos.zip

    , CP/M 2.2 with ZSDOS as BDOS replacement, all sources for system generation, download at [url=http://www.schorn.ch/cpm/zip/zsdos.zip]http://www.schorn.ch/cpm/zip/zsdos.zip

    , 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) at [url=http://www.lulu.com/content/952643]http://www.lulu.com/content/952643 . Download at [url=http://www.schorn.ch/cpm/zip/nzcom.zip]http://www.schorn.ch/cpm/zip/nzcom.zip

    , Full release of Z-System based on CP/M 3, All sources included, User manual in PDF format. Sownload at [url=http://www.schorn.ch/cpm/zip/z3plus.zip]http://www.schorn.ch/cpm/zip/z3plus.zip

    , TurboDOS in single user mode, AltairZ80 specific sources included, For more information visit Bill Buckels' The TurboDOS Museum at [url=http://www.cpm8680.com/turbodos/index.htm]http://www.cpm8680.com/turbodos/index.htm . Download at [url=http://www.schorn.ch/cpm/zip/z3plus.zip]http://www.schorn.ch/cpm/zip/z3plus.zip

    , 86-DOS version 1.00 by Seattle Computer Products. See also Howard's web site on 86-DOS at [url=http://www.86dos.org/]http://www.86dos.org/ . Download at [url=http://www.schorn.ch/cpm/zip/86dos.zip]http://www.schorn.ch/cpm/zip/86dos.zip

    , 56K IMDOS VERS 2.05, CP/M 2 compatible operating system, download at [url=http://www.schorn.ch/cpm/zip/imdos.zip]http://www.schorn.ch/cpm/zip/imdos.zip

    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. download at [url=http://www.schorn.ch/cpm/zip/cpnet.zip]http://www.schorn.ch/cpm/zip/cpnet.zip

    CPNOS 1.2
    download at [url=http://www.schorn.ch/cpm/zip/cpnet.zip]http://www.schorn.ch/cpm/zip/cpnet.zip

    Altair DOS Version 1.0
    , download at [url=http://www.schorn.ch/cpm/zip/altsw.zip]http://www.schorn.ch/cpm/zip/altsw.zip

    Altair 8k Basic
    , download at [url=http://www.schorn.ch/cpm/zip/altsw.zip]http://www.schorn.ch/cpm/zip/altsw.zip

    Altair Basic 4.0
    , download at [url=http://www.schorn.ch/cpm/zip/altsw.zip]http://www.schorn.ch/cpm/zip/altsw.zip

    8080 assembler




    Altair Basic 3.2 (4K)
    , download at http://www.schorn.ch/cpm/zip/altsw.z.../zip/altsw.zip

    MITS Disk Extended BASIC Version 4.1


    Altair Disk Extended Basic Version 300-5-C available by Scott LaBombard


    Altair Disk Extended Basic Version 5.0

    from Andrew Kessel's site at http://www.altairage.com/)

    Altair DOS Batch Language Version 1.0
    , download at =http://www.schorn.ch/cpm/zip/altsw.zip]http://www.schorn.ch/cpm/zip/altsw.zip

    MINOL based on documents retyped by Emmanuel ROCHE

    download at http://www.schorn.ch/cpm/zip/minolvt...p/minolvtl.zip

    VTL-2 based on documents retyped by Emmanuel ROCHE

    download at

    : a compiler for a C-like, Simple Programming Language

    PROLOGZ (interactive Prolog development environment)


    Pascal MT+ compiler and Pascal pretty printer (Pascal source)


    ACT 3.0 Assembler by SORCIM


    - 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


    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 found here - [url=http://www.bdsoft.com/resources/bdsc.html]http://www.bdsoft.com/resources/bdsc.html
    Download here - [url=http://www.schorn.ch/cpm/zip/bdsc.zip]http://www.schorn.ch/cpm/zip/bdsc.zip

    HI-TECH C COMPILER (CP/M-80) V3.09


    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


    Forth - UNIFORTH


    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




    UCSD Pascal II.0

    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)


    Atari 2600 with a 6507 processor emulator
    by Michael Kohn
    and Parallax Forum has an ongoing development thread here for related information
    "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.

    by PARALLAX, For software developers to add support of the Propeller chip to their projects and for users needing command-line driven Propeller chip support.
    Download at http://www.parallax.com/Portals/0/Do...ool-v1.2.7.exe

    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.
    download at http://forums.parallax.com/forums/attach.aspx?a=12580
    "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.

    Tandy TRS80 BASIC
    by Pullmoll

    Runs Basic programs on emulator

    Tandy M100 BASIC
    by Pullmoll
    Runs Basic programs on emulator


    Colour Genie EG2000 computer BASIC
    by Pullmoll

    16KB Colour BASIC ROM, adapted from TRS-80 12KB MS-BASIC

    Sinclair ZX Spectrum BASIC
    by Baggers

    ...in 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. Fully open source, 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 40 Propellers with 320 cogs.
    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.

    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.

    Download is here.

    The original discussion is here.

    Raman's web site is here.

    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 http://forums.parallax.com/showthrea...563#post943563
    embeddedBasic.pbas http://forums.parallax.com/showthread.php?p=919764
    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. Editing the program now works too. *July 5, 2010 uploaded a new version. Math works but strictly left-to-right evaluation. No "IF" or "FOR" yet. But it's getting there... *July 7 2010 uploaded a new version. Simple IF ... THEN line# expressions work now. *July 12 2010 uploaded new version. Added PEEK, POKE, DEBUG, INKEY, DISPLAY, VARS, NEW

    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... Bean.

    C3 Sphinx FemtoBasic by Mike Green
    ftp://ftp.propeller-chip.com/PropC3/...ic 2010-12-05/
    Version 1.001 for the Propeller C3,
    2010-12-05 Sphinx-only version, doesn't run without Sphinx

    PSC Propeller FemtoBasic by Mike Green
    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..

    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 http://www.bcxgurus.com/help/index.html 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)
    fb.zip 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 http://forums.parallax.com/showthrea...331-StickBasic
    StickBasic.zip http://forums.parallax.com/attachmen...5&d=1296948938
    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.

    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

    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.

    Here's a new 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. (see http://forums.parallax.com/showthrea...pp-version-0.2).

    spin2cpp translator update by ersmith spin2cpp_v05.zip‎
    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
    __________________________________________________ ___________________

    Total: 189 Languages
    __________________________________________________ ___________________

    Original posting I admit, collecting is my compulsion. Everything from computers to Stamps. Now I've started my new hobby - collecting as many working languages as possible for the Propeller Demo Board and/or HYDRA Board. The only criteria is they must be in working condition and runnable. I'm going far and wide to collect more. Any other gems out there waiting to increase this collection? humanoido.. This is what I have downloaded for the PROP, so far: (Updated 5/28/09)
    __________________________________________________ ___________________

    EDIT Notes: Please provide download links when possible! All emulators, compilers, interpreters, and scripting are welcome. Names of program writers, providers, versions, authors, please (for credit).


    Last edited by Humanoido; 08-03-2012 at 03:02 PM. Reason: Forum Migration

  2. #2


    Well. If you are happy to run interpreters then why not the Z80 emulator? Then the Prop can be programmed in at least:

    Microsoft Basic (many versions)
    C (BDSC, HITECH etc)
    Modula 2

    That should keep you going for a while:)

    Some of these may require use of the CP/M operating system many do not. For example I have been flashing patterns on LEDs of a Prop Demo board from a program written in C for the Z80 (BDS C) with no CP/M required, just the compiled binary with some support I/O routines in Spin.

    With CP/M and enough external RAM (e.g. TriBladeProp or Hydra) all of these can be compiled on the Prop itself!!

    For me, the past is not over yet.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  3. #3


    Someone out there has a Java VM for the Prop.

    For me, the past is not over yet.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  4. #4


    Believe it or not, RPG4 is still going strong. I sometimes program in that for my business contracts with IBM.
    You really can't break it.

    Heater, you may have given me a reason to relearn CPM. I did a lot of CPM programming in the early 80's for business systems.
    Now, you have given me a reason to bring back memories of a simpler, less stressful life


    Post Edited (James Michael Huselton) : 5/22/2009 1:55:01 PM GMT
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  5. #5


    You can add Z80 assembly to the list too. Sort of obvious I know. I've just been writing a big project in Z80 assembly. It is soon going to go >20k and it is nice knowing there is still plenty of memory left for big string arrays. I've been writing string and math functions in assembly. Strings especially are not all that complex in assembly. mid, left, right, instr etc. And very fast - much faster than in C or Basic. The nice thing about CP/M is there are 36 function calls you can call with a call to 0005. Useful things like print a string, or get a character from the keyboard, or get a whole line of text from the keyboard, open a file, close a file, read in 128 bytes, write 128 bytes etc. With these functions, file access becomes easy in assembly, and also is extremely fast. Heater, if you are writing C without using CP/M, you can look at borrowing bits of the bdos/fdos/bios code to run those functions in your C code.

    I know this might be going off on a tangent, but it could be useful for those writing languages like Basic for the Propeller. If you have string example code in 8080 or Z80 assembly, it could be translated to PASM and incorporated into these new languages. I guess this is from the perspective of someone who understands 8080/Z80/Basic/C but doesn't understand PASM or Spin. Or I could go and learn PASM and Spin... *grin*

    It would be fantastic to expand languages like femtobasic so most/all basic commands are included.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  6. #6


    I was just taking a "power nap" and when I woke up had this crazy idea in my head. Why not make use of some of those illegal 8080/Z80 opcodes to enable putting raw PASM instructions inline with the Z80 code ?

    That is, whilst the emulator is executing Z80 ops from external memory certain undefined ops would cause it to execute PASM instructions LMM/XMM style. especially things like rdlong/wrlong to get easy communication to other spin that is running. Or easy access to ina/outa and the rest.

    For me, the past is not over yet.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  7. #7


    Would "Boom" qualify? It is a very simple language with only 2 instructions. The first instruction sends out 56 bits of data to a shift register that selects one or more relays to close, and the second instruction tells it when to close them
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  8. #8


    Don't forget ImageCraft C.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  9. #9


    And don't forget my version of Jack Crenshaw's TINY language compiler that generates LMM PASM. It's all but useless but you can find it as crenshaw.zip here http://forums.parallax.com/showthread.php?p=776330

    For me, the past is not over yet.
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  10. #10


    What, no Atlas, JOVIAL, BRUIN, or PROLOG?

    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  11. #11


    Prolog? Are you kidding? The memory requirements are HUGE. This is a discussion of languages suitable for Prop execution.
    Forgive me if I am wrong...

    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  12. #12


    Somebody should write a brainf*** vm.


    Propalyzer: Propeller PC Logic Analyzer
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  13. #13



    You are indeed wrong, but I forgive you

    With XMM, program size is no longer an issue. There is already one compiler (Catalina) that can build XMM programs for the Prop, and one hardware platforms (i.e. the Hydra) to run them on - 96Kb is supported "out of the box", and I hope to support 288Kb on this platform shortly.

    As soon as Cluso99 gets around to delivering me a TriBladeProp, Catalina will support that, allowing Prop programs up to 1 or 2Mb. I believe ImageCraft is not far behind in this area as well.


    Catalina - a FREE C compiler for the Propeller - see Catalina
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  14. #14


    Forgive me. I was speaking of non-XMM applications. The Hydra solution is very limited to RAM expansion below 64-96 kilobytes. Above that, the card's RAM is severely limited to speeds allowing for only block transfers and not Random access.

    I dismissed that solution over a year ago because of this limitation.

    I must have missed the XMM code that provides a working solution that one can currently can implement NOW. I apologize.


    Post Edited (James Michael Huselton) : 5/23/2009 3:15:15 AM GMT
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  15. #15



    No worries. I agree the Hydra is a limited solution. But even 96K is useful - and it is available NOW.

    How about LISP for the Hydra? Written in C. Takes 96K. Took me about 10 minutes to find it, compile it, load it and run it.


    Edit: I'll include the source for this in the next release of Catalina

    Edit: added super trvial garbage collection to make it possible to execute more than just a couple of lines of lisp before running out of space!

    Edit: new version uses short pointers instead of long pointers - allows for over 3 times as many lisp nodes.

    Catalina - a FREE C compiler for the Propeller - see Catalina

    Post Edited (RossH) : 5/27/2009 9:24:10 AM GMT
    Attached Files Attached Files
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  16. #16


    Lisp for the Propeller? Now that's frakking IMPRESSIVE!

    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  17. #17


    How about SNOBOL?


    Amateur radio callsign: G1HSM
    Suzuki SV1000S motorcycle
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  18. #18


    How about VALGOL


    Catalina - a FREE C compiler for the Propeller - see Catalina
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  19. #19


    RossH said...

    No worries. I agree the Hydra is a limited solution. But even 96K is useful - and it is available NOW.

    How about LISP for the Hydra? Written in C. Takes 96K. Took me about 10 minutes to find it, compile it, load it and run it.


    Edit: I'll include the source for this in the next release of Catalina
    Is that XLISP? I ported that to the transputer many years ago.


    Amateur radio callsign: G1HSM
    Suzuki SV1000S motorcycle
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

  20. #20


    Hi Leon,

    No, it's from http://www.umcs.maine.edu/~chaitin/unknowable/ch2.html

    I have no idea what variety of lisp it is. I just grabbed it off the net and compiled it to make a point.


    Catalina - a FREE C compiler for the Propeller - see Catalina
    Last edited by ForumTools; 09-30-2010 at 01:14 PM. Reason: Forum Migration

+ Reply to Thread


Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts