All about the IBM 5100 from 1975 (also IBM 5106 and IBM 5110)

I have gathered up some notes about the IBM 5100/5110 that I’ve collected over the past year. They are available at:

Some topic highlights:

  • how to replace the PSU with modern components
  • how to substitute the keyboard with a Bluetooth interface (or serial connection)
  • how to use the built-in DCP to directly program the system in PALM machine code
  • notes on using the modern assembler to produce PALM machine code
  • dusted off the 5110 PALM emulator (can script inputs and has integrated disassembler)
  • a video on how the tape-file-system operation works, see:
    IBM 5100 Tape Usage Demonstration (internal and external IBM 5106) - YouTube

Some remaining goals:

  • I was able to get ahold of Hal Prewitt of Core, who shared some of the early 1980s CORE newsletters. However (Hal is busy dealing with Florida hurricane after effects), I haven’t yet been able to work out getting a runnable copy of the PC51 program. If anyone has any info about CORE and/or CoreNET, would like to hear about it.

  • I haven’t yet been able to get ahold of Harry Katzan (the author of THE 500+pg IBM 5100 Portable Book); I believe he is still alive in Europe, because as recently as 2019 he has published some fiction-books on Amazon (the one I read is a fictional story that is fairly obviously a kind of opinion about Megan Markle)

  • Need help in getting the IBM 5100 emulator running (the executive to language hand-off works differently than on the 5110)

  • Possibly doing a C compiler (just to show C ported to a pre-microprocessor system, but also to help motivate and see what kind of creative software the native PALM instruction set could do – demoscene type stuff)

  • I think with IOCB’s, it may be possible to interface with a WiModem232 using the external I/O pins! (now that we have a modern assembler, that’ll help write the software)

There are many “nuance” topics about the IBM 5100, such as:

  • the (competitive) relationship between SCAMP and the Wang 2200
  • the technical aspects of those “tin can” static memory chips (was it SLT, MOSFET?) Did the Executive ROS technically use different internal hardware than the non-executive ROS? Are the two “large chips” on the IBM 5100 processor a 128-byte register file?
  • did NASA/Apollo actually use PALM on anything?
  • many people seem unaware of the external monitor support of the IBM 5100 (I show it in the QIC tape usage demo video)
  • 8bit/16bit hybrid systems (8-bit ALU, 16-bit address space and registers); is it an 8-bit system?
  • why does Katzan’s extensive IBM 5100 book omit any details about the DCP and PALM? (the “microinstructions” are described in Appendix C of the 1975 MIM, but the earliest use of the term PALM I’ve found is from 1977)
  • some technical differences between the IBM 5100 and the Datapoint 2200 (e.g. 64x16 CRT versus 80x16; DP2200 maxed 8KB, the 5100 was min 16KB – the original DP2200 had no built in ROM software, though that was rectified later in follow up models, around the time as SCAMP; the 5100 certainly had a more reliable power supply)
  • the ITC tax credit may have made the IBM 5100 less expensive than it appears (for businesses)
  • the System/3, IBM 1130, and System/360 relationship (my review of the annotated APL disassembly so far hasn’t shown any S/370 specific opcodes - but there is obvious handling of many S/360 opcodes)
  • in a PC Magazine article (1983), Friedl claims the 5100 was used on an oceanography research ship, and was part of the technology demonstration shared during Nixon’s famous visit to PRC (but still don’t have verification of that)

The main interesting things to me about the IBM 5100:

  • Definitive “proof” that BASIC was a thing “long before” Microsoft (not that anyone really doubts that – but it questions what Bill Gates was talking about in his open letter; he “bummed” BASIC from a mainframe that he had been gifted time on and trimmed it down to fit on the Altair, so was it really his to sell? to be fair, there was some technical talent involved in making a viable BASIC fit in 4K {or was it 2KB originally, the MS BASIC 1.0 loaded from the paper tape?})

  • the IBM 5100 BASIC includes floating point (I think 13 digit), matrix operations, function key macros, and various “advanced” features (the ROS for IBM’s BASIC is over 32K) - but despite all that, it doesn’t have a “clear screen” command! (but think about why that is: it is emulating a line printer system that would have no concept of clearing a screen)

  • the QIC file system is a curious thing (it is much better than the later audio tapes as data tapes experience)

  • if you power on a 1981 IBM PC 5150 (with no disk), it boots to BASIC and you can save stuff to a tape. Go back to 1975 and you essentially get exactly that same experience on the 5100 (that you turn it on, “boot” to BASIC, and have a minimum of 16KB of RAM to work with) - but they’re both based on fairly different hardware technologies.

