What early computers had an excellent programming language? I know for many of them, the interpreted language was used as much or more for an operating system as language.

Definition of terms

  • early computer: prior to dominance of IBM pc and Mac, but including late alternatives such as Commodore 128
  • had: available at bootup, either motherboard ROM or ROMpac (not loaded from disk or tape)
  • excellent: directly supports most capabilities of the machine, including graphics and sound, without needing peeks and pokes
  • language: I know BASIC was extremely dominant, but some computers booted into something else, like Jupiter's Forth. (I don't know if that Forth would qualify as excellent, though.)

I am aware of several.

  1. the TRS-80 Color Computer could be bought with Extended Color BASIC
  2. the TI 99/4a had an Extended BASIC cartridge. Even their native BASIC had some support for sound and non-sprite graphics -- it had to, because neither Peek nor Poke was provided.
  3. the Commodore 128 provided an advanced BASIC when in c-128 mode
  4. the BBC Micro had BBC Basic as standard

closed as too broad by Mark, Nick Westgate, NobodyNada, wizzwizz4 Jan 27 '17 at 19:24

Please edit the question to limit it to a specific problem with enough detail to identify an adequate answer. Avoid asking multiple distinct questions at once. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • 6
    I suspect the answer, if you refer to microcomputers, is simply all of them. Surely that was their whole point. Also, don't forget that BBC Basic had PEEK and POKE, so fails your definition of excellent. – Chenmunka Jan 3 '17 at 14:33
  • 3
    @Chenmunka - The existence of PEEK and POKE is not disqualifying by my reading of the question; what disqualifies 'excellence' is the need to rely on those commands to access or make use of computer capabilities - in other words, by the OP's lights, an EXCELLENT BASIC would have had built in commands such as DRAW and PLAY rather than relying on PEEK and POKE for sound and graphics. – Jeff Zeitlin Jan 3 '17 at 14:39
  • 2
    All of these early Basics hardly qualified as excellent languages, since they had only the most rudimentary control flow features, and their global-only name spaces, combined with poor symbol resolution (sometimes only the first char or two counted) made it nearly impossible to write maintainable or comprehensible code. – Taryn Jan 3 '17 at 16:57
  • 1
    Then again, at the same time in 1979 I was consulting at an accountant's office - he had an IBM 5100 supporting both (and only) BASIC and APL - one language at a time and you had to power cycle it to switch languages. I wrote several programs for him, the first was an implementation of XMODEM (in BASIC) so he could get data on and off the thing. Computing on it was slower than you can imagine! I got $25/hr back then, awesome for moonlighting (while at Basic/Four!)! I did simple statistics programs for him in APL. – davidbak Jan 4 '17 at 0:59
  • 1
    Having lots of correct answers shouldn't cause a question to be closed; sometimes questions have many answers and no clear best answer. No-one's mentioned well-specced also-rans like the DAI, Enterprise, Memotech and SAM Coupé yet, either ... – scruss Jan 4 '17 at 15:36

29 Answers 29


The Amstrad CPC machines had a version of Locomotive BASIC clearly heavily inspired by BBC Basic. While they weren't quite as good as the latter they were still light-years ahead of the older versions of Microsoft BASIC being used by the C64 at the time, as well as Sinclair's alternatives.

The Commodore 16 had a similar, more advanced BASIC, comparable to that in the C128.

The Sinclair machines, while not supporting more advanced programming structures, did support native graphics and sound quite well in Sinclair BASIC.

  • 1
    I wouldn't say the -16 (and Plus/4) had a better basic than the 128. Definitely both were light years ahead of what was on the C64, but the 128's basic is pretty stellar. – Joe Jan 3 '17 at 14:47
  • Ah, sorry, I didn't mean that, I must have had a brainfart while writing that sentence. Will edit. I intended it to mean that it had a more advanced BASIC, like that of the C128. – Muzer Jan 3 '17 at 14:48
  • Amstrad CPC464 would be my recommended platform of choice. – PCARR Jan 3 '17 at 17:00
  • 1
    BASIC 2.0 on the C64 was primitive. However, it didn't cost very much! :-D – cbmeeks Jan 3 '17 at 19:43
  • 1
    Locomotive BASIC was pretty good: it had full sound and graphics control without POKEs, supported multiple output windows and had rudimentary interrupt controls so you could write vaguely threaded programs. – scruss Jan 4 '17 at 2:30

