Run BASIC

Run BASIC is a small, now-discontinued dialect of BASIC that Carl Gundel of Shoptalk Systems built in 2007 to solve one specific problem: he wanted people who already knew how to write a simple, interactive BASIC program - INPUT, PRINT, a FOR loop, a jump back to a label - to be able to run that same program as a web application without learning HTML, sessions, or the Common Gateway Interface. It grew out of Liberty BASIC, the Windows BASIC interpreter Gundel had sold since the early 1990s, and it shipped first as a free browser-based console at runbasic.com in January 2007, then as a paid, downloadable “Personal Server” for Windows, Mac and Linux through 2008. It never became widely used, and the language and its website are gone today, but it is a clean, well-documented example of a “batteries included” scripting environment that tried to make the statefulness of the web disappear.

History and Origins

From Liberty BASIC to the web (2006-2007)

Carl Gundel had already spent roughly a decade and a half selling Liberty BASIC, a Windows-only BASIC interpreter built, by his own account on Shoptalk Systems’ “About” page, because Microsoft chose not to bring QBasic to Windows. By late 2006 his blog, “BASIC Programming,” was previewing “a sneak peek at our web BASIC,” and on Tuesday, 23 January 2007, he and a collaborator, Scott McLaughlin, announced that the new site was live: “The new Run BASIC site is now up! This site is a starting point for new web technologies that use Liberty BASIC [as] the core language. The site is a modest (but very cool) demo of what’s to come.” At that point Run BASIC was purely a free, in-browser sandbox - no installation, no purchase - running what the site’s own footer called “Build 2.18.”

Uptake was immediate for a niche hobbyist tool: on 4 February 2007, Gundel reported “more than 1500 unique visitors” in the first two weeks, alongside “a handful of server crashes” and “numerous bugfixes.” He used the moment to sketch a roadmap: a downloadable “Run BASIC personal edition” for Windows, Mac and Linux, priced at an estimated $20 to $30, followed eventually by “an educational system for instructors” in which students would have individual accounts and work through browser-based lessons. He also noted, tellingly, that the compiler and runtime work “feeds directly into the Liberty BASIC v5.0 effort” - Run BASIC doubled as a public alpha test of engine changes destined for the desktop product.

Building out the console (spring-autumn 2007)

Over the following months Gundel’s blog logged a steady stream of features landing in the free online console: CSS class-tag support and “component-based web development” in June, in which one Run BASIC program could be embedded inside another and rendered as a reusable UI component; an embedded SQLite database, reachable with a single SQLITECONNECT statement, also in June; and, on 20 June - nine days before Apple’s iPhone actually shipped - a post looking ahead to the device’s Safari browser as a future way to reach the Run BASIC site. A “Run BASIC Personal IDE sneak peek” post on 17 March showed the direction of the standalone product, and by 11 September 2007 Gundel announced that “Run BASIC enters beta testing” for that personal edition. A built-in XML parser, useful for reading data fetched from other sites, is documented in a 27 September post.

The Personal Server product (2008)

By 9 May 2008, runbasic.com had shifted from “modest demo” to storefront: the header now read “Run BASIC Build 2.27 - Powered by Liberty BASIC,” and the front page sold “Run BASIC Personal Server” - “an all-in-one system for Windows that makes programming for the web easy and fun” - for $59.95, with Mac OS X and Linux versions marked “coming soon.” A promotional document, “Run BASIC - A Breakthrough Web Application Server,” whose sample output is dated “Copyright 2007, Shoptalk Systems,” laid out the pitch at length: no state to manage, no GET or POST, and “you never even have to think about the Common Gateway Interface.” By 7 December 2008 the promise had been kept: the site offered a free “v1.01” edition for Windows, for Mac OS X on both Intel and PowerPC Macs, and for Linux, alongside the paid Personal Server, confirming that Run BASIC applications ran, in the company’s words, “on Windows, Linux and Mac computers and many cell phones.”

A long tail, then silence

