256 Bytes to 640 Gigabytes: Fifty Years of Memory, in Constant Dollars

The first computer I built from a kit had 256 bytes of memory. Not kilobytes: bytes. It was a Netronics COSMAC ELF II, an RCA 1802 on a board with a hex keypad, and the first thing I bought for it was more memory. The biggest machine on my bench today, a refurbished rack server, has 640 gigabytes. This post is the road between those two numbers — what the machines I used had, what a megabyte cost along the way in the money of the day and in constant dollars, and how long an access took — and then a separate look at the embedded boards, where memory still comes in four distinct sizes.

Resource	Link
Price data	John C. McCallum’s memory price series, as mirrored and extended by the memory-index project and AI Impacts
The last year	DDR5 up fivefold in a year · server modules fivefold in ten months · a 32 GB kit at $429 · why: HBM for AI
Inflation	BLS CPI-U annual averages via the Minneapolis Fed
The machines	ELF II · TRS-80 Model I · IBM 5100 · IBM 1130 System Summary · IBM 1800 · IBM PC · Expanded memory · IBM 3090 · RS/6000 SP
Earlier posts	TBT #13: timelines of the tools · IBM 1130 emulator · TBT #8: BASIC on the TRS-80
Comments	Discord

On the numbers. Machine sizes are the configurations I used or the documented maximums, as labeled; the refurbished machines are dated by when I acquired them, with the hardware’s year in the table. Prices are McCallum’s lowest quoted price per megabyte for each year, in that year’s dollars; the 1978 point is my own purchase. Constant dollars use CPI-U annual averages. Access times are typical for the technology of the year, not a measurement. Hover a point for its source line.

How much

The ELF II shipped with 256 bytes, in two RCA static RAM chips, and ran from a hex keypad and eight LEDs. Netronics sold a 4K static RAM expansion card for it — $89.95 in the 1978 catalog, when the whole kit was $99.95 — so the first upgrade I ever bought cost nearly as much as the computer and multiplied its memory by seventeen. Netronics sold 4K and 16K cards; I bought the smallest one on offer, and if a 1K card was ever sold I bought that, because it was cheaper. The price on the chart below is the 4K card’s. The bus could take cards up to a theoretical 64K that nobody I knew reached. The mainboard had an expansion bus that looked like S-100 and was not; the cards were Netronics’ own.

The TRS-80 Model I, from the same couple of years, came with 4K in the keyboard unit and could take 16K there; the Expansion Interface, the box the monitor sat on, added two more banks for 48K total. The Model III did the same inside one case. The IBM 5100 family I used from 1977 to 1981 came in 16K, 32K, 48K and 64K models, and those were bytes: the 5100’s 16-bit address bus topped out at 64 KB, and the 5110 and 5120 kept the same ceiling.

The IBM 1130s I installed and repaired were the other direction: core memory, counted in 16-bit words. The 1131 came as 4K, 8K, 16K or 32K words, so a well-equipped one had 64 KB of core in a machine the size of a desk. The 1800, its process-control sibling, went further: 4K to 32K words of 18 bits in the standard models, and a maximum of 64K words with the storage extension, about 128 KB. Those numbers mattered because core did not forget when the power went off; the 1130 at a customer’s site kept its program through the weekend.

The IBM PC started at 16 KB or 64 KB on the motherboard in 1981 and hit the 640 KB wall by 1984. The way around it came in 1985, Lotus, Intel and Microsoft’s Expanded Memory Specification, which bank-switched up to 8 MB through a window in the top 384 KB; extended memory above 1 MB followed with the 286 and the XMS specification in 1988. The mainframes I worked on in the 1980s were a different world, though not as different as people assume: the 308X system I worked on first, a 3083 or 3084, had 4 MB, in a family that ran to 32 MB; later I had half of a partitioned 3090 Model 200, a 64 MB machine, so 32 MB was mine; the top 3090s of 1988 reached 512 MB. In 1996 I worked on an RS/6000 with a gigabyte, which was a number people came to look at; the SP wide nodes of those years took 1 or 2 GB.

Then the curve goes vertical. A 2016 laptop had 16 GB; the refurbished M1 Max MacBook I write this on has 64 GB, unified, so the GPU draws on the same pool. My largest systems now are refurbished: a Dell T7910 workstation with 576 GB, bought in 2024, and this year an HP DL380 Gen10 Plus 2U server with 640 GB. A DL380 with Intel Optane Persistent Memory 200 modules could go past 2 TB, and is in the cube figure below for that reason. The whole first table in one figure:

Each dot is a machine I used, at the memory I had or the maximum the model took, placed at the year I first used it; the refurbished machines at the right are older hardware, dated by when they reached my bench. The axis is logarithmic: every gridline is a step of 4 to 32 times. Hover a dot for the detail.

