PlayBASIC

PlayBASIC is a BASIC dialect for Windows designed for writing 2D video games. Its built-in command set includes sprites, tile maps, vector shapes, cameras and collision detection (pixel-perfect, rectangle, circle and polygon). A beginner can put a moving, colliding sprite on screen with a few lines of code instead of first learning graphics programming. It is the work of Kevin Picone and his company Underware Design. Development began in the early 2000s, the first public release came in 2004, and Picone was still publishing beta builds and development videos in 2026, more than twenty years later.

History & Origins

From two projects to one

The project’s own history says development “began in 2002/2003” as a collaboration between Kevin Picone, who was writing the language, and Danny Wartnaby, who was writing a visual development environment. The two projects converged. Neither was released in its original form, and Wartnaby went on to write the first PlayBASIC IDE. The copyright line on PlayBASIC.com still reads “2002 / 2026”, and a 2012 news post refers to “the ten years since PlayBASIC birth.”

Picone has written that he started programming in 1982, and that his older surviving code is mostly AMOS and 68000 assembly from his Amiga years. That background shows in the product’s focus on sprites, blitting and tile maps, the same problems the home-computer game BASICs of the 1980s and 1990s were built to solve.

Announcement and release

The dated news archive on PlayBASIC.com traces the release:

The year

Encyclopedia lists often date PlayBASIC to 2002, which is when its development started. It did not reach users until 2004: the language was announced in August 2003, it went live with downloadable prerelease builds in July and August 2004, and the retail edition shipped in October 2004. This page uses 2004 as the first-appearance year.

Design Philosophy

PlayBASIC’s launch announcement described it as a language “designed in such a way to make it easy for beginners and yet still powerful enough to produce exciting games,” achieved by “including as much inbuilt functionality as possible.” The design reflects that aim:

• Game features are built into the language. Sprites, maps, worlds, cameras, shapes, fonts, sound and music are core command sets, not add-on libraries.
• Familiar BASIC syntax. The official FAQ says PlayBASIC’s syntax is most like other game-focused BASICs such as AMOS, DarkBASIC and Blitz BASIC, “but there’s also a hint of Visual Basic and even some C ism’s also.” It is not ANSI BASIC compliant.
• Loose by default, strict when needed. Variables need no declaration unless the programmer enables Explicit. Arrays, globals, locals and statics must be declared before use.
• Game-oriented, not games-only. The FAQ says it can be used for ordinary applications, and Picone uses it for tools, including the Play Mapper editor.

Key Features

Program structure

Programs run top to bottom. Nothing appears until Sync flips the screen buffer. This example from the official Program Layout tutorial shows the basic pattern:

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

; This is two lines of program code on separate lines
  Print "Hello"
  Print "Welcome to PlayBASIC"

; Those lines could also be written on the same line, like this
  Print "Hello" : Print "Welcome to PlayBASIC"

; Show the screen
  Sync

;Wait For a key press
  WaitKey

Comments start with a semicolon. PlayBASIC is reportedly a two-pass compiler, with the first pass collecting labels, functions and psub declarations so that functions can be called before they are defined in the source; this page could not confirm that description in the current official documentation.

A sprite in a game loop

This example from the NewSprite help page creates a shaded ball image, then moves a sprite toward the mouse at up to 60 frames per second:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

  Circle_Image=CreateBallImage(100)

  MYSprite=NewSprite(Rnd(800),Rnd(600),Circle_image)
  CenterSpriteHandle MySprite

  SetFPS 60

  Do
     Cls RGB(0,0,0)
     Print "I See You!"

     Mx#=MouseX()
     My#=MouseY()

     x#=CurveValue(mx#,GetSpriteX(MySprite),10)
     y#=CurveValue(my#,GetSpriteY(MySprite),10)
     PositionSprite MySprite,x#,y#

     DrawAllSprites
     Sync
  Loop

Function CreateBallImage(Size)
  ThisImage=NewImage(size,size)
  Colour=RGB(128+Rnd(127),128+Rnd(127),128+Rnd(127))
  RenderPhongImage ThisIMage,size/2,size/2,Colour,200,255.0/(size/2)
EndFunction ThisImage

The # suffix marks a floating-point variable, $ a string, and a variable with no suffix is an integer.

Functions, psubs and multiple return values

PlayBASIC has two kinds of user-defined routine. A Function starts with fresh local variables on every call and can leave early with ExitFunction. A Psub keeps its variables between calls and must run to EndPsub. According to the official tutorial, functions run “marginally slower” than psubs. Return values follow the closing keyword, and a routine can return more than one value:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

  My_Volume,My_Mass=Block_Properties(1,2,4,7800)

  Print "Volume = "+Str$(My_Volume)+" m^3"
  Print "Mass = "+Str$(My_Mass)+" Kg"
  Sync
  WaitKey