Run BASIC did not vanish immediately after 2008. Wayback Machine snapshots show runbasic.com still serving its usual “Build” branding and download links as late as 25 June 2021, the most recent live snapshot located in this research, and the software cataloguing site AlternativeTo carries a Run BASIC listing (last updated 9 December 2020) that still lists Build 2.27 as the current version while describing the project as discontinued. As of this writing in September 2026, the runbasic.com domain refuses connections outright, and no successor project, open-source release, or archive mirror of the installer was found - Run BASIC survives only in Wayback Machine snapshots, Gundel’s old blog posts, and the PDF pitch document.

Design Philosophy

Hide the web, keep BASIC

The promotional PDF states the goal directly: “Run BASIC allows you to apply your desktop programming skills to create web applications without struggling with the overhead of typical web programming frameworks… Run BASIC hides the web technology so you can just code.” Its worked example is the kind of program a Commodore or TRS-80 owner, or a QBASIC student, would recognize instantly - an interactive multiplication-table generator using INPUT, nested FOR loops and a GOTO-style jump back to a [start] label:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

'Multiplication table
[start]
  input "How many columns?"; cols
  input "How many rows?"; rows
  for x = 1 to cols
    for y = 1 to rows
      print x*y; " ";
    next y
    print
  next x
  input "Do it again (Y/N) "; yn$
  if yn$ = "y" or yn$ = "Y" then [start]
  end

The PDF’s point is that an equivalent web application built with “other tools” would need to be “broken up into a web page that asks for the columns and rows, a script file to generate another page with the table and to ask to do it again, and then another script file to process that request” - with the values for cols and rows threaded through by hand. Run BASIC, by contrast, “does all this work for you automatically.”

The 1980s home-computer boot experience, reborn

Gundel frames the design as a conscious echo of early microcomputers: “When BASIC was at the peak of its popularity in the 1980’s most people who used it were users of home computers… With the flick of a power switch the user would almost instantly see” a BASIC prompt, ready to type and run. “Run BASIC is similar in its conception. Everything you need to write web programs comes built right in. Just start it up and you’re ready to create something useful.” The corollary, stated with a certain confidence, is that “people familiar with web programming aren’t prepared for its simplicity because they think that CGI programming is easy,” while newcomers “will quickly take it for granted that all web programming is so simple.”

A server that hides the server

Rather than being “a module that you load into a web server like Apache” - which the PDF argues forces the programmer to also learn “session management” and “preserving state between requests” - Run BASIC is itself a complete web server with the language built on top, distributed as a single installer. “Once you have it running a single button launches your web browser and connects it to the Run BASIC server. This becomes your programming interface. You write code and test it right away in the browser.” All of the code for a program lives in one editor, “a really important” property because, the PDF argues, “most modern web tools force you to break your program code up into different pieces.”

Key Features

Automatic state and control flow

The feature Gundel calls “very special” is that a Run BASIC program can be written as a classic, blocking, terminal-style interactive script - the multiplication-table example above - and the server transparently turns each pause point (an INPUT, or later a WAIT) into a fresh HTTP response that waits for the next request, then resumes execution exactly where it left off, with all local variables intact. No cookies, hidden form fields, or database rows are written by the programmer to make this work.

Widgets in the print stream

User-interface controls are added to the page the same way text is - by printing them in sequence - and respond to clicks through named event-handler labels or subroutines:

1
2
3
4
5
6
7
8
9

print "The time has come for all good men to come"
print "to the aid of their country."
button #go, "Go!", [makeItHappen]
print "The quick brown fox jumped"
print "over the lazy dog."
wait
[makeItHappen]
  print "Carpe diem!"
  end

The same button can instead invoke a named SUB, which receives the widget’s identifier as a string argument, giving the programmer a choice between the terminal-BASIC label style and a more structured subroutine style.

Built-in graphics and a database

A GRAPHIC object plus a small set of drawing verbs let a program build a bitmap and place it on the page with a single RENDER statement:

1
2
3
4
5
6
7
8

graphic #sineGraph, 300, 200
#sineGraph size(3)
for x = 1 to 300
  #sineGraph color("blue")
  #sineGraph set(x, 85*sin((50+x)/25)+100)
