electronic.alchemy :: Monotype Computer Interface
where the past meets the future
letterpress > monotype > monotype software introduction

Monotype Computer Interface

Created by hww3. Last updated by hww3, 5 years ago. Version #9.

The purpose of this document is to explain the premise of the 'Monotype' computer control system (referred to hereafter as 'the system') for 'Monotype' composition casters. The system consists of a physical component (hardware) which connects a control computer to the composition caster as well as a set of software that is used to run the system.


The purpose of the hardware assembly is to allow a computer to control the various pneumatic inputs on the composition caster, as well as to report machine cycle position and timing to the computer interface.

The hardware component of the system consists of 3 major assemblies: the computer interface board, the air valve bank and the air bar adapter. Typically, the hardware interface is attached to a composition caster in a semi-permanent fashion. While the interface requires no modification to the caster and is fairly straightforward to attach, it is usually easiest to install it and run the caster from computer.

The computer interface board connects to the caster control computer using an industry standard USB (Universal Serial Bus) interface. The interface board allows the caster control computer to control the air valve bank, and also informs the caster control computer of the cycling of the composition caster. An external power supply connects to the computer interface board and provides the 12 volt power needed to activate the various air valves. Additionally, the interface board is electrically isolated from the computer (using optical isolation) in order to protect against any dangerous electrical conditions which may accidentally appear between the caster and computer.

The air valve bank is a set of solenoid activated pneumatic valves, 31 in all, which activate the various air pins and actuators present on the composition caster. The air valves are mounted on a manifold which can be hung from a wall or ceiling near the casting machine. The air valve bank is connected to a compressed air source at 'Monotype' standard 15 PSI, as well as to the computer interface board via cable and the air bar adapter via a set of flexible hoses.

The air bar adapter consists of a machined bar which is placed over the 31 openings on the paper tower in place of a paper ribbon. A set of clamp brackets hold the adapter bar on the paper tower. Additionally, an electronic sensor is attached to the paper tower in order to detect the caster cycle.


The software portion of the system consists of 2 major components: the electronic ribbon (called eRibbons) generator and the caster control application. The caster control application is installed and runs on a computer connected to a composition caster using the computer control interface. We'll start by examining the caster control application first.

The Caster Control Application

As we've mentioned, the caster control application runs on a machine which is physically attached to a composition caster via the caster control hardware interface. The purpose of the caster control application is to send the appropriate control signals to the hardware interface at the appropriate times in order to simulate the effect of having a paper ribbon running through the caster. The caster control application is fairly simple in operation: it resembles the controls of a cassette deck or cd player. Using the caster control application, a "pre-punched" eRibbon is converted to air signals at the casting machine. The caster control application provides a set of simple operations that can be performed, such as loading a ribbon, starting or stopping the advance of the eRibbon as well as controls that allow the operator to advance forward or back through the ribbon, line by line.

The ribbon generator can be run on any computer, not necessarily one attached to a caster control interface. This separation of tasks allows an operator to generate ribbons from the comfort of an office, or while away from the foundry. When a ribbon is generated, the operator need merely transfer the prepared eRibbon to the caster control computer using a CD, USB flash drive or network.

The Ribbon Generator

Using the ribbon generator, an operator manages the various pieces of information necessary to make eRibbons. Most of these pieces of data (we refer to these as files or objects) are directly analogous with aspects of the standard 'Monotype' paper ribbon system. These objects are:

eRibbons are the direct equivalent of a punched paper ribbon. They describe the air signals required to control the casting machine for a given job and are the ultimate goal of the Ribbon generator software. eRibbon files are saved in a simple text format and are used by the caster control application. An eRibbon can be examined and modified by hand, if necessary.

Stopbars and MCAs are very similar to stopbars and matrix arrangements or keybars employed in the traditional 'Monotype' composition system. Additionally, the MCA contains some extra information used to drive certain aspects of ribbon generation. The Stopbar and MCA objects are stored as files by the ribbon generator in standard XML format. Subject to the requirement that they be correctly formatted, these files can be edited by hand or using other tools by the operator, in addition to the supplied editing tools.

Ribbon Generator Input is combined with information specified by Stopbar and MCA objects to produce an eRibbon. The Ribbon Generator Input is a text file which is similar in nature to HTML; that is, it contains the text to be cast, and is "sprinkled" with specially formatted control strings. These control strings instruct the ribbon generator to perform special functions, such as quadding a line or engaging letterspacing. Ribbon Generator Input files can be prepared using a standard text editor, such as TextEdit on the Mac.

Working with Stopbars

Stopbar arrangments, or wedges, are the first and most basic component used in generating electronic ribbons. They represent the unit width that a given wedge will produce when employed in the composition caster. In our electronic system, stopbar arrangements serve the following purposes:

  1. provide the default width for a sort when creating MCAs
  2. during the ribbon generation process, they determine whether a sort being cast requires adjustments in its width

Creating a new Stopbar is fairly easy, and it's pretty satisfying, as you can add a new wedge in very little time and feel like you've accomplished something. It's important to get the wedge/stopbar arrangments entered correctly, as everything else you do will be affected by this.

