Acorn Electron

The Acorn Electron is a budget home computer that was developed by Acorn Computers in 1983. It was designed to be a more affordable version of the company's flagship BBC Micro computer. The Electron was based on the same 6502-based architecture as the BBC Micro, but it was less expensive to produce, making it more affordable for home users. The computer featured 32 kilobytes of RAM and a built-in cassette tape interface for data storage. The Electron was also compatible with most of the software and peripherals that were available for the BBC Micro. It used BBC Basic v2 as it's operating system. The computer had only basic graphics.

160x256 in 4/16 colors
320x256 in 2/4 colors
640x256 in 2 colors

The Electron was based on the Syndertek SY6502A CPU at 2MHz, but it reduced the clock to 1MHz when RAM access occured.

The Acorn Electron used a simplified derivative of the BBC Micro’s video hardware. Instead of the BBC’s Motorola 6845 CRTC (Cathode Ray Tube Controller) paired with a custom Video ULA, the Electron relied almost entirely on a single custom ULA (Uncommitted Logic Array) chip designed by Acorn.

This ULA handled video generation, memory access arbitration, sound, and I/O, effectively replacing several chips from the BBC Micro’s design. For graphics, the Electron supported the same display modes as the BBC Micro (from simple text modes up to 640×256 in 2 colors or 160×256 in 16 colors), but with one major difference: the Electron’s ULA performed video DMA differently, introducing memory contention. This caused slower performance in graphics-intensive tasks compared to the BBC Micro.

The Electron got favorable reviews in the press, especially about the physical design of the case, which was acording to many, a big step up from the BBC Micro that this computer was derived from. One reviewer noted, "The Electron is beautifully designed and built, quite a shock compared to the BBC." Its designer case will look great on the coffee table."

The keyboard was also considered better than most of it's competitors at the time, comparable to the commodore VIC-20 The machine featured rapic BASIC keyword entry using a combination of the FUNC key with the starting letter of those keywords to quickly type out listings, preventing many typo's.

The Electron was particularly popular in the United Kingdom, where it was often used for educational purposes in schools. It was also widely used by hobbyists and home users, and it was the home computer of choice for many people who could not afford more expensive computers such as the Commodore 64 and ZX Spectrum. Despite its popularity, the Electron was eventually discontinued in 1990, due to competition from cheaper, more advanced home computers that were entering the market. However, the computer still has a strong following of enthusiasts to this day, and it remains a popular choice among collectors and retrocomputing enthusiasts.

BBC Basic Language and OS

BBC BASIC was a high-level programming language created by Acorn Computers in 1981 for the BBC Microcomputer System, commissioned by the BBC Computer Literacy Project. It was based on the earlier Dartmouth BASIC but extended with structured programming features and inline assembler support, making it both beginner-friendly and powerful for advanced users. Unlike many contemporary BASIC dialects, BBC BASIC emphasized readability, supporting named procedures and functions, local variables, and full IF...THEN...ELSE constructs, which helped foster good programming practice among students and hobbyists.

One of the most distinctive aspects of BBC BASIC was its ability to integrate 6502 assembly language directly within BASIC source code. This meant programmers could write performance-critical routines in machine code without leaving the BASIC environment, a feature that was far ahead of its time. Combined with the BBC Micro’s flexible graphics and sound capabilities, BBC BASIC provided a complete toolkit for educational, scientific, and entertainment applications, spanning simple text-based teaching programs to advanced arcade-style games.

BBC BASIC survived long beyond the BBC Micro itself. Versions were ported to CP/M, MS-DOS, RISC OS, Windows, and even modern platforms like iOS and Android through interpreters and emulators. Its legacy lies not only in its technical innovations but also in its cultural impact: an entire generation of UK students learned programming principles through BBC BASIC. Below is a simple code sample that demonstrates its syntax clarity and structure:


  10 REM BBC BASIC with inline 6502 assembly

  20 DIM code 20

  30 FOR pass = 0 TO 2

  40   P% = code

  50   [OPT pass

  60   LDA &70      \ Load value from memory location &70

  70   CLC          \ Clear carry

  80   ADC #1       \ Add 1

  90   STA &70      \ Store back to &70

 100   RTS          \ Return to BASIC

 110   ]

 120 NEXT

 130 ?&70 = 0       \ Initialize memory location to 0

 140 CALL code      \ Call machine code routine

 150 PRINT "Value now = "; ?&70

 160 CALL code

 170 PRINT "Value now = "; ?&70

 180 END

CPU - The Motorola 6502

The 6502 is an 8-bit MicroProcessor designed by MOS Technology. The team was led by Chuck Peddle and had also worked on the Motorola 6800. The 6502 is a simplified, but faster and cheaper design than the 6800.

The 6502 was introduced in 1975 and was the cheapest microprocessor on the market. Together with the Zilog Z80, the 6502 helped start the home computer revolution of the 1980s. The 6502 was used in a wide range of devices: the Atari 2600, the 8-bit Atari home computers, the Apple II, the Nintendo Entertainment System, the Commodore 64, the BBC Micro and many others. All used the 6502 or a variation of it.