next x
render #sineGraph
end

Data persistence was handled by an embedded SQLite database, reached with SQLITECONNECT and a handful of object-style method calls (execute(), disconnect()) - the PDF specifically praises SQLite for needing “no installation” and “no trained administrator.”

Components and DIV-based styling

Any Run BASIC program could be invoked from another with the RUN statement and rendered into the calling page with RENDER, letting one interactive mini-application (in the PDF’s example, a colored sine-wave plotter driven by a textbox and button) be embedded, still fully interactive, inside a larger page - “Components do not need to be rendered onto the user interface,” the PDF notes; “they can also be used as libraries of shared code or even as objects in an object oriented fashion.” For layout, Run BASIC treated DIV as a first-class block construct with matching END DIV, letting the compiler catch unbalanced tags, and let CSS rules be attached directly to a DIV or widget with CSSID.

Evolution

No version numbers beyond “Build 2.27” (the online console, as displayed on the site through at least mid-2008) and “v1.01” (the downloadable Personal Server, as of December 2008) were found in the sources available for this article; if later builds existed, no record of them survives in the snapshots examined.

Current Relevance

Run BASIC is not runnable today by any means found in this research: the official site is offline, no source code was ever released as far as could be determined, and no Docker image, package, or actively maintained fork exists. AlternativeTo’s listing, last touched in December 2020, already treated it as a dead product, and the domain itself persisted for a few more years as a static, unchanging storefront before disappearing. What remains is documentary: Carl Gundel’s “BASIC Programming” blog, still readable through the Wayback Machine, and the “Breakthrough Web Application Server” PDF, which together give an unusually complete picture, for such a small product, of how it worked and why it was built.

Why It Matters

Run BASIC is worth remembering less for its market impact, which was modest, than for how directly it attacked a specific piece of programmer pain: the mismatch between the stateful, top-to-bottom mental model that beginners learn BASIC with and the stateless, request-per-page model of the web that they then have to learn separately to put anything on the Internet. By making INPUT itself the mechanism for pausing a running program until the next HTTP request arrived - rather than asking the programmer to manage sessions or hidden form fields - Run BASIC let a program that looked exactly like 1980s home-computer BASIC become an interactive multi-page web application with no code changes. That same idea, that a language runtime should absorb the complexity of request/response cycling so ordinary sequential code can “just work” as a web app, resurfaces in later and much better-known systems for building stateful web UIs from procedural-looking code. Run BASIC’s real place in the encyclopedia is as a small, well-documented, single-author demonstration of that idea a decade or more before it became a mainstream concern - built, fittingly, by the same person who had spent the 1990s trying to make BASIC itself simple again for Windows.

Sources

• Carl Gundel, “Run BASIC - A Breakthrough Web Application Server” (PDF), libertybasic.com/RunBASICBreakthrough.pdf (undated; example output dated “Copyright 2007, Shoptalk Systems”)
• Carl Gundel, “BASIC Programming” blog (basicprogramming.blogspot.com): “New web BASIC launched!” (23 January 2007), “Run BASIC Two Weeks Report” (4 February 2007), “Run BASIC Personal IDE sneak peek” (17 March 2007), “Adding SQLite to Run BASIC,” “Run BASIC and the iPhone,” “Component Based Web Development,” “Support for CSS class tags” (June 2007), “Run BASIC enters beta testing” (11 September 2007), “Parsing XML in Run BASIC” (27 September 2007) - all retrieved via Wayback Machine CDX API and id_ snapshots
• Wayback Machine snapshots of runbasic.com: 7 February 2007, 9 May 2008, 7 December 2008, and CDX-listed snapshots through 25 June 2021
• Shoptalk Systems, “About” page, libertybasic.com/aboutshoptalk.html
• Wikipedia, “Liberty BASIC” (lists Run BASIC as a major implementation)
• Wikidata, Run BASIC (Q7379495)
• AlternativeTo, Run BASIC listing (alternativeto.net/software/run-basic/about)