Is there any text to speech program that will run on an 8- or 16-bit CPU?

Question

I'm wondering if any of the ancient 1980's style text to speech algorithms were saved from oblivion and are still available. It might be nice to hear that vintage sound like what appeared in War Games.

Answer 1

Superior Software's "Speech" was a pure software speech synthesizer that ran on the BBC Micro (which used a 2MHz 6502A processor, so had slightly more raw processing power than typical 8-bit machines); it is described in detail on this page, which states it was inspired by similar programs on C64 and Spectrum that achieve it using sound chips (so the Spectrum must have been the 128K version, as the original 16/48K versions had no sound chip) but this system just uses direct control of the built-in speaker to produce the sound.

Answer 2

First, there is a major caveat. Most of the iconic early voice synthesizers were not purely software systems. For example, the classic DECTalk system, famously the voice of the late Stephen Hawking, was a discrete unit that connected by serial RS-232. It is effectively a closed box that is sent ASCII text and generates line-level audio. Internally, I vaguely recall reading that it's a mix of a general-purpose processor with dedicated signal processors and audio synthesis hardware. The Ti LPC speech synthesis chips, as used in the Speak and Spell products, were similar. The chips can synthesize basic phonemes and words, and a microcontroller or microprocessor has to do the text analysis and drive the synthesis chip.

The fact is that the classic 8/16 bit processors just don't have enough oomph to pull off speech synthesis in software well, at least in real time. Still, there were a number of respectable attempts. SAM (Software Automatic Mouth) was one of the first, and one of the more popular. It runs on the Commodore 64 and other machines. A clever hacker recently ported the algorithm to Javascript, so you can hear it in your browser.

Answer 3

There existed a Russian text-to-speech program written for the Elektronika BK-0010 in the early 1980s, whose length was 023500 bytes == 10048, mentioned in a list of application programs for the BK-0010 under the name of ГОВОРУН ("Chatterer", after a talking bird in a childrens' book/cartoon The Mystery of the Third Planet).

Its sound quality was barely recognizable for an untrained ear, partially because the computer had only a 1-bit manipulated buzzer, but reportedly it had been written by request of the All-Union Society of the Blind, and it took the members of the target audience about 10-15 minutes to get accustomed to it and to start using it productively.

The trick was to record the phonemes using as narrow a frequency band as necessary for marginal recognition, and to encode each phoneme using as low a frequency as possible for that specific phoneme. This process has made some phonemes, like S and F, sound pretty much the same, allowing to save more memory by folding them.

Needless to say, there was the phonetic alphabet spelling mode, switchable by a keypress, and "repeat last word" and/or "repeat last sentence" keys as well.

Answer 4

Is the 68000 a 16-bit CPU? :) To some it is, and therefore Say, from 1985, for the Commodore Amiga counts. It can be found on the Workbench disk. For more reading, look up the narrator.device interface on the AmigaOS wiki: https://wiki.amigaos.net/wiki/Narrator_Device

And here's Steamed Hams recreated using Say: https://www.youtube.com/watch?v=Rx6mJ4XY0oQ

Answer 5

see:

• CZ+SK ZX SW archive

In there are TTS engines for ZX Spectrum (1bit digital sound, no DAC, no FPU, no mul/div instructions, ~3.5 MHz 8bit Z80 CPU):

1. Kecal 1.0

   very simple asm, (portable to C/C++ see the link below), very low demands on CPU. It is not very good quality

2. Kecal 2.3

   much improved quality

3. ZX Fone

   its slightly worse than Kecal 2.3

4. Hlasovy program

   this one is very good quality (much better than Kecal 2.3, you can recognize the words easily). Its just 801 Bytes of assembly code.

also see:

• SE/SO:Can arduino tell room temperature by voice call using sim900?

[Edit1] C++ port of Hlasový program

I am happily announcing that I successfully disassembled and port the awesome ancient TTS engine from Voicesoft into C++. For simplicity I added sound API header void sound_out(bool on); that must be implemented in order to use this. It should simply add a sample to sound buffer (or synchronize with time and output to sound port). Here the ported code:

//---------------------------------------------------------------------------
//---  ZX Hlasovy program Voicesoft 1985  -----------------------------------    
//--- ported to C++ by Spektre ver: 1.000 -----------------------------------
//---------------------------------------------------------------------------
#ifndef _speech_h
#define _speech_h
//---------------------------------------------------------------------------
// API:
void sound_out(bool on);    // you need to code this function (should add a sample to sound output)
void say_text(char *txt);   // say null terminated text, "a'c'" -> "áč"
//---------------------------------------------------------------------------
// internals:
void say_char(char chr);    // internal function for single character (do not use it !!!)
void say_wait(WORD ws);     // internal wait (do not use it !!!)
//---------------------------------------------------------------------------
// vars:
bool _sound_on=false;       // global state of the reproductor/sound output
//---------------------------------------------------------------------------
// config: (recomputed for 44100 Hz samplerate)
const static BYTE t_speed=5;        // [samples] speech speed (pitch)
const static WORD t_pause=183;      // [samples] pause between chars
const static WORD t_space=2925;     // [samples] pause ` `
const static WORD t_comma=5851;     // [samples] pause `,`
//---------------------------------------------------------------------------
// tables:
const static BYTE tab_char0[52]=    //  0..25 normal alphabet A..Z
    {                               // 26..51 diacritic alphabet A..Z
    0x00,0x02,0x06,0x0a,0x0e,0x10,0x12,0x16,0x1a,0x1c,0x22,0x26,0x2a,0x2e,0x32,
    0x34,0x38,0x42,0x48,0x4a,0x4e,0x50,0x50,0x56,0x1a,0x5c,0x64,0x66,0x70,0x74,
    0x7a,0x7c,0xc2,0x84,0x86,0xc2,0xc2,0xc2,0x88,0x8c,0x92,0x94,0xc2,0x9e,0xa6,
    0xa8,0xae,0xb0,0xc2,0xc2,0x86,0xbc
    };
const static BYTE tab_char1[196]=
    {
    0x36,0x81,0x34,0x19,0x31,0xab,0x18,0x19,0x91,0xc3,0x34,0x19,0x31,0xe0,0x36,
    0x84,0x92,0xe3,0x35,0x19,0x51,0x9c,0x31,0x31,0x34,0x96,0x36,0x87,0x33,0x3a,
    0x32,0x3d,0x32,0xc0,0x18,0x19,0x51,0x9c,0x33,0x22,0x31,0xb1,0x31,0x31,0x36,
    0xa5,0x31,0x31,0x36,0xa8,0x36,0x8a,0x18,0x19,0x31,0xab,0x18,0x19,0x51,0x1c,
    0x34,0x31,0x32,0x34,0x32,0xb7,0x22,0x10,0x13,0x19,0x21,0xae,0x92,0xc3,0x18,
    0x19,0x31,0xe0,0x36,0x8d,0x34,0x31,0x32,0x34,0x32,0xb7,0x18,0x19,0x71,0x1c,
    0x92,0xc3,0x32,0x31,0x32,0x43,0x32,0x44,0x32,0xc5,0x3f,0x81,0x34,0x19,0x31,
    0x2b,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x18,0x19,0x91,0xd3,0x33,0x19,0x71,0x6d,
    0x32,0x93,0x3e,0x84,0x92,0x63,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x92,0xf3,0x3e,
    0x87,0x31,0x31,0x36,0x25,0x31,0x31,0x35,0x25,0x32,0x93,0x3e,0x8a,0x18,0x19,
    0x31,0x2b,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x13,0x19,0x32,0x60,0x13,0x19,0x71,
    0xdd,0x92,0xd3,0x18,0x19,0x71,0x6d,0x32,0x93,0x3e,0x8d,0x34,0x31,0x32,0x34,
    0x32,0x37,0x33,0x3a,0x32,0x3d,0x32,0xc0,0x32,0x53,0x32,0x54,0x32,0xd5,0x1a,
    0x99
    };
