On 1976 at the HomeBrew Computer Club (HBCC), there was a lot of whining about Bill Gates charging $150 for his Basic interpreter. Dennis Allison responded by printing a "Build Your Own [tiny] Basic" article, so I asked if anybody would buy it if it cost only $5. There seemed to be some affirmation, so I wrote my interpreter. Others jumped on the same article, and I wasn't the first done, but I wanted to be paid for my efforts. As far as I know, nobody at HBCC bought it, but I sent a freebie to Byte magazine and they printed a 1-inch announcement. The next month my mailbox was full of orders, every one with $5. I didn't get rich off it, but it did pay a lot of my expenses at grad school.

This is an archive of as many versions of TinyBasic, the documentation, the user and experimenter kits as Tom Pittman could find.

Tiny BASIC in Python (tbp) is an implementation of the Tiny BASIC language first proposed by Dennis Allison in response to Bill Gate's "An Open Letter to Hobbyists." In 1976, Dr. Tom Pittman developed his version of Tiny BASIC, which was one of many developed at that time. Where the original Tiny BASIC fit into 4K of memory, tbp is, ahem, a LOT larger, but does have a full debugger, linter, and runs on macOS, Linux, and Windows. So, pull up your bell bottom jeans, slap an 8-track tape into the stereo, and see what it was like for your grandparents when they programmed computers. Let's get groovy with the good vibes!

Supports all 12 statements and the two functions of the original, including USR. Supports all 26 variables, A - Z. Supports loading and saving programs to/from disk. Has a built-in linter and debugger.

The project notes are fascinating: https://john-robbins.github.io/tbp/project-notes

An archive of articles about, executables, and PowerBASIC source code for Operation Vula, used for secure communication using one-time pads smuggled into South Africa by a flight attendant on floppy disks in the late 1980's.

An archive of the Vula cryptographic system that was used for encrypting and decrypting clandestine messages during the fall of apartheid. It implements a one-time pad and executes encryption and decryption of messages with same.

Written in PowerBASIC.

This is a skeleton C64 program that will allow you to add your own custom functions and commands to the C64's BASIC. We all know how much the C64's BASIC sucks, so with this you can add the commands that you've always wanted!

A lot of the code in here comes from the book The Advanced Machine Language Book for the Commodore 64 by Abacus Software. There's a section in the later part of the book that shows you how to add your own custom commands.

I simply took this and ran with it. I also commented it as best as I could. I know that it can be very hard to follow other people's 6510 assembly, but I'm really hoping it's clear what each line of code does.

Ever dream of compiling your own Commodore 64 BASIC language programs into fast, efficient machine language programs? This is now a reality once again. Previously a tool used especially by only the last century's elite Basic programmers, wielded with almost godly power to turn many raw basic .prg (programs) into fast lean performing programs (.prg) [ .prg file on disk >> faster ,prg on disk], Kraksnax has released once again this classic diskette tool in late Summer 2023.

Available as a .d64 disk image as well as a native .prg executable.

An implementation of BASIC for the BBC micro:bit, written in Micropython.

This is a fast interpreter for the BASIC language on the Atari 8-bit computers and the Atari 5200 console. Support for Atari floating point and 16bit integer variables. Support for string arrays, substrings and concatenation. Small size (currently the full floating point IDE is 9.3k, the integer IDE is 8k, and the runtime is less than 3k). Fast execution (currently, 2 times faster than compiled TurboBasicXL in the "sieve.bas" benchmark, 6 times faster than OSS Integer Basic). Modern syntax (no line numbers, many control structures). Procedures with parameters and short calling syntax. Feels "alike" TurboBasicXL, with many of the extended statements. Integrated editor and compiler running in the Atari 8-bit. A cross-compiler is available that directly compiles sources to Atari executables on any modern PC. Statements for Player/Missile graphics and Display List Interrupts.

