BASIC256

BASIC256 (written BASIC-256 for most of its history) is a free, open-source dialect of BASIC designed to teach programming to beginners, particularly middle- and high-school students. Its defining idea is visible as soon as it opens: the code editor, a text output window and a graphics window share one screen. That means a first program can draw a circle, play a tone or speak a sentence instead of only printing text. It started in 2006 as a one-person project called KidBASIC, was renamed within weeks, and has kept going for twenty years through several maintainers. A new release line appeared in 2026 that also runs in a web browser.

History & Origins

A reply to “Why Johnny Can’t Code”

On 14 September 2006, science-fiction author David Brin published “Why Johnny Can’t Code” in Salon. He argued that home computers had once come with a BASIC interpreter anyone could type into, but that modern machines offered children no equally simple way to start programming. It is also named as the inspiration for Microsoft’s Small Basic, which came out two years later.

Ian Paul Larsen registered a SourceForge project named KidBASIC on 29 September 2006, fifteen days after the essay appeared. The next day he uploaded KidBASIC 0.1: a Windows executable built on Qt 4, with three sample programs. A contemporary account in PCLinuxOS Magazine (October 2008) says the program was “inspired after the creator read the article ‘Why Johnny can’t code.’”

Between 30 September and 29 October 2006 KidBASIC went through versions 0.1 to 0.7, plus point releases 0.3.1 and 0.4.1, often only days apart. With version 0.8 in November 2006 the project was renamed BASIC-256. The .kbs extension used for its source files is a leftover from the KidBASIC name.

The date in catalogues

BASIC-256 is commonly dated to 2007. Wikipedia, for example, says the project “started in 2007.” The SourceForge file releases do not support that. KidBASIC 0.1 is dated 30 September 2006, the renamed 0.8 is from 8–9 November 2006, and 0.9 and 0.9.1 followed in November and December 2006. The 2007 date may reflect version 0.9.2 (1 March 2007), the release that Debian packaged in January 2008.

A change of hands

Larsen wrote the original interpreter: a flex/bison parser that compiles programs to bytecode, and a Qt interface around it. The 0.8 source already had a German translation and a function to save the compiled bytecode to a .kbc file. Releases paused after 0.9.2 in March 2007 and started again in late 2009. By then James M. Reneau was the main developer. Reneau is a faculty member at Shawnee State University in Portsmouth, Ohio. The project’s ChangeLog from 2010 onward is mostly his entries. The contributors file also credits Tony Dann, Ferry Hendrikx and Sergey Irupin as developers, plus translators for German, Dutch, Russian and Spanish.

Design Philosophy

BASIC256 is built for someone who has never programmed:

• One window, three panes. Source, text output and graphics are all visible at once, so the effect of each line is easy to see.
• Media first. Colour, shapes, sound, sprites and text-to-speech are part of the language itself, not add-on libraries. Reneau’s textbook uses them to hook students before it introduces structured programming.
• Old and new styles together. Programs can use line numbers, GOTO and GOSUB in the classic home-computer style. They can also use WHILE loops, functions, subroutines and structured error handling. Beginners can start simple and move to better structure later.
• Free and portable. The interpreter was released under the GNU GPL (version 2 or later in the original source). It was written on the cross-platform Qt toolkit from the start.

Key Features

Graphics from the first line

The earliest KidBASIC samples already bounced a ball around the graphics window. This is the complete ballanim.bas that shipped with version 0.1 in 2006, using line numbers and GOSUB:

 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

10 x = 10
20 y = 10
30 r = 8
40 xinc = 1
50 yinc = 1
60 rem move ball
70 gosub 220
80 x = x + xinc
90 y = y + yinc
100 if y > 200 then yinc = -1 * yinc
110 if x > 290 then xinc = -1 * xinc
120 if x < 10 then xinc = -1 * xinc
130 if y < 10 then yinc = -1 * yinc
140 gosub 180
150 for wait = 1 to 400
160 next wait
170 goto 60
180 rem drawBall
190 color black
200 circle x, y, r
210 return
220 rem clearBall
230 color clear
240 circle x, y, r
250 return

Functions and subroutines

Real user-defined functions and subroutines arrived around October 2012. This recursive factorial comes from the 2.0.0.11 example set:

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

# function test - Recursive function to calculate factorial
for n = 1 to 20
   print n + "! =" + fact(n)
next n
end

function fact(n)
   if n >= 2 then
      fact = fact(n-1) * n
   else
      fact = 1
   end if
end function

A function returns its value by assigning to its own name, as in classic Pascal and Visual Basic. Subroutines are defined with subroutine ... end subroutine and invoked with call.

Language and runtime features

Variables do not need to be declared. TYPEOF and ASSIGNED let a program check what a variable holds at run time. A small map example from the 2.0 test suite:

1
2
3
4
5
6

map q
q['a'] = "AA"
q['b'] = "BB"
for each i in q
   print i, q[i]
next i

Evolution

The 2026 continuation

In 2026 a new repository on GitHub, maintained by the developer known as UglyMike, announced itself as “the actively maintained continuation of the original BASIC256.” It kept compatibility with existing .kbs programs, moved the code to Qt 6 and CMake, and, according to its release pages, began shipping builds for:

• Windows (zip and installer)
• Linux x86 and Raspberry Pi (tarball and AppImage)
• macOS on Apple Silicon and Intel, requiring macOS 15 or newer
• WebAssembly, so the whole IDE runs in a browser at run.basic256.org

The browser build has documented gaps. It cannot use SYSTEM, serial ports, networking, databases or printing, and files a program writes last only for the browser session. This fork is licensed GPLv3.

Version 2.2.0 (13 September 2026) added a classic WINDOW command for logical canvas coordinates, OpenSimplex NOISE, MAT matrix operations, FRAMERATE for steady animation timing, and a turtle-graphics module. Its release notes say programs run “20-25% faster than 2.1.1.” That is the maintainer’s own figure, measured against the previous release. No benchmark suite or test machine is published with it, so read it as a relative improvement between versions, not an independent measurement. Debian picked up the new line: 2.1.1 is in Debian “forky” (testing) and 2.2.0 is in unstable.

Current Relevance

BASIC256 is in an unusual position for a 2006 teaching language: it had more activity in 2026 than at any point in the previous six years. The SourceForge project still hosts the 2.0.0.11 installer and the historical releases. The GitHub continuation provides current desktop builds, the in-browser version and a new documentation site. It still aims at the same audience Larsen had in mind: learners who benefit from seeing a program draw something right away.

Its closest relative in purpose is Microsoft Small Basic (2008). Both trace their motivation to Brin’s essay and both are small, graphics-friendly BASICs for newcomers. BASIC256 differs in being open source and cross-platform from the start, and in keeping classic BASIC features such as line numbers and GOSUB alongside structured code.

Why It Matters

BASIC256 is a direct answer to a specific cultural complaint. When Brin wrote in 2006 that children had lost the easy “type a line and see what happens” start that 1980s home computers gave, KidBASIC 0.1 appeared on SourceForge sixteen days later. For twenty years, the project has kept that design goal: a free, immediate environment where a first program can draw, move and make noise. Reneau’s Creative Commons textbook turned the interpreter into a complete course. The 2026 revival puts the same experience in a web browser, so a student can now start programming without installing anything.