In nearly all the assembly source files and published listings I read up to the early 1980s, the labels, mnemonics, and operands were written in all uppercase. Just a few years later, I noticed 80x86 code was mostly in all lowercase, as well as later code for other CPUs. By that time, all uppercase code seemed to have disappeared.

When did the switch to all lowercase assembly happen? Were there any specific CPUs or platforms that introduced or popularized this style?

  • 3
    While looking through the sources for classic Atari games, I noticed that they used upper case for all of the code and line-end comments. However, some of the longer comments are mixed case, in areas where whole lines are excluded. Example: github.com/historicalsource/missile-command/blob/main/COIN65.XX
    – fadden
    Commented Jan 30, 2022 at 15:54
  • 20
    As soon as it was available and convenient in whatever environment. But there was a history of writing assembly code in all upper case: a lot of code was written on the ASR-33. So, some assembly code would have used lower case when available devices started to conveniently support lower case, but some people still write assembly in all upper case yet today.
    – Erik Eidt
    Commented Jan 30, 2022 at 19:16
  • 29
    Your timeline seems to coincide with when computers gained lowercase letters, maybe that's your answer?
    – Glen Yates
    Commented Jan 30, 2022 at 21:14
  • 4
    @RonJohn: On many high-end line printers, depending upon the contents of the installed printing chains, lines which contained only uppercase letters, digits, and a few common symbols would print much faster than lines which contained lowercase letters or less common symbols. I don't remember the precise details, but if a printer's chain had eight sets of the digits 0-9, dollar sign, period, comma, parentheses, plus, minus, slash, and asterisk spaced around it, along with sets copies of A-Z and some more punctuation, and one set of a-z and everything else, then the printer could...
    – supercat
    Commented Jan 31, 2022 at 0:58
  • 9
    For me it was ~ 1984. I had a course in Univac 1100 assembler. Everyone was using UPPER CASE. I discovered the newer version of the assembler that handled mixed case. Asked the professor - "sure, you can use it" and I did. Commented Jan 31, 2022 at 3:48

12 Answers 12


It changed when people learned that a) they HAD lowercase, b) typing in uppercase is a pain in the neck, c) that it doesn't matter what case it's in.

It's just the natural progression as capabilities expanded.

Simply someone started and said "What the heck am I doing this for?".

The earliest published example I could find (through a non-exhaustive search) was for a Z80 routine published in Dr. Dobbs in Oct of 1981.

That said, I'm pretty sure when I was doing assembly back in the early 80s, I, too, used uppercase "because assembly".

But, yea, typing in upper case is a pain in the neck, frankly. Especially since I haven't had a CAPSLOCK key in 15 years.

  • 12
    "I haven't had a CAPSLOCK key in 15 years." Indeed, I reassign the caps lock key to control, because it's in a better location than the control key on most keyboards, I never use caps lock, and I use control characters a lot.
    – DrSheldon
    Commented Jan 30, 2022 at 18:39
  • 26
    I'm not sure your personal choice of not having a CAPSLOCK key should be relevant for the general public. With one, typing lowercase or UPPERCASE requires the same effort. Did computers of the time have a CAPSLOCK key? Commented Jan 31, 2022 at 7:50
  • 6
    If a given monitor/assembler required commands to be in uppercase, they would have been configured so that they automatically appeared that way upon entry, without the need to use the Shift key. Manually entering commands in uppercase would have been required only if you were typesetting them for publication—but even then, CapsLock keys have been around forever, notwithstanding the fact that you in particular choose to remap yours.
    – Psychonaut
    Commented Jan 31, 2022 at 9:45
  • 6
    Up until the 1980s much assembler development was done using ASR-33s or mainframes with a limited character set. I remember changing the default for a lab full of networked machines I looked after in about '85. There was a consensus that upper-case letters tended to be more rectangular in order to fill the available per-character bitmap, and that lower-case letters were easier on the eyes since their shape was more varied. Commented Jan 31, 2022 at 11:26
  • 4
    WHen I started computing in the late 70's, terminals and printers with lowercase capabilities were significantly more expensive. And some operating systems didn't have good support for lowercase.
    – Barmar
    Commented Jan 31, 2022 at 16:50

