From the 80’s to Eternity

“Prehistory” aka 1964 – 1990

10 CLS
20 PRINT “HELLO”
30 GOTO 20

Ask any professional programmer over the age of 35 what the first program they ever wrote was – in most cases it will look something like this. Sometimes it was a minor variation – another common, more complex, alternative was:

10 CLS
20 PRINT “WHAT IS YOUR NAME?”
30 INPUT A$
40 PRINT “HELLO ” ; A$

With the exception of “CLS” (which is shorthand for CLear Screen) I’ll venture to bet you can follow what’s going on here pretty easily. The computer steps through the program one line at a time executing the given instruction. PRINT prints text to the screen, INPUT gets text from the user and stores it into a variable. GOTO jump the program’s execution to the specified line number (so the first program listed above loops forever – printing HELLO over and over).

This was the power of the BASIC programming language – it was easy for anyone to understand and write programs. BASIC (which is short for Beginners All-purpose Symbolic Instruction Code) meant that you no longer needed a degree in computer science to write programs. This opened up computing first to researchers in all fields and then to the home computer market.

With BASIC, anyone could learn to program and use a computer.

Most home computers in the late 1970’s and 1980s looked something like this.

Having a dedicated monitor and disk drive was a luxury, many people connected the computers to the television and used a cassette tape drive. Yep! You could store computer programs on cassette tape! It was very finicky, but it worked and it was cheap. I, personally, didn’t know anyone with a dedicated monitor or floppy disk drive though of course it depended on your economic class.

Parents often didn’t see much value in a computer. Asking your parents to spend $250 on what they saw as a toy was bad enough. Asking them to spend another $500 on top of it for a floppy drive was often out of the question.

Having a hard drive for one of these computers was unheard of – for the models that even supported one you would pay over $1000 for a 10MB (yes 10 Megabytes) hard drive.

Unless your parents were either wealthy or into electronics tinkering, chances are the way you got most programs onto your computer was to check out books or magazines from the public library with program source code in them (like the ones near the bottom of this page), and then type the program in yourself.

As so called “IBM PC Compatible” computers became more affordable, many households switched to them. These computers typically came with a version of the BASIC language from Microsoft called GW-BASIC that was largely compatible with the earlier “microcomputers” – allowing people an easy transition into these more powerful MS-DOS based systems.

The rise and fall of QBasic: 1990 – 2000

Throughout the late 1970’s and 1980’s BASIC had established itself as the most widely used programming language on the planet – and very little had changed over the decades. GW-BASIC did offer a few features not available on some of the earlier microcomputers but the language had changed little over the decades.

Then in 1990 Microsoft introduced a new product to the business community called QuickBASIC. This was a huge leap forward for the BASIC language.

The line numbers before each instruction was now optional. Users could define their own variable types. Code could be structured into functions and subroutines instead of jumping around based on line numbers. These advances meant larger and more complex programs could be written in BASIC with better support for teams working on the same program.

The next year, Microsoft released QBasic to the consumer market, included with MS-DOS 5.0.

QBasic retained nearly all the benefits of QuickBASIC, the largest difference being that QuickBASIC would compile (translate) programs into machine code, allowing faster program execution. QBasic, on the other hand, interpreted each command in the program each time the program was run (virtually all previous versions of BASIC were also interpreted, like QBasic, so this was not a missing feature for consumers – rather, being compiled to machine code was a bonus features for the business users of QuickBASIC.)

If you took a programming class in high school or junior college in the 90’s, chances are high QBasic was the language being taught. By this time, though, fewer computer users were learning how to program.

Early in the history of automobiles, one needed to be a mechanic in order to drive. Early in the history of computers, one needed to be a programmer in order to use a computer. In both cases, advances made these technologies available to more and more people without the need for technical training.

By the time of the release of Windows95 most computer users, including Jennifer Aniston, had moved away from the text-based MS-DOS and spent most of the time in graphical environment of Microsoft Windows.

