Hubbry Logo
List of BASIC dialectsList of BASIC dialectsMain
Open search
List of BASIC dialects
Community hub
List of BASIC dialects
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
List of BASIC dialects
List of BASIC dialects
List of BASIC dialects
View on Wikipedia
from Wikipedia

This is an alphabetical list of BASIC dialects – interpreted and compiled variants of the BASIC programming language. Each dialect's platform(s), i.e., the computer models and operating systems, are given in parentheses along with any other significant information.

Dialects

[edit]

0–9

[edit]
64K BASIC
Cross-platform, interactive, open-source interpreter for microcomputer BASIC.[1]

A

[edit]
Advanced BASIC
(a.k.a. BASIC Advanced, Advanced BASIC) (DOS on the PC) by Microsoft. Available in ROM on IBM PCs. Later disk based versions for IBM PC DOS.
AlphaBasic
Altair BASIC
(a.k.a. MITS 4K BASIC, MITS 8K BASIC, Altair Disk Extended BASIC) (Altair 8800, S-100) – Microsoft's first product
Altair Disk Extended BASIC
See Altair BASIC
Amiga BASIC (Amiga)
Somewhat easier than ABasiC, see MS BASIC for Macintosh.
AMOS BASIC (Amiga)
For the Amiga, made for game programming. A descendant of STOS BASIC on the Atari ST. Later derivatives included AMOS Professional (a.k.a. AMOS Pro) and Easy AMOS.
ANSI
Standard for the programming language Minimal BASIC X3.60-1978, a 1978 standard for minimal features, and X3.113-1987, the full BASIC standard; rarely implemented fully.
Apple BASIC (Apple I)
See: Integer BASIC
Apple Business BASIC (Apple III)
Applesoft BASIC (Apple II)
Based on the same Microsoft code that Commodore BASIC was based on. Standard on the Apple II Plus/Apple II Europlus and all later models of the Apple II family.
ASIC
(DOS on the PC)
Atari 2600 Basic Programming
(Atari 2600 video game console)
SuperCharger Disk BASIC (Atari 2600 video game console)
StarPath SuperCharger cartridge plus disk-based extensions.[2][3]
Atari BASIC (Atari 8-bit)
The standard cartridge-based interpreter for the Atari 400/800 computers and successors. On later machines this was built into the ROM.
Atari Microsoft BASIC (Atari 8-bit)
ROM cartridge plus disk-based extensions.
AT&T
interpreter and compiler for the AT&T UNIX PC (3B1).
Atom BASIC (Acorn Atom)
AutoIt (Microsoft Windows)
automates other programs, e.g. with simulated mouse clicks. Interpreted. GUI. Creates EXEs.

B

[edit]
B32 Business Basic
(Data General Eclipse MV, Unix, DOS)
Microsoft BASCOM
MBASIC-compatible BASIC compiler by Microsoft
BASCOM-AVR, BASCOM-8051, BASCOM-LT
BASIC compilers by Mark Alberts for the 8051 and AVR chips, see also BASCOM (BASIC compiler) [de]
BASIC 2.0
(see Commodore BASIC)
BASIC 7.0
(see Commodore BASIC)
BASIC A+
(Atari 8-bit ) – An extended BASIC by Optimized Systems Software
BASIC Advanced
See IBM BASICA
BASIC Programming
(Atari CX-2620) – A simple version of BASIC for the Atari 2600 Video Computer System
BASIC XE
(Atari 8-bit) – An enhanced version of BASIC XL, by Optimized Systems Software[4]
BASIC XL
(Atari 8-bit) – Improved BASIC for the by Optimized Systems Software[4]
Basic4GL
Fast interpreter meant for OpenGL graphical programming, especially games
BASIC-11
(DEC PDP-11, RSX-11)
Basic-256
(Microsoft Windows, Linux, Unix) – BASIC IDE with text and graphics output, written to introduce children to programming. Originally known as KidBASIC.[5]
BASIC-E
(a.k.a. submarine BASIC) (CP/M)
BASIC Plus 2
(DEC PDP-11: RSTS/E, RSX-11)
BASIC-PLUS
(DEC PDP-11: RSTS/E)
BASIC09
(OS-9 and OS-9 68K on Motorola 6809 and 68K CPUs, respectively)
BASICA
(a.k.a. BASIC Advanced, Advanced BASIC) (DOS on the PC) by Microsoft. Available in ROM on IBM PCs. Later disk based versions for IBM PC DOS.
BASICODE
(Many 8-bit home computers, including KC 85) A subset common to many platform-specific BASICs, enabling interoperability.
batari BASIC
version primarily used for homebrew Atari 2600 development.[6]
BBC BASIC
Originally for the Acorn/BBC Micro, but has since been ported to RISC OS, Tiki 100, Cambridge Z88, Amstrad NC100, CP/M, ZX Spectrum, DOS, Microsoft Windows and many others.[7] A GPL clone of BBC BASIC named Brandy[8] written in portable C is also available (RISC OS, NetBSD, OpenBSD, FreeBSD, Linux, macOS, AmigaOS, DOS). Also a port made for the Commodore 64 by Aztec Software, written by Julian Gardner.
Beta BASIC
BASIC toolkit that extended Sinclair BASIC.
Blitz3D
(Microsoft Windows) Fast compiler made for 3D game programming, with DirectX 7 support.
Blitz BASIC
(Amiga, Windows) – Fast compiler meant for game programming. Windows version with DirectX support. Discontinued, replaced by BlitzPlus.
BlitzMax
(macOS, Linux, Windows) – Fast and compact object-oriented compiler meant for several tasks, most notably Game programming with OpenGL and DirectX support (DirectX support is Windows only).
BlitzPlus
(Microsoft Windows) Fast compiler made for 2D game programming and WinAPI event based interpreted programming. Supports both DirectX and OpenGL.
BURP
Basic Using Reverse Polish, used by the very early PSI Comp 80 "scientific computer", as published in the British radio enthusiasts magazine Wireless World
Business Basic
name given collectively to BASIC variants which were specialized for business use on minicomputers in the 1970s.

C

