IBM 1130 Assembler

IBM 1130 Assembler is the symbolic assembly language of the IBM 1130 Computing System. IBM announced the 1130 in February 1965 as a desk-sized scientific and engineering computer, and the first IBM machine to rent for under $1,000 a month. The assembler turned mnemonic instructions such as LD, STO, BSI and MDX into the 1130’s 16-bit binary machine code. It was punched onto cards or paper tape in fixed columns. It was the language in which IBM wrote the 1130’s operating system and compilers. Users wrote I/O drivers, interrupt handlers and speed-critical routines in it to call from Fortran. Over the following decade it grew from a two-pass card assembler into a disk-resident macro assembler.

The 1130 is remembered with unusual affection. An estimated 10,000 were built, and for many students, engineers and small firms it was their first hands-on computer. Its assembly language was often the next step after Fortran.

History & Origins

A small computer for engineers

IBM’s press release of 11 February 1965 introduced the 1130 as “designed for individual use by engineers, scientists and mathematicians”. The basic system rented for $695 a month or sold for $32,280; a typical configuration with a disk drive was $895 a month or $41,230. The 1130 used the Solid Logic Technology circuits of System/360 and 4,096 or 8,192 words of 16-bit core memory with a 3.6-microsecond cycle. IBM said it would deliver the first machines in the fourth quarter of 1965, from San Jose, with IBM World Trade building it in Greenock, Scotland, for customers outside the United States.

From the start, IBM supplied a basic programming package with the machine. Its 1965 Utility Routines manual (Form C26-5931-0) states that “the card and paper tape programming systems for the IBM 1130 System including the FORTRAN Compiler, Symbolic Assembler, Utility routines, and the Subroutine Library comprise the basic IBM-supplied programming systems for use by all 1130 System installations.”

The card and paper tape assembler

The first 1130 assembler worked without a disk. According to the IBM 1130 Assembler Language manual (C26-5927-2, 1966), it ran on an 1131 Model 1 processor with 4,096 words of core and either an IBM 1442 card read-punch or a paper tape reader and punch.

It was a two-pass program, and with cards the second pass was literal. The source deck went through the reader once to build the symbol table, then again. On the second pass the assembler punched the object code and any error flags into the first 20 columns of each source card, which is why source statements begin in column 21. The resulting “list deck” could be listed offline on an IBM 407 accounting machine or online with an IBM-supplied utility. It then had to go through a separate Compressor Program to produce a relocatable binary deck before it could be loaded and run.

The Disk Monitor and DM2

The disk-based 1130 Monitor came next. The 1966 manual already includes a section of “Monitor Assembler Statements”. These are DSA (Define Sector Address), which let a program refer to a disk file or core-image program by name; EXIT, which returns control to the Skeleton Supervisor; and LINK, which loads and runs another program.

In 1967 IBM introduced the Disk Monitor System, Version 2 (DM2), which is generally described as the most widely used 1130 operating system. Under DM2 an assembly was just another job step. A // ASM card invoked the assembler, and assembler control records chose its options: *LIST, *XREF (a cross-reference, on systems with 8K words or more), *PRINT SYMBOL TABLE, *LEVEL (required when assembling an interrupt service subroutine), and *TWO PASS MODE, which was required, for example, to punch a list deck on the 1442.

The Macro Assembler

The language’s last major addition was macros. IBM’s IBM 1130/1800 Macro Assembler Programming (GC26-3733-0, first edition June 1970) describes one Macro Assembler serving both the 1130 Disk Monitor System, Version 2, and the IBM 1800 Multiprogramming Executive. It added macro definition, conditional assembly (with ANOP, SET and PURG pseudo-operations), automatic name generation, concatenation and a disk-resident macro library maintained by a Macro Update Program. On the 1130 it was described as fully compatible with the existing DM2 assembler, but the macro capability needed 8K words of core.

Design Philosophy

The 1130 assembler was a classic one-for-one assembler. In its manual’s words, “the assembler produces one machine-language instruction for each symbolic-language instruction”. Its design followed from the machine and the medium:

• Small, cheap memory. A minimum 1130 had 4,096 words of core, so the assembler and the programs it produced had to be compact. Short one-word instructions with an 8-bit displacement were preferred wherever a target was within reach.
• Punched cards as the editor. Fixed columns, a 5-character label limit, and space reserved on the card for the object code all reflect a world where the source program was a physical deck.
• Relocatable, linkable code. From the start the assembler could produce relocatable object programs. It also had statements for declaring entry points and calling library subroutines, so assembler routines and Fortran programs could be combined by the loader.

Key Features

Statement format

Each statement occupied one card (or one paper tape record), in fixed fields:

The machine it targets

