TRS-80: The Best of the 1977 Trinity

In Quiz - which of the 1977 trinity for you?, @EdS asks which of the Apple II, TRS-80 (or TRS-80 Model I, as it was later to be known) and the PET 2001 you’d pick if you were a 15-year old in 1977 and had enough to buy any one you wanted.

After thinking about it a bit, I ended up choosing the TRS-80, and here I describe in detail why that is. I’ve chosen to post this as a separate thread because a) this post is quite long, and b) I’m open to discussion of these general types of features amongst all pre-1980 microcomputers, not just the trinity.

So what’s so great about the TRS-80?

Text Display

The biggest selling point for me is that the TRS-80 display has a wider text line: 64 characters rather than 40. When programming (my primary activity), overly narrow screen lines are a total productivity killer for me. Consider looking at some assembly code in a simple editor: I’ve reproduced below a few typical lines (representative of, but not actually, real code), with column numbers and a vertical line just after the 32nd, 40th, and 64th columns.

|123456789 123456789 123456789 12|3456789 |123456789 123456789 1234|
|                                |        |                        |
|002 via2         equ $f200      |; base a|ddr of 6522, 16 regs    |
|003 vddrb        equ $02        |; VIA po|rt B data dir. reg.     |
|004 via2reinit4  sta via2+vddrb |; top ha|lf input, rest output   |

Now the TRS-80 does have fewer rows (16) than the other two (24), but especially when editing code you often “lose” at least some rows due to line wrapping. (This is a frequent and major problem for me in EDASM on the Apple II, and even to some extent in BASIC.)

And further, for situations where you do need to prioritize the number of lines over line width, you can always write some code to split the screen into two halves, giving you effectively a 32 column by 32 line display. That seems like a nice option to have.

I should probably also mention here that the TRS-80 and the Apple II required (relatively simple) hardware modifications to allow the display of upper and lower case (and, in the case of the Apple II, input of lower case). The PET included both from the start, but a bit of a mess with the character set: it actually had two sets, the correct one had to be selected to see lower case, and the upper case letters changed position between the two sets.


When it comes to the keyboard, the major loser of the three is obvious: that original PET keyboard is going to utterly destroy any hope of productivity. Who cares what characters it can generate if you can’t type on it? This was fixed in later years by introducing new models with the “business keyboard,” which would probably be the best of the three, but that’s not available in 1977 when we’re making our purchase.

