CBM-Command is a disk manager for the Commodore 64, Commodore 128, Commodore VIC-20, Commodore Plus/4, and Commodore Pet/CBM computers. It is written in the vein of Norton Commander or Midnight Commander; but, it is much simpler due to the target platforms. Each Commodore model has its own native version of the application. It works on both real machines and the VICE emulators.

WADUZITDO is a high level interpreted language that fits in under 256 bytes of memory on a 6502 based system. The language was conceived by Larry Kheriaty to demonstrate 'what a computer can do in a manner simple enough for almost anyone to understand.' WADUZITDO is derived from the PILOT language. For the sake of simplicity, WADUZITDO supports only 5 statements:

• T:text - The type statement displays a line of text on the terminal.
• A: - The accept statement allows the program to receive 1 input character from the terminal keyboard.
• M:character - The match statement is used to test the character entered by the user on a previous accept. The character in the statement is compared to the last character entered by the user. The result of the match is recorded in the match flag: Y if the match is equal, N if it is not equal.
• Y<statement> and N<statement>`` - Statements can be conditionally executed after the match flag is set. This is done by placing either aY(yes) orN` (no) immediately before a statement.
• J:<number> - Statements are executed sequentially. The jump statement can be used to alter the normal sequence. The jump statement J is followed by a colon and a number from zero to nine. The J:0 statement causes a branch back to the most recently executed accept statement. Other values, one to nine, cause a branch to the nth program marker * forward from the jump.
• S: - The stop statement terminates execution of the program and returns control to the WADUZITDO editor.

I was going to mention that copies of the original articles were in the repo and they could be used as documentation, but it turns out that the docs are small enough to be reprinted above.

The environment has a very simple editor with similarly simple documentation:

• $ - Start execution.
• \ - Move edit pointer to the start of the program.
• / - Display the next line of the program.
• % - Pad remainder of the current line with nulls.
• ← (or Backspace) - Backspace to correct typing error.
• ↲ (or Enter) - End program line or statement.

GUI64 is a graphical user interface for the Commodore 64 that allows you to run programs and games, as well as to manage files by cutting, copying, pasting, deleting, and renaming them. It moreover enables you to format and rename disks, browse your folders on your SD2IEC device, and create new disk images and folders.

Supports both the Commodore 1351 mouse and joysticks as controls.

There are currently three options: the first is gui64.crt. This is a cartridge image with which you can enjoy GUI64 right after switching on your computer. The second option is gui64.prg which works great with a Kung Fu Flash cartridge. The third option is gui64.d64. Put in the disk and load GUI64 with 'LOAD"*",8,1'.

Ergonomy Joe has done a lot of decompilation and reverse engineering of classic games, including parts of Final Fantasy VII, Karateka, and some of the Ultima games. The decompilation projects he's done are all re-compilable (assuming that you have the other game assets)

Onramp is a virtualized implementation of C that can be bootstrapped from scratch on arbitrary hardware. Starting in machine code, we implement a tool to convert hexadecimal with comments to raw bytes, then a virtual machine to run a simple bytecode, then a linker, then an assembler for a custom assembly language, and then the preprocessor and compiler for a minimal subset of C.

From that subset of C we implement a partial C99 compiler and libc, which then compiles a C17 compiler toolchain. The resulting toolchain can (soon) bootstrap a native C compiler (e.g. TinyCC), which can bootstrap GCC, which can then compile an entire system.

Only the first two steps are platform-specific. The entire rest of the process operates on a platform-independent bytecode. Onramp bytecode is simple to implement, simple to hand-write, and simple to compile to, making the entire bootstrap process as simple and portable as possible. The platform independence of Onramp makes present-day C trivially compilable by future archaeologists, alien civilizations, collapse recovery efforts and more. The goal of Onramp is to maintain a timeless and universal bootstrapping path to C.

customasm is an assembler that allows you to provide your own custom instruction sets to assemble your source files! It can be useful, for example, if you're trying to test the bytecode of a new virtual machine, or if you're eager to write programs for that new microprocessor architecture you just implemented in an FPGA chip!

You can install directly from crates.io by running cargo install customasm. Then the customasm application should automatically become available in your command-line environment.

This repository contains the original source code for Elite on the Commodore 64, with every single line documented and (for the most part) explained. It is literally the original source code, just heavily documented. It is a companion to the elite.bbcelite.com website.

This project the result of reverse engineering the iconic Commodore 64 game Archon (c) 1983 by Free Fall Associates.

The reproduction code is intended to be a true replication of the source logic with the exception of original memory locations.

The code is fully relocatable and pays no heed to original memory locations. Original memory locations are provided as comments above each variable, constant or routine for reference.

Extensive comments have been provided to help understand the source code.

Library for embedding inline assembly directly inside bash. This is sheer madness - it injects machine code (assembled assembly language) directly into /proc/$$/mem for execution. Currently only supports x86-64.

A sub-1KB, self-hosting, native code Forth without compromise

At the core of paraforth is a very small assembly program - just an association list of names to subroutines, and an input loop for invoking them. By pre-populating the list with just enough functionality to build a macro assembler, a self-extensible language kernel is born.

This project is a long-running exercise in building the smallest self-sufficient Forth possible, without ANY sacrifices in speed or usability. No inputting pre-assembled machine code at runtime, and no cobbling together logic operations from NAND.

The entire language, save for just 15 words and 756 bytes of machine code, is implemented in itself - legibly - and builds in place on startup. Additionally, support for full bootstrapping coming soon.

Full source code for Impulse Tracker, including sound drivers, network drivers, and some supporting documentation.

To build Impulse Tracker, you will need Turbo Assembler v4.1, Turbo Link v3.01, Borland MAKE v4.0, and a DOS environment. Building IT.EXE should be just a single call to MAKE.

pdp7-unix is a project to resurrect Unix on the PDP-7 from scans of the original assembly code done by Norman Wilson. The scans of PDP-7 Unix are in the Unix Archive as the files 0*.pdf.

This is a reconstruction of the original 1981-82 IBM PC BIOS source code using scanning and transcription of the BIOS listings found in the IBM Technical Reference manuals.

All 3 versions of the IBM PC BIOS were built using Intel ASM86 on an Intel development system. In each case the BIOS source code is a single large file and the BIOS code is 8KB which resides at F000:E000

Study the complete source code for a self-hosting compiler that runs on and generates code for CP/M on the Z80 processor. No prior knowledge in the field of compiler construction is required. The T3X/0 language that is discussed and implemented in the book has its roots in Pascal and BCPL and is very simple. A full 20-page manual is contained in the book.

The reader should know at least one procedural programming language, such as C or Pascal, and at least one assembly language, ideally the one for the Z80 CPU. They should also know the basics of the CP/M operating system. For the determined autodicact a short introduction to Z80 assembly language is also included in the book.

Intel 8086 monitor program that fits in a single boot sector.

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.

scare is a multi-arch assembly REPL and emulator for your command line.

There aren't many modern assembly REPLs out there. The ones that do exist are either opaque webapps, or are tied to specific architecture or platform. scare was built for people who want to test, experiment, or otherwise play with assembly code. All assembled code is run in an emulator, which executes only the code you give it. The multi-architecture design for the underlying scarelib library is meant to be modular, allowing for new architectures to be added quickly.

A complete textbook on computer architecture and assembly language programming, as a website, in easy-to-digest pages.

What can you do with Vision BASIC? Pretty much anything you want to. Speed will no longer be a problem! Why? Because on it's own, Vision BASIC is VERY fast! But when you need to crank out even more speed, all you need to do is insert machine language anywhere you wish to. Yes, you can actually type machine language instructions right next to BASIC commands! You won't need to load in external machine language files, and you won't need to poke machine language code to memory. This is because Vision BASIC also doubles as an assembler – you can write BASIC programs with it or machine language programs with it, or a blend of the two!

Vision BASIC also includes a whole new batch of commands to help you realize your programming dreams! Need sprites? Vision BASIC's got you covered! Need sound and graphics? Yep, gotcha covered there too! Vision BASIC was designed to greatly minimize your need to POKE around with all those crazy registers. In fact, you might never need to POKE again! And if you find yourself needing a command or function that isn't available, you can simply create it yourself – by creating the needed subroutine and calling it by whatever name you choose to give it. These "user defined" commands and functions can be saved into separate files and added to your programs whenever you need them!

An 8-bit minicomputer with a fully custom architecture. Hardware schematics, software (firmware), and an emulator for testing.

8-bit data width. 16-bit address space (with banking). 8 general purpose registers (5 normal, 2 indirect addressing, 1 flag), 16 instruction RISC instruction set, port mapped I/O.