The weirdest "early computer" capable of booting into an excellent programming language was the Apple Laserwriter. Introduced in 1985, it had an interactive Postscript environment; if you hooked a terminal to it, you could write and execute Postscript programs via its serial port. At that time it was the fastest and most powerful computer Apple sold, with 1.5 MB of memory in a time when most PCs had only a fraction of that.

It is debatable whether the stack-oriented Postscript was an excellent language, but it was certainly a complete language, and like Forth, was able to wring a lot of performance from fairly modest hardware.

Obviously Sun4s (SPARC), from the late 80s, and PowerPC Macs, from the mid-90s don't qualify as "early [micro]computers", but they were capable of booting directly into an interactive Forth variant, Open Firmware, originally pushed by Sun, later becoming IEEE 1275-1994. For those comfortable with the peculiarities of RPN and stack-oriented languages, the Open Firmware machines provided an incredible sandbox and construction kit.

  • 1
    By the OP's definition of "excellent" for the purposes of this question, there is no question that PostScript on the LaserWriter was an "excellent" language. – Jeff Zeitlin Jan 3 '17 at 16:51
  • 1
    @steve - the OP did define it sufficiently for the purposes of the question - "excellent" means that you do not need to rely on PEEK/POKE (in BASIC) or the equivalent (in other languages) to access capabilities of the computer in question, such as sound or graphics. – Jeff Zeitlin Jan 3 '17 at 17:36
  • 2
    @steve, every other machine listed here predated the Laserwriter, but it was probably one of the first micros with a language that was not Basic, had rational control flow, and fully supported all capabilities of the device it ran on. – Taryn Jan 3 '17 at 17:46
  • 1
    In the mid 90s I bought a used Laserwriter (IIg perhaps?) from a school system. It already had many thousands of pages on its counters, possibly 6 digits worth. After stuffing in more memory, the machine served me for another 15+ years, only finally dying when I put in a toner cart that must have been ancient new stock, or stored badly, the imaging engine just clanked and creaked to a standstill. :( – Taryn Jan 3 '17 at 19:28
  • 4
    Back in 1988, my officemates realized the laser printer was the most powerful computer in our office and wrote a ray tracer for it in PostScript. Not surprisingly, performance was awful (4 seconds per pixel) but it worked: graphics.stanford.edu/pub/Graphics/RTNews/html/… – Ken Shirriff Jan 3 '17 at 20:53

The BBC Micro's built-in BASIC interpreter was very comprehensive, and supported good structured programming techniques at a time when very few other BASIC interpreters did so.

Features included:

  • FN and PROC for functions and procedures, which also supported recursion
  • REPEAT / UNTIL loops
  • direct access to graphics primitives, e.g. PLOT, MOVE, DRAW
  • direct access to sound functions, e.g. SOUND, ENVELOPE
  • trigonometric functions, e.g. SIN, COS, etc.
  • a built-in multipass assembler
  • byte ? and word ! memory access operators (c.f. PEEK and POKE)

Code entered into a program at the prompt would be automatically converted into a compact internal byte-code representation to save memory and to improve the subsequent speed of running that code.

  • 1
    the presence of recursion and function calling implies the interpreter had a much better design than most of the Basics of the time. I might have liked this one :) – Taryn Jan 3 '17 at 18:36
  • 2
    It also had sound capabilities (SOUND and ENVELOPE), the ability to invoke operating system commands (OSCLI, added in BBC BASIC II (on BBC Micros since 1982)), and the ability to call machine code (CALL), the ability to change screen mode (MODE) and define viewports, change the colour palette, define user-defined characters (VDU; though these were accessed by function numbers). The built-in assembler could use BBC BASIC as a powerful macro language. 'LINE' was not supported on the Model B. (In BBC BASIC II, lines were drawn with MOVE and DRAW; 'LINE' was added in a later version). – John B. Lambe Jan 3 '17 at 23:56
  • 1
    It also had EVAL(), which evaluated the string argument in the BASIC interpreter as a function. Downsides of BBC BASIC were that it didn't understand lower case keywords and that its speed was gained through having very little garbage collection. It was possible to have a BBC BASIC programme run out of memory while the same program on another interpreter would keep running with only occasional pauses for the garbage collector to clean up the heap. – scruss Jan 4 '17 at 1:24
  • 1
    @Alnitak - yes. most of them, as BASIC eats memory with its string heap. Two references: CBM BASIC Garbage Collection and Locomotive BASIC (Amstrad CPC) FRE() – scruss Jan 4 '17 at 15:16
  • 1
    I was a professional programmer in BBC Basic on the BBC Micro in 1982 when I was 16 years old. I wrote CAL (computer assisted learning) software. I never once ran into any memory problems. In fact, the biggest problem came from 'line numbering'. – Engineer Dollery Jan 5 '17 at 20:52