A fairly comprehensive list of stopbars with their width assignments are available from the Alembic Press website:


To create a new wedge, click on the "Wedges" tab, and then "New Wedge". Give the wedge a name (such as "S158") and click on "Create".

This will take you to the wedge position screen where you'll punch in the units for each position on the wedge. Do that (make sure you've entered them in correctly!) and then click on "Save". If you realize you've made a mistake, you can go back and make changes by clicking on the wedge name/number from the "Stopbar arrangements" menu.

Working with MCAs

The second component used by the ribbon generator is the Mat Case Arrangement, or MCA. The MCA describes the various sorts that are contained in a given physical matcase. MCAs may be of various geometries based on the particular version of composition caster you have (15x15, 15x17 or 16x17). Each position in the matcase may contain a sort, a space, or nothing at all.

Spaces come in two types: fixed spaces or justifying spaces. Each MCA may contain exactly 1 justifying space, which also doubles as a standard fixed space. The position of the justifying space will determine the minimum possible justifying space width. Normally, the justifying space will be placed in a 5 or 6 unit row, which will result in a minimum justifying space width of either 3 or 4 units, respectively.

Sorts describe a particular matrix present in the MCA. A given sort has a few attributes:

  1. the alphabet associated with the sort (bold, italic, small caps, etc)
b. the width, in units, that the sort should be when cast c. the activator, that is, the character or characters that will trigger the sort to be cast when present in the input text, which must be unique for a given alphabet d. the display value, which is how the sort will be represented in soft proofs

Normally, the activator and display value will be the same, however for flexibility they may be different. Normally, the activator is simply the character that appears on the matrix, such as "a", or "!". In certain cases, it may be desirable to employ a unique activator, such as if you have a logogram, ligature or alternate form that you want to use selectively. for example, an italic alphabet may have both a standard "M" as well as a swash variant. In this case, each "M" must have it's own unique activator. As an example, if we normally want to employ the standard "M", we might make its activator be "M", while the swash "M" might have "_M" as its activator. If, in the input text, we want to use the swash "M", we can cause it to be used by inserting "_M" into the text.

You may notice from the list of information stored for each sort that its width may be specified. The wedge associated with a given matcase and a mat will determine the default width of a sort placed in the MCA, however you can change this, for example if:

  1. you are using a non-standard wedge and want to ensure that a sort is cast at its correct width, which may be different than the width provided by the wedge
b. you know that a given sort would be better cast by default on a wider or narrower body

If a sort is defined to use a width that is not the same as the width provided by a wedge at the desired matcase position, the ribbon generator will use various techniques to ensure the sort is cast at the requested width. The MCA editor will indicate mats that have differences between the requested width and the wedge by highlighting the sort in yellow.

The MCA Editor

During the creation of a new MCA, a name for the MCA is provided. This name can be as descriptive as desired, though since the MCA is stored as a file on disk, it is best to keep the names simple, avoiding punctuation or other special characters that may be forbidden or confusing within filenames.

The operator should select the correct matcase size when creating a new MCA. Valid sizes are 15x15, 15x17 and 16x17. Note that a caster must be properly configured for using matcases other than 15x15. Currently, it is not possible to change the matcase size from within the MCA editing tool, but can be changed by manually editing the MCA file.

When creating a layout, you specify the default wedge (stopbar) to be used. This enables the matcase editor to pre-fill the unit width values for any sorts you add. All sorts start out the unit width of the row they're positioned in. Of course you can change that if you want. For example, if you want to put a 6 unit sort in a row that is normally 5 units, the ribbon generator will adjust the width of the sort being cast by using unit-shift, unit-adding or the justification wedges. To change the unit width of a character, click on it and set the value to whatever you want (there are limits, of course… you probably can't put a 18 unit "W" in a 5 unit row and have things work.) Again, the layout will show those sorts whose widths are not the same as the wedge position by coloring the background yellow.

The stopbar selected when creating an MCA is used to automatically select the proper Stop bar when generating an eRibbon. The specified Stopbar may be overridden at ribbon generation time, for example if the standard stopbar is unavailable.

The MCA editor provides a point-and-click interface for editing the contents of a MCA. The operator can either drag-and-drop a sort into the MCA from a list of unplaced sorts, or manually by clicking on a given matcase position in order to edit the matrix present in that position.

Clicking on a matcase position will pop up a "matrix editor", where you can choose from an empty matrix, a fixed space, a justifying space or a sort. If you choose a sort, you'll enter information about that matrix.

Any sorts you've added since the last time you saved will be blue.

Below the MCA display is a space that describes any "problems" with your arrangement. For example, the problem display may say,

Matcase contains duplicate mat: I|E:new C 9, orig G 8

That means that positions C9 and G8 both contain the same matrix, in this case an italic "E". One of them is probably wrong, though if your arrangement does actually have more than one italic E, that's probably okay, but the ribbon generator will only use the first one it finds. You can make the wrong one a blank matrix, or a fixed space, or perhaps there's actually a different mat in that position.

Managing sort variants