TensorFlow Lite for Microcontrollers is an open-source machine learning framework in which a TensorFlow model is built and trained on a host computer. That model is then reduced in size and computational complexity by an exporter that converts it to the TensorFlow Lite format. For the tiniest of compute platforms — microcontrollers — that model is then converted to a C array containing the model structure and any trained parameters, like weights and biases. On the microcontroller, an interpreter parses the C array to extract operations and data to run inferences against new input data.

Given that TF Lite for Microcontrollers runs on some heavily resource-constrained devices, I got to wondering whether or not I could run inferences against these models on a Commodore 64.

The official, canonical documentation for batari BASIC.

batari Basic (bB) is a BASIC-like language for creating Atari 2600 games. It is a compiled language that runs on a computer, and it creates a binary file that can be run on an Atari 2600 emulator or the binary file may be used to make a cartridge that will operate on a real Atari 2600.

A reference for batari BASIC, a compiled dialect of BASIC for the Atari 2600.

A simple interactive BASIC interpreter written in Python 3. It is based heavily on material in the excellent book Writing Interpreters and Compilers for the Raspberry Pi Using Python by Anthony J. Dos Reis. However, I have had to adapt the Python interpreter presented in the book, both to work with the BASIC programming language and to produce an interactive command line interface. The interpreter therefore adopts the key techniques for interpreter and compiler writing, the use of a lexical analysis stage followed by a recursive descent parser which implements the context free grammar representing the target programming language.

The interpreter is a homage to the home computers of the early 1980s, and when executed, presents an interactive prompt ('>') typical of such a home computer. Commands to run, list, save and load BASIC programs can be entered at the prompt as well as program statements themselves.

The BASIC dialect that has been implemented is slightly simplified, and naturally avoids machine specific instructions, such as those concerned with sound and graphics for example.

This repository collects the original source code of various Commodore Business Machines (CBM) computers converted to a modern encoding (ASCII, LF, indentation).

Using kernalemu and cbm6502asm, almost all source in this repo can be built from the UNIX command line. To build everything, run build.sh from the Unix command line, on a case-insensitive filesystem.

In the repo:

• All of the KIM and AIM machines
• All of the CBM machines
• All of the PET machines
• VIC-20
• C64, 65 and 128
• Ultimax
• C16/C116/+4
• All floppy disk drives
• Printer ROM (seems there was only one)
• Software that came in ROM
• Internal software devkits and tools
• Some games that were only on cartridge
• Firmware for an Amiga serial interface

A lightweight BASIC interpreter written in standard C. It's aimed to be embeddable, extendable and portable. It is a dynamic typed programming language, reserves structured syntax, supports a style of prototype-based programming (OOP), also implements a functional paradigm by lambda abstraction. The core is written in a C source file and an associated header file. It's easy to either use it as a standalone interpreter or embed it with existing projects.

A version of it is embedded in WWIV these days.

An interactive explorer of the disassemblies of the BASIC ROMs and kernels for the various versions of the Commodore 64. Each ROM is disassembled and lined up side by side so you can see what's different between versions and hardware releases.

The classic book BASIC Computer Games, published by Creative Computing, inspired a generation of programmers. The games were written by many people, and compiled by David H. Ahl. The fabulous illustrations accompanying each game were done by George Beker.

I've included all the games here for your tinkering pleasure. I've tested and tweaked each one of them to make sure they'll run with Vintage BASIC, though you may see a few oddities. That's part of the fun of playing with BASIC: it never works quite the same on two machines. The games will play better if you keep CAPS LOCK on, as they were designed to be used with capital-letter input.

"Commodore BASIC" (cbmbasic) is a 100% compatible version of Commodore's version of Microsoft BASIC 6502 as found on the Commodore 64. You can use it in interactive mode or pass a BASIC file as a command line parameter.

This source does not emulate 6502 code; all code is completely native. On a 1 GHz CPU you get about 1000x speed compared to a 1 MHz 6502.

The BASIC Engine is a very low-cost single-board home computer with advanced 2D color graphics and sound capabilities, roughly comparable to late-1980s or early-1990s computers and video game consoles. It can be built at home without special skills or tools and using readily available components for under 10 Euros in parts, or mass-produced for even less.

A concise overview of electronic theory for geeks.