The Microsoft BASIC present in MSX machines allows the programmer to access advanced capabilities of the machine such as sprites (with collision detection based flow control, AFAIR), redefinable characters, sound (playing in the background), redefinable function keys, and so on. You could actually write a very decent game in pure BASIC.

  • I should have mentioned MSX in the OP. I was aware of it, but had forgotten. – RichF Jan 3 '17 at 18:20
  • 1
    I'm only just discovering how good MSX (and especially MSX-II) BASIC is. The machines are virtually unknown in some countries. – scruss Jan 4 '17 at 15:20
  • 3
    It was pretty brilliant (about as good as the BBC Micro I would say). I wrote a complete PacMan clone in MSX Basic, 20 levels, complete with 2 different tile-sets for the levels and the song Popcorn as background music. Took about 1000 lines of (fairly dense) code. About half of that to define the music and the graphics: tile-sets (redefined characters) and levels (each 24 rows of 40 character strings). I was 14 at the time. Still got that MSX somewhere in the attic. I wonder if it still works... – Tonny Jan 5 '17 at 9:45
  • 2
    The MSX was 'far' better than the BBC Micro. – Engineer Dollery Jan 5 '17 at 20:54
  • @EngineerDollery depends on how you compare it. The BBC's main deficiency was lack of dedicated sprite hardware for graphics, but in terms of I/O expansion and peripherals there was nothing to touch it. I spent my whole teens messing about with various hardware interfaced to our 'B'. – Alnitak Jan 5 '17 at 21:17

Predating the Commodore 128, the Commodore 64, VIC-20, and PET all had virtually identical ROM BASICs to the 128.

The Apple II, II+, and IIe (I think the IIc did not predate the IBM PC) all had BASIC in ROM (Integer BASIC for the II, AppleSoft BASIC for the II+ and IIe), but I do not believe they qualified as 'excellent' by your definition; many programs relied on POKEing ML routines into RAM to access some of the respective computer capabilities.

Predating the IBM PC (which had the model number 5150) was the IBM 5100; there were two versions, the 5100A, which had APL in ROM, and the 5100B, which had BASIC in ROM. The computers did not have extensive capabilities, and within the limits of the capabilities, both the APL and the BASIC could meet your definition of 'excellent'.

  • 4
    The C64 and VIC-20 had terrible BASIC by the definition of the question. The Microsoft BASIC version included with the C16 and C128 are much better. – Muzer Jan 3 '17 at 14:37
  • 2
    The (later) C16's BASIC has native graphics/sound commands, and the C16 is weaker than the C64. The C64 requires you to use PEEK/POKE to do ANY sound and to do ANY graphics more advanced than character graphics. – Muzer Jan 3 '17 at 14:50
  • 1
    @JeffZeitlin The phrasing of your first paragraph is unclear. I am sure you already know the c-128 had two BASICs. There was the traditional BASIC in C-64 mode, and the much more advanced v7.0 BASIC in C-128 mode. – RichF Jan 3 '17 at 14:51
  • 1
    C64 and Vic-20 BASIC was a mixed bag. On one hand, it had no high-level support for things like graphics or sound, let alone structured programming. On the other hand, it was lightning-fast compared to other platforms available at the time. Its "print" command in particular was BLAZINGLY fast... actual programs were written that used nothing besides PRINT statements to animate the screen. Put another way, Vic-20/C64 BASIC was tedious to program... but programs written in it generally sucked WAY less than programs written in BASIC on other computers. – Bitbang3r Jan 4 '17 at 5:40
  • 1
    It took me about a week trying to program a C64 in basic before I decided I had learn 6502 machine language. – Ron Jensen Jan 6 '17 at 7:25

Most 8-bit Atari computers were sold with a fairly good BASIC interpreter, either as a cartridge (on the 400 and 800) or built-in (in all XL and XE systems). It has keywords to support:

  • quite a few graphics modes
  • graphical operations (line drawing etc.)
  • sound
  • reading the joysticks and paddles
  • I/O features