I guess there is no straight answer, as it's a fuzzy move spread across a long time, many machines, OSes and applications. Also, with each generation, systems usually start out with only one case. If restricted to a single case, western (Latin) cultures used to fall back to Roman times by using upper case only (*1).

When did Assembly code begin being written in lowercase?

I guess the most important point has already been touched by Will's answer:

  • When they finally had lower case, and
  • when assemblers started to be case-insensitive.

Both of this depends on hard-/software development, including the adoption of codes providing lower case at all and OS input routines no longer uppercasing everything entered by default. Development varied on machines, thus there is no specific point in time.

But there are maybe a few additions more to habit and psychology.

  • On a mainframe side, using upper-case remained supported by (optional but default) automatic conversion. (*2)
  • People continued with upper-case this out of habit, but also as
  • Upper case was considered 'proper'.

Then there came along a generation of programmers that first used the lowest cost devices possible - teletypes - and thus got used to the look - except to the computer, everything typed was upper case.

This generation of systems, nowadays mostly summarized as 'Minis', 'felt' several issues:

  • Default code sets were capable of upper and lower case.
  • The landscape was rather non-homogeneous, that is all lower terminals, all upper and dual case were used at the same time.
  • There was no fine chiselled OS-I/O structure unifying input.
  • There was no room for large intermediate layers.
  • Software development was decentralized and quite fast or ad hoc.

As a result, input files came in whatever case typed. Without central conversion in file upload or storage, programmers added internal case conversion to their Assemblers (*3). As a result, files not only stayed the way they were created, but also all output showed the verbatim input, not converted to upper-case like before.

Overall it was a process repeated with each new field computers reached, as early Micros showed the same limitations that mainframes and Minis had when being introduced: only caps. Just take the 'big three': TRS-80, Apple II and Commodore PET. They all started out in upper case.

  • Apple saved on character generator; lower case could only be added as hack. (*4)
  • Tandy saved as well, but sold a lower case mod soon.
  • Commodore could be switched into lower case mode, but would lose its graphics abilities in turn.

It wasn't until the mid 80s that lower case was really hassle-free on all common platforms - and the overwhelming number of them being Micros, running on software ported from, or at least inspired by, Minis (*5).

In some way it marks a generation shift, as everyone after that could use a case-insensitive Assembler without any pressure to use upper case; they simply did it, never learned different and the world moved on.

In fact, the mid/late 80s also mark the moment in time when this development in turn influenced the 'old' world of mainframes. It was around that time that mainframe assemblers started to allow bells and whistles unheard of before ... like

  • Label names longer than 8 characters,
  • Heck, at some point even variable length and even worse
  • Introduction of (optional) case sensitivity

Well, the new generation got its will, even on old iron :))

*1 - Lower case letters were added rather late, starting around the 4th century and only in handwriting. It wasn't until the 8th century that "Minuscules" looked mostly like we know them today.

*2 - That means, any input was turned into upper case processed and outputted as such, so all seen was upper case, regardless how it was inputted.

*3 - A mode nowadays called case-insensitive :=)

*4 - A seriously odd hack. Input-wise it involved connecting the shift keys to one of the game inputs, while output was handled by using Inverse characters as upper case and regular ones as lower - all still using upper case glyphs. Sounds weird, is weird, but after some time one gets used to it and it feels fine. That is until using a different computer again. :))

