The Signum! program was a popular word-processor available for the ATARI ST line of home computers and distributed by Application Systems Heidelberg (ASH). While it could be used via the MagicCMac or MagicCPC emulators, it was never ported to newer systems. The file format (*.SDO for Signum! and Signum!2) was proprietary or at least unspecified and with the exception of Papyrus for the ATARI ST and a small amount of other for-profit tools, no other software could read those files. When I started this project, I could not find any software that runs on modern systems and can read those files.

This is especially unfortunate for people (mostly german-speaking) that wrote their thesis in Signum! in the 80s and still have the floppy disks with those files but no ATARI and/or no application anymore. Yes, you can set-up an emulator, get the installation files from ASH, use or buy a product key, create/insert virtual floppy disks, install Signum!, open your files, export the text to ASCII, export the images, use vision/zView for ATARI to covert the images, fix up umlauts in the ATARI-ASCII, and be done with one document, but that is a lot to ask for and I haven't seen a single post mention all of this at once. And it's really not worth the effort for some of the less important stuff I've found in the stash of floppies I had access to.

Or you can use this (work-in-progress) tool, which can read Signum!2 documents and make some of these steps much easier. It's written in Rust, so it should work across all major platforms (Windows, Linux and OSX).

When searching for ways to decode Signum! files, I came across three general approaches:

1. Running Signum!: Print to a decodable image format
2. Running Signum!: Export to ASCII, fix the rest by hand
3. Import to RTF with papyrus

The first one works, but makes it difficult to recover the text, i.e. you need to use some sort of OCR later. The second one is probably the most straight-forward and reliable and is useful for texts that have no formatting or non-trivial fonts.

I actually found a working copy of papyrus 7 (demo) after a lot of digging around and it turns out that this actually just calls TEXTCONV.PRG by Andreas Pirner. Version 1.23 is the one that comes with papyrus and I don't agree that it's useful. Yes, it can export to RTF and all the letters and numbers survive, but subscript, superscript and formulas are not close enough to be readable, the line-height was too low, the alignment was off, and more. Also, while papyrus (for ATARI) supports signum fonts, modern tools to read those files don't, so you still end up needing to find a perfect match for your font for newer systems.

• Load Signum! 1/2 documents (*.SDO, sdoc0001)
  • Print all kinds of data from the files to a console, but most importantly
  • Print a list of charset names
  • Print some global formatting options
  • Print a list of pages with additional formatting information
  • Print text to the console, including page breaks, and some HTML-like format annotations
    • Fonts that match the default ATARI keys are translated to the appropriate unicode characters
    • Documents that use only the ANTIKRO font have working space detection. This is a WIP
  • Render a document to one PNG image per page (see examples)
    • This requires the E24 font files to be available
    • Character modifications (wide, tall, italics, ...) are not yet supported
  • Print a list of image names
• Load Signum! editor charsets (*.E24, eset0001)
  • Print height and width for each character
  • Print ASCII art for each character bitmap
  • Render a string with the font (use --input "...", currently always "Abcdefghijkl")
  • Generate a visual map of the characters on an ATARI keyboard
    • Examples of those are on the font mappings page
• Load Signum! printer charsets (*.P24/ps240001 and *.L30/ls300001)
  • Print height and width for each character
  • Print ASCII art for each character bitmap
• Load Signum! images (*.IMC, bimc0002)
  • Produce a PNG for monochrome images exported from a document
  • NOTE: It's a tiny step from there to exporting images from a document on the fly.

This project is implemented in the Rust programming language. You can either download the compiled executables (recommended) or build the program from source using cargo.

1. Go to https://github.com/Xiphoseer/sdo-tool/releases
2. Download "sdo-toolbox-XXX.zip" where XXX is your operating system
3. Unzip the archive to sdo-toolbox-XXX
4. Use/Copy sdo-toolbox/sdo-tool (Linux/OSX) or sdo-toolbox/sdo-tool.exe (Windows)

1. Install Rust
2. Clone this repository (git clone [email protected]:Xiphoseer/sdo-tool.git)
3. OR download it from https://github.com/Xiphoseer/sdo-tool/archive/main.zip
4. In the folder that contains Cargo.toml run cargo build --release / cargo.exe build --release
5. Use/Copy target/release/sdo-tool (Linux/OSX) or target/release/sdo-tool.exe (Windows)

On Linux and MacOS, you can copy sdo-tool to /usr/local/bin to have it available everywhere. On all operating systems, you can add the sdo-toolbox or release folder to the PATH environment variable (See this guide) for the same result.

At the moment, this program is not released on https://crates.io, so it cannot be installed using cargo install yet.

1. sdo-tool --format pdf SOMEFILE.SDO to get a PDF file
2. sdo-tool --format png SOMEFILE.SDO to get a sequence of PNG files
3. sdo-tool SOMEFILE.SDO to print some text to the console
4. sdo-tool SOMEFILE.E24 to print all characters in the font to the console
5. sdo-tool SOMEFILE.IMC to convert an IMC image file to a PNG file

$ ls
FILE.SDO
CHSETS
sdo-toolbox
$ cd sdo-toolbox
$ ./sdo-tool --format pdf ../FILE.SDO
...
$ open ../FILE.pdf

See this document

See this document for mappings from standard Signum! fonts to Unicode codepoints.

• Signum! Document (sdoc0001)
• Editor Charset (eset)
• Signum! Compressed Image (bimc)

You are free to download, and run this software for any personal and non-commercial reason, at your own risk and without claiming fitness for any particular purpose. If you want to contribute to this project or use it for any kind of distribution or commercial purpose, please file a github issue or send me an email at [email protected].

• Lonny Pursell for helping me figure out the image reading based on his zView-compatible codec
• Oliver Buchmann of Application Systems Heidelberg for helping me set up Signum in an emulator.
• Thomas Tempelmann for the Megamax-2 Doku as example files (with images!) and a SignumRead (S/MYUTIL/SIGNUMRE.M) Program from his MM2 dev-environment
• Georg Scheibler for his article and source code for converting 1stWord to Signum
• The image-rs Developers for the PNG generation library
• "The 68000's Instruction Set", which is excellent but sadly doesn't include an author
• Wikipedia editors for confirming that 0 means white for an ATARI ST screen dump
• The rust compiler + ecosystem people for creating a useful language with really good tooling which made porting 68K assembly to working rust code really smooth