It's rather slow though, so BASIC programmers quickly learnt to add machine-language routines or switched to one of the other BASIC interpreters (such as the excellent Turbo-Basic XL). It needs PEEK and POKE to support features such as sprites, programmable character sets, scrolling, and display lists.

  • There are some real problems with Atari BASIC that should be mentioned, however, notably its terrible speed. It did have some cool features as well, but I don't think they made up for that one honking issue. web.archive.org/web/20070524044410/http://www3.sympatico.ca/… – Maury Markowitz Jan 5 '17 at 20:29
  • 1
    I did say “It’s rather slow though” ;-). But yes, it was very slow (apart from string handling), which meant resorting to lookup tables for lots of calculations. – Stephen Kitt Jan 5 '17 at 20:42
  • 1
    I took my first programming class on Atari 400 and Atari 800 circa 1981. IMHO, the basic on these machines was much better than the C= 64. You could actually play sounds and do simple graphics without peeks and pokes. Their biggest drawback for me was you couldn't access the disk-drive if you didn't boot the machine with the drive powered up already. – Ron Jensen Jan 6 '17 at 7:20
  • 1
    @RonJensen Of course that was also a "feature", the drivers were on the diskette and loaded as part of the plug-n-play protocols. Of course, as you note, it only did that at boot time. – Maury Markowitz Jan 6 '17 at 13:08
  • BTW, one of the designers of the SIO plug-n-play unsurprisingly ended up at MS implementing USB. – Maury Markowitz Jan 6 '17 at 15:51

The Radio Shack TRS-80 Model 100 portable computer not only had an "excellent" BASIC (by your standards), but also had applications like a text editor and a telecom program built into the ROM. It also had a battery-backed SRAM filesystem, so anything you put on it was also "instantly" available. A friend and I had fun porting Forth to it.

  • 1
    Welcome to Retrocomputing. Thanks for answering and sharing your knowledge of the system; I hope that you "stick around" and contribute some more questions and answers. – wizzwizz4 Jan 4 '17 at 21:43
  • I was able to write a printer driver in Basic to run on the Model 100, and hook the Model 100 to a Royal electric typewriter that had a parallel port. Voila! a complete word-processing solution in 1982. I miss the simplicity and versatility of the Model 100 -- AA batteries, acoustic coupler modem, built-in programs, lightweight, quiet. It was a great machine. – user8356 Jan 5 '17 at 16:00
  • I was going to mention the model 100 if someone else didn't. I just put fresh batteries in my Model 100 over the weekend, powered it on and was greeted by all my programs and documents from 30 years ago. Truly an excellent little computer for it's time.. – Justin Ohms Jan 6 '17 at 20:27
  • One bit of trivia: Bill Gates personally wrote the BASIC for this machine,at least in part. – Whit3rd Jan 10 '17 at 1:47

One of the best BASIC implementations (in terms of "comfortable" and "feature-rich", not necessarily "fast") was IMHO the Sinclair QL's implementation of SuperBASIC. It had functions and procedures, loops, and was all-in-all very close to Pascal. Later in the history of this computer, there were (and still are) also compilers for the language.

Some examples on control structures (the partial capitalisation of commands was a feature of the code editor):

100 DEFine PROCedure Test (input$)
110   LOCal i%, j%
120   i% = 0 : j% = 1
130   REPeat TestLoop
140     i% = i% + 1 : j% = j% + 1
150     SELect on i%
160       = 0 : PRINT "i is zero"
170       = 1 : j % = j% + 1
180             PRINT "j is now ", j%
185             NEXT TestLoop
190       = 2 TO 10
200         PRINT "i is between 2 and 10"
210       = REMAINDER
220         PRINT "i is something else"
225         EXIT TestLoop
230     END SELect
240     PRINT input$ (2 TO)
250     IF input$ (1) == "a" THEN
260       PRINT "we have an uppercase or lowercase a"
270       RETurn
280     ELSE
290       PRINT "We have something else"
300     END IF
310   END REPeat TestLoop
320 END DEFine Test
330 :
340 DEFine FuNction TestFun$ (in$)
350   RETurn in$
360 END DEFine TestFun$