const static BYTE tab_char2[262]=
    {
    0x1a,0x99,0xe1,0xc3,0xe1,0xc7,0x8f,0x0f,0xf8,0x03,0x0f,0x07,0xc1,0xe3,0xff,
    0x40,0x17,0xff,0x00,0x03,0xf8,0x7c,0xc1,0xf1,0xf8,0x03,0xfe,0x00,0x7f,0xfc,
    0x00,0x03,0xf8,0x0f,0x09,0xf1,0xfe,0x03,0xef,0x40,0x17,0xff,0x00,0x03,0xe1,
    0x5c,0x35,0xc5,0xaa,0x35,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x8e,0x38,0x73,
    0xcf,0xf8,0x78,0xc3,0xdf,0x1c,0xf1,0xc7,0xfe,0x03,0xc0,0xff,0x00,0x00,0xff,
    0xf8,0x00,0x7f,0xf8,0x03,0xff,0xf0,0x01,0xff,0xe0,0x03,0xaa,0xca,0x5a,0xd5,
    0x21,0x3d,0xfe,0x1f,0xf8,0x00,0x00,0x1f,0xff,0xfc,0x20,0x00,0x00,0x03,0xff,
    0xff,0x08,0x79,0x00,0x02,0xff,0xe1,0xc7,0x1f,0xe0,0x03,0xff,0xd0,0x01,0xff,
    0xf0,0x03,0x7f,0x01,0xfa,0x5f,0xc0,0x07,0xf8,0x0f,0xc0,0xff,0x00,0x42,0xaa,
    0xa5,0x55,0x5a,0xaa,0xaa,0x5a,0xa5,0x5a,0xaa,0x55,0x55,0xaa,0xaa,0xa5,0x55,
    0xaa,0x5a,0xaa,0xa5,0x55,0xaa,0xaa,0xa5,0x55,0xaa,0xaa,0x55,0xa5,0xa5,0xaa,
    0xa5,0xb7,0x66,0x6c,0xd8,0xf9,0xb3,0x6c,0xad,0x37,0x37,0x66,0xfc,0x9b,0x87,
    0xf6,0xc0,0xd3,0xb6,0x60,0xf7,0xf7,0x3e,0x4d,0xfb,0xfe,0x5d,0xb7,0xde,0x46,
    0xf6,0x96,0xb4,0x4f,0xaa,0xa9,0x55,0xaa,0xaa,0xa5,0x69,0x59,0x9a,0x6a,0x95,
    0x55,0x95,0x55,0x6a,0xa5,0x55,0xa9,0x4d,0x66,0x6a,0x92,0xec,0xa5,0x55,0xd2,
    0x96,0x55,0xa2,0xba,0xcd,0x00,0x66,0x99,0xcc,0x67,0x31,0x8e,0x66,0x39,0xa6,
    0x6b,0x19,0x66,0x59,0xc6,0x71,0x09,0x67,0x19,0xcb,0x01,0x71,0xcc,0x73,0x19,
    0x99,0xcc,0xc6,0x67,0x19,0x9a,0xc6,
    };
const static BYTE tab_char3[5]={ 0x00,0x2e,0x5a,0x5e,0xfe };
//---------------------------------------------------------------------------
void say_text(char *txt)
    {
    WORD hl;
    BYTE a,b,c;
    for (b=0xBB,hl=0;;hl++)     // process txt
        {
        a=b;                    // a,c char from last iteration
        c=b;
        if (!a) break;          // end of txt
        b=txt[hl];              // b actual char
        if ((b>='a')&&(b<='z')) b=b+'A'-'a'; // must be uppercase
        a=c;
        if ((a>='A')&&(a<='Z'))
            {
            // handle diacritic
            if (a!='C'){ a=b; if (a!='\'') a=c; else{ a=c; a+=0x1A; b=0xBB; }}
            else{
                a=b;
                if (a=='H'){ a+=0x1A; b=0xBB; }
                 else{ if (a!='\'') a=c; else{ a=c; a+=0x1A; b=0xBB; }}
                }
            // syntetize sound
            say_char(a);
            continue;
            }
        if (a==',')say_wait(t_comma);
        if (a==' ')say_wait(t_space);
        }
    }
//----------------------------------------------------------------------
void say_wait(WORD ws)
    {
    for (;ws;ws--) sound_out(_sound_on);
    }
//----------------------------------------------------------------------
void say_char(char chr) // chr =  < `A` , `Z`+26 >
    {
    WORD hl,hl0,cy,cy0;
    BYTE a,b,c,ws;
    hl=tab_char0[chr-'A'];
    for (;;)
        {
        c =tab_char1[hl  ]&0x0F;
        c|=tab_char1[hl+1]&0x80;
        for (;;)
            {
            a=tab_char1[hl];
            a=(a>>5)&7;
            cy=a&1;
            hl0=hl;
            if (a!=0)
                {
                b=tab_char3[a];
                hl=hl0;
                a=tab_char1[hl+1];
                hl0=hl;
                cy0=(a>>7)&1;
                a=((a<<1)&254)|cy;
                cy=cy0;
                hl=a;
                a=0x80;
                for (;;)
                    {
                    _sound_on=(a&tab_char2[hl]);
                    for (ws=t_speed;ws;ws--) sound_out(_sound_on);
                    b--;
                    if (!b) break;
                    cy=a&1;     
                    a=((a>>1)&127)|(cy<<7);
                    if (!cy) continue;
                    hl++;
                    }
                }
            a^=a;
            say_wait(t_pause);
            c--;
            a=c&0x0F;
            hl=hl0; 
            if (a==0) break;
            }
        cy0=(c>>7)&1;
        a=((c<<1)&254)|cy;
        cy=cy0;
        if (cy) return;
        hl+=2;
        }
    }
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------