The 1130 is a 16-bit, word-addressed machine with a 15-bit address space, so at most 32,768 words of core. Programs see an accumulator (ACC) and an extension register (EXT, called the Q register in early manuals) that together hold 32-bit values. They also see carry and overflow indicators, and three index registers, XR1-XR3. On the 1130 the index registers are not hardware registers but core locations 1, 2 and 3. The closely related IBM 1800 has real ones.

Instructions come in two formats:

• Short (one word): an 8-bit signed displacement, relative to the instruction address or to an index register.
• Long (two words): a full 16-bit address word, optionally indexed and optionally indirect.

The 1966 manual’s mnemonic table lists about thirty machine-instruction mnemonics, a few of which (such as BOSC and NOP) are variants of other instructions:

Floating point, both standard (two-word) and extended (three-word) precision, was not in hardware. It was done by library subroutines. The DM2-era assembler added extended mnemonics that made intent clearer, such as B, BP, BN, BZ and BNZ for the different forms of BSC, and XCH for exchanging the accumulator and extension.

Assembler instructions

Subroutine linkage without a stack

The 1130 has no hardware stack. A subroutine is entered with BSI (Branch and Store Instruction Counter), which stores the return address in the subroutine’s first word and continues at the next. The routine returns with an indirect branch through that word. Parameters were commonly placed in line after the call, with the subroutine adjusting its own return address to skip over them. This made recursion impossible without extra work. Self-modifying code was reportedly a normal technique on the 1130, with code patching instruction addresses at run time.

A short example

The following program adds ten numbers from a table, using index register 1 as a down-counter. The listing shows card columns 21 onward, as the source looks once the 20 object-code columns are dropped:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

*    SUM THE TEN WORDS AT TBL AND STORE THE RESULT IN TOTAL
START LDX   1 10      XR1 = 10, THE LOOP COUNT
      SLA     16      CLEAR THE ACCUMULATOR
LOOP  A    L1 TBL-1   ADD THE WORD AT TBL-1+XR1
      MDX   1 -1      XR1 = XR1-1, SKIP NEXT WHEN ZERO
      MDX     LOOP    SHORT BRANCH BACK TO LOOP
      STO  L  TOTAL   STORE THE SUM
      EXIT            RETURN TO THE MONITOR
TOTAL DC      0
TBL   DC      1
      DC      2
      DC      3
      DC      4
      DC      5
      DC      6
      DC      7
      DC      8
      DC      9
      DC      10
      END     START

Several 1130 habits show up here. L1 asks for a long, two-word instruction indexed by XR1. MDX 1 -1 decrements the index register and skips the next instruction when it reaches zero. A plain MDX with no tag serves as a one-word relative branch. EXIT hands control back to the DM2 Supervisor. This program assembles without errors with the ASM1130 cross-assembler (V1.22), which places EXIT as a branch to location /0038, the monitor’s fixed return point.

Evolution

IBM produced no compatible successor to the 1130. Its later small systems, such as the System/7 and Series/1, used different architectures, so 1130 assembly programs could not move to them.

Current Relevance

The 1130 assembler is a historical language, but it is easy to run. Brian Knittel’s IBM 1130 simulator, built on Bob Supnik’s SIMH and reportedly begun in 2001, simulates an 1131 processor with up to 32K words, the console, the 1132 printer, the 1442 card read-punch and disk drives. The download from ibm1130.org includes a disk image with DMS Release 2 Version 12, Fortran and the Macro Assembler, plus the complete DMS source. Knittel’s ASM1130 cross-assembler (version 1.00, February 2002; version 1.22, November 2012) assembles 1130 code on a modern computer and can rebuild DMS from that source. Both are part of the SIMH distribution.

Real hardware survives as well. As of 2025, complete or working 1130 systems were reported at ACONIT in Grenoble, The National Museum of Computing at Bletchley Park, the Computer History Museum, the University of Stuttgart and elsewhere. Restorer Carl Claunch has worked on several machines.

Why It Matters

The 1130 assembler is a clear, compact example of mid-1960s IBM assembly language design. It sits between the card-oriented assemblers of the 1401 era and the macro assemblers of System/360, and it went through both stages within a single machine’s lifetime. Much of the 1130’s character came from software written in it: the tightly packed DM2 operating system, APL\1130, and Guy Steele’s LISP 1.6, written as a high-school student.

It also left traces outside IBM. Chuck Moore, working on an 1130 at Mohasco Industries around 1968, ported his interpreter to Fortran there. He named it FORTH because, as he later wrote, the operating system “restricted file names to 5 characters”. The same 1130 environment is where he extended a cross-assembler into an 1130 compiler, adding words such as CODE and ;CODE. For a generation of programmers, the 1130 and its assembly language were their first close look at how a computer really works.