Show HN: I Wrote A BASIC Interpreter That Boots On UEFI Machines

A developer has created a BASIC interpreter that boots directly on UEFI systems, making it possible to run vintage-style BASIC programming environments on modern hardware without relying on emulators or legacy BIOS compatibility. This development is notable because UEFI is the standard firmware interface for most modern PCs, and executing a simple, old-fashioned interpreter at this level demonstrates a novel approach to hobbyist programming and system exploration.

The project, called Thoreau BASIC, was publicly shared on Show HN by the developer, who explained that they aimed to build a small, straightforward BASIC environment with features like line numbers, immediate mode, simple graphics, strings, and arrays. The interpreter is designed to boot directly from UEFI firmware, bypassing traditional operating system layers, which allows it to run independently on any compatible machine. The developer emphasized that this setup enables users to experiment with classic programming styles in a modern context, and potentially develop educational tools or hobbyist projects that leverage this vintage environment.

The implementation involves custom UEFI bootloader code that loads the interpreter into memory and executes it directly, without requiring an OS or BIOS. The project is still in early stages, with some features like graphics and file I/O being basic or experimental, but the core functionality of a working BASIC interpreter on UEFI firmware has been demonstrated. The developer provided source code and instructions, encouraging others to test and extend the system.

Potential Impact on Retro Computing and Education

This development matters because it bridges the gap between vintage programming environments and modern hardware, enabling a new form of retro computing directly at the firmware level. It offers hobbyists, educators, and developers a platform to explore classic programming styles without the complexity of emulators or outdated hardware. Additionally, it demonstrates the flexibility of UEFI firmware, which is increasingly becoming a platform for custom low-level software, opening avenues for innovative projects that run before an operating system loads. The project also showcases how minimalistic interpreters can be adapted to modern firmware interfaces, possibly inspiring further experiments in embedded and system-level programming.

Background of UEFI and Vintage Programming Environments

UEFI (Unified Extensible Firmware Interface) has gradually replaced BIOS as the standard firmware interface for PCs, providing a modern, flexible environment for hardware initialization and pre-boot applications. Unlike BIOS, UEFI supports more advanced features, including executing custom applications directly from the firmware. Meanwhile, BASIC was a popular programming language in the 1980s and 1990s, often used in educational settings and hobbyist projects. Classic implementations like Microsoft BASIC or GW-BASIC allowed users to write simple programs with line numbers, immediate mode, and basic graphics.

In recent years, there has been a resurgence of interest in retro computing, with enthusiasts running vintage operating systems and interpreters on modern hardware. However, most of these efforts rely on emulators or compatibility layers. Few projects have succeeded in running vintage environments directly at the firmware level. This new BASIC interpreter, which boots on UEFI, represents a novel approach that combines modern firmware capabilities with the simplicity of classic programming languages, making it accessible on current hardware without additional emulation or OS dependencies.

“I wanted a small, old-fashioned BASIC interpreter that could run directly on modern hardware without relying on emulators or legacy BIOS. UEFI seemed like the perfect platform for that.”

— the developer

Limitations and Current Development Status

While the core BASIC interpreter is functional and can boot on UEFI systems, several features are still experimental or incomplete, such as advanced graphics, file I/O, and system integration. It is also unclear how well this approach scales across different hardware architectures or UEFI implementations, and whether security or stability issues might arise from running code at this level. The developer has not yet tested it extensively on various platforms, and some features remain in early development stages.

Upcoming Improvements and Community Involvement

The developer plans to refine the interpreter, add more robust graphics and file support, and improve compatibility across different UEFI firmware implementations. They also encourage others to test the system, contribute code, and experiment with extending its capabilities. Future milestones include creating a user-friendly interface, supporting networking, and integrating with modern hardware features, all while maintaining the simplicity and vintage feel of the original BASIC environment.

Key Questions

Can I run this BASIC interpreter on any UEFI machine?

It is designed to work on systems with UEFI firmware, but compatibility may vary depending on the specific hardware and firmware implementation. Testing on different platforms is encouraged.

Does this require any operating system to function?

No. The interpreter boots directly from UEFI firmware, without needing an OS or BIOS support.

What features does the BASIC interpreter currently support?

It supports line numbers, immediate mode execution, basic graphics, strings, and arrays. More advanced features are under development.

Is the source code available for modification?

Yes, the developer has shared the source code and instructions publicly, inviting community contributions.

What are the potential educational benefits of this project?

It provides a simple environment to learn about low-level programming, firmware, and vintage computing, all on modern hardware.

Source: hn