*5 - By then the percentage of programmers of mainframes or even minis started to become invisible compared to the all present desktop micro.

  • 9
    "Mixed case" -- the DEC VT05 was a nasty contributor to this. Upper-case only display, dual-case input. So you might have no idea which case you were using. The assembler didn't care. Editors did. ("I can see the damn line, so why can't the editor find it?")
    – dave
    Commented Jan 30, 2022 at 19:16
  • 8
    Back in the day, on the PET, I used lower case to make the program look "more professional". Mind, by the same token, I made a routine to print strings at "300 baud" so it would look like "a real computer". So, just shows where my head and perceptions were at in times past. Commented Jan 30, 2022 at 22:50
  • 3
    "Just take the 'big three': TRS-80, Apple II and Commodore PET. They all started out in upper case." This is the big one - people are lazy. If caps come out by default then people will type in caps. If lowercase comes out by default then people will type in lowercase.
    – J...
    Commented Jan 31, 2022 at 19:32
  • 3
    Instead of paying $100 (later $60) to Radio Shack for the lowercase kit, you could piggyback one more RAM chip onto one of the existing ones, jumper one or two leads from the chip to the board, and Do It Yourself for $10 or so. I miss that kind of hackability. I guess the millionfold performance improvement has been worth it, though.
    – jeffB
    Commented Jan 31, 2022 at 19:56
  • 1
    @Raffzahn: I think I may have a hypothesis: some programs from that era, including Tawal's Last Redoubt (which I played back then), install a character-output driver that renders mixed-case text on the hi-res screen. I wonder if I might have been in graphics mode without realizing it when I'd earlier confirmed that PRINT CHR$(97) would output a lowercase a?
    – supercat
    Commented Feb 1, 2022 at 21:17

It depends on the local culture. If you look at man pages from 1st or 2nd edition Unix, then it appears they always did use lower case. On the other hand, in DEC we tended to write in upper case.

There are two drivers for this as far as I can see: (1) the I/O devices you have available, and (2) the code you've been exposed to. I wrote MACRO-11 in upper case because all the MACRO-11 I read was written in upper case. I don't even recall whether the DEC assemblers were case-insensitive; probably they were.

In short - I dispute the notion that there was 'a time' when this happened.

