PBASIC

PBASIC is a compact dialect of BASIC created by Parallax, Inc. to program its BASIC Stamp microcontroller modules. It is not a general-purpose language meant for desktop applications; it is a small, hardware-aware scripting language whose entire reason for being is to make controlling pins, motors, sensors, and serial peripherals approachable for people who are not professional embedded engineers. For much of the 1990s and 2000s — well before the Arduino popularized accessible microcontrollers — PBASIC running on a BASIC Stamp was, for countless students and hobbyists, their first encounter with making hardware do something under program control.

History & Origins

Parallax was founded in the late 1980s by Chip Gracey (with co-founder Lance Walley, according to the company’s own history), and in 1992 the company introduced the original BASIC Stamp 1 (BS1) along with PBASIC 1.0. The module earned its name from its small footprint — roughly the size of a postage stamp — and its appeal from a simple promise: you could write a few lines of BASIC, download them over a cable, and have a real circuit respond.

The breakthrough product was the BASIC Stamp 2 (BS2-IC), released in 1995 and built around a Microchip PIC16C57 microcontroller. The BS2 came with a considerably richer PBASIC and became the line’s flagship; it is the variant most people mean when they refer to “the BASIC Stamp.” Over the following years Parallax broadened the family with sub-variants — BS2e, BS2sx, BS2p, BS2pe, and BS2px — each adding some combination of more memory, faster execution, additional I/O pins, and extra specialized PBASIC commands, with several later models using the Parallax SX processor.

Adoption grew quickly. Parallax reported more than 200,000 modules in use by mid-2000 and over three million BASIC Stamps in use by 2002. In 2003, PBASIC 2.5 added structured-programming constructs that modernized the language and made larger programs easier to maintain.

Design Philosophy

PBASIC is built around accessibility and tight integration with hardware rather than generality or performance:

• Hardware-first vocabulary. Alongside the familiar BASIC repertoire, PBASIC provides commands that map directly onto microcontroller tasks — HIGH and LOW to set pins, PULSOUT to emit timed pulses, FREQOUT to generate tones, PWM, SEROUT/SERIN for serial communication, and DEBUG to print values back to the PC.
• Small and deterministic. The language deliberately avoids the heavyweight machinery of general-purpose languages so it can run on extremely modest hardware with only a few dozen bytes of variable RAM.
• Beginner-friendly. Programs are short, readable, and tolerant; a newcomer can blink an LED or read a sensor in a handful of lines.

How It Runs

PBASIC’s execution model is distinctive. Programs are not compiled to native machine code. Instead, the BASIC Stamp Editor (a Windows IDE) tokenizes the source on the PC and downloads the tokens into the module’s serial EEPROM. On the BS2, that EEPROM is 2 KB and holds the tokenized program; a small on-chip firmware interpreter then reads and executes those tokens at run time.

To pack programs into limited EEPROM, the tokens are stored efficiently — described as Huffman-compressed, non-byte-aligned, variable-length tokens. This interpreted, tokenized approach is the reason PBASIC is easy to use but comparatively slow: on the BS2, the interpreter executes on the order of a few thousand PBASIC instructions per second (commonly cited as roughly 4,000 per second on the PIC16C57-based BS2), a figure that is more than adequate for blinking LEDs, reading sensors, and driving hobby servos, but far below what a compiled program on the same chip could achieve. Performance varies across the BS2 variants, with the faster SX-based models running noticeably quicker.

Key Features

• Integer-only, sized variables. PBASIC variables are declared with explicit sizes — Bit, Nib (nibble), Byte, and Word (16-bit) — and there is no built-in floating-point type. Arithmetic is unsigned integer math.
• Constants and program structure. Variables and constants are typically declared at the top of a program; later PBASIC (2.5) added structured constructs such as DO...LOOP, FOR...NEXT, SELECT...CASE, and IF...THEN...ELSE...ENDIF.
• Direct pin and timing control. Built-in commands address the I/O pins and on-board timing directly, which is what makes PBASIC feel purpose-built for electronics.
• DEBUG for visibility. The DEBUG command sends text and values back over the programming cable to a terminal window, serving as PBASIC’s primary debugging and teaching aid.
• Apostrophe comments. As in classic BASIC dialects, comments begin with an apostrophe (').

A flavour of the syntax

' Blink an LED on pin 0 forever (PBASIC 2.5 style)
counter VAR Byte

Main:
  DO
    HIGH 0              ' turn the LED on
    PAUSE 500           ' wait 500 ms
    LOW 0               ' turn the LED off
    PAUSE 500
    counter = counter + 1
    DEBUG "Blinks: ", DEC counter, CR
  LOOP

Evolution

PBASIC moved from the original BS1’s PBASIC 1.0 to the richer 2.x language that shipped with the BASIC Stamp 2, and finally to PBASIC 2.5 in 2003, which introduced the structured-programming features that bring it closer to how modern BASIC dialects are written. Rather than evolving into a sprawling language, PBASIC’s growth came largely through the expanding set of hardware-specific commands tied to successive BASIC Stamp models. The BASIC Stamp Editor IDE has continued to receive updates to support newer operating systems and connection methods (RS-232 and later USB).

Current Relevance

PBASIC occupies a transitional place in the history of accessible embedded computing. It demonstrated, years before the Arduino, that ordinary people could meaningfully program hardware, and it became a staple of electronics education. Parallax has since introduced more capable platforms — notably the multi-core Propeller (programmed in Spin) and microcontrollers programmable in C — yet the company has continued to sell and support BASIC Stamp modules and PBASIC, and the language remains a fixture in many classrooms and hobbyist toolkits. Its lineage also lives on indirectly: the PICAXE system, for example, uses a BASIC closely related to the one used on the original BASIC Stamp.

Why It Matters

PBASIC’s significance is less about technical sophistication than about democratization. By pairing a friendly, hardware-aware BASIC with an inexpensive, breadboard-friendly module and a one-click download workflow, Parallax lowered the barrier to physical computing for a generation of learners. The patterns it popularized — simple I/O commands, a tokenized download-and-run cycle, and a DEBUG-driven feedback loop — anticipated the accessible-microcontroller movement that platforms like Arduino later carried to a mass audience. For that reason, PBASIC is best remembered as a foundational on-ramp into embedded programming.