QBasic remained a DOS-only programming language but Microsoft published a new language, called Visual Basic that gained popularity with its version 4.0, around the same time that Windows 95 was released.

Visual Basic was considerably more powerful than QBasic – allowing users to easily create graphical applications with buttons, text, images, check boxes, etc. all made using a drag and drop interface and minimal programming required.

Visual Basic was extremely popular, though it only saw another 2 releases, being discontinued after version 6.0 in 1998 despite protests from its userbase. Visual Basic 6.0 remains popular with some programmers.

The cost of progress: 2000 – 2007

With new development on Visual Basic, QBasic, and QuickBASIC (by then renamed BASIC PDS) all halted things certainly looked bleak for the BASIC community. By this time BASIC and its variants had fallen out of favor, being surpassed by newer languages like C++ and Java.

Then in 2001, Microsoft released VB.NET as part of its new .NET platform – a powerful system that allows multiple programming languages to seamlessly work together, and one of the most powerful and popular frameworks to this day.

Bu there is a problem. VB.NET was not compatible with older Visual Basic. And Visual Basic wasn’t compatible with older QBasic/QuickBASIC. When you have a program that just prints HELLO to the screen, ok no problem, you just rewrite it. But QuickBASIC introduced the possibility for large, complex projects produced by entire teams of developers.

Converting a complex program from QBasic or QuickBASIC to Visual Basic or from Visual Basic to VB.NET is non-trivial and can be expensive and error-prone. Since each BASIC dialect uses different ways of solving problems, its not as simple as making a computer program to automatically convert them.

In many cases its cheaper and safer to maintain an older MS-DOS computer with a program you already know works than it is to rewrite your software in what is, though similar, a different and incompatible programming language. Imagine you have a computer program that has been controlling industrial equipment just fine for the last 30 years – are you willing to risk an unforeseen bug in a rewrite leading to equipment, product, or even human loss if the equipment malfunctions due to the software?

There are a lot more such systems in operation than you probably realize. BASIC has traditionally been used extensively in industrial equipment control and other embedded systems.