P.S. Come to think of it, I also wrote BLISS in upper case (the compiler didn't care), simply because all the BLISS code I read was in upper case. You can perhaps regard this as adhering to convention for the sake of readability: today, I use Java conventions for Java, Python conventions for Python, etc.

  • 1
    Re "...they always did use lower case": And we still suffer to this day. Commented Jan 31, 2022 at 16:31
  • On UNIX the convention was to use lowercase, and if you had an upper-case only terminal it would convert everything to lowercase on input and back to uppercase on output, using backslash to get "real" uppercase. Linux still supports the XCASE terminal mode for doing this, though it was removed from POSIX.
    – Chris Dodd
    Commented Aug 23, 2023 at 0:12

Just guessing here, but the answer might be related to whether the typical input method (punch cards, teletype, video terminal, typing code using the built-in keyboard and character generator) for editing or entering assembly language code into a system defaults to UPPERCASE, or is even limited only to such representation of text. Ditto for printers used for printing out the program code listings.

For instance, the Commodore PET boots up in a mode which only allows uppercase characters. Granted, you can switch to an alternate character set which allows mixed case but at the expense of losing access to many block graphics characters (see PETSCII). On such a system, programming in uppercase is the natural default.

Conversely, programming would be awkward on a system which defaults to lowercase (mixed case) if the assembler or machine code monitor only accepted uppercase mnemonics — that is, if the programmer were required to constantly hold down the Shift key or keep the Shift Lock or Caps Lock function enabled while editing the code. On such a system, programming in lowercase is the natural default.

Computers started out as programmable number-crunching, code-breaking, data processing, simulation, and automation devices. For such purposes, all-caps text is sufficient. The glorified typewriter thing (word processing) only came later, and was perhaps the first application that actually required implementing lowercase?

The uppercase/lowercase usage in program code listings likely reflects these developments.

  • 1
    In the days before people were concerned about being able to interchange data among different computers, PETSCII was a clever approach to not only making it possible to use a bigger range of graphics characters than would be otherwise be possible, but also avoiding the need to use caps-lock when feeding data to programs that expected uppercase ASCII codes and had no idea that lowercase even existed.
    – supercat
    Commented Jan 31, 2022 at 23:56
  • 1
    re Conversely, programming would be awkward on a system which defaults to lowercase (mixed case) if the assembler or machine code monitor only accepted uppercase mnemonics. In my experience, this is not true. The average terminal that has lower case "defaulted" to lower case (i.e., shift/caps lock needed for upper case), and yet we wrote assembly code in upper case. Having the caps lock key engaged was not particularly inconvenient - press it once when you started editing your code.
    – dave
    Commented Feb 1, 2022 at 13:09

RT-11 Realtime PDP-11 Operating System:

All code was written in MACRO-11. A short experiment of writing some of the utilities in C freaked out the attorneys and was stopped.

As of 1979, all source editing was done on VT100s or better, which readily handled cased input and display. Printers were capable of displaying both cases. Some still did compressed descenders to save a couple of pins in the print heads. (Incidentally, compressed descenders have reappeared in my Jeep's instrument and Sirius-XM radio displays – UGH!)

As RT-11 architect (in the 1980s and early 90s), I introduced a concept I called semper shiftus. The maximum MACRO-11 symbol was 6 characters long. It was case insensitive because it was converted to rad50 (don't ask), which was stored as uppercase. However, the visual representation of a symbol could have 6 bits of information added by using camelcase. The cases of individual letters could give more clues about the meaning of the name.

For instance, PMTBLK, when displayed as pMTblk, could more easily be understood as "pointer to empty block".

This concept was not accepted with universal joy.

  • Despite not really answering the question, it did a great job putting an incredible wide smile on my face - especially the 'joyful' part. Thanks :))
    – Raffzahn
    Commented Jan 31, 2022 at 4:07
  • 4
    RAD50, or "so who says a character has to have an integral number of bits, anyway?".
    – dave
    Commented Jan 31, 2022 at 14:31
  • For non-DECies, 50 characters was sufficient: 32 upper-case alphabetics, 12 decimal digits, space, dollar-sign, dot, and one other that tended to be OS-dependent.
    – dave
    Commented Jan 31, 2022 at 23:16
  • 1
    Sure: 0 1 2 3 4 5 6 7 8 9, count 'em: 12.
    – dave
    Commented Feb 1, 2022 at 15:08
  • 3
    RAD40 only stored 26 upper-case alphabetics, 10 decimal digits, space, dollar-sign, dot, and one other that was OS (or application) dependent. (Rad40 was for those who thought in decimal (i.e. those who thought their thumbs were fingers)).
    – jfwfmt
    Commented Feb 1, 2022 at 21:24

Back in the 1970s, most line printers only did upper case. Some had lower case, but the longer print chain slowed them down considerably. So you couldn't rely on all printers having lower case, so you only used it occasionally.

Moreover, until the late 1970s you'd be lucky to have an input device that did lower case. Punched cards were upper-case only. So were teletypes. I typed (and edited, and printed out) my PhD thesis in 1975 using a paper-tape device called a Flexowriter, but they were expensive and scarce (I used them at night when the queues were shorter).

Lower-case started to become widely available around 1980, with the advent of VDUs and dot-matrix printers. It probably affected assembly programming rather later than most things because when you're dealing with short instruction names like ADD and SUB the readability benefit from lower-case is rather marginal. Certainly I was programming in assembler from 1977-1982 and it never occurred to us to use lower-case, even if it was becoming possible.

Incidentally some of my colleagues who wrote assembler were quite slow to move off punched cards. They found that inserting and removing cards from a deck was an intuitive way of editing an assembly-language program. Probably says something about the quality or performance of the interactive editors available at the time.


From personal experience, I started programming in assembler on a BBC micro in 1982. The documentation at the time used upper case, probably for historical reasons but perhaps to make it easy to identify code vs English text, so I did the same until I found out by accident that lower case was also valid. I tended to use upper case though because my teletype couldn’t print lower case characters as upper case even though it had an 8-bit paper tape punch. In later years, using lower case by default allowed the regression to camel-case, once the programming community had got used to using variable names of more than one character.

  • 2
    I had a similar experience. Since I touch type, I didn't look at what I was typing and had a whole load of code in lowercase. Only realized what I had done when the assembler picked out a syntax error. I still prefer using uppercase for assembler
    – cup
    Commented Jan 30, 2022 at 22:31
  • 1
    I think you mean "regression to camel case" :-)
    – dave
    Commented Feb 1, 2022 at 13:11