Year	Machine	Memory	Note
1977	IBM 1130	4K to 32K words of core	16-bit words; 8K words is 16 KB
1977	IBM 1800	4K to 32K words, 64K max	18-bit words with parity and protect bits
1977	IBM 5100, 5110, 5120	16 KB to 64 KB	bytes; 64 KB is the 16-bit address limit
1978	Netronics ELF II	256 bytes	RCA 1802; 4K and 16K static RAM cards
1978	ELF II + 4K card	4 KB + 256	$89.95 for the card, $99.95 for the kit
1979	TRS-80 Model I	4 KB to 16 KB	in the keyboard unit
1980	TRS-80 + Expansion Interface	48 KB	two more 16K banks in the Interface
1981	IBM PC	16 KB or 64 KB	640 KB with expansion cards
1985	PC + EMS	8 MB expanded	bank-switched through a 64 KB window
1983	IBM 308X, a 3083 or 3084	4 MB	the family ran to 32 MB
1987	IBM 3090 Model 200	64 MB, my half 32 MB	a partitioned machine; the top 3090s reached 512 MB
1996	IBM RS/6000	1 GB	SP wide nodes took 1 or 2 GB
2024	Dell T7910 workstation	576 GB	2016 hardware, refurbished
2026	M1 Max MacBook Pro	64 GB unified	2021 hardware, refurbished; CPU and GPU share it
2026	HP DL380 Gen10 Plus, 2U server	640 GB	2021 hardware, refurbished; the biggest on the bench

Logarithmic axes hide how big these numbers are. So, with apologies to xkcd: let 4 KB, the card I added to the ELF II, be a cube one centimeter on a side, a sugar cube, and build everything else out of sugar cubes. The 256 bytes I started with is a sixteenth of one.

One sugar cube is 4 KB. The ELF II's 256 bytes is a 4 mm chip off one. The PC's 640 KB is 160 cubes, a block 5 cm on a side; a 1990s PC's 16 MB is 16 cm, bigger than the mug. Then the zoom: the 1996 gigabyte is a 64 cm cube, up to your waist; the M1 Max's 64 GB of unified memory is 2.6 m, taller than the room; the server's 640 GB is 5.5 m on a side, a two-story house; and 2 TB, where a persistent-memory server could go, is 8 m, the house to its ridge. Side of each cube is the cube root of bytes over 4,096, in centimeters.

What it cost

“Never under $100.” Around 1980 an IBM architect and I were talking about the new hobby computers, and I said I hoped prices would keep falling until there was a $100 PC. He was adamant: the power supply alone will never be under $100. The mechanical keyboard alone will never be under $100. He did not need to get to memory, the CPU or the disk. Today the power supply is a $5 USB charger, the keyboard is $8, a display is $15 to $25, a $25 ARM or RISC-V board carries 32 to 256 MB of RAM, and a 256 MB SD card is $5 — about $60 for the lot, or the same money for an assembled LilyGo T-Deck, an ESP32-S3 with a keyboard, screen and LoRa radio. And $100 in 1980 is over $400 today, which is the price of an entry-level laptop, a Chromebook, or a smartphone, if a virtual keyboard is allowed.

The price line is John McCallum’s series, the lowest quoted price per megabyte each year, and it says the same thing for fifty years: a factor of ten about every five years until 2010, and much slower since. My ELF II card sits right on it. $89.95 for 4 KB is about $23,000 per megabyte in 1978 money. By the time I bought PC memory in the mid-1980s a megabyte was a few hundred dollars; in 1995 it was $30, and the next year, when I had the gigabyte workstation, about $7, which still made that gigabyte a $7,000 proposition before the machine around it. In 2024 a megabyte cost three tenths of a cent. Then the line turned around, for the first time in the series, and the green stub at the right end of the chart is that story; it gets its own section below.

The orange line is the same prices restated in 2026 dollars. It tells the same story a little steeper at the start, because a 1978 dollar was worth about five of today’s.

Price per megabyte of RAM, McCallum's series with my 1978 card added. Blue is the dollars of the day; orange is the same prices in 2026 dollars. Both axes are logarithmic.

The last year: five times

For fifty years the only direction on that chart was down. In 2025 and 2026 it went up, hard. A 32 GB DDR5 kit that cost about $90 in the summer of 2025 cost $429 to $500 a year later; server-grade 32 GB DDR5 RDIMMs went past $2,000, more than fivefold in ten months. The cause is not a shortage of fabs but a change in what they make: Samsung, SK Hynix and Micron moved capacity to high-bandwidth memory for AI accelerators, which earns more per wafer and uses about three times the wafer area per gigabyte, and ordinary DRAM got what was left. Micron has said the squeeze lasts into 2028. On the log chart it is a small green stub, because the axis spans seven orders of magnitude; on a monthly budget it is the difference between a $90 upgrade and a $450 one, and the first time in my career that waiting a year made memory cost more.

The constant-dollar question is more interesting asked the other way: what did a megabyte cost in the money of a particular year of my career? Here are six years of prices restated in 1977, 1985, 1995 and 2016 dollars.