[edit]
CA-Realizer
dialect similar to VisualBasic by Computer Associates, last version 3.0, no longer under development/supported
Casio BASIC
used in Casio calculators
Cassette BASIC
An interpreter on IBM and IBM-compatible PCs to which the machine will default if no operating system is detected.
CBASIC (CP/M, DOS)
BASIC-E successor.
CBASIC
standard interpreter for 8-bit SORD computers (M23, M68 in Z80 mode, etc.), a.k.a. APU BASIC when the arithmetic processor is installed
Chinese BASIC
Several Chinese-translated BASIC versions developed in the early 1980s.
Chipmunk Basic
(Apple Macintosh, CLI ports for Win32, Linux) – copyrighted freeware
Color BASIC
(Tandy, RadioShack TRS-80 Color Computer)
Commodore BASIC
(a.k.a. CBM BASIC) (Various computers in CBM's line of 8-bit computers) – Integrated in the ROM of CBM 8-bit computers. Built on an early version of 6502 Microsoft BASIC. Several versions existed; the best-known was Commodore Basic V2, as used in the Commodore 64.
Compaq BASIC for OpenVMS
DEC BASIC, renamed after DEC was acquired by Compaq. Now named VSI BASIC for OpenVMS.

D

[edit]
Dartmouth BASIC
the original BASIC version. It was a compiler. Later versions included MAT statements for matrix operations. See also True BASIC.
Data General Business Basic
(Data General Nova and later DG minicomputers)
DEC BASIC
Formerly VAX BASIC; renamed after VAX/VMS was ported to Alpha processors and renamed OpenVMS. Now named VSI BASIC for OpenVMS due to corporate acquisitions.

E

[edit]
Extended Color BASIC
(TRS-80 Color Computer and Dragon 32/64)

F

[edit]
Famicom BASIC
(Nintendo Entertainment System) – For the Nintendo Entertainment System.
FreeBASIC
(DOS (DPMI32), MS Windows, Xbox, Linux, FreeBSD) – An open-source (GPL) BASIC compiler, that employs a similar syntax to QuickBASIC's, with more advanced features like pointers and object-oriented programming, it also supports a dialect specially designed to be compatible with QuickBASIC.
FutureBASIC
(macOS) – Free compiled, procedural, provides access to Carbon API (Mac OS Toolbox), GUI and file system of System 6 to macOS[9]
FUZE BASIC
(MS Windows, Linux, Nintendo Switch[10]) – Highly modernized adaptation of classic BASIC[11] also deployed on custom Raspberry Pi machines.[12]

G

[edit]
Galaksija BASIC
(Galaksija) – Firmware version for Galaksija home computer.
Gambas
(Linux, Unix, Cygwin) – A rapid application development environment for BASIC on Linux by Benoît Minisini. Similar approach as Visual Basic.
GFA BASIC
(Atari ST, Amiga, DOS, Windows) – Originally conceived on the Atari ST where it became one of the most popular BASICs for that platform (it almost became a standard language for the Atari ST). Was later ported to the Amiga, DOS and Windows.
GLBasic
(main target platforms: Windows, Linux, Apple iPhone, Pocket PC. IDE environment: Windows) – optimized for games
GW-BASIC
(DOS and Windows) by Microsoft. BASICA compatible; independent of IBM ROM routines. Came with versions of MS-DOS before 5.0. Included music macro language and advanced loops.

H

[edit]
HP BASIC for OpenVMS
Originally VAX BASIC; renamed to DEC BASIC after VAX/VMS was ported from VAX to Alpha processors; renamed to Compaq BASIC after Compaq acquired DEC; renamed to HP BASIC for OpenVMS name after HP acquired Compaq. Now known as VSI BASIC for OpenVMS.
HP Time-Shared BASIC
(HP 2100 line of minicomputers)
HTBasic
Version of Rocky Mountain BASIC by TransEra

I

[edit]
IBM Cassette BASIC
(PC) – Built into the first IBM PCs. Ran independently of DOS and used audio cassettes as a storage medium.
Integer BASIC
(Apple II) – Steve Wozniak's own creation. Originally known simply as "Apple BASIC". For the BASICs available at the time, it was very fast and memory-efficient. Only supported integers. Came as standard on the Apple I and original Apple II

J

[edit]
JR-BASIC
used on the Matsushita JR series home computers

L

[edit]
Liberty BASIC
(Windows, Macintosh, Linux) – Traditional structured BASIC with extensions for desktop GUI programming.
Locomotive BASIC
(Amstrad CPC, Amstrad NC100) – built into the ROM, (ZX Spectrum +3) on CP/M disk
LotusScript
(IBM Lotus Notes)
Luxor Basic
(Luxor ABC 80)

M

[edit]
MacBASIC
Apple's original BASIC for the Macintosh, released as Beta software and discontinued due to a deal with Microsoft
MAI Basic Four Business Basic
(misc. minicomputers)
Mallard BASIC
(Amstrad PCW, ZX Spectrum +3 on CP/M) – Similar to Locomotive BASIC
MapBasic
procedural language used specifically for GIS programs.
MBASIC
(CP/M) – Further development of OBASIC, also by Microsoft. MBasic was one of the BASICs developed by Microsoft. Came with a line editor.
Microsoft BASIC
many versions for several different CPUs and system architectures exist, and many other BASICs are derivatives of some Microsoft BASIC
Microsoft Small Basic
Microsoft Level III BASIC
(Tandy / RadioShack TRS-80)
Mobile BASIC
(Java enabled mobile phones)
MS BASIC for Macintosh
(macOS)
MSX BASIC
(MSX) – by Microsoft

N

[edit]
NorthStar BASIC
(Processor Technology, NorthStar Horizon, later adapted to x86 as Bazic '86) and S.A.I.L.B.O.A.T. (a basic optimized for Z80 and X86 MS-DOS)
NS Basic
(Newton OS, Symbian OS, Palm OS, Windows CE, Windows Mobile, Microsoft Windows ) – IDE and Bytecode-interpreter

O

[edit]
Oasis Basic
see THEOS Multi-User Basic
OBASIC
(CP/M) – by Microsoft
Open Programming Language OPL
(Symbian OS phones and PDAs) – Originally developed for Psion's product line of organisers and PDAs. OPL used to stand for Organiser Programming Language but after becoming open source in 2003, it was renamed. Available for most of Psion's classic organisers and PDAs, Nokia 9210/9290/9300/9500 Communicators and Sony Ericsson P800/P900/P910.

P

[edit]
PBASIC
for use with the Parallax BASIC Stamp microcontroller
PowerBASIC
(DOS, Win16, Win32) – free and commercial compilers for DOS and Windows, which focus on fast compile speeds and small binaries. They are Turbo Basic successors.
Processor Technology
5 KB and 8 KB BASICs. Created for the SOL-20 computer, but widely ported to other platforms as Processor Technology published the 8080 source code. Nevada BASIC (CP/M) and Utah BASIC [MS-DOS] were the latest ports.
Professional Development System (PDS)
A superset of Microsoft QuickBASIC targeted at professional software developers.[13]
PureBasic
(Microsoft Windows (x86, x64), Linux (x86, x64), AmigaOS, macOS (x64, arm64 Apple silicon) and Raspberry Pi (arm32, arm64)) – Cross-platform program development language, 32 & 64bit. Fast compiler with many functions that creates fast and small standalone native executables which do not require runtime DLLs. It compiles with FASM or a C compiler, and has inline support.

Q

[edit]
QB64
(Windows, Linux and macOS) – Self-hosting BASIC compiler for Microsoft Windows, Linux and macOS. Aims at full compatibility with Microsoft QBasic and QuickBASIC. BASIC code is translated to C++ and then compiled to executable form. An event driven GUI builder named InForm exists for QB64.[14]
QBasic
(DOS on the PC) – by Microsoft. Subset of QuickBASIC. Came with versions of MS-DOS from 5.0 to 6.22. Also included with DOS 7 (what Windows 95 runs on,) and available from the install CD of Windows 98.
QuickBASIC
(DOS on the PC) by Microsoft. An evolution of BASICA/GW-BASIC to block-structured lexical syntax that does not require line numbers, with many added intrinsic functions and language features (e.g. loop and conditional control constructs, file modes, and mixed-language programming support). Has an Integrated Development Environment (IDE), intended to compete with Borland Turbo language products (e.g. Turbo BASIC and especially the contemporarily popular Turbo Pascal). Mostly backward-compatible with BASICA source code. Includes a compiler and linker, and produces MS-DOS executables. Released in versions 1.0, 2.0. 3.0. 4.0, & 4.5. QuickBASIC 4.5 was released in 1988. The QuickBASIC 4.5 IDE includes an interpreter, syntax checking, debugging aids, and online help including a full language reference.

R

[edit]
RapidQ
(Windows, Linux, Solaris/SPARC and HP-UX) – Free, borrowed from Visual Basic. Useful for graphical interfaces. Works mainly with QuickBASIC instructions. (Cross-platform, free, no longer being developed). Semi-OO interpreter. Includes RAD IDE.
Rocky Mountain BASIC
created by HP to control instruments through HP-IB

S

[edit]
S-BASIC
"Structured" BASIC, came with Kaypro CP/M systems
SAM BASIC
(SAM Coupé)
sdlBasic
Free, multiplatform, based on core of wxBasic, but uses the SDL library.
Simons' BASIC
A cartridge-based utility that added 114 additional keywords to the standard BASIC 2.0 on the Commodore 64 computer
Sinclair BASIC
(ZX80, ZX81/TS1000, ZX Spectrum, Timex Sinclair 2068, Ringo R470, Lambda 8300)
SmallBASIC
(Android, Windows, Linux, DOS, Palm OS, etc.) – A small open-source GPL-ed interpreter.
Small Basic
(Windows) – by Microsoft DevLabs Team.[15]
SmartBASIC
(Coleco Adam)
SmileBASIC
A retro dialect of BASIC used in Petit Computer (for the DSi) and SmileBASIC (for the 3DS)
SOBS
(ICT 1900 series) Southampton BASIC System
StarBasic
StarOffice Basic
StarOffice Basic
(a.k.a. StarBasic) (OpenOffice.org, StarOffice)
ST BASIC (Atari)
(Atari ST) – This came with the Atari ST
STOS BASIC
(Atari ST) – For Atari ST made for game programming. Predecessor of AMOS BASIC on the Amiga.
SuperBASIC
(Sinclair QL)

T

[edit]
Tektronix
For the 4050 series computers, extensive graphics commands[16]
THEOS Multi-User Basic
(THEOS operating system)
TI BASIC
(note: no hyphen) (TI-99/4A)
TI Extended BASIC
(TI-99/4A)
TI-BASIC
(note: hyphen) (Texas Instruments programmable calculators)
Tiny BASIC
(any microcomputer, but mostly implemented on early S-100 bus machines) – Minimalist version which source code was smaller than this article, used on low-memory platforms.
TRS-80 Level I BASIC
(TRS-80) – based on Tiny BASIC.
TRS-80 Level II BASIC
(Tandy / RadioShack TRS-80) – based on Microsoft BASIC
True BASIC
(DOS, Windows, macOS, Linux, Unix) – Direct descendant of the original BASIC, Dartmouth BASIC, marketed by its creators. Strictly standards-compliant.
Turbo-Basic XL
(Atari 8-bit) – Freeware interpreter and compilerbased on Atari BASIC. Even this slower interpreter was about four times faster than the built-in BASIC. Written by Frank Ostrowski, the person who then developed GFA BASIC. Came from Happy Computer.
Tymshare SuperBasic
(SDS 940)

U

[edit]
UBASIC
(DOS on the PC) – Interpreter with many mathematical routines. Strong emphasis on number theory. Can work with many-digit numbers, complex numbers.
UniVerse
dialect that is part of the UniVerse database, with strong focus on data access and manipulation.

V

[edit]
VAX BASIC
DEC's BASIC-Plus-2 ported to VAX/VMS
VBScript
(a.k.a. VBS, Visual Basic Script, Visual Basic Scripting Edition) – A subset of Visual Basic used in ASP, Internet Explorer, or under Windows using the Windows Script Host (WSH) as a general-purpose scripting language. VBScript is often used as a replacement for DOS batch files.
Vilnius BASIC
(Elektronika BK-0010-01, BK-0011M and UKNC computers)
Visual Basic
(Windows) – Microsoft's object-oriented dialect with rapid application development environment.
Visual Basic .NET
(Windows) – Version within the .NET Framework by Microsoft.
Visual Basic for Applications
(a.k.a. VBA) (Microsoft Office on MS Windows and Apple Macintosh)
Visual Basic Script
See VBScript
Visual Basic Scripting Edition
See VBScript
Visual Test
(Originally MS-TEST) – Basic in Visual Test
VSI BASIC for OpenVMS
Originally released as VAX BASIC by Digital Equipment Corporation, owned by VMS Software Inc. (VSI) since 2014. Runs on the OpenVMS operating system.

W

[edit]
WordBasic
versions of Microsoft Word before MS Word 97
wxBasic
Open-source GPL interpreter based on the platform independent wxWidgets toolkit library. For Linux, macOS (proposed), and Windows.

X

[edit]
XBasic
(Windows, Linux) – open-source compiler with a GUI designer
XBLite
(Windows) – open-source compiler with integrated editor
Xojo
(MacOS, Linux, Windows, iOS, Raspberry Pi and Web) – Platform independent BASIC. Object-oriented Visual Basic-like Basic variant. Formerly known as REALbasic.

Y

[edit]
Yabasic
(Linux, Windows and PlayStation 2) Small interpreter. (GPL)
yab
(BeOS, Zeta, Haiku) Adaptation of Yabasic that enables the creation of graphical programs using the BeOS API.[17]

Z

[edit]
ZBasic (Zedcor Zbasic)
first released by Zedcor (Tucson, Arizona) in mid-1985. Versions were made for Apple, DOS, Macintosh CP/M and TRS-80 computers. In 1991, 32 Bit Software Inc. (Dallas, Texas) bought the DOS version and expanded it. Zedcor concentrated on the Apple Mac market and renamed it FutureBASIC. ZBasic was very fast, efficient and advanced, with BCD math precision up to 54 digits.

BASIC extensions

[edit]

BASIC extensions (a.k.a. BASIC toolkits) extend a particular BASIC.

(Platforms: APCW = Amstrad PCW; A8 = Atari 8-bit; C64 = Commodore 64; C128 = Commodore 128; Spec+3 = ZX Spectrum +3; VIC-20)

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

List of BASIC dialects

View on Grokipedia
from Grokipedia
BASIC dialects refer to the diverse implementations, extensions, and variants of the BASIC (Beginner's All-purpose Symbolic Instruction Code) programming language, originally created in 1964 by and at to enable novice users, including non-science students, to learn programming through an interactive, system on GE-225 mainframes. Designed for simplicity with features like numbered lines for easy editing, immediate execution, and a minimal set of 15 statements, the original Dartmouth BASIC emphasized accessibility and expandability while remaining hardware- and operating system-independent. The proliferation of BASIC dialects began in the early as the language entered the , coinciding with the advent of affordable microcomputers and home systems that required lightweight, interpretable code for limited memory environments. By the mid-, dialects adapted for specific hardware, such as (1975) by and for the MITS , which optimized for 4K memory and sparked the personal computing revolution; (1975) by Bob Albrecht and Dennis Allison for resource-constrained 2K RAM systems; and Apple Integer BASIC (1977) by for the , focusing on integer arithmetic for games and applications. Other prominent early dialects included for the PET (1977) and (1981), (1978) for the Atari 400/800 series, and Radio Shack Level I BASIC for the , each bundled in ROM to make programming instantly available on these mass-market machines. In the 1980s and beyond, dialects evolved to support structured programming, compilation, and graphical interfaces, with IBM's BASICA and Microsoft's GW-BASIC (early 1980s) extending functionality for MS-DOS PCs; QuickBASIC (1985) introducing compilation and modules; and Visual Basic (1991) revolutionizing Windows application development through drag-and-drop GUI tools, becoming widely used for software on Windows 9x. Standardization efforts, such as ANSI Minimal BASIC (X3.60-1978) and Full BASIC (X3.113-1987), aimed to unify core features across dialects, while later variants like Visual Basic .NET (2001) integrated object-oriented capabilities comparable to Java or C#. These dialects, spanning interpreted and compiled forms, reflect BASIC's enduring adaptability, from embedded systems like TI-BASIC on Texas Instruments calculators to modern tools, underscoring its role in democratizing computing for over six decades.

Origins and Early Implementations

Original Dartmouth BASIC

The Original Dartmouth BASIC was developed in 1964 by mathematicians and at to provide an accessible programming language for non-STEM students and faculty, enabling them to engage with computing without prior expertise in advanced mathematics or . The project stemmed from a 1963 grant that funded the acquisition of a GE-225 , on which the Dartmouth Time-Sharing System (DTSS) was built to support multiple simultaneous users via remote terminals. The first successful program in this new language, named Beginner's All-purpose Symbolic Instruction Code (BASIC), ran on May 1, 1964, marking the debut of an interpreted system designed for rapid, interactive use in educational settings. Key features of the original Dartmouth BASIC emphasized simplicity and immediacy, with programs structured as sequences of line-numbered statements for easy editing and execution in a compile-and-go manner on the GE-225. The syntax supported basic mathematical operations through commands like LET for assignments (e.g., LET X = (7+8)/3), PRINT for output, and IF...THEN for conditional logic, alongside input via READ and DATA statements. Variables were limited to single letters or letter-digit combinations, with support for one- and two-dimensional arrays via DIM, and built-in functions for trigonometry (SIN), logarithms (LOG), and random numbers (RND), using exponentiation denoted by an up-arrow (↑). Control structures included FOR...NEXT loops, GOTO for branching, and subroutines with GOSUB and RETURN, all executed interpretively to allow quick feedback during time-shared sessions. The initial version, often referred to as DT BASIC, was released in May 1964 and revised through several editions by 1966, with undergraduate students contributing to implementations under Kemeny and Kurtz's direction. The third edition manual, published in 1966, introduced the INPUT statement for interactive and matrix operations via MAT commands (e.g., MAT C = A + B for ), enhancing support for linear in educational applications, while string handling remained limited until later updates. These revisions focused on refining usability for beginners, with the system running on the GE-225 until its upgrade to a GE-635 in 1966, maintaining compatibility for Dartmouth's growing user base. The impact of Original Dartmouth BASIC was profound in democratizing programming, as it integrated computing into courses like and , reaching approximately 85% of Dartmouth students by 1968 and inspiring similar time-sharing adoptions at other institutions. By making programming approachable—"How can sensible decisions about computing… be made by persons essentially ignorant of it?" as Kurtz later reflected—it fostered widespread educational adoption and laid the groundwork for BASIC's role in broadening beyond elite scientific circles.

Pre-Microcomputer Variants

Following the original Dartmouth BASIC, early commercial adaptations emerged on mainframes and minicomputers to support time-sharing environments for multiple users. One of the first such variants was HP Time-Shared BASIC, released in 1968 for the HP 2000 series minicomputers, which enabled up to 16 simultaneous users via teleprinters on a system with 16K core memory. This implementation emphasized conversational interaction, allowing users to develop and execute programs in real-time without batch submission, though it integrated with disc storage for program persistence supporting hundreds of files. Limited to numeric and basic string operations, it lacked advanced graphics, relying on text-based output for results. In the same year, introduced CALL/360:BASIC for the System/360 mainframe family, designed for batch and interactive use on models like the 360/50, with support for file I/O and matrix operations tailored to business and scientific computing. This dialect extended the core BASIC syntax for compatibility with OS/360, incorporating features like subroutine calls and conditional branching suited to the era's punched-card input and line-printer output, without graphical capabilities beyond alphanumeric displays. Digital Equipment Corporation (DEC) contributed BASIC-8 in 1969 for the PDP-8 , an interpreter fitting within 4K words of memory for simple numeric calculations and interactive sessions under monitors like OS/8. A close relative, FOCAL (FOrmula CALculator), debuted around the same time for the PDP-8, sharing BASIC's line-numbered structure and loop constructs but using floating-point line numbers for subroutines and emphasizing scientific functions like , while remaining distinct in its lack of string handling. Both supported via terminal access but integrated through tape or disc loaders, with output confined to teletype text. By the early 1970s, expansions like DEC's BASIC-PLUS (1970) for the PDP-11 under further enhanced interactivity, adding string functions, matrix math, and file handling for up to 64 users in time-shared environments, bridging batch job submission with online editing. These variants collectively prioritized ease of access for non-experts on shared systems, fostering the shift toward personal that influenced later designs.

Microcomputer Era Dialects

8-Bit Home Computer BASICs

The 8-bit home computer era of the late and early saw dialects integrated directly into ROM, allowing users to begin programming immediately upon powering on the machine, a departure from earlier mainframe-based implementations that required loading from tape or disk. These dialects were tailored to the limited resources of affordable consumer hardware, typically featuring 4-64 KB of RAM and processors like the , Z80, or MOS 6502, enabling hobbyists to experiment with simple games, utilities, and educational programs without advanced setup. This accessibility fueled the democratization of computing, with systems like the and becoming staples in homes and schools. One early precursor was , released in 1975 by for the MITS , marking the company's first product and setting a template for compact interpreters on microcomputers. Written primarily by and , it supported and was distributed via paper tape or cassette, influencing later home dialects by demonstrating BASIC's viability on 8-bit hardware. The TRS-80 Model I, launched in 1977 by Tandy/Radio Shack, featured Level I BASIC in its 4 KB ROM, a simplified interpreter based on Li-Chen Wang's Palo Alto Tiny BASIC, offering core commands like PRINT and GOTO for text-based programs on a 64x16 character display. Upgraded to Level II BASIC in 1978 for 16 KB models, it added double-precision math, string handling, and USR calls for machine code, stored in 12 KB ROM, which became standard across the TRS-80 line and sold over 250,000 units in its first year. For the 1980 TRS-80 Color Computer, Extended Color BASIC extended these with graphics commands (e.g., LINE, CIRCLE) and sound via POKE to memory-mapped registers, supporting 16-color modes and joysticks for interactive applications. Commodore's PET 2001, introduced in 1977, included 1.0 in 8 KB ROM on its MOS 6502 processor, providing immediate access to a 40x25 character screen and cassette I/O, with commands for high-resolution via software routines. Updated to 2.0 in 1979 for the PET 2001-N series, it fixed bugs, added disk support, and enhanced speed for business and educational use, contributing to over 100,000 units sold by 1980. These dialects emphasized direct hardware control through , allowing users to manipulate screen memory for custom displays. Apple Integer BASIC, authored by for the 1976 Apple I and integrated into the 1977 , occupied 10 KB ROM and focused on math for efficiency on the 6502, supporting color and with commands like HGR for hi-res mode. It enabled rapid prototyping of applications, driving the Apple II's adoption; by 1982, cumulative sales reached approximately 650,000 units, underscoring BASIC's role in hobbyist innovation. Wozniak prioritized compactness, fitting core functionality into minimal space while allowing extensions via the monitor ROM. Atari BASIC, developed by Shepardson Microsystems for the 1979 Atari 400 and , was an 8 KB cartridge-based interpreter (later built-in) with structured elements like multi-statement lines and error handling, plus modes for player-missile graphics via POKE. It supported the system's custom ANTIC chip for smooth animations, making it popular for game development on these 6502-based machines; the Atari 8-bit family sold over 4 million units worldwide. Sinclair BASIC, debuting on the 1982 , evolved from earlier / versions and filled 16 KB ROM, incorporating keywords like and for 15-color attribute-based graphics, alongside for beeper output through direct port access. Tailored to the Z80 processor, it included floating-point support and USR for assembly integration, powering a vast software library on the budget-friendly Spectrum, which achieved over 5 million sales worldwide. BBC BASIC, created by for Acorn's 1981 , stood out with features including procedures, functions, and local variables, implemented in 16 KB ROM on the 6502. It offered modes for and sound synthesis via the chip, aligning with the BBC's educational mandate and contributing to over 1.5 million units sold, primarily in schools. Other notable dialects included Locomotive BASIC for the 1984 , a Z80-based with built-in sprite and mode commands for 160x200 resolution in 16 colors. These dialects collectively transformed 8-bit home computers into accessible creative tools, bridging the gap from institutional to personal use.

Apple and Atari Systems

Applesoft BASIC, introduced in 1978 for the Apple II series, represented a significant advancement over the original Integer BASIC by incorporating floating-point arithmetic for more precise numerical computations, enabling its use in scientific and business applications. Developed under license from Microsoft, it was initially available as Applesoft I on cassette in late 1977 and evolved to Applesoft II in spring 1978, with ROM integration in the Apple II Plus by June 1979, which freed up system memory and streamlined booting. Key enhancements included dedicated HI-RES graphics commands such as HPLOT for plotting points, DRAW for lines, and XDRAW for XOR lines, allowing programmers to leverage the Apple II's hardware for high-resolution (280x192 pixel) monochrome graphics with dithering for color simulation. These features, built on the core structure of 8-bit home computer BASIC dialects, facilitated the creation of early graphic adventure games like Mystery House (1980), which combined text parsing with simple plotted visuals to pioneer interactive fiction on personal computers. For the business computer, emerged in 1980 as a specialized tailored for , extending standard BASIC compatibility to include advanced report formatting for professional output, such as aligned columns and calculated fields. This variant supported non-programmers in developing custom applications for and analysis, integrating with the Apple III's Sophisticated Operating System () to handle file I/O and peripherals efficiently, though it retained core BASIC syntax for broad program portability. Its emphasis on structured data handling distinguished it from consumer-oriented dialects, prioritizing workflows over experimentation. On Atari systems, Microsoft BASIC, released in 1979 as a cartridge-based interpreter for the Atari 400 and , provided an alternative to the standard with enhanced support for the platform's custom hardware, including 16-digit floating-point precision and relaxed string operations. Delivered via an 8 KB (with an 11 KB extension disk), it introduced modes through the command (modes 0-11 for resolutions up to 320x192 pixels) and primitives like PLOT for line drawing, FILL for area filling, and SETCOLOR for hue/ adjustments, enabling color (up to 16 colors) via the GTIA chip. Sound capabilities were bolstered by the statement, which controlled four voices with parameters for , , volume, and duration, interfacing directly with the chip for polyphonic audio effects. The Disk Extended variant of Atari Microsoft BASIC, available via the 1980 extension diskette requiring an Atari 810 drive and DOS 2.0S, added file management commands like KILL, LOCK, SAVE with protection, and MERGE for program combination, expanding utility for larger projects while maintaining the core graphics and sound features. These elements supported game development, particularly text-based adventures and simple arcade titles, by simplifying access to player-missile graphics for sprites and sound for effects like collision beeps. For the 16-bit Atari ST line, third-party dialects like ST BASIC (by Abacus Software, 1985) offered GEM integration via VDI subroutines for vector graphics and AES for windowed interfaces, with primitives such as LINEF for lines, CIRCLE and ELLIPSE for shapes, PCIRCLE for filled circles, and SOUND for three-voice polyphony (volume 0-15, waveform control via WAVE); it required loading from diskette. This dialect's GEM compatibility allowed creation of graphical applications, including early multimedia demos and adventure games utilizing the ST's 512x342 resolution and mouse input.

Commodore and MSX Ecosystems

The Commodore ecosystem featured several variants of BASIC tailored to its 8-bit home computers, beginning with the VIC-20 BASIC introduced in 1980. This implementation, known as BASIC 2.0, provided 5 KB of RAM (with 3.5 KB accessible to users) and supported color graphics, sound capabilities, and programmable function keys through the VICBASIC interpreter, making it suitable for entry-level programming and educational use. The Commodore 64, released in 1982, retained BASIC 2.0 with enhancements for its advanced hardware, including 64 KB RAM and integration with the VIC-II chip for graphics and SID synthesizer for audio, though direct sprite manipulation required machine language calls or POKE statements in BASIC. By 1985, the Commodore 128 upgraded to BASIC 7.0, expanding to over 140 commands and functions, including built-in disk operations such as DLOAD, DSAVE, and DIRECTORY for direct file management without device specifiers, alongside support for 80-column text modes and compatibility. Sprite support in these Commodore BASIC dialects was not native but achieved through extensions and cartridges that augmented the core language. For instance, the Super Expander 64 cartridge added commands for easier graphics and sound handling, including simplified sprite positioning and animation via BASIC extensions, bridging the gap between the interpreter's limitations and the hardware's capabilities like the eight hardware sprites on the VIC-II chip. Similarly, Simons' BASIC, a 1983 cartridge extension for the Commodore 64 developed by David Simons, introduced 114 new commands focused on advanced structures such as nested procedures, local variables, and direct sprite control (e.g., SPRITE ON/OFF and MOVE commands), enabling more without resorting to assembly. These add-ons emphasized practical enhancements for graphics and data handling, including built-in disk commands in later variants and support for international character sets through encoding, which allowed mixed upper/lowercase and graphics modes. In parallel, the MSX ecosystem standardized BASIC across multiple vendors, starting with in 1983 as part of the Sony and Philips-backed platform. This dialect, an extension of , included versions up to 3.0 by the late 1980s, with progressive enhancements: 1.0 supported text modes (40x24 characters), mixed graphics with sprites, and sound via the General Instrument AY-3-8910 chip; 2.0 added high-resolution modes and improved peripherals; and 3.0 integrated turbo modes for faster execution on . The MSX standard enforced cartridge compatibility for , allowing seamless software distribution across hardware from manufacturers like , , and Yamaha, and incorporated international character sets through multilingual ROMs and screen modes supporting Japanese and European alphabets. These ecosystems fostered cross-compatibility in the 8-bit era, with variants dominating U.S. education in the 1980s due to the affordability and prevalence of models like the Commodore 64, which powered widespread classroom computing initiatives and sold over 17 million units globally. Meanwhile, BASIC gained traction internationally, particularly in and Europe, where the platform's open standard led to over 5 million units sold in alone, promoting a unified software library and cartridge ecosystem that extended BASIC's reach beyond proprietary systems.

Personal Computer and Commercial Dialects

Microsoft-Derived BASICs

Microsoft-derived BASIC dialects represent a significant evolutionary branch of the BASIC programming language, originating from Microsoft's early implementations for personal computers and progressing toward structured, event-driven, and object-oriented paradigms integrated with graphical user interfaces and enterprise frameworks. These dialects built upon the foundations of earlier microcomputer BASICs, such as those for the Altair and IBM PC, by emphasizing compatibility, ease of use, and professional development tools tailored for the MS-DOS and Windows ecosystems. GW-BASIC, released in 1983 as part of , served as an interpreted dialect derived from IBM's BASICA, which was itself a port of 's for the IBM PC. It supported line-numbered programs with features like GOSUB for subroutines and was designed for text-based applications, including simple and on early PCs. GW-BASIC became a standard for DOS users, running on 8088 processors and enabling hobbyist and educational programming without requiring additional hardware. Its , written in 8088 assembly, was later open-sourced by in 2020 under the , confirming its role as a bridge from 1970s to more advanced interpreters. QuickBASIC, introduced in , marked a shift toward compiled execution and integrated development environments (IDEs), allowing developers to create standalone executables from . Versions from 1.0 to 4.5 emphasized , introducing optional line numbers, named subroutines (SUB and FUNCTION), and modules for better code organization, reducing reliance on statements. It included a full-screen editor and , supporting up to 640 KB of memory and optimizing for performance. QuickBASIC's compiler capabilities addressed limitations of pure interpreters, enabling faster runtime and larger applications, and it remained in development through the . QBasic, released in 1991 as an interpreter bundled with 5.0, was a scaled-down version of without the full compiler, focusing on accessibility for beginners while retaining structured elements like subroutines and event handling. It featured an IDE with and integrated games like Nibbles to demonstrate capabilities, and was also included in later DOS versions up to 6.x and early Windows releases. QBasic supported up to 256 labels and improved error handling over , facilitating a smooth transition for users upgrading from older DOS systems. Visual Basic, launched in 1991 alongside , revolutionized BASIC by introducing an event-driven, graphical IDE for building Windows applications with drag-and-drop controls, forms, and intrinsic objects like buttons and timers. It combined interpreted code with optional compilation to executables, eliminating mandatory line numbers in favor of procedural blocks and properties, and supported object-oriented extensions in later versions. By 6.0 in 1998, it had achieved market dominance, with reporting approximately 3.5 million users worldwide by 2001, powering millions of business applications due to its and integration. Updates in VB6 also addressed Y2K compliance by enhancing date-handling functions to properly interpret four-digit years, mitigating risks from two-digit assumptions in earlier dialects. Visual Basic for Applications (VBA), introduced in 1993 with 5.0 and expanded to the full Office suite, embedded a subset of syntax directly into productivity applications for macro automation and customization. It enabled subroutine-based scripting for tasks like and report generation, sharing the same IDE as while focusing on host application integration via objects like worksheets and ranges. VBA's event-driven model allowed seamless extension of Office tools, becoming a staple for business users without requiring separate development environments. Visual Basic .NET, released in 2002 as part of Visual Studio .NET, fully transitioned to a compiled, object-oriented language on the .NET Framework, diverging from classic Visual Basic by adopting for cross-language interoperability and web services support. It enforced with classes, , and namespaces, removing legacy interpreted modes in favor of for improved performance and scalability. This version integrated tightly with for and addressed prior limitations like Y2K-vulnerable date formats through robust .NET libraries, marking the culmination of Microsoft's BASIC evolution toward enterprise-grade programming.

Business and Professional Variants

Business and professional variants of BASIC emerged primarily in the 1970s and 1980s, tailored for enterprise environments such as minicomputer-based , , and multi-user transaction systems. These dialects extended standard BASIC with specialized features for business operations, including indexed methods (ISAM), file locking for concurrent access, and built-in support for report formatting and database integration, distinguishing them from general-purpose implementations. One of the earliest and most influential was MAI Basic Four, introduced in 1972 by the Basic/Four Corporation (later MAI Systems) as the first multi-user system using a Business dialect. This interpreter ran on proprietary hardware with Microdata CPUs, supporting applications through integrated file handling and real-time data entry via terminals. By 1975, the system's revenue had grown significantly, reflecting its adoption for and inventory management in mid-sized enterprises. Data General Business Basic, marketed from the mid-1970s for the company's Nova and minicomputers under the RDOS operating , further exemplified these variants' focus on professional use. It provided robust record I/O capabilities, including sequential, random, and contiguous file types accessible via up to 16 channels per user, with data-sensitive writes up to 134 bytes and automatic element size alignment to multiples of four for compatibility. Multi-user locking was managed by the Resource Lock Server (RLS2), supporting up to 584 concurrent locks and record-level to prevent data conflicts in shared environments, while report generation tools like the spooler and ACNTNGRPT utility enabled formatted output to printers and terminals. Integration with the INFOS II database allowed for efficient querying and updates in scenarios such as order processing. B32 Business Basic, developed by Murray Haszard in 1986 as a competitor to Data General's offering, targeted the MV line with enhanced ISAM support for indexed file access in database-driven applications. It emphasized technical superiority in for minicomputer-based enterprise tasks like financial record-keeping. In the , variants like CA-Realizer facilitated migration to Windows environments, serving as a visual development tool for applications with event-driven syntax compatible with earlier dialects. Developed by Within Technologies and initially released in 1991, it was acquired by Computer Associates and rebranded/released as CA-Realizer in 1992, supporting for 16-bit Windows and , including form-based interfaces for data entry and reporting in professional settings. PowerBASIC, evolving from Turbo Basic in the late 1980s, offered compilers for DOS and Windows targeted at business programming, producing efficient executables for and tools with extensions for file I/O and modular code organization. These later dialects paralleled Microsoft-derived BASICs in syntax but prioritized non-PC, industry-specific optimizations for legacy ecosystems. Many such systems persisted in maintenance roles for enterprise applications into the 2000s, underscoring their reliability in sectors requiring stable .

Modern and Open-Source Dialects

Cross-Platform Implementations

Cross-platform implementations of BASIC dialects emphasize portability across operating systems, enabling developers to write code that compiles and runs on Windows, Linux, macOS, and sometimes other platforms without major modifications. These dialects often build on Microsoft-derived syntax from earlier eras, such as , to maintain familiarity while incorporating modern features like 64-bit support and enhanced libraries. They support revival efforts by providing free or accessible tools for hobbyists, educators, and legacy code migration, fostering community-driven enhancements for contemporary hardware and software environments. FreeBASIC, first released in 2004, is an open-source compiler that generates native executables using tools, including the Compiler Collection (GCC) backend for optimization. It targets Windows (32-bit and 64-bit), (x86, x86_64, and ), and DOS, with a syntax closely compatible to and for seamless porting of older code. Key features include procedural, object-oriented, and paradigms, along with extensions for 64-bit integers and string handling to address modern data requirements. Community updates since 2020 have focused on refining 64-bit compatibility and support, though web export capabilities remain limited to third-party integrations. PureBASIC, introduced in 1998 by Fantaisie Software, is a commercial dialect that compiles to native without external dependencies, supporting Windows, , macOS, and from the same source files. It emphasizes simplicity and performance, with built-in libraries for , networking, and database access, alongside protection features such as executable obfuscation and DLL preloading safeguards to deter . Recent developments, including version 6.00 in 2022, added a backend for broader platform access and improved cross-compilation efficiency. Version 6.20, released in February 2025, introduced TLS support for the Network library. Post-2020 updates have enhanced handling and 64-bit optimizations, driven by user feedback on the official forums. QB64, originally launched in 2006 as an open-source emulator for and 4.5, compiles to and supports Windows (7+), , and macOS with embedded for graphics-intensive applications. It preserves classic syntax while adding modern extensions like 64-bit data types and support for international text processing. The Phoenix Edition, released in 2021, introduces enhanced integrations for contemporary hardware, including improved rendering and input handling. Community efforts post-2020 have expanded web export options through QBjs, allowing BASIC code to run in browsers via JavaScript transpilation, alongside ongoing syntax refinements for 64-bit environments. As of March 2025, updates continue to improve compatibility and add features.

Specialized and Niche Variants

Specialized and niche variants of BASIC have emerged since the 1990s to address specific constraints in hardware, educational needs, or creative domains, often prioritizing simplicity, small footprints, or integration with particular platforms. These dialects adapt the core syntax of early BASICs to modern niche applications, such as resource-limited devices or beginner-focused learning environments. SmallBASIC, developed in the , targets embedded systems and personal digital assistants (PDAs) with its compact interpreter, fitting in under 100KB to enable scripting and calculations on low-memory devices like and Windows CE platforms. It includes built-in support for graphics, file I/O, and mathematical functions, making it suitable for prototypes and everyday without requiring extensive resources. The language emphasizes portability across mobile and embedded environments, with a compact interpreter that enables efficient execution on low-resource devices. The latest updates as of April 2024 include version 0.12.27 for ports. In the gaming domain, batari BASIC, released in 2007, serves homebrew development by compiling BASIC-like code into 6502 assembly for the console's 128-byte RAM and TIA chip constraints. It provides commands for sprites, , and kernel management, allowing hobbyists to create full without deep assembly knowledge, and has been used in over 100 community projects. Similarly, SmileBASIC, introduced in the for the , offers a portable interpreter with sprite editing, synthesis (up to 24 voices), and a 400x240 resolution graphics mode, enabling users to build and share directly on the handheld. Its editor supports multiple programs and community asset sharing via QR codes, fostering a creative ecosystem for portable programming. Educational variants focus on accessibility for young learners. , launched in , simplifies syntax for children with just 16 keywords and an integrated for drawing shapes, animations, and text, running on Windows to bridge block-based coding to text-based programming. It includes a turtle-like object for interactive and has been downloaded millions of times for classroom use. BASIC-256, originating in the 2000s and inspired by educational needs, provides a full IDE with turtle commands (e.g., FORWARD, TURN) to teach loops, conditionals, and visualization, targeting middle and high school students across , Windows, and other platforms. Its open-source nature ensures free distribution for global education. More recent developments include FUZE BASIC, introduced in the 2010s for Raspberry Pi-based education, which integrates hardware control for LEDs, motors, and sensors to teach coding alongside . Post-2020 updates, such as version 3 released freely in 2021, added an enhanced editor, , and expanded libraries for IoT projects like networked device control, making it ideal for STEM curricula on affordable single-board computers.

Extensions and Derivatives

BASIC Toolkits and Add-Ons

BASIC toolkits and add-ons were modular extensions designed to enhance the capabilities of existing BASIC interpreters on microcomputers, typically through cartridges or software cartridges that added new commands without replacing the core language. These tools addressed limitations in the original ROM-based BASICs, such as restricted memory access, basic graphics, and sound features, by providing elements, advanced I/O, and specialized functions. Developed primarily for and hobbyist platforms, they enabled users to create more sophisticated programs while maintaining compatibility with standard BASIC syntax. One prominent example is Action! for the Atari 8-bit family, released in 1983 by Optimized Systems Software. This cartridge-based toolkit introduced constructs like procedures, local variables, and conditional branching, allowing for faster compilation and execution on the 6502 processor compared to . It included an integrated editor and assembler, facilitating development of efficient games and utilities that exceeded the speed limits of interpreted . For Commodore systems, the Super Expander cartridge for the VIC-20, introduced by Commodore in 1982, expanded the unexpanded 5 KB RAM to 8 KB while adding 16 new BASIC commands for graphics, color control, and music synthesis. It supported programmable character sets and high-resolution plotting, enabling bitmap-style drawing and sound effects that were otherwise cumbersome in stock VIC-20 BASIC. Similarly, Simons' BASIC for the Commodore 64, developed by 16-year-old David Simons and released in 1983, augmented BASIC 2.0 with 114 keywords, including advanced loop structures (e.g., FOR...NEXT with STEP), multi-dimensional arrays, and file handling routines for better data management. Distributed officially by Commodore, it became a staple for C64 programmers seeking enhanced control over sprites, windows, and disk operations. On the series, extensions like DWBAS augmented Mallard BASIC in mode, adding features for structured data handling and integration with word processing tasks, such as formatted text output and file beyond the base interpreter's limits. For the +3, the Plus implementation included a toolkit for seamless integration, featuring Mallard BASIC as an add-on that provided -compatible commands for disk file handling, printer control, and cross-platform compatibility, allowing Spectrum users to run business-oriented programs. These toolkits typically focused on plotting, generation, and expanded file I/O to overcome hardware constraints like limited ROM space. Many of these add-ons persist in legacy through modern emulation software, where they recreate the original cartridge loading and command extensions to fill interpretive gaps for retro developers and preservationists. For instance, emulators like for Commodore and Atari800 for support direct loading of these toolkits, enabling contemporary users to experiment with enhanced on authentic-feeling environments. VBScript, introduced by in 1996 as part of the Windows Script Technologies, serves as a lightweight for automating tasks within the Windows environment and integrating with components via the (COM). It enables developers to embed scripts in web pages, applications, and the for system administration and event-driven automation, drawing syntax from [Visual Basic](/page/Visual Basic) but optimized for non-compiled execution. WordBasic, the macro language for versions 6.0 (released in 1993) and 95, provided a procedural scripting interface during the early for customizing and user interactions within the application. It transitioned to (VBA) with Word 97 in 1997, where legacy WordBasic commands were converted to VBA modules to support more structured, object-oriented macro development. Other languages adopting BASIC-like syntax for specialized scripting include AutoIt, developed in 1999 as a tool for Windows (GUI) and general task scripting. AutoIt simulates user inputs, interacts with windows and controls, and supports COM , making it suitable for repetitive administrative tasks without requiring full programming environments. LotusScript, introduced in Lotus Notes Release 4 around 1995, extends BASIC with object-oriented features for developing agents, formulas, and event handlers within the Notes/Domino platform. It facilitates database interactions, , and custom workflows by leveraging Notes' object model. These scripting languages mark a shift from traditional BASIC's emphasis on standalone, line-numbered programs toward embedded, host-integrated execution with enhanced support for event handling—such as responding to user actions or system triggers—and direct API calls through COM, DLLs, or proprietary interfaces. Unlike core BASIC dialects, they prioritize modular embedding in applications like browsers, office suites, or enterprise tools, reducing the need for independent interpreters while focusing on interoperability with host environments. Following the year 2000, adoption of these languages has declined in favor of more versatile options like and , with announcing VBScript's starting in late 2024 and full removal from future Windows versions due to security concerns and reduced relevance. They persist in niche roles for maintaining legacy automation in enterprise systems, such as Windows administration scripts, Office macros, and Notes applications where migration costs outweigh modernization benefits.

References

  1. https://www.dartmouth.edu/basicfifty/commands.html
  2. https://americanhistory.si.edu/explore/stories/50-years-computer-language-basic
  3. https://www.thoughtco.com/history-basic-programming-language-1991662
  4. https://www.q7basic.org/History%20of%20BASIC.pdf
  5. https://www.historyofinformation.com/detail.php?id=815
  6. https://ethw.org/Milestones:BASIC_Computer_Language%2C_1964
  7. https://www.dartmouth.edu/basicfifty/basic.html
  8. https://www.labouseur.com/courses/tpl/History%20of%20BASIC-kurtz.pdf
  9. https://www.cs.cornell.edu/wya/AcademicComputing/text/earlytimesharing.html
  10. http://www.decodesystems.com/hp2000/
  11. https://www.hpl.hp.com/hpjournal/pdfs/IssuePDFs/1968-07.pdf
  12. https://retrocomputing.stackexchange.com/questions/24604/weird-example-code-for-call-360basic
  13. https://bitsavers.org/pdf/dec/pdp8/handbooks/IntroToProgramming1969.pdf
  14. http://bitsavers.informatik.uni-stuttgart.de/pdf/dec/pdp8/focal/DEC-08-AJAB-D_FOCAL_Programming_Manual_Jan70.pdf
  15. http://www.bitsavers.org/pdf/dec/pdp11/rsts-11/V004/DEC-11-ORBPA-A-D_BASIC-PLUS_LangMan_Oct72.pdf
  16. http://www.trs-80.org/level-2-basic.html
  17. https://www.commodore.ca/commodore-products/commodore-pet-the-worlds-first-personal-computer/
  18. https://www.gatesnotes.com/microsoft-original-source-code
  19. https://colorcomputerarchive.com/repo/Documents/Manuals/Hardware/Getting%20Started%20With%20Extended%20Color%20Basic%20%28Tandy%29.pdf
  20. https://woz.org/apple-basic/
  21. https://www.cs.columbia.edu/~sedwards/classes/2011/4840/apple.pdf
  22. https://atariwiki.org/wiki/Wiki.jsp?page=Atari%20BASIC
  23. https://atari-owner.com/club/articles/atari-8-bit-units-sold.23/
  24. http://www.retroisle.com/general/sinclair_basic.php
  25. https://www.bbcbasic.co.uk/bbcbasic/history.html
  26. https://archive.org/download/Apple2HistoryWeyhrich1991/Apple2HistoryWeyhrich1991.pdf
  27. http://s3data.computerhistory.org/brochures/apple.iii.1980.102646176.pdf
  28. https://seriouscomputerist.atariverse.com/media/pdf/manual/Atari%2520Microsoft%2520BASIC%2520II%2520-%2520Manual.pdf
  29. https://www.atarimania.com/documents/Abacus09_Atari%2520ST%2520Basic%2520Training%2520Guide.pdf
  30. http://bitsavers.org/pdf/datapro/datapro_reports_70s-90s/Commodore/M09-160-10_8106_Commodore_VIC20.pdf
  31. https://www.c64-wiki.com/wiki/BASIC_2.0
  32. https://www.commodore.ca/manuals/128_system_guide/app-l.htm
  33. https://www.atarimagazines.com/creative/v9n11/60_Simons_Basic.php
  34. https://www.powerprograms.nl/commodore-64/commodore-64-about-basic.html
  35. https://www.msx.org/wiki/Category:MSX-BASIC
  36. https://segaretro.org/MSX
  37. https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/
  38. https://github.com/microsoft/GW-BASIC
  39. https://archive.org/details/microsoft-quick-basic-1.00
  40. https://www.pcjs.org/software/pcx86/lang/microsoft/basic/quickbasic/1.00/
  41. https://winworldpc.com/product/qbasic
  42. https://archive.org/details/msdos_qbasic_megapack
  43. https://devblogs.microsoft.com/vbteam/tag/visual-basic-history/
  44. https://www.computer.org/csdl/magazine/co/2001/08/r8016/13rRUxBa5fe
  45. https://www.ppm.express/glossary/vba-visual-basic-for-applications
  46. https://learn.microsoft.com/en-us/dotnet/visual-basic/whats-new/
  47. https://www.codecademy.com/resources/blog/what-is-visual-basic-used-for
  48. https://www.ithistory.org/db/companies/mai-basic-four
  49. http://www.simulogics.com/archive/public/docs/dg/sw/lang/bbasic/093-000388-01__Business_BASIC_System_Managers_Guide__1985-1989.pdf
  50. https://www.fundinguniverse.com/company-histories/mai-systems-corporation-history/
  51. https://www.computinghistory.org.uk/det/5761/Data-General-Corporation
  52. https://www.thocp.net/software/basic/business_basic.htm
  53. https://www.edm2.com/index.php/CA-Realizer
  54. https://www.computerhistory.org/collections/catalog/102641645
  55. https://freebasic.net/about.html
  56. https://www.purebasic.com/
  57. https://qb64.com/
  58. https://www.freebasic.net/wiki/wikka.php?wakka=CompilerHistory
  59. https://freebasic.net/forum/viewtopic.php?t=32254
  60. https://www.purebasic.com/documentation/PureBasicSmall.pdf
  61. https://www.purebasic.com/documentation/mainguide/history.html
  62. https://qb64phoenix.com/
  63. https://github.com/QB64-Phoenix-Edition/QB64pe
  64. https://sourceforge.net/projects/qb64.mirror/
  65. https://sourceforge.net/projects/smallbasic/
  66. https://bataribasic.com/
  67. https://smilebasic.com/en/
  68. https://smallbasic.github.io/index.html
  69. https://github.com/batari-Basic/batari-Basic
  70. https://smilebasic.com/en/spec/
  71. https://smallbasic-publicwebsite.azurewebsites.net/
  72. https://apps.microsoft.com/detail/9pfqkjljpb1r?hl=en-US&gl=US
  73. https://download.microsoft.com/download/9/0/6/90616372-C4BF-4628-BC82-BD709635220D/Introducing_Small_Basic.pdf
  74. https://basic256.org/
  75. https://sourceforge.net/projects/kidbasic/
  76. https://www.fuze.co.uk/
  77. https://forums.raspberrypi.com/viewtopic.php?t=112462
  78. https://www.fuzebasic.com/bin/FUZEBASIC_Programmers_Reference_Guide_Nov16.pdf
  79. https://atariwiki.org/wiki/Wiki.jsp?page=Action
  80. https://www.atarimania.com/8bit/files/atari-action-reference_runtime_pack.pdf
  81. https://ia801301.us.archive.org/17/items/Super_Expander_1982_Commodore/Super_Expander_1982_Commodore.pdf
  82. http://tech.guitarsite.de/rc_images/commodore_super_expander_user_guide.pdf
  83. https://www.seasip.info/Cpm/software/amstrad.html
  84. https://www.crashonline.org.uk/53/cpm.htm
  85. https://devblogs.microsoft.com/premier-developer/vbscript-deprecation-timelines-and-next-steps/
  86. https://news.microsoft.com/source/1996/07/18/microsoft-announces-activex-scripting/
  87. https://learn.microsoft.com/en-us/windows/win32/lwef/using-vbscript
  88. https://learn.microsoft.com/en-us/office/vba/api/word.application.wordbasic
  89. https://learn.microsoft.com/en-us/office/vba/word/concepts/customizing-word/converting-wordbasic-macros-to-visual-basic
  90. https://www.autoitscript.com/autoit3/docs/intro/dev_history.htm
  91. https://www.autoitscript.com/site/autoit/
  92. https://www.ibm.com/docs/en/domino-designer/9.0.0?topic=lotusscript-what-is
  93. https://www.ibm.com/docs/SSVRGU_8.5.3/com.ibm.designer.domino.main.doc/LSAZ_WHAT_IS_LOTUSSCRIPT_3179_OVERVIEW.html
  94. https://techcommunity.microsoft.com/blog/windows-itpro-blog/vbscript-deprecation-timelines-and-next-steps/4148301
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.