Editing Tiny BASIC (section)

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

{| class="wikitable sortable"
|+ Prominent dialects of Tiny BASIC (in Dr. Dobb's Journal)
|-
! Date published !! Issue !! Dialect !! Author !! Processor !! Size
|-
| December 1975 || style="text-align:right;" | 1<ref>{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=Design Note |volume=1 |issue=1 |date=December 1975}}</ref> || Design Note || Dennis Allison || {{N/A}} || {{N/A}}
|-
| February 1976 || style="text-align:right;" | 2<ref name="Tiny BASIC Extended"/> || Tiny BASIC Extended (TBX) || Dick Whipple & John Arnold || [[8080]] || style="text-align:right;" | 2.9K
|-
| March 1976 || style="text-align:right;" | 3<ref name="Denver Tiny BASIC"/> || Denver Tiny BASIC (DTB) || Fred Greeb || 8080 || style="text-align:right;" | 2.75K
|-
| March 1976 || style="text-align:right;" | 3<ref>{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=6800 Tiny BASIC |volume=1 |issue=3 |date=March 1976}}</ref> || 6800 Tiny BASIC (6800TB) || Tom Pittman || [[Motorola 6800|6800]] || style="text-align:right;" | 2K<ref>{{cite web | url=http://www.ittybittycomputers.com/IttyBitty/TinyBasic/TBuserMan.htm | title=TINY BASIC User Manual+}}</ref>
|-
| April 1976 || style="text-align:right;" | 4<ref name="MINOL"/> || MINOL || Eric T. Mueller || 8080 || style="text-align:right;" | 1.75K
|-
| May 1976 || style="text-align:right;" | 5<ref>{{Cite journal|last=Wang |first=Li-Chen |author-link=Li-Chen Wang |title=Palo Alto Tiny BASIC |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |volume=1 |issue=5 |pages=12–25 |date=May 1976}}</ref> || Palo Alto Tiny BASIC (PATB) || Li-Chen Wang || 8080 || style="text-align:right;" | 1.77K
|-
| November 1976 || style="text-align:right;" | 10<ref name="NIBL">{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=NIBL |volume=1 |issue=10 |date=November 1976}}</ref> || National Industrial Basic Language (NIBL) || Mark Alexander & Steve Leininger || [[SC/MP]] || style="text-align:right;" | 4K
|-
| October 1980 || style="text-align:right;" | 49<ref>{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=Enhanced & Modified 6800 Tiny BASIC |date=October 1980}}</ref> || Enhanced 6800 Tiny BASIC || Robert Hudson || 6800 || {{N/A}}
|-
| February 1985 || style="text-align:right;" | 100<ref>{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=TBI68K |date=February 1985}}</ref> || TBI68K || Gordon Brandly || [[68000]] || {{N/A}}
|-
| January 2006 || style="text-align:right;" | 351<ref>{{Cite journal |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |title=Return of Tiny BASIC |date=January 2006}}</ref> || Return of Tiny BASIC || Tom Pittman || {{N/A}} ([[C (programming language)|C]]) || {{N/A}}
|}

TBX was also known as Texas Tiny BASIC.<ref>{{Cite journal |title=Texas Tiny BASIC (TBX) Marries TV-Cassette Operating System (TVCOS) |journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]] |volume=1 |issue=5 |pages=28–31 |date=May 1976}}</ref>

