course · new for 2026
HiSoft C for the Tatung Einstein
HiSoft C is the C compiler that was sold for the Tatung Einstein: a small, fast K&R C from 1985 that turns a source file into a runnable program in one step - HC NAME.C at the DOS prompt, about half a minute, and NAME.COM is on the disc - with a library of the Einstein's own screen, keyboard, graphics, sprite and sound routines beside it. This course teaches C with it, from the very beginning, on the Einstein. It covers HiSoft-C Compiler V1.35 and nothing else: not the C standard, not another compiler, not C on any other machine. Where this compiler differs from the C you may have met - and it does, in ways that matter - the course says so, because the machine showed it.
You do not need to own an Einstein. Everything here runs on an emulator on your own computer, and everything you need is free.
Like our other courses, this one builds towards a single game: Breakout, the arcade game of 1976 - a bat, a ball, and a wall of bricks to knock out, with three lives, levels that come back faster, a score, a title screen, colour and sound. It is built a section at a time in the last part of the course, and the finished game is on the course disc for you to play first.
Thirty-five sections and four appendices. The first part is the workshop, and it is the point of the course: an editor, a compiler and a DOS prompt, used one at a time with the floppy turning, the way software was written on small computers in 1985 - and one section on what is honestly known about C on the Einstein, from the compiler's own manual and the users' group's catalogue. The second is the language: printing, numbers, names, choices, loops, functions, input, arrays, pointers, strings, structures, the preprocessor, files and memory - each with what this compiler does, measured, rather than what C usually does. The third is the machine, which is where C stops hiding it: keys without ENTER, the screen as a grid, redefining characters, lines, sprites, the video chip's own clock, and how fast and how big a program can be. You read two real programs along the way - the Einstein library and the CP/M library, both on the disc as C source - and find a bug in one of them. The fourth part is the game, and the last section is the way on: down to our assembly course, sideways to the other C on the site, up to every C since.
Every section has the same shape: an explanation, the code to type, what you should see, a few single changes to make with a question attached to each, exercises, and the failures we actually hit. Worked solutions to every exercise are in an appendix. Everything you type is typed into ED80, the editor HiSoft shipped, on the machine, and every line fits its 40-column screen.
It is written for both keyboards. Keys are called what the Einstein calls them; wherever a key is somewhere else on a modern keyboard under MAME, a line beginning In MAME says where, and an appendix has the whole keyboard - the characters C needs that the Einstein hides on its arrow keys, the codes a program sees, and all of ED80's command keys - in one place.
Three things, all free: MAME, the Einstein ROM, and the HiSoft C Course Disc from our Downloads page. The disc carries the compiler, its four library files and their help, ED80 under both the names the compiler needs, the finished game with its source, and 72K of free space for your own work. It is an .mfi rather than a .dsk because MAME will not write to a .dsk, so on a .dsk the first program you tried to keep would be lost. The third section sets all of it up.
The same way as the other courses, and here the rule mattered more than anywhere. C is a standardised language with forty years of books about it, and almost everything that can be read about C describes a later C, a bigger machine, or the language in the abstract - and almost all of it is nearly right. So nothing here is taken from the standard, from a C textbook, or from HiSoft's manual alone without first running it on the machine and watching what happens. The manual was read first, for what to test and what to call things; where the manual and the machine disagree, the machine wins.
It disagreed often enough. An int is sixteen bits and rolls over without a word; a char is unsigned; there is no floating point at all. Two structures may not share a member's name, and a global may not share one either - the compiler builds a two-byte structure or stops, depending. A structure initialised with braces gets each value in one byte. There is no #ifdef. A function called with the wrong number of arguments compiles cleanly and then breaks the machine three different ways. The library's own sprite routine has its arguments the wrong way round, and its help file has the graphics upside down. And underneath it all is the reason for a compiler: an empty loop runs ten thousand times a second, every character printed costs four milliseconds, and the video chip ticks fifty times a second whatever else is happening - which is how the game is timed.
Every listing, every change and every exercise solution was compiled and run on HiSoft-C V1.35 before it was written down, and every screenshot is of the machine actually doing it. Well over a hundred recorded runs of some two hundred and fifty test programs stand behind the thirty-five sections, and they are kept so that any claim can be checked again. What has not been done is a test on real hardware: the course was written and checked entirely under emulation, and if you follow it on a real Einstein we would like to hear what differs.
This course was written with Claude Code, directed and tested by Gavin Watson. We say so openly because we think it is the right way to use these tools, and because you deserve to know how the thing you are learning from was built.