(but the main “fault” of the IBM 5100 is lack of a proper expansion bus; the Altair had S-100 {which had some power issues} and Datamaster/32 introduced ISA in 1981 – the IBM 5110 did have some IEEE-488 support on its parallel card expansion; this lack of bus does kind of put the DP2200/Wang/5100 in the category of glorified-multi-line programmable calculators, as opposed to a system that could at least kind of organically grow in capability over time – which is, to me, what the hallmark of the IBM PC was really about; still, being able to store megabytes of data to tape did make the 5100 a useful record keeping system, terminal emulation capabilities, and of course the robust CRT-based editing capabilities and legendary typewriter-inspired keyboard!)

Lastly, should anyone happen to have “spare parts” for an IBM 5110 – I have a “half complete” IBM 5110 that is need of some parts (but its case it is in fairly pristine condition).


Very nice site and collection of resources! I hope you don’t mind if I showcase your attractive diagram:

Absolutely! Thanks, it took me awhile to think of a way to convey the idea of those two minicomputers being “compressed” into the 5100. I’ve worked with some old HARRIS systems that used 9-track tapes, but never had the honor of using any of the older IBM mini’s first-hand (at least in their base form, I’ll call them mini’s).

Reading through “the DP2200” book, it describes how in early 1970s IBM “strong-armed” the industry into only renting/leasing computers. That alone made it difficult for “upstarts” to compete (because you have to upfront a lot of money to build the system, and leasing money won’t come back in till over a year later – plus then having to deal with customers that don’t pay).

Another nugget of history we often forget: the IBM anti-trust lawsuit began in 1975 (here) , with a claimed violation of the Sherman Act. This was eventually withdrawn after years of trial (in 1982). This is interesting, because Alvin Ginsburg refers to this in his letter about the 5100: "My next hurdle were the anti-trust lawyers. They were concerned that building BASIC into the unit would open us to charges of bundling, locking out competitor’s who might want to sell a BASIC interpreter. "

( if anyone knows or has contact with Alvin Ginsburg of IBM, would love to get in contact! hope he is still around, but I haven’t been able to find a contact )

1 Like

Great site!
For those who may lust for a bit of hands-on experience, there is Norbert Kehrer’s IBM 5110 online emulator (now hosted on GitHub):

(Maybe also worth a link on the page?)

1 Like

This is good example of how CPU’s in the first half of the 1970’s out paced memory at
the time. Intel had 1024 x 1 Drams in 1973 and the 8008 cpu with 16kb address space.
4k rams, 8080 in 1975. Intel 8086/16 K drams 1979.
The base unit of any thing was inexpensive compared to a product with use full memory, and or I/O since you only had about 1/4 of the full memory for a base unit. memory chips
seemed to be always about $20 each back then. Core forget the price, as they pushed faster core, not lower price.

The Apollo program was essentially over by the time the prototype that evolved into the 5100 was created, so I can’t see how there would be any relation between the two.

Another example of a processor with 8 bit ALU but 16 bit registers and addresses is the RCA 1802, though the Z80 and 6809 might also partly count as such. I agree that the term “hybrid 8 bit” is more descriptive, but everyone just calls them “8 bit” machines.

A pure 8 bit machine would use 8 bit addresses, like the Kenbak-1, for example.

but despite all that, it doesn’t have a “clear screen” command! (but think about why that is: it is emulating a line printer system that would have no concept of clearing a screen)

If it’s emulating a line printer, then, in theory, the form feed character should act as a clear screen.

I just stick to alu width. Many 16 bit computers ,just had 32K of memory with the top
bit for indirect.

That was one of the differences between the emulated Nova in the Xerox Alto machine and the actual Data General Nova. The Alto used 16 bit addresses for 128KB instead of 15 bits plus an indirection bit. A few other Nova clones did the same thing.

Speaking of the Nova, when talking about “alu width” we should add “as seen by the programmer”. The original Nova only had a 4 bit physical ALU but the programmer saw a 16 bit one. The Z80 also had a 4 bit ALU that looked like an 8 bit one. The 68000 had three 16 bit ALUs that looked like a 32 bit one.

