Tiny BASIC

Tiny BASIC is a family of dialects of the BASIC programming language that can fit into 4 or fewer KBs of memory. Tiny BASIC was designed by Dennis Allison and the People's Computer Company (PCC) in response to the open letter published by Bill Gates complaining about users pirating Altair BASIC, which sold for $150. Tiny BASIC was intended to be a completely free version of BASIC that would run on the same early microcomputers.

Tiny BASIC was released as a specification, not an implementation, published in the September 1975 issue of the PCC newsletter. The article invited programmers to implement it on their machines and send the resulting assembler language implementation back for inclusion in a series of three planned newsletters. Li-Chen Wang, author of Palo Alto Tiny BASIC, coined the term "copyleft" to describe this concept. The community response was so overwhelming that the newsletter was relaunched as Dr. Dobb's Journal, the first regular periodical to focus on microcomputer software. Dr. Dobb's lasted in print form for 34 years and then online until 2014, when its website became a static archive.

The small size and free source code made these implementations invaluable in the early days of microcomputers in the mid-1970s, when RAM was expensive and typical memory size was only 4 to 8 KB. While the minimal version of Microsoft's Altair BASIC would also run in 4 KB machines, it left only 790 bytes free for BASIC programs. More free space was a significant advantage of Tiny BASIC. To meet these strict size limits, Tiny BASIC dialects generally lacked a variety of features commonly found in other dialects, for instance, most versions lacked string variables, lacked floating-point math, and allowed only single-letter variable names.

Tiny BASIC implementations are still used today, for programming microcontrollers such as the Arduino.

History

Altair BASIC

File:Altair BASIC Paper Tape.jpg

A paper tape containing the expanded 8K version of Microsoft BASIC