The 6502 is a 1MHz design, while the 6502A is designed for 2MHz. The 6502A is 100% compatible with the original 6502.

Commodore soon bought MOS Technology, but conitnued to sell the microprocessor to competitors and licensed the design to other manufacturers.

Source: WikiPedia - MOS Technology 6502

The 650x Instruction Set

Mnemonic	Operation	Description
ADC	Add with Carry	Adds a memory location and the carry bit to the accumulator.
AND	Logical AND	Performs a logical AND between memory and the accumulator.
ASL	Arithmetic Shift Left	Shifts all bits one position to the left (in memory or accumulator).
BCC	Branch on Carry Clear	Branches to a new address if the carry flag is clear (0).
BCS	Branch on Carry Set	Branches to a new address if the carry flag is set (1).
BEQ	Branch on Equal (Zero Set)	Branches to a new address if the zero flag is set (1).
BIT	Bit Test	Tests bits in memory with the accumulator without modifying the accumulator.
BMI	Branch on Minus	Branches to a new address if the negative flag is set (1).
BNE	Branch on Not Equal	Branches to a new address if the zero flag is clear (0).
BPL	Branch on Plus	Branches to a new address if the negative flag is clear (0).
BRK	Force Break	Forces an interrupt request and pushes status and PC to the stack.
BVC	Branch on Overflow Clear	Branches to a new address if the overflow flag is clear (0).
BVS	Branch on Overflow Set	Branches to a new address if the overflow flag is set (1).
CLC	Clear Carry Flag	Clears the processor carry flag.
CLD	Clear Decimal Mode	Clears the processor decimal mode flag.
CLI	Clear Interrupt Disable	Clears the interrupt disable flag, allowing maskable interrupts.
CLV	Clear Overflow Flag	Clears the processor overflow flag.
CMP	Compare Accumulator	Compares the contents of a memory location with the accumulator.
CPX	Compare X Register	Compares the contents of a memory location with the X register.
CPY	Compare Y Register	Compares the contents of a memory location with the Y register.
DEC	Decrement Memory	Subtracts one from the value held at a specified memory location.
DEX	Decrement X Register	Subtracts one from the X register.
DEY	Decrement Y Register	Subtracts one from the Y register.
EOR	Exclusive OR	Performs a logical Exclusive OR between memory and the accumulator.
INC	Increment Memory	Adds one to the value held at a specified memory location.
INX	Increment X Register	Adds one to the X register.
INY	Increment Y Register	Adds one to the Y register.
JMP	Jump	Sets the program counter to a new address.
JSR	Jump to Subroutine	Pushes the return address to the stack and jumps to a new address.
LDA	Load Accumulator	Loads a byte of memory into the accumulator.
LDX	Load X Register	Loads a byte of memory into the X register.
LDY	Load Y Register	Loads a byte of memory into the Y register.
LSR	Logical Shift Right	Shifts all bits one position to the right (in memory or accumulator).
NOP	No Operation	Performs no operation, consuming 2 machine cycles.
ORA	Logical Inclusive OR	Performs a logical OR between memory and the accumulator.
PHA	Push Accumulator	Pushes a copy of the accumulator onto the stack.
PHP	Push Processor Status	Pushes a copy of the status flags onto the stack.
PLA	Pull Accumulator	Pulls a byte from the stack into the accumulator.
PLP	Pull Processor Status	Pulls a byte from the stack into the processor status flags.
ROL	Rotate Left	Rotates all bits one position left through the carry flag.
ROR	Rotate Right	Rotates all bits one position right through the carry flag.
RTI	Return from Interrupt	Pulls the processor flags and program counter from the stack.
RTS	Return from Subroutine	Pulls the program counter from the stack and resumes execution.
SBC	Subtract with Carry	Subtracts memory and the inverse of the carry bit from the accumulator.
SEC	Set Carry Flag	Sets the processor carry flag.
SED	Set Decimal Flag	Sets the processor decimal mode flag.
SEI	Set Interrupt Disable	Sets the interrupt disable flag, preventing maskable interrupts.
STA	Store Accumulator	Stores the contents of the accumulator in memory.
STX	Store X Register	Stores the contents of the X register in memory.
STY	Store Y Register	Stores the contents of the Y register in memory.
TAX	Transfer Accumulator to X	Copies the current value of the accumulator into the X register.
TAY	Transfer Accumulator to Y	Copies the current value of the accumulator into the Y register.
TSX	Transfer Stack Pointer to X	Copies the current value of the stack pointer into the X register.
TXA	Transfer X to Accumulator	Copies the current value of the X register into the accumulator.
TXS	Transfer X to Stack Pointer	Copies the current value of the X register into the stack pointer.
TYA	Transfer Y to Accumulator	Copies the current value of the Y register into the accumulator.