It does not use any libs,files or whatever... If your environment does not have BYTE,WORD then use unsigned int instead... I tried it with 44100Hz sampling rate on PC and the sound is superior to any other TTS I tried over the years.

The sound is quite good even on AVR32 (however need a normal reproduktor instead of the small beepers).

In case you're interested how it works see this:

• Understand/Reverse simple (but good quality) TTS engine

Where much more in depth analysis (up to the last bit of data) and much more didactical code and data can be found for this.

Here a small win32/waveout demo for testing just do not forget to write the text phoneticaly... have fun:

• win32 TTS port

It responds to these keys:

• [enter ] will send text from edit box to TTS
• [up arrow] will return last string to edit box
• [escape ] clears the edit box

Answer 6

Of course there was the Acorn Speech System for the BBC Micro.
This required two Texas Instruments chips to be fitted below the keyboard, so was not a pure software solution.

Different to most of the other answers in that it took phoneme input rather than pure text but that meant that it gave much clearer, comprehensible audio than many of its competitors.
Back in the day I used it do provide alarms in a process automation setting. It was deemed much safer to have a call like Crane A Descending, or "Crane B Ascending" than to have a range of different bleeps that everyone forgot which was which.

It famously used the digitized voice of Kenneth Kendall, a BBC newsreader at the time. He also appeared in the film 2001: A Space Odyssey, playing a BBC newsreader.

Answer 7