The PDP-1 computer from DEC built in 1960, used lower case for Assembler. I seem to recall that upper case was used for some special purpose, like referencing a macro parameter.

You can see some PDP-1 assembler for the Spacewar program here


There was, once, a compelling reason for all programs to be written in all-caps: not all computers have always supported lowercase. This convention stuck longer for the languages that were typically used on those machines. In particular, Intel 8086/8088 assembly code was designed to be similar to 8080 assembly code, and some of the original microcomputers with an 8080 or Z80 CPU, such as the original TRS-80, did not have lowercase. You also see it with languages that were originally used on mainframes, such as Fortran and COBOL.

The shift seems to parallel the transition, circa 1980, from uppercase keywords in languages such as Fortran and Algol to lowercase keywords. Most older languages that started out with keywords like BEGIN and END also accepted begin, rather than reject programs where the intent was obvious. Then, newer languages made those the default, or even mandatory. C, designed on minicomputers of the early 1970s without already-obsolete mainframes or early 8-bit microcomputers in mind, was one of the first major languages to only accept lowercase keywords.

I have the impression that this became a stylistic choice. lowercase was the newfangled way to program, ALLCAPS the old-fashioned way, and only someone with a dinky little computer would need it. But it was probably mostly a matter of convenience. Once programmers switched from card punches to keyboards, lowercase was easier to type.

  • 3
    Algol 60 the language never had "upper case" keywords. Some implementations did, but not the ones I used. On KDF9 paper tape, for example, the keywords were made from underlined lowercase letters, identically to the reference language. Any decision about upper case keywords was taken by the implementer. Algol 68 did have upper-case stropping as one of the suggested means of representing bolded characters (in 68, not just keywords, but other indicants too) but in that case, no pun intended, you were very much in mixed-case land -- INT and int were syntactically different entities.
    – dave
    Commented Feb 1, 2022 at 15:24
  • 1
    I remember that the Research Machines 380Z running CP/M would have caps lock on by default, and I think that may have been the case for the BBC micro too, so the idea of programming in upper case certainly continued well after lower case was supported.
    – Frog
    Commented Feb 1, 2022 at 19:33
  • @another-dave, Algol60 had no "keywords in (any) case", they were separate symbols. Algol60 was designed as a literary language, not really for computer implementation. Different Algol compilers handled "keywords" differently, e.g. all caps, 'in apostrophes', as keywords (like newer languages), ...
    – vonbrand
    Commented Feb 2, 2022 at 23:14
  • 1
    I am aware of Algol 60 terms (indeed, the machine I used equated each Algol basic symbol to one 8-bit value, i.e., procedure was a single "character" on this machine, as stored in an on-disc Algol 60 source program). I was following the terminology of this particular answer. I obviously disagree with the "not really for computer implementation", since for several years it was my primary programming language on several different computer systems.
    – dave
    Commented Feb 2, 2022 at 23:36
  • No, it's not a stylistic choice. Using lower case allows to use numbers at the same time on modern keyboard layouts without the need to press a shift key. That's not possible, if you use upper case letters. With uppercase you either always have to press the shift key as well, which is inconvenient, or you activate Caps Lock, but the number keys are no longer available in Caps Lock mode, to use them you would have to switch this mode off again. But digits are often required in programming. So it makes sense to write most of the code in lower case because it means fewer keystrokes.
    – Coder
    Commented Aug 20, 2023 at 2:03

In the late 60s when I learned assembly (first for a Honeywell 200, an IBM 1401 clone more-or-less, and then the GE 635) we submitted our programs on punch cards, which had only uppercase. Not too long after Dartmouth Time Sharing went live on the 635, a fellow student wrote a macro assembler which ran (and stored our code!) on the time sharing system, letting us get rid of the punch cards.