As you can see, very PASCALish... The language as such could have done completely without line numbers, still they were mandatory.

  • And iirc it could do large integer arithmetic in strings rather easily – PlasmaHH Jan 23 '17 at 13:40
  • @PlasmaHH Integers have a range of +- 32767 in original QL SuperBASIC. You could, however, mix assignments between data types - Assign an integer to a string to "stringify" it, or a string to an integer and SuperBASIC would execute the equivalent of a VAL() in other Basics – tofro Feb 2 '17 at 12:44

Hewlett Packard machines, in particular the HP9825 and the later HP9845 would boot directly into a language that meets your "excellent" criterion.

The HP9825 used HPL ("Hewlett Packard Language") which was a variant of APL and the HP9845 HP-BASIC.

Both these ROM-based languages contained very extensive graphics commands. Indeed they were intended to drive HP Plotters using the HP-IB (aka IEEE488) interface bus.

Other HP machines in the range had similar capabilities.

  • They were very nice for the time, predating the PET and Apple II by about four years. They were hideously expensive and very slow, unfortunately. – scruss Jan 4 '17 at 1:26
  • And had sucky keyboards too. All HP computerized instrumentation and their terminals too had those horrible keyboards back then. Otherwise their terminals were highly capable. Much better than contemporary terminals like VT52, VT100. But you couldn't type on them, which sort of made them unfit for purpose. – davidbak Jan 4 '17 at 5:12
  • I used a 9825 that had a "graphics translator" on the HP-IB bus. It drove 1024x1024 vector plot graphics on a green screen monitor, and we had 8 inch floppy drives attached, too. – Ron Jensen Jan 6 '17 at 7:23
  • I seem to recalls the 9825 actually could compile the BASIC so it was "really fast" (compared to other machines I used) - and it could use "long" variable names ("time" instead of "T"). Also, I used the HP-85 ; it only allowed variable names that were a single character-digit combination, which could get messy. And it stored programs on little tapes; that could get really slow... – Floris Jan 6 '17 at 15:42