Year	Nominal $/MB	in 1977 $	in 1985 $	in 1995 $	in 2016 $
1978	$23,027	$21,403	$38,002	$53,824	$84,763
1985	$385	$217	$385	$545	$859
1995	$30.00	$11.93	$21.18	$30.00	$47.24
2005	$0.1300	$0.0403	$0.0716	$0.1014	$0.1598
2016	$0.0030	$0.0008	$0.0013	$0.0019	$0.0030
2024	$0.0029	$0.0006	$0.0010	$0.0014	$0.0022

And what a fixed sum bought. The second column takes the $89.95 I paid for 4 KB in 1978, converts it to each year’s dollars, and spends it on memory at that year’s price:

Year	What $100 bought	What the 1978 card’s $89.95 buys, in that year’s money
1978	4.4 KB	4 KB
1985	266 KB	395 KB
1995	3.3 MB	7.0 MB
2005	769 MB	2.0 GB
2016	33 GB	108 GB
2024	34 GB	146 GB

How fast

Speed moved less than size or price, and that gap is most of what computer architecture has been about since. The 1130’s core cycled in 3.6 microseconds. The ELF II’s static RAM answered in a few hundred nanoseconds, and the IBM PC’s DRAM in about 200, roughly its clock period. By 1990 DRAM was at 80 nanoseconds, by 2000 around 50, and then the access time of the memory array itself stopped moving much: DDR3, DDR4 and DDR5 all sit near 13 to 15 nanoseconds of latency, with the bandwidth climbing instead. Persistent memory trades some of that back: Optane PMem answers in a few hundred nanoseconds, slower than DRAM and a thousand times faster than a disk, which is the whole reason to have it.

Typical access time for the memory technology of each machine, log scale. Three orders of magnitude in fifty years, against nine for capacity and seven for price.

The embedded boards: four sizes, not one line

The boards on my bench now do not belong on the chart above, because they are not one line. They come in four distinct classes of memory, and which class a board is in decides what it can run far more than its clock speed does.

Class	Memory	Boards	What fits
Tiny	under 512 KB of SRAM	Arduino Uno, 2 KB · Arduino Mega, 8 KB · Arduino Due, 96 KB · ESP8266, about 160 KB · Raspberry Pi Pico, 264 KB · ESP32-C3, 400 KB	a program and its state; no heap to speak of
Small	512 KB to a few MB	ESP32, 520 KB SRAM plus up to 8 MB PSRAM · ESP32-S3, 512 KB plus 8 MB PSRAM · COR24-TB, 1 MB SRAM	an interpreter, buffers, a small language runtime
Medium	32 MB to 512 MB	Luckfox Pico, 64 MB · Milk-V Duo, 64 MB · Milk-V Duo 256M, 256 MB · LicheeRV Nano, 256 MB · Milk-V Duo S, 512 MB · Raspberry Pi Zero, 512 MB	Linux, a shell, a language and its libraries
Large	1 GB to 16 GB	Raspberry Pi 2 and 3, 1 GB · Atomic Pi, 2 GB · Raspberry Pi 4, 1 to 8 GB · Raspberry Pi 5, 2 to 16 GB	a desktop, a build, a small model

The tiny class is the ELF II’s world with better tools: the Uno’s 2 KB is eight times my first kit and a quarter of the TRS-80 I had next. The small class is where the COR24-TB sits, a megabyte of SRAM in an FPGA, which is more than any machine in the first table had until the PC’s 640 KB wall and enough to run an APL. The medium class is the 1980s mainframe in a board the size of a stick of gum: the Luckfox and the Duo have sixteen times the 4 MB of the 308X I worked on in 1983, and the Duo S has as much as the 3090 I shared. And the large class, the Pis, run past the 1996 gigabyte workstation on the low end and reach a 2016 laptop at the top.

What the fifty years say

Three curves, three different slopes. Capacity went up nine orders of magnitude, from 256 bytes to 640 gigabytes. Price per megabyte fell seven, from $23,000 to a fraction of a cent, and in constant dollars a bit more. Access time improved by about three, and then stopped, which is why every machine since the 1990s has been mostly cache. The embedded table is the reminder that all four of those eras are still for sale, at the same time, for under fifty dollars each — and that choosing a board is choosing which decade of memory you want to program in.

And the last year adds a fourth slope, pointing the wrong way. For my whole career the right answer to a memory problem was to wait: the next machine would have more, cheaper. Programs were written on that assumption, and so were languages, runtimes, frameworks and browsers. If a megabyte now costs five times what it did a year ago and the people who make it say that holds until 2028, the assumption is off for a while, and the skill that the 256-byte ELF II, the 4K core 1130 and the 2 KB Arduino all demand — knowing what every byte is for — is worth having again. Maybe we should be more efficient with memory, again. The tiny and small boards in the table above are a good place to practice, and an array language that keeps a whole computation in a few typed arrays is not a bad one either.