A common cause of "Matcase contains duplicate mat" warnings is when a matcase contains multiple variations of a given sort for a particular alphabet. If, for example, your arrangement has a regular italic "E", and a swash "E", you might only want to employ the swash E in certain places. So, you'd leave the regular "E" as it is, and give the swash "E" a different activator. The activator is the text in your ribbon file that will trigger that matrix to be used. Normally, the activator is the same as the character, but they don't have to be. You could make the activator for the swash e something like "_E_", so that if the ribbon generator encounters that bit of text, it knows you really meant "use the swash E". A good option (though you are free to choose a convention that suits you) to use "@E_SWASH". The "@" at the beginning tells the ribbon generator to not use it unless I tell it to actually to, using a special code in the text. That way, it's less likely to get accidentally used if the input text contains the activator. You can do the same thing for ligatures that you don't want to automatically use, such as "st" or so on. See the "Ligatures" section below.


By default, any ligatures you add to a matcase will automatically be used when they appear in the ribbon input. For example, if if your text has the word "ruffle" in it, the ribbon generator will notice the "ffl" and cast an "ffl" ligature instead of the 3 individual letters. If you don't want a ligature to be used automatically, you add a "@" sign to the beginning of it's activator. For example, if you add a "ct" ligature and you only want to use it by specifying it manually in the ribbon input, you type "ct" in the character box and "@ct" in the activator box. Then, in your input text you can cause the "ct" ligature to be cast by including "@ct" in your text: for example "benedi@ct".

Manual Matrix Editing

By clicking on a postion in the MCA, a pop-up editor will appear that allows modification of any of the parameters of the matrix in the selected position:

for sorts, the following information may be provided:

Matrices that have been changed since the last save are surrounded by a blue border. Matrices which have a specified unit width different than the width provided by the default Stopbar for the MCA (such as in a unit shift arrangement) will have their background highlighted in yellow.

To add a sort to an MCA manually:

  1. select the location you'd like to add the custom sort to, and click on the cell (the pointer may or may not change to the "pointing finger", but it shouldn't matter).

  2. When you click on the matrix position, a popup should appear that allows you to set that matrix position as a sort (there will also be options for fixed and justifying spaces, or empty). Choose "sort" and a set of options should appear.

  3. Type the custom sort character into the "character" field. If you hit tab, it should also copy the same sort into the "activator" field.

  4. Click "save", and the matrix picker should disappear.

  5. The custom sort should appear in the matrix position you just edited.

  6. Click "save" to save the MCA.

1 Creating Ribbons

Once you have defined Stopbars and MCAs, you can use these to generate eRibbons. To generate an eRibbon, you must tell the ribbon generator about the text you'd like to set. You may do this in one of two ways: a) by creating a text file that you provide to the ribbon generator or b) for smaller texts, by entering the text directly into the ribbon generator.

If you are generating a text that contains non-ASCII characters (simple english text), from a text file, you must make sure that the text is saved in UTF-8 format. If your text contains non-ASCII characters and you do not provide UTF-8, unexpected results, including errors, may occur.

Ribbon generation codes

A ribbon input file is basically plain text that contains special codes that tell the ribbon generator to perform specific functions, such as quadding a line or inserting a particular ligature into the generated text. The following table includes a list of these special codes that can be used to perform these special functions.

Note that in order to create a new paragraph, or to break a line in a particular place, you must use one of the codes below; the ribbon generator ignores extra white-space (tabs, spaces and empty lines).

Control Code Description
<A[activator]> insert character or ligature identified by [activator]
<qo> quad out the current line and begin a new line
<p> start a new line, quadding out if the line cannot be justified (differs from <qo> in that will always result in spaces of the minimum allowable width)
<i>...</i> select italic alphabet for the text contained within, if available
<b>...</b> select bold alphabet for the text contained within, if available
<sc>...</sc> select small cap alphabet for the text contained within, if available
<center> center justify
<left> left justify (aka ragged right)
<right> right justify (aka ragged left)
<justify> default justification mode
<s[n]> insert a fixed [n] unit space
<l[n]>...</l[n]> adjust all sorts contained within by adding [n] units (letterspacing)
<indent[n]>...</indent[n]> indent paragraphs, where N is a positive or negative integer indicating the number of units to indent. Negative numbers trigger hanging indentation.
<header>...</header> define the current header for all (even and odd) pages.
<footer>...</footer> define the current footer for all (even and odd) pages.
<eheader>...</eheader> define the current header for even pages.
<efooter>...</efooter> define the current footer for even pages.
<oheader>...</oheader> define the current header for odd pages.
<ofooter>...</ofooter> define the current footer for odd pages.
<pagebreak> manually force a page break
<setpagenumber n> set the current page number to [n].
<pagenumber> insert the current page number as an arabic numeral
<romanpagenumber> insert the current page number as an upper case roman numeral
<lowercaseromanpagenumber> insert the current page number as a lower case roman numeral

very simple example:

My Life Story<qo>
<i>by Bill Welliver</i><qo>
It was a dark and stormy night. <qo>

Posted in monotype | RSS Feed | BackLinks

comments powered by Disqus