Between the Apple II and the TRS-80, ostensibly the Apple II keyboard wins for the programmer. Neither has a full ASCII keyboard (the Apple II is missing [\_`{|}~, but the TRS-80 is additionally missing ]^ and ESC and, far worse, has no control key (though it does generate ^C with BREAK, I believe).

However, hiding underneath the covers is a key difference that makes the TRS-80 keyboard far more powerful. Unlike the Apple II, which has a keyboard generating ASCII characters via fixed hardware in the keyboard itself, the TRS-80’s keyboard is actually just a matrix of switches scanned by the CPU.

This is a major advantage because you can write your own code to scan the keyboard and remap the keys to whatever you wish. This is not terribly difficult: when you enable the line for keyboard scan you set a bit of the address bus corresponding to the row you’d like to scan and on the data bus will appear bits matching the keys in that row that are depressed.

There are some restrictions on what keys you can depress at the same time and still get correct scanning, but you can always distinguish any two keys, so this allows you to make any arbitrary keys into “alternate code” keys. The down arrow key is conveniently placed to the left of the “A” key and would make a good candidate for the control key.

So with just a bit of software hacking, the TRS-80 keyboard can generate the full ASCII character set. While the Apple II could be modified (via a fairly trivial hardware hack plus software) to generate lower-case characters, there was no easy way to get it to generate the full ASCII character set.

A secondary advantage (though perhaps not so important given my lesser focus on gaming) is that you can detect not just keys being struck, but their depression, hold and release. This is mainly useful for games where, e.g., you could move in a direction as long as the key for that direction is held down, and stop when the key is released, but it might be useful for other purposes as well.


Though cost wasn’t an object in the original post, it’s clearly important in real life. Even if you have enough money to buy any of the three computers, there’s always more to buy to expand your system, such as memory, a printer, an EPROM programmer, and the like.

The base price of the TRS-80, with 4K RAM, a 12" display and a cassette deck, was $600. That’s $200 cheaper than the PET 2001 (which came in the same configuration, with monitor and cassette) and more than $700 cheaper than the Apple II, which was $1300 before adding a monitor and cassette. (Though with the Apple II you could instead buy an RF modulator and use a TV, if you didn’t care so much about display quality).

Expanding RAM to 16K was probably about the same price for the TRS-80 and the Apple II. That would probably have been adequate for my earlier programming activities; remember, everything had to be saved to and loaded from cassette tape anyway. The Apple II could go to 48K and beyond in the chassis as it came, whereas the TRS-80 required a $300 expansion unit to go beyond 16K. But even here you end up paying less (still only $900 versus more than $1300 for the Apple II), not to mention that you get a floppy disk interface and parallel printer port thrown in. (Those would be an extra $200 on the Apple II.)


The Apple II and the PET used the MOS 6502 processor; the TRS-80 used the Z80. I must admit to a mild preference for the 6502, but that’s probably as much due to lack of programming experience with the Z80 as anything else. But with more registers and a larger instruction set, Z80 code is more compact than 6502 code, which would be a particular advantage in the early days of small RAM sizes (remember again, limited mainly by the practicalities of cassette storage). So while it doesn’t make a huge difference, the TRS-80 does come out slightly ahead here.


For graphics, the PET seems the worst of the three. The character set has a wider variety of graphical symbols than the other two, but the block graphic characters are 2×2, giving a resolution of 80×48. The TRS-80, with its 2×3 block graphic characters and more characters per line gives 128×48. The Apple is still the clear winner here, with 280×192 resolution on a monochrome monitor (but only 140×192 on a colour monitor), but graphics aren’t all that important to me if I have a good text mode, and having 64 characters across rather than 40 is much more important to me.

Disk Drives

There were no drives available for any of these machines in 1977, but we can look forward to see how things panned out for the three systems.

The Commodore had the most expensive and the slowest drives, due to the drive unit containing its own computer and using a parallel interface and custom protocol between the PET and the drive unit. (It wasn’t all that much slower, the way the VIC-20 and C64 were with their serial interfaces, but it wasn’t as fast as the computer controlling the drives directly, either.) Commodore did have one big advantage in schools and computer labs: you could connect multiple computers to a single drive unit and let them share the drives. But that isn’t of much consequence to the home computer user. A more serious problem might be that Commodore’s DOS was run on the disk drive unit, not in the computer, which greatly limits hacking opportunities. (E.g., it wasn’t practical to write your own filesystem in order to get one that was faster or had better resistance against hardware failures, or just was able to read diskettes from some other computers.)

The Apple II comes out 30% ahead of the TRS-80 in diskette capacity (114K vs. 88K) and is similar in price if bought from the original vendor. But the TRS-80 had an advantage in using standard drives. (Apple had a customized disk drive and standard SA-400 drives could not be connected to the Apple controller without some serious hardware hacking knowledge.) This gave the TRS-80 a slight advantage at the start if you were willing to buy bare drives and build (or buy) the cables and PSU yourself. And I think the TRS-80 would allow you to hook up 8" drives as well, if you were willing to write the software to access them. (The SA-400 5.25" drive used almost exactly the same interface as Shugart 8" floppy drives.)

Where the TRS-80 really came out ahead of the Apple, though, was in the DOS, at least early on. Apple’s DOS was rather a hack and the public API for handling files was to print Ctrl-D to the screen followed by a command for the DOS, and then have the DOS essentially pretend to be the keyboard and screen for input and output to a file. Ouch.


For a programmer, unless you have a strong interest in graphics, the better display, more flexible keyboard, and additional toys you could get with the cost savings made the TRS-80 the home computer to get in 1977 and beyond, if you couldn’t afford a “real” S-100 machine and a good terminal.


It was the ads for the Compucolor II that caught my eye back then.

A few years ago I loaded a TRS-80 emulation into an FPGA board and thought that something had gone wrong since it was so slow compared to 8 bit micros. I had forgotten that it was a very early Z80 machine, before the Z80A allowed 3.58MHz or faster computers.

Apple II floppies were quickly upgraded to 140KB (16 instead of 13 sectors per track). You had to replace a PROM in the controller which made it incompatible with previously recorded disks, though there was a software solution.

1 Like

The Model I’s 1.774 MHz Z80 in theory ought not be noticably slower than the 1 MHz 6502s used in its competitors. While the 6502 was significantly more efficient per clock cycle than the Z80, the minimum instruction time is still 2 cycles, and the paucity of registers and instructions in the 6502 didn’t help, either. (Consider that for a short (256 byte or less) memory move, the 6502 took 16 cycles or 15.6 μs at 1 MHz, whereas the Z80 took 21 cycles or 11.8 μs at 1.774 MHz even for moves over 256 bytes. That’s admittedly one of the more dramatic examples.) But maybe I’m missing something here.

That TRS-80 series increased to 2 MHz in 1980’s Model III, and 4 MHz with the Model IV in 1983. The Apple II series stayed at 1 MHz throughout its lifetime, unless you count the 1986 IIGS as part of the Apple II series.

Well, I don’t know if I’d call two years “quick,” but regardless, the TRS-80s were also upgraded over their lifetime. In 1980, the same year that Apple upgraded to 16-sector 140 KB format, the Model III was released with 180 KB drives, and larger ones continued to become available over time, supported to varying degrees by the various DOSes available for the TRS-80 series.

Not that anybody would know about this in the summer of 1978 when Apple and Radio Shack released their first drives. I suppose you might have guessed that Radio Shack machines had a better chance of growing larger and faster, since they used standard SA-400 drives instead of Apple’s custom drives.

The PET 2001 actually had a upper case/lower case character set! However, this came with a few peculiarities:

– You could switch character sets only by poking a hardware address (the Peripheral Control Register of the VIA), there wasn’t a key combination or a CHR$() code for this like on later models.

– Lower case was implemented “the other way round”, meaning, unshifted characters were still upper case, like with the upper case / graphics set, and lower case characters were achieved in combination with the shift key! (Since this is just a matter of the character ROMs, upgrades were possible.)

So technically, there was lower case, but operations were rather unusual and not what you expected for word processing. (Not that our 15-year old alter ego would have cared much about word processing …)

As we’re at it, I’m not sure, if all the mentioned features and restrictions were that clear in the beginning, especially for a 15-year old. E.g., the ortho layout of the keyboard may have been perceived as progressing to new times – “this is not a typewriter (I can’t touch type anyway), this is the keyboard of the future”. Also, since, most peripherals weren’t available yet, especially disk drives, the PET implementing a standard bus (kind of), may have been an argument. (Not that a 15-year old would have easy access to some pretty expensive HP equipment or the like.) And, while I do agree that 64 characters per line is the killer feature, I’m not sure, if a 15-year old would have cared for this that much (for games, vertical resolution does matter, but for games, the Apple II clearly takes the crown).

Nice analysis! When I went to college, there was one computer - infinitely many more than my secondary school - and it was a TRS-80, owned by some element of the student body. Oddly, I never used it, or even saw it. I think I felt a bit intimidated - it was in the basement of a building I wouldn’t normally have any reason to visit. (I’m in the UK, and Tandy outlets were everywhere - the TRS-80 would have been particularly easy to find, try, and buy.) Thinking about it, it’s a 1977 computer, and I’m talking about 1980, which says something about the rate of progress.

1 Like

Regarding 6502 vs Z80, I guess, this will be never sorted out completely. :slight_smile:

On the defense of the 6502, there are actually two ways of looking at it: Either, there are just three usable registers, or there are 256 of them (the zeropage) and three “super fast” registers. The difference is just a processor cycle (even faster than the processor stack) and the zeropage is special and required for some addressing modes anyway. (Zeropage addresses are as important for some operations as are the X and Y registers for indexing.) Which may justify looking at these locations as registers, like it is commonly done in the case of the auto-increment registers of the PDP-8.

Whoops! Yes; lower case was there from the start. I had gotten confused by the swapping of the two sets (shifted became unshifted and vice versa) between the first PET and subsequent models. I’ve corrected my post.

Actually, it seems to me it would have worked fine for word processing, and I certainly would probably have been interested. I learned to touch type at 13 (though I might not have learned so early had I not started playing with computers around then!) and would have been quite pleased to use a word processor for essays and the like.

That said, I know that the Apple II was fine for word processing as well; my mother wrote at least one of her books on a borrowed one (using AppleWriter), and felt it was superior enough to an electric typwriter that she eventually bought a Franklin. The Apple she used did not have a modification for lower case display (it displayed lower-case characters as upper case, and upper case as inverted characters) and I believe that it did not even have the shift key modification (one had to press ESC before a character you wished to be upper-case).

It now occurs to me, could the TRS-80 display inverted characters? I think not; the video RAM was only 6 bits wide without the lower-case mod. If not, it would be by a little margin the worst of the three for word processing, though the larger display (1024 characters instead of 960) would have been a minor plus.

True enough. There’s definitely a decent chunk of “based on what I know now” in my post. But given a hacker mentality and a basic knowledge of electronics (PIA + address decoding = WIN! :-)) I don’t see any particular advantage to the IEEE bus. In fact, it might have made it more difficult to build simple peripherals. But that didn’t matter on the PET anyway, as it also had the user port with half a PIA already wired up for you.

1 Like

Well, yes, I do take into account the zero page and its uses when I analyze this. (I’ve been doing a fair amount of 6502 programming lately.) But the issue with the zero page is it still requires another 2-3 memory loads (the ZP address from the instruction and the data itself from the ZP address(s)) over using a register in the Z80. So for your basic indexed load:

  • ld R,(hl): 7 clock cycles, 4 μs at 1.774 MHz.
  • LDA ($00),Y: 5 clock cycles, 5 μs at 1 MHz.

I reckon about as accurate as you’re going to get without having an actual program to benchmark is, “A Z80 at around 2 MHz is more or less the same speed as a 6502 at around 1 MHz.”

On the 6502 and the zeropage: I think, in the 1970s, when the PDP-8 and alike, which used fast memory for registers, were still the prevailing minis, it was quite natural to think of the zeropage as an entire page of registers. Now you have 256 of them! I guess, this must have been the original design idea, as well.
However, this is not how the zeropage was actually used. In actuality, these were all occupied by the OS and used as a fast storage facility. (Imagine MS BASIC using some Z80 registers to store the cursor position. :wink: )

Personally, I only realized this when programming for the Atari 2600 (VCS), where all the memory and all the device addresses are in the zeropage. Now, with the zeropage actually being available, everything is faster by 25% and a trip to memory isn’t that expensive. (However, the reasons for this are totally different from a mini. It’s not for memory access times, but for halving the addresses bytes to fetch per instructions, which is about the most expensive operation for a MPU.)

One factor not mentioned - reliability of the tape drive. The PET may have had a slow tape drive, but it’s also the only one which was pretty reliable. Besides the obvious factor of not using any random audio tape player, it also recorded everything twice - so missing bits from one copy’s playback could be filled in with bits from the second copy’s playback.

If I were making the decision back in 1977, I would not have known about that and I would have gotten a TRS-80. The SET/RESET commands for graphics would have been important to me, and I wouldn’t have known about the TRS-80’s finicky-ness with tape drives and connector ports and such.

Knowing everything I know now, I probably would have gone with the PET. Yes, the keyboard was awful. But with the amount of RAM I could have afforded at the time, I wouldn’t have been writing big programs anyway. And the command shortcuts might have helped with that. (At the time, the only one I used regularly was “?” for PRINT, though. But that was with a VIC-20, with its good keyboard.)

1 Like

I always had a soft spot in my heart for the TRS-80. Probably because it was the first computer I ever used. But the schools in my area used Commodore PETs, so I got to know both over time.

The PET did have a much more reliable tape drive, but that was because it was made for computer use, while the TRS-80’s tape recorder was an off-the-shelf one Radio Shack sold for regular voice usage. The main problem was with the volume knob. It had to be set just right in some cases.

I also found that the SET/RESET “graphics” to be much more useful than the PET’s graphic characters - at least for the programs that I was working on. While I did write games (like every teenager), I also used it to automate my math/science homework. The teachers simply insisted that they get a copy of the program that I wrote.

One thing that I did like with the PET over the TRS-80 was the program editing. You just LISTed the line you wanted to change, cursored up and over to what you wanted to change and pressed Enter. While on the TRS-80, you had to use what amounted to a line editor (which, interestingly, survived into GW-BASIC on the IBM). I remember this because I was just playing with my Tandy 1400LT and needed to make some edits on the Super Star Trek program.

But my TRS-80 Model 4P does see much more use than my C-64 - but that could be because of the amount of stuff I have to use to hook the C-64 up to a modern(-ish) VGA monitor.

1 Like

I think, I would have gone with the PET, falling for the idea of “well adjusted” components in a single unit. (In reality, these were pretty random, but they were still somewhat guaranteed to work in combination.) And I may have fallen for the futuristic looks, as well. On the other hand, the PET requires quite an amount of space, which may have been a real problem.

I’m a great fan of the 6502, and I like the simplicity, but the z80 has a big advantage in availability of native C compilers. I notice that CP/M will run on a TRS-80 Model 4, and there are several CP/M implementations available, but also there’s a relatively simple hardware modification for the Model I.

Oh, that’s a great page, and kind of gives a flavour of the level of hacking common amongst microcomputer owners in the late '70s, before the Apple II, TRS-80 and PET destroyed the community by letting all these non-technical people in. :-)

I note that they have a (switchable) speed upgrade on that site, to 3.548 MHz. Presumably this would require upgrading the CPU (I will go out on a limb and guess that the Model I did not include a Z80B); I wonder if the other hardware was up to it.

I hadn’t even thought about CP/M when writing my post, but yeah, when I first found out about CP/M I thought it was the bee’s knees. I never owned a CP/M system myself until the late '80s, but I used them via RCP/M BBSs, and they seemed so much more sophisticated than the Apple II. (Well, in several ways they were.) So yes, being able to run CP/M would have been a big bonus.

There were a number of modifications to do this, of which that one is the simplest. I was looking at one in 80 Microcomputing (I think) the other day that was a bit nicer: it used a hardware switch rather than a software switch so you could boot up normally, run a program and just automatically switch into CP/M land. It also did the ROM/RAM swap between $0000 and $C000, but if you were more serious about it I suppose you’d just add another 16 KB of RAM and replace the ROM at $0000 to get a full 64K system.

The Apple II as well could run CP/M, and more easily (if more expensively) at that, using Microsoft’s Z80 SoftCard. However that did have the disadvantage that you were stuck with a disk format entirely incompatible with any other CP/M system. (The soft-sectored, single-density, single-sided sector format used by the TRS-80 was writable by most CP/M systems with 5.25" drives, and of course the controller could be upgraded for double-density.)

The PET was the one left out there, though its descendants did get CP/M compatibility via a cartridge (C64) and built-in (C128).

The Z80 seems to have been very popular as an alternate processor on non-Z80 systems, I guess because of CP/M. The 6809-based Fujitsu FM-7 also has a expansion slot, slightly different from the other two, specifically designed for their Z80 processor board. (Though I have secret plans to build a 6502 board for that slot instead.)

Well, I was in this position as a 19 year old, but I went with the Atari 800.

And I went with the Atari specifically because of the graphics and sound chip set. (And Star Raiders, natch…)

If I were forced to choose between the Apple, PET and TRS-80, that would be a hard choice.

At the time, I was seriously thinking about the Model III. But clearly flashy graphics were of interest to me. I wasn’t looking for a word processor. The Apple’s were never compelling to me because I always felt they were too expensive. And whenever I interacted with them (outside of shoving in a Lode Runner diskette), I found them particularly inelegant. All the praise the Apple gets for its hacks and such definitely show it as a bunch of hacks stacked upon each other.

I spent 3 years on the PETs in high school, and I certainly liked the machine. We made our miserly 8K machines jump through hoops. We had stacks upon stacks of 5m computer cassettes for programs we wrote. I even wrote a grade book application for a teacher (that saved the file on to its own tape!). But the keyboard was off putting when it came to get something of my own. I loved the crispness of the B&W (or B&G) monitor. The C64 was not out yet, and the VIC was completely underwhelming with its huge characters and small screen.

In contrast to all of these, the Atari was a real wonder with it’s custom graphics and sound chips, with its internal operating system and extensible device handlers. It was all designed at once with no legacy to hold it back at the time, rather just simply engineering and cost limitations.

For some reason at the time, the OSI boards were captivating me. I spent many moment staring at magazine ads and such. But, in hindsight, perhaps something was lost, but, “what was I thinking”. Those machines weren’t in the same league as these 3 (or 4) were.