Another such program from the early ’80s was the Software Automatic Mouth. I also had hazy memories of a demo of The Voice by Muse Software, for Apple ][e. (“Merry Christmas from Santa and the voice of Muse ....”)

Answer 8

The Texas Instruments TI-99/4A could do text-to-speech if you had the Terminal Emulator II cartridge and the Solid State Speech Synthesizer. (More information about the latter can be found in the manual.)

Answer 9

For the 1980's Microbee (z80) there was a hardware module named "Bee Talker" which plugged into a parallel port. It looks nearly exactly like the "Beethoven" unit in this image (seen sitting next to the "keyboard"), except it was labelled "Beetalker":

It had a simple Text-to-Speech software interface that came with the module. Whatever you typed in the console would be somewhat weirdly converted to speech. I don't remember exactly what worked well, but sometimes you had to phonetically misspell the word to get the desired result.

The module has been re-released should you want to connect it to an Arduino or whatever.

EDIT: Finally found a better image:

Answer 10

You can find various incarnations of the formant synthesizer underlying DECTalk here

I doubt you could get satisfactory results on an 8-bit processor. 16-bit, yes (though you may need to rewrite the floating point code as fixed point). I assume the original Macintalk used a fairly similar algorithm, though I never saw that source code. MacinTalk 3 ("Fred" and related voices), that has been available on Macs for more than 30 years, uses a similar method.

Klatt also wrote a fairly readable book describing a somewhat earlier system.

Ultimately, it's probably memory that is the limiting factor for a 1980s system. Processing power of 16 bit processors is OK for formant synthesis, but in English, you're never going to have very accurate pronunciation without a large dictionary or an enormous rule set.

Answer 11

Here is an online version of S.A.M. for c64, you can type some text onto the web page and tape the audio: https://discordier.github.io/sam/

There are music plugins also based on mac and atari st which are designed for music enhancements on top of the original speech engine code: https://www.youtube.com/watch?v=FmaeI5eoeH0&ab_channel=PlogueArtetTechnologie%2CInc. there are demo versions of it someplace on the web.

Answer 12

The IIgs has enough hardware to pull off pretty good software only speech using SmoothTalker. The speech engine from SmoothTalker was used in a number of other IIgs programs including the Talking series for reading and math. Even a typing program for the IIgs used speech, my daughter used it and the speech is pretty good by current standards.

Answer 13

War Games... was not actually computer generated

You mention the War Games voice. It was not an artificial voice, but an actor. He said the sentences with words in reversed order, which were edited later. Ref:

• https://www.imdb.com/title/tt0086567/trivia#tr5373943
• 8bit guy video mentioned by @RCDAWebmaster link to relevant instant

What you've been asking for: "...saved from oblivion and are still available"

Yes! Thanks to the 8bit guy for the information. You can:

• visit https://www.simulationcorner.net/index.php?page=sam
• get source code https://github.com/s-macke/SAM or https://github.com/vidarh/SAM

This does compile and work on a modern machine.

Software-only solutions, of the era

It looks like there is a full software-based solution (I have not tested it): https://cpcrulez.fr/applications_music-superior_software-speech__MANUEL__ENGLISH.htm

Common solution at the time: 8-bit speaking machines often used dedicated optional chips

As mentioned in one comment, during the 8bit era, common solutions used dedicated chips.

• General Instrument SP0256 demoed on the same page and e.g. on Roland in Space with SSA-1 Speech Synthesiser and GLEN HODDLE SOCCER with SSA-1 Speech Synthesiser. Each chip was more or less specialized, the most common one did generic English voice.
• MEA8000 was more flexible, allowing several languages.

Example: the SSA-1 for the Amstrad CPC

Typically, it was a multi-tier solution.

Below is outlined the example of SSA-1 the Amstrad CPC:

• the early (high-level) part of the text-to-speech was done on the host computer CPU, and transformed regular (English) text into a series of allophones (typically, 64 different) -- this could be bypassed using an API that provides a way to directly request a series of allophones. On the Amstrad CPC, both options were available: user was offered to load specific software, made additional commands "RSX" available from Basic, (and therefore from assembly code, too, although assembly production would typically directly target the next step because they don't need to parse generic English sentence, only pronounced pre-defined utterances).
• allophones codes were transmitted to the chip, one byte per allophone, via regular I/O interchip communication
• on the chip, a real-time microcontroller turned allophone codes into low-level vocal tract simulation parameters, and tuned in real time the hardware registers to command the next step
• dedicated hardware performed the digital computation of the vocal tract model, and output a PCM signal
• a digital-to-analog step provided analog output signal at line level
• an amplifier brings signal to speaker level.

All those steps (including the speakers) are integrated in the SSA-1 solution for the Amstrad CPC. In the very first step, the solution is software running on the host computer, the rest is extra hardware.

More details on the SSA-1: Amstrad SSA-1 Speech Synthesizer - CPCWiki

Answer 14

The early days of audio on IBM PC compatibles have a few examples of speech synthesis. These qualify for your 16-bit category as the 8088 and 80286 were 16-bit CPUs (though the 8088 was crippled by an 8-bit data bus).

The Covox Speech Thing was a parallel port DAC intended to be used with software-based speech synthesis. I assume such a program came with it, given that while there were a decent number of programs that supported it, I never ran across anything to do with speech synthesis.

Creative Labs shipped a program called Dr Sbaitso with the original Sound Blaster cards. It was essentially an ELIZA chat-bot coupled to a speech synthesiser (all done in software). Being an 8-bit ISA card that worked in an original 16-bit IBM PC, this definitely qualifies.

The later Sound Blaster 16 ASP and Sound Blaster AWE32 included the Advanced Signal Processor chip, which provided hardware-accelerated speech synthesis capabilities, but didn't get much, if any, use outside of Creative's own software. Whether these two qualify is debatable, given they're 16-bit ISA cards that probably would work in a 286, but which came out when everyone was using 32-bit 386 or 486 CPUs.

The OPL2 FM synthesiser chip that powered the Adlib and early Sound Blaster cards' music capabilities included a Composite Sine Modelling mode that could be used for hardware-assisted speech synthesis, but as far as I know it was never used. Adlib's programming guide from 1987 mentions the feature, then promptly dismisses it saying there are better-quality methods available.

There were certainly a few programs that could produce speech through the PC Speaker, but I have no idea if they were synthesising it or just playing back samples, and I don't remember any names, anyway.

Answer 15

Sure; e.g. the Naval Research Laboratory published a document (NRL-7948) in 1976 entitled: "Automatic Translation of English Text to Phonetics by Means of Letter-to-Sound Rules" (a copy here)

This was within the capability of 8-bit machines. (I myself have implemented the algorithm a few times on microcontrollers - in this case, the rules took just over 8,000 bytes. You'll need a little more for the code that runs them.)

This performs the text-to-speech operation, converting English text to a phoneme sequence that would then be fed into the synthesis device. This part was usually hardware.

Edit: If you're curious about the results using this ruleset, here is sample output from text-to-speech'ing the lyrics to The Doors 'Hello'. There are a few mispronunciations that are amusing; e.g. 'sky' is pronounced as we would 'ski'.

Answer 16

If you want a decent history of speech synthesis check out this video by the 8 bit guy

Answer 17

The original 1984 Macintosh (which ran on a Motorola 68000) had Macintalk. It ran reasonably well. It voiced one of the characters in the movie WALL-E. It shows up in a large number of pop culture places. Check out the In Popular Culture section of https://en.m.wikipedia.org/wiki/PlainTalk

I bet if I pulled my 1984 Mac out of the closet and found the right diskette, I could convince it to talk. It was a pretty amazing party trick back in the day