SwiftII: Bringing Modern Swift Programming to the Apple II

When Apple co-founder Steve Wozniak hand-wired the original Apple II motherboard in 1977, the absolute frontier of personal consumer computing was defined by an 8-bit MOS Technology 6502 microprocessor running at a modest 1.023 MHz, backed by a baseline configuration of just 4 KB of RAM. Fast forward to the modern era, and Apple’s Swift programming language stands as a highly sophisticated, multi-paradigm language featuring automatic reference counting (ARC), generics, and a rich standard library designed to power resource-heavy applications on multi-gigahertz, multi-core processors. To bridge these two wildly disparate eras is an engineering task of monumental proportions. Yet, prominent retrocomputing enthusiast and maker Yeo Kheng Meng has bridged this 40-year architectural chasm with the launch of SwiftII, a project that brings a “Swift-flavored” development environment natively to the Apple II line of personal computers.

The Architecture of SwiftII: Bridging the 6502 Gap

The core challenge of running a modern language on a vintage 8-bit microprocessor lies in register and execution constraints. The MOS 6502 is an accumulator-based CPU with an incredibly lean register set: a single 8-bit Accumulator (A), two 8-bit index registers (X and Y), a 16-bit Program Counter (PC), a Stack Pointer (S), and a Processor Status register (P). Because of this minimalism, compiling modern high-level constructs natively to 6502 machine code is highly inefficient, quickly ballooning the binary size and exhausting the CPU’s limited registers. To solve this fundamental problem, the compiler in the SwiftII ecosystem does not compile directly to native machine code. Instead, it compiles a tailored subset of Swift syntax into a custom, highly compressed bytecode.

To execute this bytecode natively on the 1 MHz processor, Yeo Kheng Meng wrote a custom virtual machine (VM) interpreter entirely in hand-optimized 6502 assembly. The VM emulates a virtual stack-based processor, providing a flexible execution environment that sidesteps the severe physical register limitations of the actual hardware. By utilizing this stack-based virtual architecture, SwiftII programs achieve a level of code density that is impossible with direct compilation. This compact representation is essential, as it allows sophisticated programming structures to be loaded and processed within the strict bounds of the Apple II’s architecture.

Wrestling with 8-Bit Memory Constraints

While the original 1977 Apple II shipped with a baseline of 4 KB of RAM, the immense memory footprint required to host an on-device compiler, parser, abstract syntax tree (AST), and virtual machine interpreter demands far more headroom. To run the SwiftII ecosystem natively, the Apple II must have its memory upgraded to at least 48 KB or 64 KB. However, a standard 64 KB space is still an incredibly tight squeeze when attempting to build and run a modern compiler suite on-device. To push past these limits, the project natively integrates support for historic hardware memory expansions:

• Saturn Paged RAM Cards: These classic expansion cards allow the Apple II to access an additional 32 KB, 64 KB, or 128 KB of bank-switched memory. By utilizing system soft-switches mapping to the $D000-$FFFF address window, the compiler can swap active memory banks in and out on the fly, allowing it to maintain large compilation symbol tables without colliding with system ROMs.
• Apple IIe Auxiliary Slot Memory: On the Apple IIe, the compiler utilizes the auxiliary slot’s paged memory, using bank-switching techniques to expand the working memory of both the interactive editor and the execution runtime.

By mapping these paged memory architectures, the system manages to split its processing duties. The compiler can construct its parsing trees in auxiliary memory while keeping the primary system memory free for the VM’s active execution stack, preventing the dreaded out-of-memory crashes that routinely plague large projects on 8-bit platforms.

The On-Device Suite: A Native Ecosystem

A standard convention in the retrocomputing community is “cross-compilation”—writing code on a modern high-performance PC (such as a modern Mac or x86 workstation) and transferring the compiled binary to the vintage target machine via emulator bridges or floppy emulators. What sets SwiftII apart is that it is designed as a fully native, on-device development suite. The environment runs completely on the Apple II itself, turning the vintage computer into an active programming terminal. The suite is composed of four core pillars:

1. The Interactive REPL (Read-Eval-Print Loop): Modeled after the modern command-line experience in Xcode, the SwiftII REPL allows developers to type Swift-flavored statements directly into the console, parsing, compiling, and executing them on the fly on a 1 MHz machine.
2. The Native Bytecode Compiler: Running completely within the 6502 CPU environment, this component parses local text source files and writes optimized bytecode binaries (.bin) directly to the system’s disk storage.
3. The Virtual Machine Runner: A fast, lightweight runtime execution engine that loads the generated bytecode files, initializes the virtual stack, and executes the compiled application.
4. The Custom Text Editor: A bespoke, ultra-lightweight source-code editor built from scratch to allow on-device writing and saving of Swift files.

Peripherals, Graphics, and Keyboard Gymnastics

Developing on a half-century-old system forces a programmer to confront the raw physical limitations of early computer peripherals. In 1977, the Apple II text interface was limited to a 40-column monochrome display. For a highly expressive programming language like Swift, which relies heavily on descriptive variable names, brackets, and nested closures, 40 columns of text are restrictive and hard to read. To address this, SwiftII includes native support for the Videx Videoterm 80-Column Display Card. This classic slot peripheral overrides the built-in video display, granting developers a crisp, readable 80-column text terminal that makes reading code structures immensely easier.

Furthermore, the environment is capable of driving the Apple II’s native High-Resolution (Hi-Res) Graphics Modes (HGR). Developers can write high-level, Swift-styled scripts to interact with the screen buffers, drawing lines, plotting coordinates, and creating visual animations natively through virtual machine commands. This links the visual heritage of the Apple II directly to modern structured code.

Keyboard layouts also presented a significant hurdle. The Apple II+ keyboard lacked lowercase letters, arrow keys, and essential coding symbols like curly braces `{}` and square brackets `[]`. To make programming viable, Yeo Kheng Meng implemented a customized keyboard engine. For Apple II+ users, the editor features specialized “digraphs” and case-switching inputs to generate symbols. Conversely, when running on an Apple IIe, the system bypasses these workarounds, leveraging the IIe’s built-in keyboard enhancements, uppercase/lowercase hardware, and dedicated navigation keys to provide a fluid, standard text editing experience.

AI-Driven Software Archaeology: Claude Code and GPT-5.5 Codex

Fitting a complete development suite—including a compiler, editor, REPL, and virtual machine—into just tens of kilobytes of memory is a masterclass in extreme assembly optimization. Historically, such a project would have required a dedicated team of system engineers working for months. To accelerate the process, Yeo Kheng Meng turned to a highly contemporary resource: modern artificial intelligence developer agents. By employing Claude Code and GPT-5.5 Codex, the developer was able to speed up the low-level assembly implementation dramatically.

Programming for the 6502 in assembly is highly tedious, requiring developers to keep constant track of cycle counts, zero-page pointers, and CPU branch page crossings. AI agents were utilized to analyze written routines and suggest highly optimized instruction sequences. For example, Claude Code assisted in refactoring branches to prevent page-boundary crossing penalties—which add an extra clock cycle to a branch instruction—and finding opportunities to utilize faster zero-page indexing instead of absolute addressing modes. Concurrently, GPT-5.5 Codex was utilized to generate strict unit test suites and mock execution traces, verifying that the output generated by the high-level compiler perfectly aligned with the behavior of the VM’s assembly runtime. This fusion of 21st-century AI tooling with 20th-century hardware demonstrates a groundbreaking paradigm for software preservation and digital archaeology.

A Triumph of Optimization

The launch of SwiftII has captured the imagination of retrocomputing forums and software developers worldwide. By bridging a massive 40-year architectural gap, the project stands as an absolute triumph of optimization and code conservation. It proves that the limitations of legacy hardware can be bypassed not by abandoning them, but by applying modern computer science patterns, dense custom bytecodes, and advanced AI-assisted coding tools. For hobbyists and computer scientists alike, it is a reminder of the enduring versatility of the machines that started the personal computing revolution, proving that even a 1 MHz computer from 1977 can run modern-styled code.