Both [[SCELBAL]]<ref name="SCELBAL">{{cite magazine |magazine=Dr. Dobb's Journal |date=February 1976 |title=SCELBAL – A Higher Level Language for 8008/8080 Systems |first1=Mark |last1=Arnold |first2=Nat |last2=Wadsworth |url=https://archive.org/details/dr_dobbs_journal_vol_01/page/n31/mode/2up |pages=30–53}}</ref> and 6800 Tiny BASIC were announced in the magazine but did not publish their source code.

===Palo Alto Tiny BASIC===
{{Infobox programming language
| name = Palo Alto Tiny BASIC
| logo =               <!-- (filename) -->
| logo caption = 
| screenshot =         <!-- (filename) -->
| screenshot caption = 
| paradigm =           <!-- or: | paradigms = -->
| family =  
| designer =           <!-- or: | designers = -->
| developer = Li Chen Wang
| released = 1976
| latest release version = 
| latest release date =     <!-- {{start date and age|YYYY|MM|DD|df=yes/no}} -->
| latest preview version = 
| latest preview date =     <!-- {{start date and age|YYYY|MM|DD|df=yes/no}} -->
| typing = 
| scope = 
| programming language = 
| discontinued =
| platform = 
| operating system = 
| license = Public domain
| file ext = 
| file format =        <!-- or: | file formats = -->
| website =            <!-- {{url|www.example.com}} -->
| implementations = 
| dialects = 3K Control Basic
| influenced by = Tiny BASIC Design Note, Tiny BASIC Extended
| influenced = [[Bally Astrocade#Astro BASIC|Astro BASIC]], [[Level I BASIC]], [[Sharp PC-1211|Sharp PC-1211 BASIC]]
}}
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 [[kilobyte]]s of memory and assumed the use of a [[Teleprinter|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>{{Cite journal|last=Wang|first=Li-Chen|author-link=Li-Chen Wang|date=May 1976|title=Palo Alto Tiny BASIC|journal=[[Dr. Dobb's Journal|Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte]]|volume=1|issue=5|pages=12–25}} (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>{{cite book |last1=McCabe |first1=Dwight [editor] |title=PCC's Reference Book of Personal and Home Computing |date=July 1, 1977 |publisher=People's Computer Company |location=Menlo Park, CA |isbn=0-918790-02-6 |pages=248 |edition=1st}}</ref>

One of the most notable changes in PATB is the addition of the [[for loop|FOR...NEXT loop]]. In the original TB, loops could only be implemented using {{code|IF}} and {{code|GOTO}}. 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 {{code|STEP}} 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 {{code|;}} to separate statements, rather than the already common colon {{code|:}}.

Other changes include the addition of a single numeric array, with the variable name {{code|@}}, {{code|STOP}} in addition to {{code|END}}, and the use of {{code|#}} for not-equals in comparisons, as opposed to {{code|<>}}.<ref name=revisit />{{efn|Hash was also used for not-equals in [[HP Time-Shared BASIC]].}}

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 {{code|WHAT?}} for syntax errors, {{code|HOW?}} for run-time errors like GOTOs to a line that didn't exist or numeric overflows, and {{code|SORRY}} for out-of-memory problems.<ref name=revisit/>

Wang also wrote a ''[[Star Trek (1971 video game)|STARTREK]]'' program in his Tiny BASIC that appeared in the July 1976 issue of the ''[[People's Computer Company|People's Computer Company Newsletter]]''.<ref>{{cite web|title=People's Computer Company|url=https://archive.computerhistory.org/resources/access/text/2017/09/102661095/102661095-05-v5-n1-acc.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://archive.computerhistory.org/resources/access/text/2017/09/102661095/102661095-05-v5-n1-acc.pdf |archive-date=2022-10-09 |url-status=live|access-date=25 December 2019}}</ref><ref>{{cite web|last=Turnbull|first=Pete|title=Startrek.asc|url=http://www.dunnington.info/public/startrek/startrek.asc|access-date=25 December 2019|archive-date=24 February 2021|archive-url=https://web.archive.org/web/20210224135453/http://www.dunnington.info/public/startrek/startrek.asc|url-status=dead}}</ref>

He later adapted the language into 3K Control Basic for [[Cromemco]], adding variable names of the form letter-digit (e.g., <code>A0</code> to <code>Z9</code>), logic functions (<code>AND()</code>, <code>OR()</code>, <code>XOR()</code>), a <code>CALL</code> command to execute machine language routines, more <code>PRINT</code>-formatting options, and others (<code>GET()</code> and <code>PUT()</code> instead of <code>PEEK</code> and <code>POKE</code>; I/O port functions).<ref>{{cite web|title=3K Control Basic Instruction Manual |url=http://www.dunnington.u-net.com/public/Cromemco/Cromemco%203K%20Basic%20Instruction%20Manual.PDF |publisher=Cromemco |access-date=2013-02-18 |url-status=dead |archive-url=https://web.archive.org/web/20131222220843/http://www.dunnington.u-net.com/public/Cromemco/Cromemco%203K%20Basic%20Instruction%20Manual.PDF |archive-date=2013-12-22 }}</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 [[Bally Astrocade#Astro BASIC|Astro BASIC]] (1982, by [[Jamie Fenton]]).<ref name="AstroBASIC">{{cite book |last1=Ainsworth |first1=Dick |title=Astro BASIC |date=1982 |publisher=Astrocade, Inc. |page=3}}</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 {{code|GOSUB}} and {{code|RETURN}}.
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; {{code|!}} returns a random number, {{code|$}} before an expression loads a string at that address; {{code|OS}} 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)"); {{code|CALL}} executes a machine language subroutine.<ref name="MINOL"/>

===Miscellaneous dialects===
Many dialects appeared in various other publications.

[[File:FloppyRom_Magazine.jpg|thumb|right|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<sup>99</sup>, and by being published for free as a [[Flexi disc|"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>{{Cite web | url=https://deramp.com/swtpc.com/BASIC_2/Uiterwyk.htm | title = Robert Uiterwyk's BASIC}}</ref><ref>{{Cite web | url=https://deramp.com/swtpc.com/NewsLetter1/MicroBasic.htm | title = Robert Uiterwyk's Micro Basic}}</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>{{cite web | url=http://www.bitsavers.org/pdf/interfaceAge/197612/110-124.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/interfaceAge/197612/110-124.pdf |archive-date=2022-10-09 |url-status=live | title=Part 1 Of LLL 8080 BASIC Interpreter}}</ref>

===4K BASICs===
[[Altair BASIC]], 4K BASIC, could run within a 4&nbsp;KB RAM machine, leaving only about 790 bytes free for program code.<ref>{{cite web |url=http://www.virtualaltair.com/virtualaltair.com/vac_Altair_BASIC.asp |title=4 Altair Language Systems |website=Altair BASIC}}</ref><ref>{{cite book |url=http://www.virtualaltair.com/virtualaltair.com/PDF/AltairBasic_1275.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.virtualaltair.com/virtualaltair.com/PDF/AltairBasic_1275.pdf |archive-date=2022-10-09 |url-status=live |title=Altair BASIC |date=25 August 1975 |publisher=MITS}}</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 (computer scientist)|Tom Pittman]] (6800 Tiny BASIC). Wozniak concluded that his [[Apple I|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&nbsp;KB RAM, he made that the minimum memory for the design.<ref>{{cite web
 |first=Steven |last=Wozniak
 |title=How Steve Wozniak Wrote BASIC for the Original Apple From Scratch
 |website=Gizmodo
 |url=https://gizmodo.com/how-steve-wozniak-wrote-basic-for-the-original-apple-fr-1570573636
 |date=1 May 2014
}}</ref> [[Integer BASIC]] was originally published on [[Compact Cassette (data)|Compact Cassette]] in 1976.

In 1977, [[Radio Shack]] (as it was known then) released their first computer, the [[TRS-80]], a [[Zilog Z80|Z80]] system with [[Level I BASIC]] in a 4&nbsp;KB ROM. [[Tandy Corporation|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 {{code|READ/DATA/RESTORE}} statements.<ref name=pump>{{cite book |last1=Welsh |first1=David |last2=Welsh |first2=Theresa |title=Priming the Pump: How TRS-80 Enthusiasts Helped Spark the PC Revolution |date=2007 |page=7}}</ref>

Originally developed in 1979, [[Sinclair BASIC|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&nbsp;KB implementation with integer arithmetic only.<ref>{{cite web|title=ZX80 – 8K BASIC ROM UPGRADE|url=http://www.fruitcake.plus.com/Sinclair/ZX80/ROMUpgrade/ZX80_ROMUpgrade.htm}}</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>{{cite web|last1=Ness|first1=Stephen|title=XYBASIC|url=http://www.nesssoftware.com/home/mwc/XYBASIC.php|website=Ness Software|access-date=4 August 2020}}</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>{{cite web | url=https://github.com/BleuLlama/TinyBasicPlus | title = TinyBasicPlus| website = [[GitHub]]}}</ref>
* Half-Byte Tiny Basic – adapted from Arduino BASIC.<ref>{{cite web | url=https://halfbyteblog.wordpress.com/2014/11/26/its-here-half-byte-tiny-basic-2-for-arduino-and-compatibles-3/ | title = It's here! Half-Byte Tiny Basic 2 for Arduino and compatibles| date = 27 November 2014}}</ref>
* Tiny Basic on the [[Micro Bit|micro:bit]] – adapted from Palo Alto Tiny BASIC.<ref>{{cite web | url=https://halfbyteblog.wordpress.com/2020/03/27/running-tiny-basic-on-the-micro-bit/ | title = Running Tiny Basic on the Micro: Bit| date = 28 March 2020}}</ref>

===Later implementations===
In 2002, Emmanuel Chailloux, Pascal Manoury and Bruno Pagano published a Tiny BASIC (lacking {{code|GOSUB}}/{{code|RETURN}}) in ''Developing Applications with Objective Caml'' as an example [[Objective Caml]] application.<ref>{{cite book |last1=Chailloux |first1=Emmanuel |last2=Manoury |first2=Pascal |last3=Pagano |first3=Bruno |title=Developing Applications with Objective Caml |date=2002 |publisher=O'Reilly |location=France |isbn=2841771210}}</ref>

In 2013, Alex Yang published an implementation in [[Python (programming language)|Python]].<ref>{{cite web |url=https://github.com/aleozlx/tinybasic |title=aleozlx/tinybasic |website=[[GitHub]] |access-date=2020-09-20}}</ref>

In 2019, Sergey Kuznetsov published a version in [[Ruby (programming language)|Ruby]].<ref>{{cite web |url=https://sourceforge.net/p/paloalto-basic/code/ci/master/tree/paloaltobasic.rb |title=PaloAltoTinyBasic |access-date=2020-09-20}}</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>{{cite web |last1=Williams |first1=Al |title=bootBASIC Fits Your Favorite Language in the Boot Sector |url=https://hackaday.com/2019/07/31/bootbasic-fits-your-favorite-language-in-the-boot-sector/ |website=Hack A Day |date=31 July 2019 |access-date=26 March 2022}}</ref> Additionally, it lacks GOSUB and RETURN but does include a RND function (without arguments, returning a value between 0 and 255).<ref>{{cite web |last1=Gutierrez |first1=Oscar Toledo |title=bootBASIC is a BASIC language in 512 bytes of x86 machine code. |url=https://github.com/nanochess/bootBASIC |website=Github |access-date=26 March 2022}}</ref> The language uses an array to store program lines, requiring 20,000 bytes to do so.<ref>{{cite book |last1=Gutierrez |first1=Oscar Toledo |title=Programming Boot Sector Games |date=27 July 2019 |publisher=Lulu |isbn=978-0-359-76262-0 |page=155}}</ref>

In 2023, [https://projects.drogon.net/author/gordon/ 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>{{Cite web |last=Henderson |first=Gordon |date=2023 |title=A Tiny Basic for the 6502 |url=https://projects.drogon.net/gibl/ |website=Drogon Projects}}</ref>

===Dialects compared===
The following table compares the language feature of Tiny BASIC implementations against other prominent BASICs that preceded them.
<div style="overflow-x: auto;">
{{table alignment}}
{{sort-under}}
{| class="wikitable sortable sort-under col4center"
|+ style="text-align: left;" | Comparison of BASIC Implementations – Tiny BASICs and Other BASICs
|-
! {{verth|Date<br/>Published}} 
! 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
|-
! {{verth|va=middle|{{Date table sorting|October 1964}}}}
! {{verth|va=middle|DTSS Dartmouth BASIC<br/>(version 2)<ref>{{cite web|url=http://www.mirrorservice.org/sites/www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.mirrorservice.org/sites/www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf |archive-date=2022-10-09 |url-status=live|title=BASIC}}</ref>}} 
| (Dartmouth students) || GE-225 || Compile-and-go || {{N/A|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 || {{N/A}} || NEW [prompts for program name] || REM || FOR / TO / STEP / NEXT || READ, DATA || STOP || {{N/A}} || precedence, ^ || < <= = >= > <> || INT, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN || RND(0) 0..1 || {{N/A}} || 1 to 99999 || {{CNone|None}} || 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 || {{CNone|None}} (added in version 4)
|-
! {{verth|va=middle|{{Date table sorting|February 1970}}}}
! {{verth|va=middle|DEC BASIC-8<ref>{{cite web|url=https://archive.org/details/bitsavers_decpdp8tsseb70_4173869|title=TSS/8 TIME-SHARING SYSTEM USER'S GUIDE|date=February 1970 }}</ref>}} 
| (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)) || {{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 || {{N/A}} || 1 to 2045 || {{CNone|None}} || 23 defined || {{dunno}} || ±134,217,727;  14E-38<N<1.7E38 || A–Z, AA–Z9 || DIM (one letter name, two dimensions) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|June 1974}}}}
! {{verth|va=middle|UIUC BASIC<ref>{{cite web|url=https://archive.org/details/basiclanguageint658weav|title=A BASIC LANGUAGE INTERPRETER FOR THE INTEL 8008 MICROPROCESSOR|year=1974 }}</ref>}} 
| 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 || {{no2|not documented}} || {{no2|not documented}} || {{no2|not documented}} || REM || FOR / TO / STEP / NEXT || {{N/A}} || DEF FN, STOP || {{N/A}} || precedence, ^ || < <= = >= > # AND OR NOT || FNA..Z, SIN, COS, LOG, SQR, EXP, ATN || {{N/A}} || {{N/A}} || 0 to 999 || {{CNone|None}} || {{no2|not documented}} || 4-byte mantissa and 1-byte exponent [Datapoint 2200 floating-point arithmetic package] || {{no2|not documented}} || A–Z, A0–Z9 || DIM (one letter name, three dimensions) || {{CNone|None}}
|-
! {{Date table sorting|1975}}
! {{verth|va=middle|Altair 4K BASIC<ref>{{cite web|url=https://deramp.com/downloads/mfe_archive/010-S100%20Computers%20and%20Boards/00-MITS/40-Software/BASIC/Altair%20BASIC%203.0/Documentation/Altair_8800_BASIC_Reference_Manual_1975.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://deramp.com/downloads/mfe_archive/010-S100%20Computers%20and%20Boards/00-MITS/40-Software/BASIC/Altair%20BASIC%203.0/Documentation/Altair_8800_BASIC_Reference_Manual_1975.pdf |archive-date=2022-10-09 |url-status=live|title=MITS ALTAIR BASIC REFERENCE MANUAL}}</ref>}} 
| 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) || {{N/A}} || NEW || REM || FOR / TO / STEP / NEXT || READ, DATA, RESTORE || STOP || {{N/A}} || precedence || < <= = >= > <> || ABS, INT, SGN, SQR, TAB, USR || RND(X) <0, new using X as seed; =0, repeat; >0, next || {{N/A}} || 1 to 65535 || : || 12 defined || 40-bit operand floating || {{dunno}} || {{dunno}} || DIM (one dimension) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|December 1975}}}}
! {{verth|va=middle|Design Note<ref>{{cite web|url=http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-01-v1n1.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-01-v1n1.pdf |archive-date=2022-10-09 |url-status=live|title=Dr. Dobb's Journal of Computer Calisthenics and Orthodontia: Running Light Without Overbyte}}</ref>}} 
| Dennis Allison || {{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] || {{N/A}} || {{N/A}} || {{N/A}} || {{N/A}} || {{N/A}} || {{N/A}} || precedence || < <= = >= > <> >< || {{CNone|None}} || {{CNone|None}} || {{N/A}} || 1 to 255 || {{CNone|None}} || 8 defined || 16-bit || ± 32767 || A–Z || {{CNone|None}} || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|February 1976}}}}
! {{verth|va=middle|Tiny BASIC Extended<ref>{{cite web|url=http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-02-v1n2.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-02-v1n2.pdf |archive-date=2022-10-09 |url-status=live|title=Dr. Dobb's Journal of Computer Calisthenics and Orthodontia: Running Light Without Overbyte}}</ref>}} 
| Dick Whipple & John Arnold || 8080 || Interpreter || IN || (LET) var = expression || PR expr-list {,|;} || GO TO || IF expression [no THEN] statement || GO SUB || RET || END || RUN || LST (first (, last)) || {{N/A}} || NEW || {{N/A}} || FOR-NXT (no STEP) || DTA (array LET) || {{N/A}} || {{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 || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|March 1976}}}}
! {{verth|va=middle|Denver Tiny BASIC<ref name="classiccmp_1976-03">{{cite web|url=http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-03-v1n3.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-03-v1n3.pdf |archive-date=2022-10-09 |url-status=live|title=Dr. Dobb's Journal of Computer Calisthenics and Orthodontia: Running Light Without Overbyte}}</ref>}} 
| Fred Greeb || 8080 || Interpreter || IN || (LET) var = expression || PR expr-list {,|;} || GOTO || IF expression [no THEN] statement || GOSUB || RET || END || RUN || LIST (first last) || [eq. to NEW] || {{N/A}} || {{N/A}} || {{N/A}} || {{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 || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|March 1976}}}}
! {{verth|va=middle|6800 Tiny BASIC<ref name="classiccmp_1976-03"/>}} 
| 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] || {{N/A}} || REM || {{N/A}} || {{N/A}} || {{N/A}} || {{N/A}} || precedence || < <= = >= > <> >< || USR() || RND() || {{N/A}} || 1 to 65535 || {{CNone|None}} || 53 defined || 16-bit || ± 32767 || A–Z || {{CNone|None}} || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|April 1976}}}}
! {{verth|va=middle|MINOL<ref>{{cite web|url=http://www.schorn.ch/cpm/zip/minolvtl.zip|title=Dr. Dobb's Journal of Computer Calisthenics and Orthodontia: Running Light Without Overbyte}}</ref>}} 
| Eric T. Mueller || 8080 || Interpreter || IN || {{Codett|code=(LET) var = expression|lang=basic}}|| {{Codett|code=PR expr-list {;}|lang=basic}}|| [{{Codett|code=GOTO 0|lang=basic}} jumps back to start of direct statement] || {{Codett|code=IF expression relop expression&nbsp;; statement|lang=basic}}|| {{N/A}} || {{N/A}} || END || RUN || LIST || CLEAR [only variables] || NEW || {{N/A}} || {{N/A}} || {{N/A}} || {{N/A}} || {{No|No spaces permitted except in strings}} || {{No|No operator precedence}} || < = # || {{Codett|code=$ [CHR$]|lang=basic}}||{{Codett|code=! [RND]|lang=basic}}|| {{N/A}} || 1 to 254 || : || 6 defined || 8-bit || 0 to 255 || A–Z || (H,L) memory location || single char
|-
! {{verth|va=middle|{{Date table sorting|May 1976}}}}
! {{verth|va=middle|Palo Alto Tiny BASIC<ref>{{cite web|url=http://www.autometer.de/unix4fun/z80pack/ftp/altair/tinybasic-1.0.asm|title=Interface Age}}</ref>}} 
| 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) || {{N/A}} || NEW || REM || FOR / TO / STEP / NEXT || {{N/A}} || STOP || {{N/A}} || precedence || < <= = >= > # || ABS() || RND() || SIZE || 1 to 32767 || ; || 3 defined || 16-bit || ± 32767 || A–Z || @(1 array of 1 dimension) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|November 1976}}}}
! {{verth|va=middle|NIBL<ref>{{cite web|url=http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-11-12-v1n10.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.classiccmp.org/cini/pdf/DrDobbs/DrDobbs-1976-11-12-v1n10.pdf |archive-date=2022-10-09 |url-status=live|title=Dr. Dobb's Journal of Computer Calisthenics and Orthodontia: Running Light Without Overbyte}}</ref>}} 
| 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 || {{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 || {{Codett|1=INPUT$,
PRINT$,
$exp=exp|2=basic}}
|-
! {{verth|va=middle|{{Date table sorting|August 1977}}}}
! {{verth|va=middle|Level I BASIC<ref>{{cite web|url=http://www.classiccmp.org/cpmarchives/trs80/mirrors/www.vavasour.ca/jeff/level1/help.html#language|title=Help for TRS-80 Level I BASIC}}</ref>}} 
| 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) || {{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) || {{Codett|A$, B$|basic}}
|-
! {{verth|va=middle|{{Date table sorting|June 1976}}}}
! {{verth|va=middle|MICRO BASIC 1.3<ref>{{cite web|url=http://www.swtpc.com/mholley/NewsLetter1/MicroBasic.htm|title=Robert Uiterwyk's MICRO BASIC|access-date=2012-01-15|archive-date=2012-02-05|archive-url=https://web.archive.org/web/20120205030911/http://www.swtpc.com/mholley/NewsLetter1/MicroBasic.htm|url-status=dead}}</ref>}} 
| 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)) || {{N/A}} || NEW || {{N/A}} || FOR/TO/NEXT (no STEP) || {{N/A}} || TAB() || {{N/A}} || precedence || < <= = >= > <> >< || RND, SIZE || RND [returns 1-32762] || SIZE (statement that prints bytes used and bytes free) || 1 to 65535 || {{CNone|None}} || 17 defined || 16-bit [later BCD!] || ± 32767 || A–Z || DIM (two dimensions, max size of 255) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|June 1976}}}}
! {{verth|va=middle|SCientific ELementary<br/>BAsic Language<br/>(SCELBAL)<ref>{{cite web|url=http://www.pestingers.net/pdfs/other-computers/mark-8/software/scelbal.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.pestingers.net/pdfs/other-computers/mark-8/software/scelbal.pdf |archive-date=2022-10-09 |url-status=live|title=SCELBAL – A higher level language for 8008/8080 systems}}</ref><ref name="SCELBAL" />}} 
| Mark Arnold & Nat Wadsworth || 8008 || Interpreter || INPUT var-list || (LET) var = expression || PRINT expr-list {, / ; / } || GOTO number || IF expression relop expression GOTO line-number | THEN statement || GOSUB number || RETURN || END || RUN || LIST || {{N/A}} || SCR[atch] || REM || FOR / TO / STEP / NEXT || {{N/A}} || SAVE, LOAD || UDF [USR] || precedence, ^ || < <= = >= > <> || INT, SGN, ABS, SQR, CHR [usable only in PRINT], TAB || RND(0) 0..1 || {{N/A}} || 1 to 999999 || {{CNone|None}} || 18 defined || 32-bit operand floating or fixed point || ±134,217,727;  14E-38<N<1.7E38 || {{dunno}} || DIM (one letter name, one dimension; up to 4 arrays of up to 64 entries in total) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|October 1976}}}}
! {{verth|va=middle|Apple I BASIC<ref>{{cite web|url=https://archive.org/details/applei_basicman|title=PRELIMINARY APPLE BASIC USERS MANUAL|date=October 1976}}</ref>}} 
| 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)) || {{N/A}} || SCR || REM || FOR / TO / STEP / NEXT || {{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 || {{CNone|None}} [early version, then :] || 16 defined || 16-bit || ± 32767 || A–Z followed by any number of alphanumeric || DIM (one dimension) || dimensioned
|-
! {{verth|va=middle|{{Date table sorting|December 1976}}}}
! {{verth|va=middle|LLL BASIC<ref>{{cite web|url=http://bitsavers.trailing-edge.com/pdf/interfaceAge/197612/110-124.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.trailing-edge.com/pdf/interfaceAge/197612/110-124.pdf |archive-date=2022-10-09 |url-status=live|title=Interface Age}}</ref>}} 
| (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 || {{N/A}} || SCR || REM || FOR/TO/NEXT (no STEP) || {{N/A}} || STOP || CALL, GET(), PUT() || precedence || < <= = >= > <> >< ||  || {{dunno|No RND?}} || {{N/A}} || 0 to 32767 || : || 14 defined || 32-bit operand floating point || {{dunno}} || A–Z, A0–Z9 || DIM (integers only, one letter name, one dimension, max size of 255) || {{CNone|None}}
|-
! {{verth|va=middle|{{Date table sorting|January 1980}}}}
! {{verth|va=middle|Sinclair 4K BASIC<ref>{{cite web|url= https://cdn.hackaday.io/files/1707077303528288/ZX80_OperatingManual.pdf}}</ref>}} 
|John Grant|| Z-80 || Interpreter || INPUT var || LET var = expression || PRINT expr-list { , / ;} || GO TO number || IF expression THEN statement || GO SUB number || RETURN || {{N/A}} || RUN (number) || LIST || CLEAR || NEW || REM || FOR/TO/NEXT (no STEP) || {{N/A}} || STOP || POKE || precedence || < = > || ABS, CHR$, CODE, PEEK, RND, STR$, TL$, USR || RND, RANDOMISE || {{N/A}} || 1 to 9999 || {{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$
|}
</div>