Nevertheless, our terminals were model 33 and 35 teletypes. Again, only uppercase. And, of course, the line printer also had only uppercase.

As I remember, and I could be wrong, even the early CRT terminals I first encountered in grad school on Decsystem 10 circa 1972 were upper case only. But we did have a primitive WYSIWYG editor, written by one of our professors. Night and day in terms of productivity, but still not particularly pretty.

I wish I could remember when I first saw a terminal with lower case, but I can't.


It may be worth noting that in the early days of computing, many documents consisting entirely of human-language text which was intended to be read solely by humans were reproduced in all caps. Photocopying machines were uncommon, and while typing a document on a mimeograph stencil would be more convenient than typing it onto a stack of cards, there was no convenient way to copy a mimeograph stencil into a form that could be distributed and allow multiple recipient to independently run off their own copies. If a supplier of computer equipment or software for it wanted to distribute documentation to customers who had printers, including the documentation in a form that could be reproduced easily using computer equipment could be cheaper and more useful than having to produce the document using a mimeograph, Linotype, or other such means.

If the documentation for how a language works is going to be printed in all caps, any language examples will need to be likewise, regardless of whether the language designer would have favored the use of all caps over lower case or mixed case.


I remember that in the early 1970s the Math Faculty at my university had a Honeywell GECOS system with a dual-case printer.

Most input was via IBM 2741 selectric typewriter, which allowed me to submit assignments for most of my essay courses on computer printout, rather than having to use a typewriter to directly type them on paper as most other students did. (Minor corrections were trivial, as opposed to having to retype the entire page.)

Input from punched cards (EBCDIC or BCD) was also possible, but those characters were by default all lower-case when sent to the printer (much easier to read than all upper-case).

The oldest personal code I could find in my archives is from 1976:

$ ls -l ap2c.txt
-r--r--r-- 1 ray ray 1245 Feb 19  1976 ap2c.txt

$ more ap2c.txt
.ent    INTER
INTER:  inta   2];Interrupt Routine.
        skpdz  DIO
]jmp    XDIO
]skpdz  RTC
]jmp    XRTC
]skpdz  TTI
]jmp    @.INC
]skpdz  TTI1
]jmp    @.INT
]skpdz  TTO
]jmp    @.OUTC
]skpdz  TTO1
]jmp    @.OUTT
]sta    3, DIO3];clear garbage interrupt.
]lda    3,CLEAR
]add    2,3
]sta    3,.+1
]lda    2,FALSE];Stack false interrupt message.
]jmp    STORE
XDIO:   sta    3,DIO3];DIO Interrupt.
DLOOP:  dias   3,DIO];restart device.
]lda    2,CALARM
]movl   3,3,snc];select CRT or TTY.
]lda    2,TALARM
STORE:  lda    3,TOP];get stack pointer.
]inc    3,3
]addl#  3,3,szc];check for wrap around.
]lda    3,STACK
]sta    3,TOP
        sta    2,@TOP];store AC2 on stack.
]skpdz  DIO
]jmp    DLOOP]];loop if DIO has interrupted again.
]skpbz  TTO1
]jmp    DIOX]];if stack was empty, send a null
]sub    2,2 ]];character to CRT and TTY to cause interrupts.
]doas   2,TTO1
]doas   2,TTO
DIOX:   lda    3,DIO3
]jmp    @0
XRTC:   nios   RTC];RTC interrupt.
]isz    CLOCK
]jmp    @0
DIO3:   0
CALARM: 101461
TALARM: 130403
FALSE:  134070
CLEAR:  nioc   0

I believe that was for a "real time lab" course, where we wrote programs that monitored and controlled an electric train using a mini computer.

I managed to save one mail message from the professor for that course:

From: mamalcolm
Date: Fri Mar 12 1976 17:21
Subject: realtime train lab


Given that he could type the subject in lowercase, I've no idea why the body is in TUC.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .