Gfilui

I tried xdotool after reading @dessert's answer but couldn't get it to work for some reason. So I came up with this:

while read line
do
 grep -o . <<<$line | while read a
 do
 sleep 0.1
 echo -n "$a:- "
 done
 echo
done

Pipe your text into the above code and it will be printed like typed. You can also add randomness by replacing sleep 0.1 with sleep 0.$((RANDOM%3)).

Extended version with fake typos

This version will introduce a fake typo every now and then and correct it:

while read line
do
 # split single characters into lines
 grep -o . <<<$line | while read a
 do
 # short random delay between keystrokes
 sleep 0.$((RANDOM%3))
 # make fake typo every 30th keystroke
 if [[ $((RANDOM%30)) == 1 ]]
 then
 # print random character between a-z
 printf "\$(printf %o "$((RANDOM%26+97))")"
 # wait a bit and delete it again
 sleep 0.5; echo -ne 'b'; sleep 0.2
 fi
 # output a space, or $a if it is not null
 echo -n "$a:- "
 done
 echo
done

You mention a consistent delay between characters, but if you really want it to look like its being typed, the timing won't be perfectly consistent. To achieve this you can record your own typing with the script command and play it back with scriptreplay:

$ script -t -c "sed d" script.out 2> script.timing
Script started, file is script.out
Wake up ...
Wake up ...
Wake up Neo ...
Script done, file is script.out
$ 
$ scriptreplay script.timing script.out
Wake up ...
Wake up ...
Wake up Neo ...

$ 

Recording is stopped by hitting CTRL-D.

Passing the -t parameter to script instructs it also generate timing information, which I have redirected to the script.timing file. I have passed sed d as a command to script as this is simply a way to absorb input (and this record the keystrokes) with no side-effects.

If you want to do all the tput/reset stuff too, you might want to do a script recording for each of your lines, and play them back, interleaved with the tput/reset commands.

Another possibility is using Demo Magic, or, to be more precise just the print function of this script collection, which basically amounts to

#!/bin/bash

. ./demo-magic.sh -w2

p "this will look as if typed"

Under the hood, this uses pv, which of course you can also use to directly get the desired effect, the basic form looks as follows:

echo "this will look as if typed" | pv -qL 20

In line with my nickname I can offer another solution:

echo "something" | 
 perl 
 -MTime::HiRes=usleep 
 -F'' 
 -e 'BEGIN =1 for (@F) print; usleep(100_000+rand(200_000)) '

Looks weird, doesn't it?

• 
  -MTime::HiRes=usleep imports the function usleep (microsecond sleep) from the Time::HiRes module because the usual sleep accepts only integer seconds.


• 
  -F'' splits the given input into characters (the delimiter being empty '') and puts the characters in the array @F.


• 
  BEGIN =1 disables output buffering so each character is immediatly printed.


• 
  for (@F) print; usleep(100_000+rand(200_000)) just iterates over the characters


• putting underscores in numbers is a common way to use some kind of thousands separators in Perl. They are simply ignored by Perl, so we can e.g. write 1_000 (==1000) or even 1_0_00 if we consider that easier to read.


• 
  rand() returns a random number between 0 and the given argument, so together this sleeps between 100,000 and 299,999 microseconds (0.1-0.3 seconds).

Another tool that might work, which does not depend on x11 or whatever, is asciicinema. It records everything you do in your terminal and lets you replay that as if it were a screen capture, only then it's purely ascii based! You might have to temporarily disable your prompt however for it to be purely visually clean. As other have pointed out, adding a consistent delay will not look natural, and typing it yourself might be one of the most natural looks you can achieve.

After having recorded the text, you can do something like:

$ asciinema play [your recording].cast; cmatrix

I'm surprised nobody's mentioned this yet, but you can accomplish this with stock tools and a loop:

typeit() 
 local IFS=''
 while read -n1 c; do
 echo -n "$c"
 sleep .1
 done <<< "$1"

It just loops over the input character by character and prints them out with a delay after each. The only tricky bit is that you have to set your IFS to an empty string so bash doesn't try to split away your spaces.

This solution is dead-simple, so adding variable delays between characters, typos, whatever is super easy.

EDIT (thanks, @dessert):
If you want a slightly more natural interface, you could instead do

typeit() 
 local IFS=''
 while read -n1 c; do
 echo -n "$c"
 sleep .1
 done <<< "$@"

This would allow you to call the function as typeit foo bar rather than typeit 'foo bar'. Be aware that without quotes, the arguments are subject to bash's word splitting, so for example typeit foo<space><space>bar will print foo<space>bar. To preserve whitespace, use quotes.

First, "look as though it's being typed, with a consistent delay between characters..." is a little contradictory, as others have pointed out. Something being typed doesn't have a consistent delay. When you see something produced with an inconsistent delay, you'll get chills. "What's taken over my computer!!!??!?"

Anyway...

I have to make a shout out to expect, which should be available on most Linux distributions. Old School, I know, but- assuming it's installed- it could hardly be simpler:

echo 'set send_human .1 .3 1 .05 2; send -h "The Matrix has you......n"' | expect -f /dev/stdin

From the man page:

The -h flag forces output to be sent (somewhat) like a human actually typing. Human-like delays appear between the characters. (The algorithm is based upon a Weibull distribution, with modifications to suit this particular application.) This output is controlled by the value of the variable "send_human"...

See https://www.tcl.tk/man/expect5.31/expect.1.html