Here is the catch – these systems often do need small updates and ongoing maintenance. Most programmers want to work with languages that are new and cool (C# and JavaScript are very popular right now). Finding someone willing to work with a programming language that hasn’t seen an update in 30 years, and who has the knowledge and skills to do so, becomes increasingly harder and more expensive each year. Sometimes these older systems eventually run into limitations in the original QBasic language, reaching the maximum possible program size for example. Normally in this case you would have to “bite the bullet” and rewrite your application in a newer language.

Enter QB64

One man, going by the name of Galleon, finally got fed up with the limitations of QBasic and its cousins QuickBasic and BASIC PDS – himself maintaining a large QBasic-based program.

He decided a better way would be to write a modern compiler to translate the old QBasic code into C++ and then compile this into machine code. This became the QB64 project and is today managed and developed by an international team of volunteers.

This approach means older programs can run mostly unchanged and new features can be added – and even further, programs can interact with modern programming libraries, leveraging all the power of C++ (widely considered the most powerful language in common use).

The practical effect of this for business is that developers that maintain older QBasic programs get something new and shiny and cool to work with and programmers are able to take advantage of all the advances in computing from the last 30 years. All without having to port your old QBasic source code to a new system and without any added licensing cost – QB64 is completely free software, even its source code is free for anyone to use and modify.

Beyond this commercial usecase, QB64 has inspired a renaissance in using BASIC as a beginner language. With its simple, clear syntax and easy setup, QB64 is considerably easier to get started with compared to virtually all other modern languages. A book on using QB64 as a tool to teach kids game is even in its second edition!

Whether you have never programmed before, have nostalgia for 80’s and 90’s computing, or you are interested in experimenting with a unique and powerful take on a piece of computing history, then QB64 is worth the download. It’s totally free – give it a try!

To download QB64, head to official project download page and grab the version for your operating system. Note that on Windows you will also need the 7-Zip program to extract the .7z file.

If you run into any problems or questions or just want to share your experience, head over to the QB64 Chatrooms (based on the popular Discord chat platform) or the QB64 Forum.

Learn more about QB64 programming in the project’s wiki.

You can find QB64, QBasic, and BASIC resources and merchandise on our Kit page.

To donate to the QB64 project, please visit the QB64 Patreon page.

Comments ( 4 )

  • Ken G.

    Great article! I started programming in BASIC since the mid-80’s and used different variants of it (Texas Instruments, Apple 2, MS-DOS), and then in the 90’s I switched to QBasic and then found a free little DOS based ASIC 5.0 one with a compiler. Then I took a long break and finally last July or so I found QB64 and it was a dream come true. I even bought a website domain and put most of my programs I’ve made with it on there, it’s http://www.KensPrograms.com/

    • You're Perfect Studio

      Thanks for your feedback! I owned several microcomputers myself (most 2nd hand) – the CoCo3, TI 99/4A, Timex Sinclair, and Vic-20. The CoCo3 was by far the most powerful, having 128kb RAM and high-res graphics modes. The TI 99/4A, however, was my favorite to use, something about its design just made it a joy to work with.

      I dreamed of making a QBasic compiler for years, even dabbled in it and got some of the most basic things working but set it aside – then discovered QB64 recently and was amazing at the work that has gone into this project. The team behind it has really done a fantastic job.

  • Richard Kasparowsky

    CONST object = 80: CONST tail = 32: CONST title$ = ” THANKS ”
    SCREEN _NEWIMAGE(660, 500, 256), , 1, 0
    VIEW PRINT 1 TO 30
    RANDOMIZE TIMER
    DIM Char(3, object, tail), CharSet(59) AS STRING * 1
    FOR i = 0 TO 63
    OUT 968, i: OUT 969, 0: OUT 969, i: OUT 969, 0
    NEXT
    FOR i = 0 TO 36: CharSet(i) = CHR$(i + 129): NEXT i
    FOR i = 37 TO 52: CharSet(i) = CHR$(i + 187): NEXT i
    FOR i = 1 TO object: Char(1, i, tail) = 150: NEXT i
    DATA ” QB64 ”
    DIM N$(1): FOR M = 1 TO 1: READ N$(M): NEXT M
    DO
    FOR Q = 1 TO 1
    texto$ = N$(Q)
    FOR P = 1 TO 400
    REDIM bg(100, 30)
    COLOR 7
    LOCATE 1, 1
    PRINT title$
    PRINT N$(Q)
    FOR i = 0 TO 28: FOR j = 0 TO 78
    IF POINT(j, i) > 0 THEN
    bg(j + 1, i + 1) = 50
    bg(j + 2, i + 1) = -20
    bg(j + 2, i + 2) = -20
    END IF
    NEXT j, i
    FOR i = 1 TO object
    FOR j = 1 TO tail – 1
    FOR k = 0 TO 2
    Char(k, i, j) = Char(k, i, j + 1)
    NEXT k
    IF RND 30 THEN
    Char(0, i, tail) = INT(RND * 80) + 1
    Char(1, i, tail) = 1
    Char(2, i, tail) = RND * 52
    Char(3, i, tail) = RND + .1
    END IF
    Char(2, i, tail) = (Char(2, i, tail) + 1) MOD 53
    NEXT i
    FOR i = 1 TO object
    FOR j = 1 TO tail
    yy = Char(1, i, j)
    xx = Char(0, i, j)
    IF yy > 0 AND yy 0 AND xx < 80 THEN
    IF j = tail THEN c = 35 ELSE c = INT(j / tail * 30)
    c = c + bg(xx, yy)
    c = 1 * -(c 0)
    c = 63 * -(c > 63) + c * -(c “”

Give a Reply