The earliest microcomputers, like the MITS Altair 8800, generally had no built-in input/output (I/O) beyond front-panel switches and LED lamps. Useful work generally required the addition of an I/O expansion card and the use of some form of terminal. At the time, video-based terminals were very expensive, costing much more than the computer, so many users turned to mechanical devices like the Teletype Model 33. The Model 33, like most teleprinters of the era, included a tape punch system intended to allow operators to pre-record their messages and then play them at "high speed", faster than most individuals could type the message live. For the early microcomputers, this provided a convenient computer data storage format, allowing the users to write programs to paper tape and distribute them to other users.<ref name="tv_typewriter">{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

The Homebrew Computer Club met for the first time in March 1975, and its members soon used the meetings to swap software on punched tape. At the June meeting, a tape containing a pre-release version of Altair BASIC disappeared. The tape was given to Steve Dompier, who passed it on to Dan Sokol, who had access to a high-speed tape punch. At the next meeting, 50 copies of Altair BASIC on paper tape appeared in a cardboard box.Template:Sfn When Ed Roberts, founder of MITS, learned of this, he stated "Anyone who is using a stolen copy of MITS BASIC should identify himself for what he is, a thief."<ref>Template:Cite journal</ref> Bill Gates made this more formal, writing "An Open Letter to Hobbyists", complaining that "As the majority of hobbyists must be aware, most of you steal your software."Template:Sfn

Tiny BASIC

The complaint was not well received. Among the many responses, Bob Albrecht, another Homebrew member and founder of the People's Computer Company (PCC), felt the best response would be to produce their own BASIC that was completely free to use by anyone. He approached Dennis Allison, a member of the Computer Science faculty at Stanford University, to write a specification for a version of BASIC that would fit in 2 to 3 kilobytes of memory.Template:Efn To aid porting, the design was based on an intermediate language (IL), an interpreter for the interpreter, which meant only a small portion of the total code had to be ported.

Allison's initial design was published in the September 1975 edition of the PCC newsletter, along with an Intel 8080 version of the IL interpreter. The article called on programmers to implement the design on their computer and send the resulting assembly language version back to the PCC. They stated their plans to publish three special newsletters containing these user-submitted versions, along with bug fixes, programs written in the new BASIC, and suggestions and enhancements. The concept gained further notice when it was republished in the January 1976 edition of the ACM Special Interest Group on Programming Languages.<ref name="Allison 1976">Template:Cite journal</ref> Submissions poured in. Among the notable early versions was Tiny BASIC Extended by Dick Whipple and John Arnold which ran in 3K of RAM, added FOR...NXT loops, and allowed a single numeric array. They avoided the use of the IL and wrote it directly in machine code, using octal.<ref name="TB Code Sheet"/>

The first of the three planned newsletters, with the title "Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte", was published in January 1976.<ref name="TB Code Sheet">Template:Cite journal</ref> It starts with a note from Albrecht, under the penname "the dragon", suggesting that three editions would not be enough, and asked the readers if they would like to see it continue. It also reprinted the original article on Tiny BASIC from PCC, included the complete listing of Extended TB, and included a number of small BASIC programs including tips-and-tricks from Allison.Template:Sfn Response to the first issue was so impressive that the introduction to the second issue stated they had already decided to continue publishing the new newsletter under the simplified name Dr. Dobb's Journal. Over the next several issues, additional versions of the language were published, and similar articles began appearing in other magazines like Interface Age.

Spread

File:Copyleft All Wrongs Reserved.png

The use of "Copyleft; All Wrongs Reserved" in 1976<ref name="issue1976"/>

By the middle of 1976, Tiny BASIC interpreters were available for the Intel 8080, the Motorola 6800 and MOS Technology 6502 processors. This was a forerunner of the free software community's collaborative development before the internet allowed easy transfer of files, and was an example of a free software project before the free software movement.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> Computer hobbyists would exchange paper tapes, cassettes or even retype the files from the printed listings.<ref name="Warren 1976">Template:Cite journal</ref>

Jim Warren, editor of Dr. Dobb's, wrote in the July 1976 ACM Programming Language newsletter about the motivations and methods of this successful project. He started with this: "There is a viable alternative to the problems raised by Bill Gates in his irate letter to computer hobbyists concerning 'ripping off' software. When software is free, or so inexpensive that it's easier to pay for it than to duplicate it, then it won't be 'stolen'." The Bill Gates letter was written to make software into products. The alternative method was to have an experienced professional do the overall design and then outline an implementation strategy. Knowledgeable amateurs would implement the design for a variety of computer systems. Warren predicted this strategy would be continued and expanded.<ref name="Warren 1976"/>

The May 1976 issue of Dr. Dobbs has Li-Chen Wang's Palo Alto Tiny BASIC for the 8080. The listing begins with the title, author's name, and date but it also has "@COPYLEFT ALL WRONGS RESERVED".<ref>Template:Cite journal Source code begins with the following six lines.

TINY BASIC FOR INTEL 8080
VERSION 1.0
BY LI-CHEN WANG
10 JUNE, 1976
@COPYLEFT
ALL WRONGS RESERVED

The June date in the May issue is correct. The magazine was behind schedule, the June and July issues were combined to catch up.</ref> A fellow Homebrew Computer Club member, Roger Rauskolb, modified and improved Wang's program and this was published in the December 1976 issue of Interface Age magazine.<ref name="issue1976">Template:Cite journal The source code begins with the following nine lines:

;*********************************

TINY BASIC FOR INTEL 8080
VERSION 2.0
BY LI-CHEN WANG
MODIFIED AND TRANSLATED
TO INTEL MNEMONICS
BY ROGER RAUSKOLB
10 OCTOBER,1976
@COPYLEFT
ALL WRONGS RESERVED

</ref> Roger added his name and preserved the COPYLEFT Notice.

Description

Basic concepts

Tiny BASIC was designed to use as little memory as possible, and this is reflected in the paucity of features as well as details of its interpreter system. Early microcomputers lacked the RAM and secondary storage for a BASIC compiler, which was more typical of timesharing systems.

Like most BASICs of the era, Tiny Basic was interactive with the user typing statements into a command line. As microcomputers of the era were often used with teletype machines or "dumb" terminals, direct editing of existing text was not possible and the editor instead used takeout characters, often the backslash, to indicate where the user backed up to edit existing text.

If the user typed a statement into the command line the system examined it to see if it started with a number. If it did not, the line was immediately parsed and operated on, potentially generating output via <syntaxhighlight lang="text" class="" style="" inline="1">PRINT</syntaxhighlight>. This was known as "direct mode".

If the line was entered with a leading number, the number was converted from decimal format, like "50", and converted to a 8-bit value, in this case, <syntaxhighlight lang="text" class="" style="" inline="1">$32</syntaxhighlight> hexadecimal. This number was used as an index into an array-like storage area where the rest of the line was stored in exactly the format it was typed. When the user typed <syntaxhighlight lang="text" class="" style="" inline="1">LIST</syntaxhighlight> into the command line the system would loop over the array, convert the line number back to decimal format, and then print out the rest of the text in the line.

When a program was present in memory and the user types in the <syntaxhighlight lang="text" class="" style="" inline="1">RUN</syntaxhighlight> command, the system enters "indirect mode". In this mode, a pointer is set to point to the first line of the program, for instance, 10 (Template:Mono). The original text for that line is then retrieved from the store and run as if the user had just typed it in direct mode. The pointer then advances to the next line and the process continues.

Formal grammar

The grammar is listed below in Backus–Naur form, almost exactly as it was specified in the Design Note.<ref>Template:Cite magazine</ref> In the listing, an asterisk ("*") denotes zero or more of the object to its leftTemplate:Snd except for the first asterisk in the definition of "term", which is the multiplication operator; parentheses group objects; and an epsilon ("ε") signifies the empty string. As is common in computer language grammar notation, the vertical bar ("|") distinguishes alternatives, as does their being listed on separate lines. The symbol "CR" denotes a carriage return (usually generated by a keyboard's "Enter" key). A BREAK from the console will interrupt execution of the program. <syntaxhighlight lang="abnf">

   line ::= number statement CR | statement CR

   statement ::= PRINT expr-list
                 IF expression relop expression THEN statement
                 GOTO expression
                 INPUT var-list
                 LET var = expression
                 GOSUB expression
                 RETURN
                 CLEAR
                 LIST
                 RUN
                 END

   expr-list ::= (string|expression) (, (string|expression) )*

   var-list ::= var (, var)*

   expression ::= (+|-|ε) term ((+|-) term)*

   term ::= factor ((*|/) factor)*

   factor ::= var | number | (expression)

   var ::= A | B | C ... | Y | Z

   number ::= digit digit*

   digit ::= 0 | 1 | 2 | 3 | ... | 8 | 9

   relop ::= < (>|=|ε) | > (<|=|ε) | =

   string ::= " ( |!|#|$ ... -|.|/|digit|: ... @|A|B|C ... |X|Y|Z)* "

</syntaxhighlight>

Note that string wasn't defined in the Design Note.

This syntax, as simple as it was, added one innovation: <syntaxhighlight lang="text" class="" style="" inline="1">GOTO</syntaxhighlight> and <syntaxhighlight lang="text" class="" style="" inline="1">GOSUB</syntaxhighlight> could take an expression rather than just a line number, providing an assigned GOTO<ref>Template:Cite magazine</ref> rather than the switch statement of the <syntaxhighlight lang="text" class="" style="" inline="1">GOTO/GOSUB ... OF ...</syntaxhighlight>, a structure then supported in HP Time-Shared BASIC and predating <syntaxhighlight lang="text" class="" style="" inline="1">ON ... GOTO</syntaxhighlight>. The syntax allowing <syntaxhighlight lang="text" class="" style="" inline="1">IF-THEN statement</syntaxhighlight> (as opposed to just a line number to branch to) was not yet supported in Dartmouth BASIC at this time but had been introduced by Digital<ref>Template:Cite book</ref> and copied by Microsoft.

Implementation in a virtual machine

The Design Note specified a virtual machine, in which the Tiny BASIC interpreter is itself run on a virtual machine interpreter. The designer's idea to use an application virtual machine goes back to Val Schorre (with META II, 1964) and Glennie (Syntax Machine). The choice of a virtual machine approach economized on memory space and implementation effort, although the BASIC programs run thereon were executed somewhat slowly.<ref>Template:Cite journal</ref>

Dialects that used the virtual machine included Tiny BASIC Extended, Tom Pittman's Tiny BASIC<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> and NIBL. Other dialects such as Denver Tiny BASIC (DTB) and Palo Alto Tiny BASIC were direct interpreters. Some programmers, such as Fred Greeb with DTB, treated the IL (Interpretive Language) program as pseudocode for the algorithm to implement in assembly language; Denver Tiny BASIC did not use a virtual machine, but it did closely follow the IL program.

This is a representative excerpt from the 120-line IL program: <syntaxhighlight lang="nasm"> S1: TST S3,'GO' ;GOTO OR GOSUB?

    TST     S2,'TO'       ;YES...TO, OR...SUB
    CALL    EXPR          ;GET LABEL
    DONE                  ;ERROR IF CR NOT NEXT
    XFER                  ;SET UP AND JUMP

S3: TST S8,'PRINT' ;PRINT. </syntaxhighlight>

A common pattern in the program is to test for a keyword or part of a keyword, then act on that information. Each test is an assertion as to what is next in the line buffer. If the assertion fails, control jumps to a subsequent label (usually looking for a new keyword or token). Here the system advances its buffer cursor over any spaces and tests for Template:Mono and if it fails to find it then jumps to line Template:Mono. If it finds it, execution continues with the next IL command. In this case, the system next tests for Template:Mono, skipping to line Template:Mono if it fails (a test for Template:Mono, to see if this is instead a Template:Mono command). If it passes, control continues; in this case, calling an IL subroutine that starts at label Template:Mono, which parses an expression. In Tiny BASIC, <syntaxhighlight lang="text" class="" style="" inline="1">GOTO X*10+100</syntaxhighlight> (a computed GO TO) is as legal as <syntaxhighlight lang="text" class="" style="" inline="1">GOTO 100</syntaxhighlight> and is the alternative to the ON-GOTO of larger BASIC implementations. The subroutine Template:Mono pushes the result of the expression onto the arithmetic stack (in this case, the line number). Template:Mono verifies no other text follows the expression and gives an error if it does. Template:Mono pops the number from the stack and transfers execution (GOes TO) the corresponding line number, if it exists.

The following table gives a partial list of the 32 commands of the virtual machine in which the first Tiny BASIC interpreter was written.<ref>Dr. Dobb's Journal, Volume 1, Number 1, 1976, p. 12.</ref>

Template:Mono

If string matches the BASIC line, advance cursor over Template:Mono and execute the next IL instruction; if the test fails, execute the IL instruction at the label lbl

Template:Mono

Execute the IL subroutine starting at Template:Mono; save the IL address following the CALL on the control stack

Template:Mono

Report a syntax error if after deleting leading blanks the cursor is not positioned to reach a carriage return

Template:Mono

Test value at the top of the AE stack to be within range. If not, report an error. If so, attempt to position cursor at that line. If it exists, begin interpretation there; if not, report an error.

Template:Mono

Continue execution of the IL at the label specified

Template:Mono

Return to the IL location specified at the top of the control stack

Template:Mono

Print characters from the BASIC text up to but not including the closing quotation mark

Template:Mono

Print number obtained by popping the top of the expression stack

Template:Mono

Insert spaces to move the print head to next zone

Template:Mono

Output a CRLF<ref>The CRLF there symbolizes a carriage return followed by a line feed.</ref> to the printer

Tom Pittman, discussing the IL, says: "The TINY BASIC interpreter was designed by Dennis Allison as a recursive descent parser. Some of the elegant simplicity of this design was lost in the addition of syntactical sugar to the language but the basic form remains. The IL is especially suited to Recursive Descent parsing of TINY BASIC because of the general recursive nature of its procedures and the simplicity of the TINY BASIC tokens. The IL language is effectively optimized for the interpretation of TINY. Experience has shown that the difficulty of adding new features to the language is all out of proportion with the nature of the features. Usually it is necessary to add additional machine language subroutines to support the new features. Often the difficulty outweighs the advantages."<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Deviations from the design

Defining Tiny BASIC for the Homebrew Computer Club, Pittman wrote, "Tiny BASIC is a proper subset of Dartmouth BASIC, consisting of the following statement types only: LET, PRINT, INPUT, IF, GOTO, GOSUB, RETURN, END, CLEAR, LIST, RUN. Arithmetic is in 16-bit integers only with the operators + - * / and nested parentheses. There are only the 26 single letter variable names A, B, ...Z, and no functions. There are no strings or arrays... Tiny BASIC specifies line numbers less than 256."<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> He then went on to describe his implementation: "This language has been augmented to include the functions RND, USR, and PEEK and POKE, giving the user access to all his system components in the 6800 from the BASIC program."

Many implementers brought their own experiences with HP Time-Shared BASIC or DEC BASIC-PLUS to their designs and relaxed the formal Tiny BASIC language specification. Of the seven prominent implementations published by 1977:

• All added some sort of random number function, typically <syntaxhighlight lang="text" class="" style="" inline="1">RND()</syntaxhighlight>. Though not included in the specification, a newsletter article prior to the Design Note for Tiny BASIC requested only this function.
• All enabled <syntaxhighlight lang="text" class="" style="" inline="1">LET</syntaxhighlight> to be optional and most let expressions in assignment statements contain relational operators.
• All but 6800TB supported statement delimiters in lines, typically <syntaxhighlight lang="text" class="" style="" inline="1">:</syntaxhighlight> although TBX used <syntaxhighlight lang="text" class="" style="" inline="1">$</syntaxhighlight> and PATB used <syntaxhighlight lang="text" class="" style="" inline="1">;</syntaxhighlight>.
• In <syntaxhighlight lang="text" class="" style="" inline="1">IF</syntaxhighlight> statements, all but MINOL removed the need for expressions to contain relational operators (e.g., <syntaxhighlight lang="basic" class="" style="" inline="1">IF X THEN LET Y=X</syntaxhighlight> was valid). Implementations removed <syntaxhighlight lang="text" class="" style="" inline="1">THEN</syntaxhighlight> altogether or made it optional or supported it only for implied <syntaxhighlight lang="text" class="" style="" inline="1">GOTO</syntaxhighlight>. None supported <syntaxhighlight lang="text" class="" style="" inline="1">ELSE</syntaxhighlight> clauses.
• Many modified <syntaxhighlight lang="text" class="" style="" inline="1">PRINT</syntaxhighlight> to support print zones, using <syntaxhighlight lang="text" class="" style="" inline="1">,</syntaxhighlight> to go to the next zone and <syntaxhighlight lang="text" class="" style="" inline="1">;</syntaxhighlight> to not advance the cursor.
• All but 6800TB and DTB added <syntaxhighlight lang="text" class="" style="" inline="1">NEW</syntaxhighlight>.
• All but 6800TB and MINOL added a function to return memory size: TBX had <syntaxhighlight lang="text" class="" style="" inline="1">SZE</syntaxhighlight>, DTB and PATB had <syntaxhighlight lang="text" class="" style="" inline="1">SIZE</syntaxhighlight>, L1B had <syntaxhighlight lang="text" class="" style="" inline="1">MEM</syntaxhighlight>, and NIBL had <syntaxhighlight lang="text" class="" style="" inline="1">TOP</syntaxhighlight>.
• Four implementations added arrays, whether a single, undimensioned array in PATB and L1B or <syntaxhighlight lang="text" class="" style="" inline="1">DIM</syntaxhighlight>ensionable arrays in TBX and DTB.
• Four implementations added the <syntaxhighlight lang="text" class="" style="" inline="1">REM</syntaxhighlight>ark statement.
• Four implementations added the <syntaxhighlight lang="text" class="" style="" inline="1">FOR</syntaxhighlight> loop: PATB, NIBL, and L1B offered <syntaxhighlight lang="text" class="" style="" inline="1">FOR-TO-STEP/NEXT</syntaxhighlight>, while TBX did not support <syntaxhighlight lang="text" class="" style="" inline="1">STEP</syntaxhighlight> and used the keyword <syntaxhighlight lang="text" class="" style="" inline="1">NXT</syntaxhighlight> to end a loop.
• Only NIBL had any nod towards structured programming, with <syntaxhighlight lang="text" class="" style="" inline="1">DO/UNTIL</syntaxhighlight>, despite Allison's lament in Issue 2 about problems with BASIC.

As an alternative to tokenization, to save RAM, TBX,<ref name="Tiny BASIC Extended">Template:Cite journal</ref> DTB,<ref name="Denver Tiny BASIC">Template:Cite journal</ref> and MINOL<ref name="MINOL">Template:Cite journal</ref> truncated keywords: <syntaxhighlight lang="text" class="" style="" inline="1">PR</syntaxhighlight> for <syntaxhighlight lang="text" class="" style="" inline="1">PRINT</syntaxhighlight>, <syntaxhighlight lang="text" class="" style="" inline="1">IN</syntaxhighlight> for <syntaxhighlight lang="text" class="" style="" inline="1">INPUT</syntaxhighlight>, <syntaxhighlight lang="text" class="" style="" inline="1">RET</syntaxhighlight> for <syntaxhighlight lang="text" class="" style="" inline="1">RETURN</syntaxhighlight>. The full, traditional keywords were not accepted. In contrast, PATB allowed accepted traditional keywords but also allowed any keyword to be abbreviated to its minimal unique string, with a trailing period. For instance, <syntaxhighlight lang="text" class="" style="" inline="1">PRINT</syntaxhighlight> could be typed <syntaxhighlight lang="text" class="" style="" inline="1">P.</syntaxhighlight>, although <syntaxhighlight lang="text" class="" style="" inline="1">PR.</syntaxhighlight> and other variations also worked. This system was retained in Level I BASIC for the TRS-80, which used PATB, and was also later found in Atari BASIC and the BASIC of various Sharp Pocket Computers.<ref name=revisit>Template:Cite magazine</ref>

Dialects

The most prominent dialects of Tiny BASIC were the original Design Note, Tiny BASIC Extended, Palo Alto Tiny BASIC, and 6800 Tiny BASIC. However, many other versions of Tiny BASIC existed.

List of prominent dialects

Tiny BASIC was first published in a newsletter offshoot of the People's Computer Company, a newsletter which became Dr. Dobb's Journal, a long-lived computing magazine. About ten versions were published in the magazine.

Prominent dialects of Tiny BASIC (in Dr. Dobb's Journal)

Date published	Issue	Dialect	Author	Processor	Size
December 1975	1<ref>Template:Cite journal</ref>	Design Note	Dennis Allison	Template:N/A	Template:N/A
February 1976	2<ref name="Tiny BASIC Extended"/>	Tiny BASIC Extended (TBX)	Dick Whipple & John Arnold	8080	2.9K
March 1976	3<ref name="Denver Tiny BASIC"/>	Denver Tiny BASIC (DTB)	Fred Greeb	8080	2.75K
March 1976	3<ref>Template:Cite journal</ref>	6800 Tiny BASIC (6800TB)	Tom Pittman	6800	2K<ref>{{#invoke:citation/CS1|citation	CitationClass=web }}</ref>
April 1976	4<ref name="MINOL"/>	MINOL	Eric T. Mueller	8080	1.75K
May 1976	5<ref>Template:Cite journal</ref>	Palo Alto Tiny BASIC (PATB)	Li-Chen Wang	8080	1.77K
November 1976	10<ref name="NIBL">Template:Cite journal</ref>	National Industrial Basic Language (NIBL)	Mark Alexander & Steve Leininger	SC/MP	4K
October 1980	49<ref>Template:Cite journal</ref>	Enhanced 6800 Tiny BASIC	Robert Hudson	6800	Template:N/A
February 1985	100<ref>Template:Cite journal</ref>	TBI68K	Gordon Brandly	68000	Template:N/A
January 2006	351<ref>Template:Cite journal</ref>	Return of Tiny BASIC	Tom Pittman	Template:N/A (C)	Template:N/A

TBX was also known as Texas Tiny BASIC.<ref>Template:Cite journal</ref>

Both SCELBAL<ref name="SCELBAL">Template:Cite magazine</ref> and 6800 Tiny BASIC were announced in the magazine but did not publish their source code.

Palo Alto Tiny BASIC

Template:Infobox programming language One of the most popular of the many versions of Tiny BASIC was Palo Alto Tiny BASIC, or PATB for short, by Li-Chen Wang. PATB first appeared in the May 1976 edition of Dr. Dobbs, written in a custom assembly language with non-standard mnemonics. This led to further ports that worked with conventional assemblers on the 8080.<ref name=revisit/> The first version of the interpreter occupied 1.77 kilobytes of memory and assumed the use of a Teletype Machine (TTY) for user input/output. An erratum to the original article appeared in the June/July issue of Dr. Dobb's (Vol. 1, No 6). This article also included information on adding additional I/O devices, using code for the VDM video display by Processor Technology as an example.

Wang was one of the first to use the word copyleft. In Palo Alto Tiny BASIC's distribution notice, he had written "@COPYLEFT ALL WRONGS RESERVED".<ref>Template:Cite journal (NB. Source code begins with the following six lines. "TINY BASIC FOR INTEL 8080; VERSION 1.0; BY LI-CHEN WANG; 10 JUNE, 1976; @COPYLEFT; ALL WRONGS RESERVED". The June date in the May issue is correct. The magazine was behind schedule, the June and July issues were combined to catch up.)</ref> Tiny BASIC was not distributed under any formal form of copyleft distribution terms, but was presented in a context where source code was being shared and modified. In fact, Wang had earlier contributed edits to Tiny BASIC Extended before writing his own interpreter.<ref name="Tiny BASIC Extended"/> He encouraged others to adapt his source code and publish their adaptions, as with Roger Rauskolb's version of PATB published in Interface Age.<ref name="issue1976"/> He also published a third version in PCC's Reference Book of Personal and Home Computing.<ref>Template:Cite book</ref>

One of the most notable changes in PATB is the addition of the FOR...NEXT loop. In the original TB, loops could only be implemented using <syntaxhighlight lang="text" class="" style="" inline="1">IF</syntaxhighlight> and <syntaxhighlight lang="text" class="" style="" inline="1">GOTO</syntaxhighlight>. As in Microsoft BASIC, the upper and lower bounds of the loop were set on loop entry, and did not change during the loop, so if one of the bounds was based on a variable expression; changing the variable did not change the bound. The <syntaxhighlight lang="text" class="" style="" inline="1">STEP</syntaxhighlight> modifier was optional, as in MS.<ref name=revisit/>

Another significant change was the ability to place several statements on a single line. For reasons not explained, PATB used the semicolon <syntaxhighlight lang="text" class="" style="" inline="1">;</syntaxhighlight> to separate statements, rather than the already common colon <syntaxhighlight lang="text" class="" style="" inline="1">:</syntaxhighlight>.

Other changes include the addition of a single numeric array, with the variable name <syntaxhighlight lang="text" class="" style="" inline="1">@</syntaxhighlight>, <syntaxhighlight lang="text" class="" style="" inline="1">STOP</syntaxhighlight> in addition to <syntaxhighlight lang="text" class="" style="" inline="1">END</syntaxhighlight>, and the use of <syntaxhighlight lang="text" class="" style="" inline="1">#</syntaxhighlight> for not-equals in comparisons, as opposed to <syntaxhighlight lang="text" class="" style="" inline="1"><></syntaxhighlight>.<ref name=revisit />Template:Efn

PATB used words for error messages instead of numbers. To reduce the amount of memory required, there were only three messages and they consisted of single words. The system would respond with <syntaxhighlight lang="text" class="" style="" inline="1">WHAT?</syntaxhighlight> for syntax errors, <syntaxhighlight lang="text" class="" style="" inline="1">HOW?</syntaxhighlight> for run-time errors like GOTOs to a line that didn't exist or numeric overflows, and <syntaxhighlight lang="text" class="" style="" inline="1">SORRY</syntaxhighlight> for out-of-memory problems.<ref name=revisit/>

Wang also wrote a STARTREK program in his Tiny BASIC that appeared in the July 1976 issue of the People's Computer Company Newsletter.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref><ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

He later adapted the language into 3K Control Basic for Cromemco, adding variable names of the form letter-digit (e.g., A0 to Z9), logic functions (AND(), OR(), XOR()), a CALL command to execute machine language routines, more PRINT-formatting options, and others (GET() and PUT() instead of PEEK and POKE; I/O port functions).<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Palo Alto Tiny BASIC was adapted for many other implementations, including Level I BASIC (1977), BASIC for the Sharp PC-1211 pocket computer (1980), and Astro BASIC (1982, by Jamie Fenton).<ref name="AstroBASIC">Template:Cite book</ref>

MINOL

Written by a junior in high school, MINOL was the only implementation that didn't support the full Design Note, lacking operator precedence, having only three relational operators (<, =, #), omitting <syntaxhighlight lang="text" class="" style="" inline="1">GOSUB</syntaxhighlight> and <syntaxhighlight lang="text" class="" style="" inline="1">RETURN</syntaxhighlight>. It only supported unsigned 8-bit precision (in contrast to signed 16-bit precision for every other implementation) and line numbers from 0 to 254.

No spaces were permitted except in strings; <syntaxhighlight lang="text" class="" style="" inline="1">!</syntaxhighlight> returns a random number, <syntaxhighlight lang="text" class="" style="" inline="1">$</syntaxhighlight> before an expression loads a string at that address; <syntaxhighlight lang="text" class="" style="" inline="1">OS</syntaxhighlight> returns to operating system. Memory was addressable as if it were a two-dimensioned array of high and low bytes (e.g., "(0,0)" to "(255,255)"); <syntaxhighlight lang="text" class="" style="" inline="1">CALL</syntaxhighlight> executes a machine language subroutine.<ref name="MINOL"/>

Miscellaneous dialects

Many dialects appeared in various other publications.

File:FloppyRom Magazine.jpg

The May 1977 issue featured a Floppy ROM containing MICRO-BASIC.

Inspired by PCC's call for Tiny BASICs, Robert Uiterwyk wrote MICRO BASIC 1.3 for the SWTPC 6800 system), which SWTPC published in the June 1976 issue of the SWTPC newsletter. Uiterwyk had handwritten the language on a legal tablet. He later expanded the language to 4K, adding support for floating point; this implementation was unique among BASIC interpreters by using Binary Coded Decimal to 9 digits of precision, with a range up to 10⁹⁹, and by being published for free as a "Floppy ROM" magazine insert. An 8K version added string variables and trigonometry functions. Both the 4K and 8K versions were sold by SWTPC. In January, 1978, Uiterwyk sold the rights of the source code to Motorola.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref><ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Thomas F. Waitman wrote a Tiny BASIC in 1976 for the Hewlett-Packard HP-2640 and HP-2645 terminals (which used the Intel 8008 and 8080 processors), which was published in the Hewlett-Packard Journal.

Published in the December 1976 issue of Interface Age was LLL (Lawrence Livermore Laboratory) BASIC, the first draft of which was developed by Steve Leininger from Allison's specification before Leininger left National Semiconductor for Tandy Corporation. The final interpreter was developed by John Dickenson, Jerry Barber, and John Teeter at the University of Idaho on a contract with LLL. Taking 5K, it included a floating-point package, developed by David Mead, Hal Brand, and Frank Olken. The program was placed into the public domain by LLL, which developed the system under the auspices of the U.S. Energy Research and Development Administration.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

4K BASICs

Altair BASIC, 4K BASIC, could run within a 4 KB RAM machine, leaving only about 790 bytes free for program code.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref><ref>Template:Cite book</ref> The Tiny BASIC initiative started in response to the $150 charge for Altair 4K BASIC.

In 1975, Steve Wozniak joined the newly formed Homebrew Computer Club, which had fellow members Li-Chen Wang (Palo Alto Tiny BASIC) and Tom Pittman (6800 Tiny BASIC). Wozniak concluded that his machine would have to have a BASIC of its own, which would, hopefully, be the first for the MOS Technology 6502 processor. As the language needed 4 KB RAM, he made that the minimum memory for the design.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> Integer BASIC was originally published on Compact Cassette in 1976.

In 1977, Radio Shack (as it was known then) released their first computer, the TRS-80, a Z80 system with Level I BASIC in a 4 KB ROM. Tandy-employee Steve Leininger had written the first draft of the NIBL (National Industrial Basic Language) interpreter for the SC/MP while employed at National Semiconductor. <ref name="NIBL"/> Unable to take that source code with him, he adapted Li-Chen Wang's Palo Alto Tiny BASIC for the original prototype of the TRS-80 Model I. He extensively revised the interpreter, adding floating-point support, simple black-and-white graphics, and <syntaxhighlight lang="text" class="" style="" inline="1">READ/DATA/RESTORE</syntaxhighlight> statements.<ref name=pump>Template:Cite book</ref>

Originally developed in 1979, Sinclair 4K BASIC, written by John Grant, used as its language definition the 1978 American National Standards Institute (ANSI) Minimal BASIC standard, but was itself an incomplete 4 KB implementation with integer arithmetic only.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Microcontroller dialects

Tiny BASIC implementations have been adapted for processor control and for microcontrollers such as the Arduino:

• Stephen A. Ness wrote XYBASIC for the Mark Williams Company in 1977, a 4K integer implementation. The language was often used for process control applications.<ref>{{#invoke:citation/CS1|citation

|CitationClass=web }}</ref>

• Arduino BASIC – adapted from Gordon Brandly's 68000 Tiny BASIC, ported to C by Mike Field.
• TinyBasic Plus – adapted from Arduino BASIC by Scott Lawrence.<ref>{{#invoke:citation/CS1|citation

|CitationClass=web }}</ref>

• Half-Byte Tiny Basic – adapted from Arduino BASIC.<ref>{{#invoke:citation/CS1|citation

|CitationClass=web }}</ref>

• Tiny Basic on the micro:bit – adapted from Palo Alto Tiny BASIC.<ref>{{#invoke:citation/CS1|citation

|CitationClass=web }}</ref>

Later implementations

In 2002, Emmanuel Chailloux, Pascal Manoury and Bruno Pagano published a Tiny BASIC (lacking <syntaxhighlight lang="text" class="" style="" inline="1">GOSUB</syntaxhighlight>/<syntaxhighlight lang="text" class="" style="" inline="1">RETURN</syntaxhighlight>) in Developing Applications with Objective Caml as an example Objective Caml application.<ref>Template:Cite book</ref>

In 2013, Alex Yang published an implementation in Python.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

In 2019, Sergey Kuznetsov published a version in Ruby.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Also in 2019, Oscar Toledo Gutierrez published bootBASIC, which fits in the 512 bytes of the boot sector of an 8086/8088 machine, making it the smallest BASIC implementation yet. To accomplish this, the language drops relational operators (IF statements work on nonzero values), limits lines of code to 19 characters or less, and doesn't update the display when backspace is pressed.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> Additionally, it lacks GOSUB and RETURN but does include a RND function (without arguments, returning a value between 0 and 255).<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref> The language uses an array to store program lines, requiring 20,000 bytes to do so.<ref>Template:Cite book</ref>

In 2023, Gordon Henderson published a Tiny Basic implementation in 6502 assembler. It is influenced by NIBL and can run in as little as 3.5KB of ROM requiring at least 1KB of RAM for data and program storage. It supports DO/UNTIL, FOR/NEXT, simple strings and memory peek/poke (byte or 16-bit word), GOSUB/RETURN, CALL, RND with facilities for hexadecimal input and output.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>

Dialects compared

The following table compares the language feature of Tiny BASIC implementations against other prominent BASICs that preceded them.

Comparison of BASIC Implementations – Tiny BASICs and Other BASICs

Template:Verth	Dialect	Programmer(s)	Processor	Type	INPUT	LET	PRINT	GOTO	IF ...THEN	GOSUB	RETURN	END	RUN	LIST	CLEAR	NEW	REM	FOR/NEXT	READ / DATA / RESTORE	Added BASIC commands	Customizations	Expressions	relop	Functions	RND	Memory Function	Line numbers	Statement delimiter	Errors	Precision	Arithmetic	Variables	Arrays	Strings
Template:Verth	Template:Verth	(Dartmouth students)	GE-225	Compile-and-go	Template:N/A [!]	LET var = expression	PRINT expr-list { , / ; / }	GO TO number	IF expression relop expression THEN line-number	GOSUB number	RETURN	END	RUN	LIST--start	Template:N/A	NEW [prompts for program name]	REM	FOR / TO / STEP / NEXT	READ, DATA	STOP	Template:N/A	precedence, ^	< <= = >= > <>	INT, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN	RND(0) 0..1	Template:N/A	1 to 99999	Template:CNone	22 defined	9 digits	±999,999,999; E notation base 2 -256 to +255 (E±76).	A–Z, A0–Z9	DIM (one letter name, two dimensions); if omitted, assumed to go from 0 to 10; up to 1500 elements across all arrays	Template:CNone (added in version 4)
Template:Verth	Template:Verth	(DEC staff)	PDP-8	Compile-and-go	INPUT var-list	LET var = expression	PRINT expr-list { , / ; / }	GO TO number	IF expression relop expression [THEN/GO TO] line-number	GOSUB number	RETURN	END	RUN	LIST (first (, last))	Template:N/A	NEW [prompts for program name]	REM	FOR / TO / STEP / NEXT	READ, DATA, RESTORE	STOP, OLD, SAVE, UNSAVE	DELETE (first (, last)), BYE	precedence, ^	< <= = >= > <>	INT, SGN, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN	RND(0) 0..1	Template:N/A	1 to 2045	Template:CNone	23 defined	Template:Dunno	±134,217,727; 14E-38<N<1.7E38	A–Z, AA–Z9	DIM (one letter name, two dimensions)	Template:CNone
Template:Verth	Template:Verth	Alfred Weaver, Michael Tindall, Ronald Danielson	8008	Interpreter	INPUT <variable> {, <variable>}*	LET var = formula	PRINT <string> / <formula> {, <string> / <formula>}*	GO TO number	IF expression THEN line-number	GOSUB number	RETURN	END	RUN	Template:No2	Template:No2	Template:No2	REM	FOR / TO / STEP / NEXT	Template:N/A	DEF FN, STOP	Template:N/A	precedence, ^	< <= = >= > # AND OR NOT	FNA..Z, SIN, COS, LOG, SQR, EXP, ATN	Template:N/A	Template:N/A	0 to 999	Template:CNone	Template:No2	4-byte mantissa and 1-byte exponent [Datapoint 2200 floating-point arithmetic package]	Template:No2	A–Z, A0–Z9	DIM (one letter name, three dimensions)	Template:CNone
Template:Date table sorting	Template:Verth	Bill Gates, Paul Allen, Monte Davidoff	8080	Interpreter	INPUT ("string",) var-list	(LET) var = expression	PRINT expr-list { , / ; }	GOTO number	IF expression THEN line-number/statement	GOSUB number	RETURN	END	RUN	LIST (start)	Template:N/A	NEW	REM	FOR / TO / STEP / NEXT	READ, DATA, RESTORE	STOP	Template:N/A	precedence	< <= = >= > <>	ABS, INT, SGN, SQR, TAB, USR	RND(X) <0, new using X as seed; =0, repeat; >0, next	Template:N/A	1 to 65535	:	12 defined	40-bit operand floating	Template:Dunno	Template:Dunno	DIM (one dimension)	Template:CNone
Template:Verth	Template:Verth	Dennis Allison	Template:N/A	Interpreter	INPUT var-list	LET var = expression	PRINT expr-list	GOTO expression	IF expression relop expression THEN statement	GOSUB expression	RETURN	END	RUN	LIST	[eq. to NEW]	Template:N/A	Template:N/A	Template:N/A	Template:N/A	Template:N/A	Template:N/A	precedence	< <= = >= > <> ><	Template:CNone	Template:CNone	Template:N/A	1 to 255	Template:CNone	8 defined	16-bit	± 32767	A–Z	Template:CNone	Template:CNone
Template:Verth	Template:Verth	Dick Whipple & John Arnold	8080	Interpreter	IN	(LET) var = expression	;}	GO TO	IF expression [no THEN] statement	GO SUB	RET	END	RUN	LST (first (, last))	Template:N/A	NEW	Template:N/A	FOR-NXT (no STEP)	DTA (array LET)	Template:N/A	Template:N/A	precedence	< <= = >= > <> ><	TB() spaces in print	RN (random 0-10000)	SZE	1 to 65535	$	14 defined	16-bit	± 32767	A–Z	DIM, 1- or 2-dimensions, 255x255 max	Template:CNone
Template:Verth	Template:Verth	Fred Greeb	8080	Interpreter	IN	(LET) var = expression	;}	GOTO	IF expression [no THEN] statement	GOSUB	RET	END	RUN	LIST (first last)	[eq. to NEW]	Template:N/A	Template:N/A	Template:N/A	Template:N/A	TAPE [SAVE], LOAD	CLRS [CLS]	precedence	< <= = >= > <> ><		RND(0), RND(1)	SIZE	2 to 255	:	20 defined	16-bit	± 32767	A–Z, A1 to A6 to Z6	DIM, 1 dimension	Template:CNone
Template:Verth	Template:Verth	Tom Pittman	6800	Interpreter	INPUT (expression) var-list	LET var = expression	PRINT expr-list { , / ; }	GOTO expression	IF expression relop expression THEN statement	GOSUB expression	RETURN	END	RUN	LIST (first last)	[eq. to NEW]	Template:N/A	REM	Template:N/A	Template:N/A	Template:N/A	Template:N/A	precedence	< <= = >= > <> ><	USR()	RND()	Template:N/A	1 to 65535	Template:CNone	53 defined	16-bit	± 32767	A–Z	Template:CNone	Template:CNone
Template:Verth	Template:Verth	Eric T. Mueller	8080	Interpreter	IN	Template:Codett	Template:Codett	[[[:Template:Codett]] jumps back to start of direct statement]	Template:Codett	Template:N/A	Template:N/A	END	RUN	LIST	CLEAR [only variables]	NEW	Template:N/A	Template:N/A	Template:N/A	Template:N/A	Template:No	Template:No	< = #	Template:Codett	Template:Codett	Template:N/A	1 to 254	:	6 defined	8-bit	0 to 255	A–Z	(H,L) memory location	single char
Template:Verth	Template:Verth	Li-Chen Wang	8080	Interpreter	INPUT [(expression) var]*	(LET) var = expression	PRINT expr-list	GOTO expression	IF expression [no THEN] statement	GOSUB expression	RETURN	STOP	RUN	LIST (start)	Template:N/A	NEW	REM	FOR / TO / STEP / NEXT	Template:N/A	STOP	Template:N/A	precedence	< <= = >= > #	ABS()	RND()	SIZE	1 to 32767	;	3 defined	16-bit	± 32767	A–Z	@(1 array of 1 dimension)	Template:CNone
Template:Verth	Template:Verth	Mark Alexander & Steve Leininger	SC/MP	Interpreter	INPUT ($)var	(LET) var = expression	PR/PRINT expr-list	GOTO expression	IF expression (THEN) statement	GOSUB expression	RETURN	END	RUN	LIST (start)	CLEAR [variables & stack]	NEW	REM	FOR / TO / STEP / NEXT	Template:N/A	DO/UNTIL	Memory addressing (@ [PEEK/POKE], STAT, PAGE)	precedence	< <= = >= > <>	MOD(), AND, OR, NOT,	RND(A,Z)	TOP	0 to 32767	:	13 four-char defined	16-bit	± 32767	A–Z	memory addressing	Template:Codett
Template:Verth	Template:Verth	Steve Leininger	Z80	Interpreter	INPUT (#digit) [(expression) var]*	(LET) var = expression	PRINT (#digit) expr-list	GOTO number	IF expression THEN statement	GOSUB number	RETURN	END	RUN (start)	LIST (start)	Template:N/A	NEW	REM	FOR / TO / STEP / NEXT	READ, DATA, RESTORE	STOP, CONT, ON-GOTO/GOSUB	CLOAD, CSAVE, CLS, SET, RESET	precedence	< <= = >= > <> ><	ABS(), INT(), MEM, POINT(X,Y)	RND()	MEM	1 to 32767	:	3 defined	16-bit	± 32767	A–Z	A(1 array of 1 dimension)	Template:Codett
Template:Verth	Template:Verth	Robert Uiterwyk	6800	Interpreter	INPUT var-list	(LET) var = expression	PRINT expr-list { , / ; }	GOTO expression	IF expression relop expression THEN statement	GOSUB expression	RETURN	END	RUN	LIST (first (, last))	Template:N/A	NEW	Template:N/A	FOR/TO/NEXT (no STEP)	Template:N/A	TAB()	Template:N/A	precedence	< <= = >= > <> ><	RND, SIZE	RND [returns 1-32762]	SIZE (statement that prints bytes used and bytes free)	1 to 65535	Template:CNone	17 defined	16-bit [later BCD!]	± 32767	A–Z	DIM (two dimensions, max size of 255)	Template:CNone
Template:Verth	Template:Verth	Mark Arnold & Nat Wadsworth	8008	Interpreter	INPUT var-list	(LET) var = expression	PRINT expr-list {, / ; / }	GOTO number	THEN statement	GOSUB number	RETURN	END	RUN	LIST	Template:N/A	SCR[atch]	REM	FOR / TO / STEP / NEXT	Template:N/A	SAVE, LOAD	UDF [USR]	precedence, ^	< <= = >= > <>	INT, SGN, ABS, SQR, CHR [usable only in PRINT], TAB	RND(0) 0..1	Template:N/A	1 to 999999	Template:CNone	18 defined	32-bit operand floating or fixed point	±134,217,727; 14E-38<N<1.7E38	Template:Dunno	DIM (one letter name, one dimension; up to 4 arrays of up to 64 entries in total)	Template:CNone
Template:Verth	Template:Verth	Steve Wozniak	6502	Interpreter	INPUT ("string",) var-list	(LET) var = expression	PRINT expr-list { , / ; }	GOTO expression	IF expression relop expression THEN line-number/statement	GOSUB expression	RETURN	END	RUN (start)	LIST (first (, last))	Template:N/A	SCR	REM	FOR / TO / STEP / NEXT	Template:N/A	AUTO, DEL, POKE	TAB (command), CALL	precedence	< <= = >= > <> # AND OR NOT MOD	SGN, ABS, PEEK(), LEN()	RND(X) 0..X (or X..0!)	HIMEM, LOMEM	1 to 32767	Template:CNone [early version, then :]	16 defined	16-bit	± 32767	A–Z followed by any number of alphanumeric	DIM (one dimension)	dimensioned
Template:Verth	Template:Verth	(University of Idaho staff)	8080	Interpreter	INPUT var-list	(LET) var = expression	PRINT expr-list { , / ;}	GO TO number	IF expression relop expression (THEN) statement	GO SUB number	RETURN	END	RUN	LIST	Template:N/A	SCR	REM	FOR/TO/NEXT (no STEP)	Template:N/A	STOP	CALL, GET(), PUT()	precedence	< <= = >= > <> ><		Template:Dunno	Template:N/A	0 to 32767	:	14 defined	32-bit operand floating point	Template:Dunno	A–Z, A0–Z9	DIM (integers only, one letter name, one dimension, max size of 255)	Template:CNone
Template:Verth	Template:Verth	John Grant	Z-80	Interpreter	INPUT var	LET var = expression	PRINT expr-list { , / ;}	GO TO number	IF expression THEN statement	GO SUB number	RETURN	Template:N/A	RUN (number)	LIST	CLEAR	NEW	REM	FOR/TO/NEXT (no STEP)	Template:N/A	STOP	POKE	precedence	< = >	ABS, CHR$, CODE, PEEK, RND, STR$, TL$, USR	RND, RANDOMISE	Template:N/A	1 to 9999	Template:N/A	10 defined	16-bit integer	16-bit integer	A–Z followed by any number of alphanumeric	DIM A-Z (integers only, one letter name, one dimension, max size of 255)	A$-Z$

See also

• BASIC interpreter
• Copyleft
• Dartmouth BASIC

References

Bibliography

• Template:Cite journal
• Template:Cite book

External links

• Tiny Basic User Manual and Experimenter's Kit – by Tom Pittman
• Robert Uiterwyk's BASIC Template:Webarchive and Robert Uiterwyk's Micro Basic Template:Webarchive – A MC6800 tiny BASIC later sold with the SWTPC 6800 computer
• MINOL – Erik Mueller's MINOL – Tiny BASIC with strings for Intel 8080
• Tiny BASIC – A version for the curses character screen handling library
• tinyBasic – An implementation written in iziBasic
• Tiny BASIC – A live web version, ported to Run BASIC from iziBasic
• Palo Alto BASIC less than in 500 lines – Example BASIC interpreter written in Ruby.
• TinyBasic – A port of Tom Pittman's TinyBasic C interpreter to Java, C# and Adobe Flex. Includes live web versions.
• TinyBASIC Windows – A Windows version of TinyBASIC
• Category:Tiny BASIC Tasks implemented in Tiny BASIC on rosettacode.org
• Category:Palo Alto Tiny BASIC Tasks implemented in Palo Alto Tiny BASIC on rosettacode.org