1 Like

Well with my FPGA cpu design I have 1 32 bit alu / data path, 16 bit bus.
20 bit Addressing. Just doing the final tweeking of the design now for a MSI/LSI
version using 2901 alu’s , 3 512x8 roms and 3 22v10’s replacing 82S100’s
~ 21 chips for the control card, ~ 26 chips for a 16 bit alu card.
82S100’s replaced ~ 6 TTL chips each for microcode decoding. ~39 chips
for the control card.
I favor a simple slower 32 bit design with more address space, rather than a complex fast 16 bit design (PDP11) and a 16 bit MMU.
More talk would drift from IBM and similar machines in the UK.

The KENBAK-1 replicas have become popular this year :smiley: (anniversary year)

Yes, 1972 was end of Apollo (and probably the “writing on the wall” in major reductions in budget to space-science projects, since “mission accomplished”; although there was Skylab work in the mid-1970s, ramp up in satellite work - like Voyager 1977, and increased use of onboard computers in aerospace (F-14/15/16, etc.).

I don’t think the suggestion is that any IBM 5100 was involved with the Apollo craft itself, but maybe that SCAMP used some “space age derived technology” like the ability to have microcode at all (as an intermediate solution between TTL discrete and the eventual microprocessors). That is, the metals and techniques involved to reliably have a “static memory” to store bits (at an increasing capacity and performance) helped make a full-featured portable computer system possible. Maybe it’s not an explicit relationship to Apollo, but an indirect one.

That makes the term ‘PALM’ itself a bit nebulous. Is it the instruction set itself (i.e. the set of 16 main opcodes described in IBM 5100 MIM Appendix C), or the notional idea of some kind of metal sandwich used to store microcode? (where that microcode implements a few instructions, like ADD immediate, JUMP, etc). Then also finding the boundaries in the environment on where that can be used reliably (relative to heat, ambient radiation, etc).

In the GENASM manual from 1977 (IBM internal manual on the “General Assembler”) it uses the term “6 PALM” which I have to assume is a kind of version number, implying earlier iterations of PALM - so how much earlier? (maybe I’m wrong and the “6” just refers to a section number, or refers to a “class” of systems that use a “category 6” set of opcodes?) The exact quote is:

Initially I thought this all meant compiling an assembler to run on the 5100 - but now I’m thinking this doesn’t mean what I thought. The full manual is here:

Maybe someone more experienced can help decipher this.

Haven’t read the link, but it sounds to me like a statement of performance: the assembler itself, as an example of a significant program written in assembly language, can be assembled in 45 minutes.

I love Norbert’s emulator, it just needs a feature added to script inputs. I found Corti’s original emulator baseline at the IBM museum FTP site, and noticed he already had a condition to support cross-compiling it to the Wintel environment. So I ripped out the X11 GUI parts and used text-based pdcurses, to run the PALM emulator from the command line. That works, then added some command line arguments to be able to script inputs. That ended up being a little harder than it sounds, since the IBM 5110 doesn’t use standard ASCII, and how to invoke the special key presses to enable DCP and such? So in the text file input, some interpretation is done to apply the special keys.

Conceptually, that same PALM emulator should work on the IBM 5100 executive ROS – and it actually does. However, there is an issue/difference in how the 5100 transitions to the active language. So a viable IBM 5100 emulator is close but after trying to resolve that issue for a few days, I had to move onto other projects.

Hmm, good idea. But… the IBM 5100 isn’t using ASCII natively, so can’t assume 13/10 for CR/LF. But, “FF” should just be some other native code. The thing is, in the Executive ROS disassembly, IBM themselves “clear the screen” by loading “0200” (address of the memory mapped CRT content) and writing two spaces 512 times. However, somewhere in the MIM I thought I recall the “Display Device” had an OUT control bit labeled as “clear screen” - but I haven’t been able to find that again.

So may misspeaking to say “emulating a line printer” - but rather, emulating systems whose main interface is via a line printer. (some of those systems did have a kind of vector screen at some point - but generally programmed through a serial I/O, not really a native/normal part of the system)

In both systems, here is their “clear screen” code…

IBM 5100 Executive ROS code...

; Clear entire screen
1066	8E02		LBI R14, #$02
1068	0EED		MLH R14, R14
106A	8E00		LBI R14, #$00		; top of screen
106C	8C10		LBI R12, #$10		; 16 rows
; ----------

; Clear part of screen
; R14: address
; R12: number of rows
106E	2F53		MOVE R15, ZERO     (for 5100, ZERO is blank/space)
1070	813E		LBI R1, #$3E		; last two columns? (x3E == 62)
1072	CE1D		SNBS R14, R1         (is R14 pointing there?)
1074	FC00		SUB R12, #$01		; yes, next row
1076	5FE1		MOVE (R14)+, R15	; clear two characters
1078	CC03		SZ R12             (end last row? if yes skip next)
107A	F00B		BRA $1070		; -> -$0C(R0)
107C	0024		RET R2
; ----------


IBM 5110 Executive ROS code...

; Clear screen

1DFC	8E02		LBI R14, #$02           (init 0x0200 start address of screen)
1DFE	0EED		MLH R14, R14
1E00	8E00		LBI R14, #$00

; Clear to end of screen

1E02	8940		LBI R9, #$40      (for 5110, #$40 is blank/space)
1E04	099D		MLH R9, R9           (use R9 as "  ", two spaces)
1E06	59E1		MOVE (R14)+, R9
1E08	8106		LBI R1, #$06
1E0A	CE17		SBSH R14, R1      (have we reached 0x0600?)
1E0C	F007		BRA $1E06	; -> -$08(R0)  (no, keep looping)

1E0E	0024		RET R2
; ----

But another interesting tidbit: in BASIC (on the 5110), the screen itself is assigned a file number, so you can “open” that file and write to it (that is, it had a “stream” mode – which is kind of “unix-ish” in the “everything is a file” sense). A special “FLS” file on the 5110 made an interface to use BASIC to do things like make the speaker beeper, turn on/off the display, change character sets, and to query the available “work space” memory. (the 5100 had a somewhat similar capability - when issuing a “RUN” command, you do could “RUN P=D” and then any PRINT FLP commands would go to the Display instead).

There was also the “RD” (round) command, to specify how near two (float) values could be for declaring them equal. (the IBM 5100 BASIC manual explicitly compares itself against the System/370 BASIC - which it say, the 5100 didn’t innovate these features, but leveraged much of that mainframes BASIC)

Regarding the Apollo and high-end technology discussion: It may be also interesting to consider the lower end, top-down dynamic. In 1976/77 IBM was working on various home computer concepts, and I guess, if any of these had become reality, we may recognize one or the other element of the 5100 in them. (The Aquarius project seems to have come pretty far with production prototypes and a concept for a software ecosystem, but was canceled over doubts of the real-world viability of bubble memory.) Had any of this happened, we may regard the 5100 as an important intermediary step in scaling down mainframe technology and bringing it to the masses.

PS: I’d really love to see someone with access to the IBM archives coming forward with something like “The untold story of IBM’s struggle for the home computer.”

On the speculative side, this may provide a reason for IBM being so secretive on the PALM technology, as this may have played a role in protecting a closed software ecosystem.

Regarding the BASIC implementation: A notable feature are multi-line user defined functions with RETURN and FNEND keywords. (I’ve always found BASIC’s single-line DEF FN somewhat limited.)

For example, from Harry Katzan’s 5100 book, a multi-line factorial function with multiple returns:

0020 DEF FNF(N)
0030 IF N≠0&N≠1 GOTO 0050
0040 RETURN 1
0050 K=1
0060 FOR J=2 TO N
0070 K=K*J
0080 NEXT J
0100 FNEND

(Mind the syntax of the condition at line 0030, using “|” and “&” for OR and AND, respectively.)
And no, you can’t have recursive function calls, but you may call other user defined functions from within a user defined function.

On the other hand, you may still have single-line user defined functions using assignments. This dual nature of the DEF FN keyword is quite peculiar and seldom found in BASIC.

0010 DEF FNX(A,B,C) = (A*A+B)/C
1 Like

Just to break it down…

"IT TAKES ABOUT 45 MINUTES ON A 5100 " assuming this refers to the IBM 5100

"COMPLETELY PROCESS ALL OF ‘PALM’ " why is ‘PALM’ in a quote? (recall the 5100 only has a single quote, not a double quote - was the document itself done in a 5100?) What is it processing? Imagine you had a source code that was larger than 16KB (or even 64KB with comments), so it can’t completely fit in main memory. So we have to process portion of the code at a time through files? Maybe ‘PALM’ is that set of files? (but PALM is a concept, and IBM is making multiple processors – like special processors in their own high end 9-track tape controllers – and GENASM has input options to specify certain aspects of the target processor)

“PRODUCE THE PALM ASSEMBLER” assuming this means an assembler like in the modern sense – which is, something that takes string mnemonics and converts it into machine code. But how does it work once produced? i.e. how do you “run” it, and (presumably) give it command line arguments such as “what data product to assemble.” Is the assembler itself a binary product that is then loaded into main memory? Imagine you’re developing the Executive ROS itself - absolutely that’d be in some PALM assembly (and with comments, I imagine that would quickly be a file {or set of files} larger than 32KB). But… I imagine the assembler to convert that to machine code would be ran on some pre-existing mainframe, not the 5100 itself? [ like when using modern MCUs – we compile to the Arduino or ESP32 on the desktop PC, and serially upload the resulting binary; we don’t compile, assemble, link on the embedded device itself ] [ or maybe that’s the amazing thing: once the assembler was first made on the mainframe, the 5100 {or an earlier intermediate since the prototype} was able to “run itself” { run its own assembler} ] [ compilers are like that - the folks developing visual studio use visual studio itself; or I recall the Borland folks saying “Delphi now compiles itself” ]

"WHICH IS IN ‘6 PALM’ " and the mystery, was there a “5 PALM”, “4 PALM”, etc?? (Nintendo had developer-versions of its Famicon system with special features, maybe “6 PALM” just refers to an internal special system build tailored to those doing things like writing the Executive ROS – hopefully they didn’t need to compile this assembler very often! but if found bugs in the code generator, or saw a more optimal way to generate the machine code, it’s 45min to “process” the code changes?). But again, why is ‘6 PALM’ in quotes? One nuance about the IBM 5100 executive ROS (and 5110) is the very first 4-bytes indicates what address offset to start running at (i.e. it’s not an instruction, it’s data). Maybe other IBM processors had different policy/convention, and maybe ‘6 PALM’ just refers to that particular IBM 5100 convention.

Looks like 6 PALM refers to the 6th file on the tape, which contains the definition for the PALM assembler. Whereas 3 GENASM refers to the 3rd file on the tape, which is the GENASM program.

It seems reasonable to me to expect a native assembler - yes, cross-assemblers were common and remain common, but a self-contained computer system needs a native assembler.

And yes, for small-memory machines, it’s normal not to expect to read the whole of input into memory - it is indeed normal to open a file for read and proceed by reading bytes or records or sections. It’s also normal to use one or more intermediate files, or more than one pass.

Brilliant! And to imagine that original Executive ROS assembly is sitting out there, either archived on some 9-track tape or on a QIC tape. Corti produced an annotated version of the disassembled Executive ROS, maybe about 50% commented (mingled in with the emulator source code), and also of the disassembled APL ROS code - both very insightful, even if incomplete.

The spec on the QIC tape for the 5100 (in the MIM) say the max “file size” is 0x3FFF (16KB). So even if you had a decked out 64KB system, the work is spread across 16KB files.

So, I imagine the 45 minutes is also “tape-deck-movement-time” (loading portions of the assembler program itself, loading the portions of data to be assembled, and writing the binary products back out to other files) and not just strictly CPU processing time.

The original SCAMP didn’t use QIC; I was always curious if it was using a regular audio tape. My understanding on the DP2200 was it wasn’t using “regular” audio tapes either (likewise for the MCM/70). i.e. if one did travel back to 1973, I’m not sure where you’d get suitable tapes for those systems (if not audio tapes, then can’t use a regular record store?)

I don’t think that regular audio tape (as in compact cassette) had been in option. The very first computers to use compact cassettes for storage (according to Wikipedia) were the HP 9821A / HP 9830 (both 1972). So this was then very new technology and only used by what was then considered an electronic calculator. Moreover, HP was then still a rather low-end computer manufacturer. I assume, not what IBM would have considered a persuasive recommendation in 1973. (Also, where’s the potential for serious over-engineering in audio cassettes? :slight_smile: )