The Sinclair ZX Spectrum (1982) had Sinclair Basic built in. IIRC, the preceding ZX80 and ZX81 also did, though I didn't spend as much time on them.

  • 1
    ... and despite the appalling keyboard, it was a pretty good BASIC, was designed to win the BBC education contract (it didn't; Acorn won) and a model for a learner's manual. Sinclair 128 BASIC got rid of the messy keyboard limitations. Surprising features include the VAL() function which was a full function evaluator like BBC BASIC's EVAL(). Its string handling is similar to certain mainframe/mini BASICs, but very different from most other micro BASICs – scruss Jan 4 '17 at 15:26

In France, Thomson 8-bit micros were installed in some primary schools in the 80s (in a similar fashion to BBC micros in the UK), and schoolchildren were supposed to learn programming on them. Three programming languages were available: BASIC (a Microsoft dialect), LSE and LOGO. LOGO was available on cartridge, and many of the micros in schools were used with nothing else.

The LOGO dialect is excellent by your definition; it has keywords to support

  • graphics using the turtle
  • sound (albeit only with named musical notes)
  • disk access
  • printing
  • light-pen input
  • joystick input

It also has lots of mathematical functions.

The school I attended also had the Tortue Jeulin, a large physical turtle which could be driven alongside the on-screen turtle, so we could take our drawings home!

  • I agree, it's one of the best implementation of basic I saw; It was an implementation of the Microsoft basic with a very good syntax access to all I/O, etc – Thomas Jan 5 '17 at 0:19

The Commodore SuperPET had an optional Waterloo Structured BASIC chip which presented a more advanced dialect of BASIC than the standard Commodore BASIC that I learned to program on. We had a Waterloo BASIC SuperPET in my elementary school library but as a ten-year-old I did not fully appreciate how much of an improvement it was over regular BASIC.

You can read the manual here; see the introduction for a list of the advanced features.


Fun fact: I worked with Ian McPhee when I was an intern in the early 1990s. Super nice guy. I had not realized until just now that he worked on the BASIC chip that was in the PETs in my elementary school.


I believe the only alternative to BASIC was Forth in the British Jupiter Cantab Jupiter Ace and French Micronique Hector HRX.

Forth would be considered a bit arcane compared to BASIC but it might be considered "excellent" as it was faster (usually 5 to 10 times) than interpreted BASIC and required structured programming techniques with IF..ELSE..THEN, DO..LOOP, BEGIN..UNTIL, and BEGIN..WHILE..REPEAT, etc. No GOTOs.

Jupiter Cantab Jupiter Ace

Micronique Hector HRX

  • 1
    LOGO was quite popular on some 8-bit micros (especially the Thomson micros in France). – Stephen Kitt Jan 3 '17 at 15:15
  • 1
    You don't need to sell me on Forth. I once wrote a screen editor that fit on one 64x16 character screen. It wasn't very readable, but it worked! I miss the old paradigm of 100% control of everything all the time. Heck, you could even run a multi-user system in 64 kbytes of RAM. – RichF Jan 3 '17 at 15:15
  • 1
    @StephenKitt was the LOGO present at power-up? If so, its turtle graphics would qualify it for "excellent" status, especially if sound were also supported. – RichF Jan 3 '17 at 15:24
  • @RichF it was available on cartridge, so I think it would meet your definition. I'll add another answer. – Stephen Kitt Jan 3 '17 at 15:42
  • The ace was excellent, and FORTH isn't that weird -- ok, it's pretty weird, but it still has some modern uses (mostly at NASA I think) – Engineer Dollery Jan 5 '17 at 20:58

The Sinclair QL from 1984 had Sinclair's superBASIC baked in -- in fact this was also the commandline. I don't remember much about it but I do remember some rather sophistictated sound support at least compared to the other BASICs I'd used at the time (late 80s by the time I got my hands on one).


The IBM 5100, announced/shipped in 1975, had the options of either/both BASIC and APL. The version of BASIC was the same as shipped on the IBM System 3, and the APL was IBM's S/370 time-share version -- both were pretty full-functioned. Internally the 5100 ran System 3 (for BASIC) and 370 (for APL) emulators on a "PALM" 16-bit processor.

In the shop where the 5100 was developed we had a Canadian machine, I think 8008-based, that ran a primitive version of APL. I cannot remember the brand of that machine, though.


No discussion of BASIC available at bootup would be complete without inclusion of the Wang 2200 series of minicomputers, produced by Wang Labs in various models from 1973 to 1992. Not only was an excellent BASIC immediately available on startup, it was the only language available to programmers and users of the 2200 series.

Wang 2200 BASIC was converted to internal byte-code on entry, and interpreted at runtime. The only developers who ever programmed the 2200 in assembler were the four or five who wrote the operating system, source editor, and BASIC interpreter.

The following paragraphs are taken from Jim Battle's excellent historical site.

Wang produced three generations of "2200" CPUs; that is, the CPUs were not compatible at the microcode level, requiring Wang to implement the Wang BASIC interpreter from scratch for each. There were comparatively minor changes within each generation, such as improved packaging density or increased microcode storage.

Wang BASIC was interpreted. Although it hurt performance somewhat as compared to a compiled BASIC, it made the implementation much simpler and less costly. Interpreted BASIC is more interactive and immediate. Also, because the CPU didn't have floating point accelerator hardware, much of the time was spent in the floating point routines. While a compiler speeds up the interpretation and symbol table look-ups, it does nothing to help time spent in library routines, such that a compiled version would only be a small factor faster than an interpreted one.

Wang BASIC had two fundamental data types: double precision floating point numbers (8 bytes holding 13 bcd mantissa digits, two bcd exponent digits, and one nibble encoding the signs of the mantissa and exponent), and fixed size character strings, from 1 to 64 characters. Wang BASIC also supported 1-D and 2-D arrays of both of these types.

  • I wonder if the HP-2000 would also meet the criterion, since the lack of support for any other language meant that anything that could be done at all, could be done in BASIC? – supercat Jan 6 '17 at 18:19

The Acorn Atom - the predecessor of the BBC Micro Models A and B.

This had BBC BASIC I (an earlier version than all except very early BBC Micros). This had the features mentioned in Alnitak's answer (BBC Micro), sound, graphics, and functions/procedures, but not the ability to call operating system commands (OSCLI) (except by calling the OS routine by its address; this was added in BBC BASIC II).


In 1982, in Australia, Hitachi had the Peach, a Motorola 6809 based computer with a version of BASIC in ROM. The Peach looked a little like the Apple II, but with a metal case and a keyboard with Hiragana and Katakana characters as well as English.

It was a powerhouse and could have 48K bytes memory.

  • Welcome to Retrocomputing! Thanks for your answer, I hope you stick around to ask and answer more questions. – JAL Jan 5 '17 at 4:36

The original Radio Shack TRS-80 broke down BASIC into two retail levels, a Level I and Level II BASIC. The system had nothing but black and white, 64x16 character mode and the most primitive graphics on what I think was a 128x48 layout that led to the chunkiest graphical displays, but you'd be amazed at what some really creative people did with it - some of the bridge console animations from the first Star Trek movie in 1979 were done on an old black and white TRS-80.

Some developers figured out how to write surprisingly performant graphics apps on the ol' TRS-80 series using PEEK and POKE's when it was discovered you could POKE directly to screen memory, which was much faster than calling the BASIC SET or UNSET calls. The version of BASIC was stripped of function definitions, and all programs had to be saved to a flaky cassette interface. I remember typing in the "Super Star Trek" game from the great old "Creative Computing" magazine's "101 Basic Computer Games" into my 16K TRS-80 and having to do the function conversions myself. Was a great golden age of computing.

  • Welcome to Retrocomputing. Thanks for the detailed answer; I hope to see more of yours around the site. Also, you can make commands look more commandy with the code syntax (achieved by surrounding text with backticks). (Don't use it for emphasis though; that's what italics is for.) – wizzwizz4 Jan 6 '17 at 18:36

The Netronics Explorer had Microsoft Basic at boot. Built one of these myself back in the day.


  • 1
    Welcome to Retrocomputing! This is a borderline link-only answer. Would you mind elaborating on the Explorer/85's BASIC implementation. – JAL Jan 3 '17 at 19:31

The Radio Shack “Pocket Computer” (circa 1980) and later the PC-2 had excellent BASIC that I thought ran rings around the Apple ][ I encountered later.


The initial release spec of the IBM PC — 16 KB RAM, Cassette BASIC immediate mode on boot, TV output — is hardly what we'd recognize as a PC. Its ROM BASIC was BASICA, a very capable traditional interpreter with the same roots as Microsoft's GW-BASIC. It was too expensive for the home market, though, and IBM moved away from marketing it that way.

Should one wish to re-live the Cassette BASIC experience on a modern computer, Rob Hagemans' PC-BASIC interpreter is an interesting project. It supports cassette audio I/O (BASICODE too!), and yes, you can play DONKEY on it …

  • I don't even remember a 16 kbyte model, though I know about the diskless, cassette-based config, But dayamn, 16 kb? I bet that let you run PC-DOS and edlin, simultaneously! // BASICA in ROM allowed something useful, I guess. – RichF Jan 4 '17 at 16:23
  • The 16 K and 64 K cassette only models didn't run PC-DOS: they booted straight into BASIC immediate mode. – scruss Jan 5 '17 at 2:30

Started with the Sinclair ZX80. While great BASIC, sound and graphic support, when I tried to port a chess program written for an Amiga to the ZX, I encountered major troubles, as there were sparse array issues.

Most liked by me was later the Atari ST, having a complete Midi Synthesizer written in BASIC, that featured an almost modern looking GUI.

  • Welcome to Retrocomputing Stack Exchange. Thanks for the information, and for sharing your personal experience not as an offside but to back up and provide more information about the BASICs on each computer. It seems as though you have read the tour before creating your account, but you can get a badge for it if you do so again. – wizzwizz4 Jan 8 '17 at 10:42

The Sharp PC-1211 introduced in 1980 was a pocket computer (weight 170gr / 0.37 lbs., 300 hours of battery life) programmable in BASIC, equipped with a 4-bit CPU and a 24-digit alphanumeric dot matrix LCD display.

enter image description here

The CPU was a SC43177/SC43178 4-bit processors running at 256 kHz with three TC5514P 4 Kbit RAM.

Its BASIC language was capable of these commands (RUN, NEW, MEM, DEBUG, LIST, CONT, CLEAR, INPUT, PRINT, PAUSE, USING, LET, STOP, REM, BEEP, FOR, TO, STEP, NEXT, GOTO, GOSUB, RETURN, IF, THEN, END, AREAD), these operations (+, -, *, /, (, ), >, <, >=, <=, <>, =) and these functions (SIN, COS, TAN, ASN, ACS, ATN, EXP, LN, LOG, INT, ABS, square root, DEG, DMS, SGN, DEGREE, RADIAN, GRAD, pi, power)

Variables can be named A~Z, A( ), A$~Z$, A$( )

Programs and data can be saved in, and load load from a tape recorder by these commands (CSAVE, CLOAD, CLOAD?, PRINT#, INPUT#, CHAIN)

The Stack was: For data: 8 stacks, For function: 16 stacks (in parenthesis, 15 levels), For subroutine: 4 stack, FOR-NEXT statement: 4 stack.

Program memory: 1424 steps, Fixed Memory: 26 permanent variable locations, Flexible memory: 178 pcs, Reserve Memory: max. 48 steps, Reserver Program: max. 18 kinds

This is a sample of its BASIC programming from Sharp documentation:

enter image description here

Radio Shack marketed a badge-engineered version of PC-1211 called TRS-80 PC-1


I'll head off in a different direction...

In my high school c. 1970 we had a PDP-8, which didn't "boot up" in any sense of that word, but for half of the school year (Fall into Winter) when you powered it on, it was instantly running a Basic interpreter. That was because that was what was loaded up into the core memory (real magnetic core memory that does not forget when the power is off). In fact, if the Basic programs hadn't been erased before it was powered off, they'd still be there, too.

The other half of the year it was running Focal, a pretty much PDP-8 specific language similar to but better in several ways than Basic. This was the way the computer course was organized, the teacher thought that students needed to learn that there were multiple languages and most concepts carried through, but details were different.

The PDP-8 was a multi-user system which for either language supported three user stations (TTY ASR 33s) in 12K words (12 bits/word on a PDP-8), but no mass storage. The users (students) loaded and saved their programs with the TTY's built in paper tape punch.


All the Sinclair computers, the ZX80, ZX81, Timex Sinclair TS1000 (and subsequent models), ZX Spectrum, and the QL, had basic as first thing you saw when you switched them on. The spectrum was the first really good machine of the bunch, but the ZX81 is probably responsible for Britain's large number of mature programmers as it sold exceptionally well and all you could really do with it, at first, was learn to programme. That's how I started my career over 30 years ago.

  • Me too. Having 16K space to add code to a 1K program was great! – Glen Little Jan 6 '17 at 20:38

The Amiga had ABasiC for the A1000 (Workbench 1.0/1.1) and then AmigaBasic (courtesy of Microsoft) for Workbench 1.2/1.3. The AmigaBasic implementation was fairly decent, certainly much better than the version that shipped with C64.

Along with Microsoft's very similar BASIC for the Apple Macintosh, AmigaBASIC was the first BASIC interpreter to not require line numbers, adopting instead a top-down approach to executing the lines of code, and labels to indicate the GOTO instruction where to jump. However programs that contained line numbers were able to run; the line numbers were simply treated as labels for the purpose of flow control. It was also the first Microsoft interpreted language capable of calling OS functions and dynamic libraries through the command "LIBRARY". For example: LIBRARY Graphics.library command invokes the standard Amiga Graphics.library from which to call functions1.

  • 2
    Thank you James. I am very aware of the Amiga, having owned and learned a lot from both an Amiga 1000 and 3000. But your answer missed a limitation of my question -- neither BASIC you mention was available at bootup. They needed to be loaded from disk. I agree with you though, that AmigaBASIC was really good. – RichF Jan 6 '17 at 5:13

The Tektronix 4051 and 4052 series had a pretty full-featured BASIC interpreter. One interesting thing their version had was the ability to directly enter arithmetic statements and have the answer displayed (no PRINT 3 * 6, just enter 3*6 and get 18 back). It also syntax-checked statements at entry, instead of at run-time, so you could correct typos right away instead of getting SYNTAX ERROR AT ### the next time you ran your program.

  • Welcome to Retrocomputing. Answers here are expected to answer the question; while this answer has enough information to gain an insight into the "excellence" of the Tek 4052's BASIC, it doesn't directly provide an answer to the question. Please make this a bit clearer, perhaps adding some more information in the process. – wizzwizz4 Jan 6 '17 at 18:33
  • Thanks for improving your answer. Were there any commands to directly interface with computer features (e.g. vector graphics) without PEEKing / POKEing? This is also a requirement of "excellence" as described by the question. – wizzwizz4 Jan 20 '17 at 21:09

The IBM PS2 has a Build in GWBasic from Microsoft. If the system can't boot from floppy disk, it loads ROM GWBasic. This Basic is ideal for students. In my school has this computers and you can turn on an start to program without any disk.

  • Welcome to Retrocomputing Stack Exchange. What makes this BASIC "excellent"? Please edit your answer to include this information. – wizzwizz4 Jan 7 '17 at 9:19

Not the answer you're looking for? Browse other questions tagged or ask your own question.