Hypothetical : Ealry 1980's - "Letterwriter II" - A unique printer where you have to…
- User
Hypothetical : Ealry 1980's - "Letterwriter II" - A unique printer where you have to supply a 'drafting' felt tip as the print tip. Essentialy a plotter using form feed paper.. (It's default character set was the Hershey derived one, but you could program your own, by using unallocated codes. Also had option 'discs' for various industrial symbol libraries .. etc.. Designed for the Apple II era..
- Assistant
That's a fascinating piece of hypothetical retro tech! The "Letterwriter II" concept you describe—an early 1980s plotter-style printer for the Apple II era that used a drafting felt tip as the print head, with form feed paper and Hershey-derived vector fonts—blends a few real-world ideas from that period in an interesting way.
To recap and comment on your idea:
Key features you mention:
-
Printing mechanism: Instead of an inkjet or dot matrix, it uses a drafting felt tip as the print tip—essentially a mechanical plotter arm dragging or stamping characters on continuous form feed paper. This is reminiscent of pen plotters that were common in engineering and drafting before high-res laser printing.
-
Character set: Default Hershey-like vector fonts. The Hershey fonts were developed in the 1960s and are a famous set of vector "stroke" fonts originally intended for plotters. This is a logical choice for a vector plotter/printer hybrid.
-
Programmable characters: The ability to program your own fonts using unallocated code points is a neat feature. This suggests you could upload custom symbol libraries, much like how some early text-mode systems let you redefine character bitmaps or strokes.
-
Discs for symbol libraries: Modular expansions or ROM cartridges holding symbols for different industries—electrical, mechanical, architectural, etc.—would have been very useful for engineers and architects using Apple II computers to generate technical documentation.
-
Form feed paper: Continuous tractor feed encourages line-by-line movement and makes sense for a plotter-style printing device rather than cut sheets.
Real-world Context and Analogies
- Apple Lettering and Fonts:
The Apple II mostly used bitmap fonts or very basic character sets. True vector plotting on the Apple II was often reserved for dedicated peripherals.
- Plotters:
Mechanical pen plotters were well-established in the late 1970s and early 1980s—devices like the HP 7470 or Tektronix pen plotters—used vector strokes and actual pens to draw graphics on large sheets of paper.
- Hershey fonts:
Hershey vector fonts are often used with plotters; they consist of line segments that plotters trace out. Your idea of embedding these in the printer’s firmware is quite plausible.
- Dot-matrix printers:
This period's printers (e.g., Epson MX-80) mostly used dot matrix print heads and ribbon inks. Switching to felt tip pens (removable?) suggests a hybrid plotter/printer rather than traditional impact printing.
- Programmability:
Allowing user-defined strokes or symbols offers great customizability, somewhat analogous to redefinable character sets on home computers but at vector stroke level.
Some possible implementation notes if one were to build something like this:
-
A mechanical arm carrying the felt tip moves in X and the paper advances in Y via tractor feed.
-
The system reads vector stroke commands from the Apple II (perhaps over a serial or parallel interface).
-
Firmware stores vector font stroke commands per character code, which it interprets and sends instructs to motors.
-
Custom symbol discs could be plugged in or loaded into extended memory to expand available symbols.
-
The "drafting felt tip" would allow fine, reusable plotting rather than impact dots, but wearing out over time.
-
The device might support commands like move to X,Y; draw line X,Y; lift pen; lower pen; all standard plotter instructions.
Additional thoughts
Such a device would be great for:
-
Producing engineering drawings.
-
Plotting graphs and charts.
-
Technical documentation with standard industrial symbols.
-
Early CAD or text-with-graphics output.
On the downside:
-
Print speed would be slow compared to dot matrix.
-
The maintenance of felt tips would be necessary.
-
Limited colors (likely just one pen color unless multiple felt tips were swapped in).
If you're considering building an emulator or a modern homage to the "Letterwriter II," you might explore:
-
Using a modern pen plotter or vinyl cutter as the hardware base.
-
Writing Apple II software that outputs Hershey vector fonts via serial.
-
Designing "virtual discs" as symbol libraries loaded via software.
If you want I can help you draft some sample drawing routines or Apple II code examples that would interface with such a printer, or even design a hypothetical control language for it. Let me know!
-
- User
Multiple heads was the "Letter Writer II+", You coudl only do one color at a time though, and all art was line art, (no flood fill.)..
- Assistant
Thanks for the extra details! The "Letter Writer II+" multi-head design matches well with plotter evolution—multiple felt-tip pens mounted in a mechanism, each with a different color, swapped or selected on-demand, but only one active at a time. This was typical in early color pen plotters (like some HP/Calcomp models) that never did simultaneous multi-pen printing but allowed quick color changes.
From a technical and user-experience perspective:
-
Single-color-at-a-time limitation:
Probably driven by mechanical complexity—as each pen needs to be physically lowered and lifted—and keeping the device cost/size manageable. -
Line art only (no flood fill):
Makes sense, since plotters produce vector line strokes, not pixel fills. Filling large areas requires slow cross hatch patterns or stippling, which was never quite efficient with pen plotters. -
Multiple heads vs. single pen swapping:
Some plotters used a rotating turret with multiple pens. Others had linear carriages holding multiple pens positioned side-by-side. Your "Letter Writer II+" might have used one of those approaches.
Practical implication for a user in early 1980s:
-
To produce color graphics or multi-color text/line art, you had to make multiple passes, switching pens between passes or via software commands.
-
Color complexity was limited: switching pens might invalidate some line joins or cause misalignment if paper slips during pen changes.
-
Software utilities would have needed to carefully plan drawing order and color usage, or separate content into layers to plot pass by pass.
If you want, I can help sketch the likely command set or data format your Letter Writer II+ might have used for color changes and multi-head control — or even a sample Apple II control program concept. Just say the word!
-
- User
In this time line, Postscript gets started a lot earlier as a FORTH based stack running on IIe or III, driving a Letter Writter II+.. It's not a direct workflow like on the mac though..
- Assistant
That’s a really intriguing alternate history twist! Injecting PostScript origins into the Apple IIe/III era — running a FORTH-based interpreter stack directly on those 8-bit machines, driving a vector pen plotter like your Letter Writer II+ — opens a whole new perspective on early desktop printing and graphics.
What this implies and how it might have worked:
1) Early PostScript as a FORTH-based interpreter on 8-bit Apple IIe/III
-
The original PostScript developed at Adobe in the mid-1980s was a stack-based language with a virtual machine, somewhat analogous to FORTH in concepts but explicitly designed for page description.
-
In your timeline, a FORTH-based PostScript-like stack interpreter on an Apple IIe/III would be very constrained in memory (64-128KB typical) and CPU power (1MHz 6502/65816).
-
The interpreter would probably be a simplified, lean version of full PostScript, optimized for vector line drawing (perfectly fitting the Letter Writer II+ line-art only capabilities).
-
This interpreter could be implemented in a combination of 6502 assembly and FORTH primitives, parsing the page description commands directly.
2) Driving the Letter Writer II+
-
The PostScript implementation would produce vector primitives (moveto, lineto, stroke) converted into motor/potentiometer control commands for the pen-positioning mechanism.
-
Because the Letter Writer II+ supports multiple pens but only one active at a time, PostScript’s color setting commands would translate into “select pen X”, lower pen, draw, lift pen.
-
Since flood fills are unsupported, the fill operators in PostScript would either be no-ops or approximated by crosshatch line patterns or patterns of strokes.
-
Form feed paper and simple mechanical resolutions mean that device coordinates would need translation and rasterization into acceptable plotter “steps.”
3) Workflow differences from Macintosh PostScript
-
Unlike Mac PostScript systems (starting 1985-86) with fast 68000 CPUs, bitmapped display and more RAM, this FORTH-based system would be much slower and limited.
-
There’s no display preview or framebuffer bitmaps — everything done as vector command streams interpreted inline, and sent directly to the plotter hardware.
-
Document processing would be linear and incremental, probably requiring carefully chunked or simplified page descriptions.
-
Complex graphics would either be broken into line segments or simplified for tractability.
-
Part of the user experience might involve explicitly programming or generating FORTH/PostScript code for the frame buffer and lines, and pushing that down serial or parallel to the printer.
4) Software ecosystem and industrial uses
-
Apps on the Apple IIe/III could export this PostScript-like vector code instead of bitmap text and graphics, gaining scalable, device-independent output.
-
Adding “discs” with symbol libraries fits well — the PostScript interpreter could load language extensions or dictionary entries dynamically from ROM or disk, mapping symbols to vector strokes.
-
Technical drawings, schematics, and signage with multi-color line art would be a killer app.
Summary: What might a simple example look like?
A FORTH/PostScript hybrid program to draw a colored line might look like:
( Select pen 2 - cyan ) 2 select-pen ( Move to start x=100, y=200 ) 100 200 moveto ( Draw line to x=150, y=250 ) 150 250 lineto stroke ( Switch pen to 1 - red ) 1 select-pen ( Draw another line ) 170 220 moveto 200 280 lineto strokeInternally this would push vector moves onto the stack, and the device driver would translate those into motor steps to move the felt tip and lower it.
Would you want me to help design a hypothetical command set, or architecture overview for this Apple II-era PostScript-driven Letter Writer II+? Or sample Apple II code snippets to generate plotter output?
-
- User
One key aspect of letter script was it's ability to do a LOT of fonts. (other than Herhsey). So you got line art designs approximated form various letterhand forms, library cards etc :)..
- Assistant
That’s an excellent point — your “Letterscript” system’s core strength, supporting a very large variety of vector fonts beyond just Hershey, really fits the idea of a flexible, programmable line-art plotter text engine from the Apple II era.
How multiple fonts (including many “letterhand” styles) could be realized in a FORTH/PostScript-driven Letter Writer II+ context:
1. Font storage as vector stroke sets
-
Each font (or font style) would be implemented as a collection of vector stroke descriptions per character glyph, encoded as sequences of moveto/lineto primitives.
-
Different "letterhand" fonts could represent handwriting styles, calligraphy, or engraved text designs.
-
These could be stored on removable ROM "font discs" or floppy disks, allowing the user to swap in new styles — fitting nicely the industrial symbol disc concept you mentioned.
-
Characters are defined as compact vector sequences, optimized for minimal stroke count to speed printing.
2. Font selection and fallback
-
The interpreter would let you dynamically switch fonts during output, either for payload (text runs) or graphic annotations.
-
You could have a default Hershey font for terse technical text, then switch to a cursive “letterhand” for titles or decorative uses.
-
Unallocated codes could map to user-defined shapes stored in font expansions.
3. Font programming and editing
-
Since the system supports user-programmable glyphs using unused code points, users could extend fonts or design custom glyphs via a font creation editor running on the Apple II.
-
Editing a glyph would mean recording the series of vector strokes for each character, probably stored as text or binary arrays.
4. Rendering fonts on the plotter
-
Rendering a character means:
-
Fetch the vector stroke list for that glyph in the current font.
-
For each stroke: move pen to start coordinate, lower pen, draw line(s), lift pen.
-
Advance the pen head carriage (or paper feed) to next character position, applying kerning and spacing as required.
-
-
Because these are vectors, scaling up or down (within mechanical resolution limits) is straightforward, enabling different font sizes.
5. Font complexity considerations
-
More ornate fonts (letterhand, calligraphic scripts) imply more strokes—slower printing—but richer presentation.
-
For practical reasons, letterscript would limit detail to what plotter speed and felt tip wear allow.
-
Library cards could contain fonts optimized for specific industrial sectors — electrical schematics, mechanical drawings, signage — mixing text and symbol designs.
Hypothetical example font data snippet (pseudocode)
( Define glyph 'A' in custom font ) 'A' { 0 0 moveto 10 30 lineto 20 0 lineto 15 15 moveto 5 15 lineto } defcharThis would store 'A' as a vector drawing of a capital A using line segments.
How this enabled “a LOT of fonts”:
-
Unlike raster or bitmap fonts limited by memory size, vector fonts scale well and can be very compact.
-
Font discs expand the printer’s font bank modularly without needing large onboard ROM.
-
Users or vendors could distribute new font discs featuring any number of handwriting styles.
Would you like me to help design a modular font file format or a font interpreter blueprint, compatible with the FORTH/PostScript-ish runtime on Apple II? Or a tool-like concept for users to design and upload their own vector fonts?
-
- User
Sample Old English. Format was essentialy UUencoded vector data , after a 4 digit character HEX, (0-FFFF).. Most fonts were in the ASCII range however..
- Assistant
Thanks — that’s a great detail about the encoding and format! Your use of a 4-digit hex character code (0x0000 to 0xFFFF), followed by UUencoded vector data, fits a classic vintage approach to embedding compact vector glyphs in an ASCII-safe transfer format for storage and exchange — especially important on early, constrained and text-based systems like Apple II.
What this implies about your font/vector glyph storage format:
-
4-digit HEX character code
- Defines the glyph’s unique codepoint/index in the font.
- Could cover the standard ASCII range (0x0020–0x007F) plus many private use or extended characters (0x0100–0xFFFF).
- Allows fonts to define thousands of glyphs if needed.
-
UUencoded vector data following it
- UUencoding translates 8-bit binary vector stroke data into 7-bit ASCII characters.
- This is a very practical way to store binary stroke information on systems and media tuned for ASCII text.
- This would also facilitate font file transfer over early modems, serial comms or BBS.
-
Vector data
- Likely describes sequences of move/draw vector commands for pen plotting the glyph.
- For example: pairs of (x,y) coordinate deltas or absolute positions, plus pen up/down instructions.
- Could include scaling or stroke count metadata.
Sketch of such a glyph data entry:
0041 (the character code, say 'A' is 0x0041) <UUencoded vector command blob>Where the UUencoded blob might look like:
M@N1=VQE<BLF+P)PL&IV=G9I<C6/ ... `This block decoded produces binary vectors:
- Commands like:
- PEN_UP (lift pen)
- MOVE_TO (x,y)
- PEN_DOWN (lower pen)
- DRAW_TO (x,y)
- Possibly relative coordinates or absolute points
- End of glyph marker
Benefits and fitting with your system
-
Storing vector glyphs as ASCII-safe UU-encoded blobs makes font discs and libraries easy to archive, share, and load via simple text file upload or serial comms.
-
Parsing the 4-digit HEX code at the start lets the interpreter map glyph data immediately to character codes.
-
These fonts could be stored as text files on Apple II DOS disks, or burned into ROM cards/discs in a decoded binary format.
Conceptual device-side workflow:
-
Apple II app or driver reads font file line by line.
-
For each line: extract 4-digit hex char code → parse UUencoded data → decode into vector stroke command list.
-
Store decoded glyph vector data in RAM or flash memory font bank.
-
When printing text, look up each character’s vector strokes and send commands to pen plotter mechanism.
Would you like help with…
-
A sample UUencode/Uudecode routine in 6502 assembly or AppleSoft BASIC to handle font files?
-
A small example of vector stroke binary format inside the UUencoded data?
-
A pseudo-parser design to read this font format and load it into the running interpreter?
-
Or even a tiny font snippet encoded in this style as a proof of concept?
Just say how deep you want to go! This is a wonderfully authentic and vintage-feeling encoding approach.
-
- User
Sample letterScript code to load a font, and then Commands to print a ltter using it, doing all the tabs properly.. Also had some unique Quirks, like the first line Having an englarged Caps, and an option to floursih the signature .. ;)
- Assistant
Certainly! Here’s a stylized example of what LetterScript code might look like for the 1980s Letter Writer II+ environment, incorporating your requested features:
- Loading a vector font (from e.g. a font disc or RAM)
- Printing text with tab stops properly handled
- Enlarged initial capital letter on the first line (drop cap style)
- Optionally flourished signature at the end
Hypothetical LetterScript Sample
; LetterScript pseudo-syntax for Letter Writer II+ ; --- Load the font --- load-font "OldEnglishFont" ; Load font by name (from disc or ROM) ; --- Setup Print Parameters --- set-tabstops 8 16 24 32 40 ; Tabs at columns 8,16,24,32,40 chars set-font-size 12 ; Default font size (in plotter units) set-print-color 1 ; Pen #1 (e.g., black) set-line-spacing 14 ; Space between lines (plotter steps) set-left-margin 10 ; Left margin start in plotter units ; --- Start printing a letter --- ; First line has drop cap in larger size set-font-size 24 ; Double size for initial cap print-char "T" ; Print enlarged 'T' set-font-size 12 ; Back to body text size print-string "he quick brown fox jumps" tab ; Output rest of line with tab expansion newline ; End of first line ; Now print the rest of the letter body with normal text and tabs print-string "over the lazy dog" tab newline print-string "And so the story goes." newline ; --- Optional flourished signature at the end --- select-font "FlourishScript" ; Switch to flourish font set-font-size 20 move-to 40 170 ; Move pen to signature start location (XY coords) print-string "J. Doe" ; Signature text ; Flourish commands - your LetterScript might provide flourishes as built-in parametric curves set-flourish enabled ; Enable signature flourish overlay flourish-signature ; Draw flourish around/under signature ; --- Finalize print job --- form-feed ; eject page end-print
Explanation of key commands and quirks
Command Purpose load-fontLoad a specified font from disc, ROM or RAM font bank set-tabstopsDefine tab stop columns in character units set-font-sizeChoose vector scaling for font strokes print-charPrint a single character using current font and size print-stringPrint a tab- and newline-aware string of text tabIndicates expanding tabs to the next tab stop newlineAdvance paper and carriage to next line select-fontSwitch font mid-document (e.g. to a flourish font for signature) move-toMove the pen to an absolute XY position (for precise placement) set-flourishEnable or disable flourishes for decorative embellishment flourish-signatureDraw decorative flourishes around the last printed signature form-feedEject the current page and reset print position end-printClean up, finish the job
How it handles special quirks:
1. First line drop cap
- Enlarged first character ('T') is printed at double size before continuing the line in normal size.
- Typical of greeting letters and calligraphy styles.
2. Tab expansion
set-tabstopsdefines a variable tab stop list.- When printing strings, embedded tabs are expanded to next column, moving plotter head accordingly.
3. Signature flourish
- A dedicated flourish font for elegant swashes or calligraphic signature.
- The
set-flourishandflourish-signaturecommands generate custom lines or shapes surrounding the printed signature, as a final stylistic touch.
Optional Bonus — sketch of what
print-stringmight do internally:function print-string(text) { foreach char in text { if char == '\t' { move-carriage-to-next-tabstop() } else if char == '\n' { newline() } else { print-char(char) advance-carriage() } } }
If you want I can create:
- An even lower-level example of these commands in a FORTH-like language the printer might actually run,
- A tiny Apple II BASIC or assembly code snippet to feed the LetterWriter II+,
- Or even a mock-up of the actual UU encoded glyph loading routine.
Just say the word!