Function Block_Properties(Width,Length,Height,Density)
  Volume=Width*Length*Height
  Mass=Volume*Density
EndFunction Volume,Mass

Arrays and typed arrays can be passed into functions by pointer, so one routine can work on Alien() and Bullet() arrays of the same user-defined Type.

Language and runtime features

How programs run

PlayBASIC compiles source to bytecode for its own virtual machine, not to native machine code. The official FAQ says so directly (“Exe’s run upon a custom Virtual Machine”). Retail editions include two runtimes: a debug runtime and a release runtime with safety checks such as array bounds removed. The FAQ puts the release runtime’s speed gain at “anywhere from 1% to 20%” depending on the program. That is the vendor’s own estimate, with no published test programs or hardware. Native code is only available through the separate PlayBASIC2DLL tool (2014), which translates PlayBASIC functions into machine code in a DLL that a PlayBASIC program can call.

Platform

The official FAQ says PlayBASIC supports “Only Windows using DirectX at this time.” The download page lists the Learning Edition as compatible with Windows 98 through Windows 11 and says it requires DirectX 9.

Evolution

The classic line and PlayBasicFX

From 2004 to 2008 PlayBASIC moved through frequent numbered upgrades, from V1.02 to V1.63. It rendered through DirectDraw, which the FAQ describes as “designed primarily for 2D hardware acceleration.” By February 2007 Picone was shipping alphas of PlayBasicFX to registered users (the 16 February build was the second), “a complete rewrite” using Direct3D so that games could use 3D hardware acceleration. PlayBasicFX V1.74 (December 2008) also introduced a new runtime, VM2. Picone’s release notes estimated VM2 at “anywhere from 2 to 5 times the real time performance of the Vm1 runtime.” That is the developer’s own comparison against the previous runtime, not a published benchmark.

PlayBasicFX stayed a prototype. The FAQ calls it “the prototype PlayBasicFX editions,” and the main product continued as the “classic” V1.64 line. The V1.64 upgrade (September 2008) gave the DirectDraw edition much of the same sprite and blending functionality as PlayBasicFX. The FAQ notes that the classic version kept being updated “for almost ten years, even after it was discontinued.”

The V1.64 revisions

The V1.64 line ran from 2008 to 2016 in lettered revisions (V1.64 to V1.64P4). It added:

• The ++/+= operators, dynamic function calling, optional parameters, and passing and returning arrays and types (listed in the V1.64L notes, April 2010)
• Multi-core threading for the BlitImage post-processing library (V1.64N3, 2012)
• Compatibility with PlayBASIC2DLL and the G2D OpenGL library (V1.64P, 2014)

A new virtual machine (V1.65)

V1.65 (October 2016) replaced “everything on the execution side of the product” with a new VM. Picone warned that some existing programs would not compile or run. V1.65C (October 2018) completed the move, running all commands on the new VM. V1.65C2 (July 2021) was a stabilization release. V1.65C3 reached release-candidate status in October 2025 and was still in numbered betas in 2026. The later betas extend an experimental software 3D renderer, PS3D, with Z clipping, polygon subdivision, Gouraud-shaded textures and point sprites. The FAQ still calls the 3D commands experimental and calls PlayBASIC a 2D language.

Editions

Current Relevance

PlayBASIC is a small, one-developer project, but it is still active. In 2025 and 2026 PlayBASIC.com posted a website relaunch, the V1.65C3 release candidate, numbered betas, tutorial videos and development logs on software 3D rendering and map editing. The community forums at UnderwareDesign.com went offline in February 2024 and reopened in March 2024. Since January 2023, development has been supported partly by donations. The site also has a placeholder page for a “PlayBASIC 2,” with no details beyond a waitlist.

The official FAQ is frank about the language’s limits. Its listed disadvantages are that it is “Virtual Machine based, 2D / 2.5D Focused,” and less widespread than mainstream languages. It admits that only “some, but not many” commercial games have been made with it and that most users write freeware.

Why It Matters

PlayBASIC belongs to the group of PC game BASICs that appeared around 2000, alongside Blitz BASIC and DarkBASIC. These languages carried the AMOS and STOS approach of the Amiga and Atari ST onto Windows: a BASIC in which sprites, maps and collision are ordinary commands. Many of its contemporaries were discontinued, open-sourced or replaced. PlayBASIC has kept the same author and codebase for over twenty years, moving from DirectDraw to a Direct3D prototype, from one virtual machine to another, and from a commercial product to a free learning edition with an optional retail version. Its forums, competitions and dev logs also form a detailed public record of how a small language was built and maintained by one developer.