genact: A Nonsense Activity Generator for the Terminal

What genact Does and Who Uses It

genact plays back fake terminal sessions that look like real developer work. Each run cycles through one or more modules, each of which outputs a stream of plausible-looking text: a Cargo build log, a Docker image pull, a kernel compilation, a cryptomining session, or a download progress bar. The output is generated procedurally and differs on each run because it draws on random data, so the screen never looks static or looping.

The README describes the primary use case directly: pretending to be busy or waiting for the computer when you should be doing real work, and impressing people with apparent multitasking. It also suits demonstrations where a terminal in the background adds credibility, screen recording scenarios where the background looks technical, or screensaver use. Nothing in any module reflects actual system state. No real processes run, no files are read or written, and the output has no side effects on the host.

Twenty-Two Fake Scenes: The Module System

genact organizes its output into discrete modules. The full list as of v1.5.1 includes: ansible, bootlog, botnet, bruteforce, cargo, cc, composer, cryptomining, docker_build, docker_image_rm, download, julia, kernel_compile, memdump, mkinitcpio, rkhunter, simcity, terraform, uv, weblog, and wpt. Each module outputs text that mimics a specific developer tool or system event. The cargo module produces output that looks like a Rust compilation. The docker_build module prints lines resembling a Docker image build. The kernel_compile module simulates a Linux kernel compilation with the file names and stage labels that make it recognizable.

The modules use the fake crate (v5.0 in Cargo.toml) to generate random names, dates, and identifiers, and the rand and rand_distr crates for randomized timing and pacing. The sha2 and hex crates produce realistic-looking hash strings that appear in modules like cryptomining. All of this produces output that reads as authentic at a glance, even though the underlying data is entirely synthetic.

By default, genact picks modules at random and cycles through them. The -m flag restricts the run to a specific set of modules. You can see the available options by running:

./genact -h

The help output lists every flag including -l for listing modules, -s for the speed factor, --exit-after-time, and --exit-after-modules.

Installing genact on Linux, macOS, Windows, and FreeBSD

genact provides pre-built binaries for all major platforms. No runtime dependencies are required beyond the binary itself. On Linux, download genact-linux from the releases page and run:

chmod +x genact-linux
./genact-linux

On macOS, Homebrew provides a direct install path:

brew install genact

MacPorts is also supported for macOS:

sudo port install genact

On FreeBSD the package manager installs and runs it in two commands:

pkg install genact
genact

On Windows, Scoop users can run:

scoop install genact

For those with a Rust toolchain already installed, the Cargo install path works across all platforms:

cargo install genact
genact

The Docker image is available at svenstaro/genact on Docker Hub. To print help and see all available flags from the container:

docker run -it --rm svenstaro/genact -h

Controlling Speed, Duration, and Startup Behavior

Three flags control how long genact runs and how fast it outputs text. The -s or --speed-factor flag accepts a floating-point multiplier: 2 runs at double speed, 0.5 at half speed. The --exit-after-time flag stops genact after a fixed duration, accepting values in a human-readable format such as 2h10min. The --exit-after-modules flag stops after a set number of modules have finished.

The -i or --instant-print-lines flag prints a given number of lines instantly at startup before switching to the normal timed output. This is useful when genact is started mid-presentation and you want the screen to already look busy before the audience notices.

The keepawake crate is included as a dependency on Linux, macOS, and Windows targets. This prevents the system from sleeping while genact is running, which is useful for the screensaver use case but means leaving genact unattended will keep the machine awake. The crate is explicitly excluded from the wasm32 target in Cargo.toml, so the browser version does not carry this behavior.

The WebAssembly Web Version

A live web version runs at https://svenstaro.github.io/genact/ and requires no installation. The same Rust source compiles to WebAssembly using the Trunk build tool. The build-web target in the Makefile shows the compile command:

RUSTFLAGS='--cfg getrandom_backend="wasm_js"' trunk build --release

The web version accepts URL query parameters to configure behavior. To run specific modules, append them as module parameters: https://svenstaro.github.io/genact?module=cc&module=memdump. To set the speed factor: https://svenstaro.github.io/genact?speed-factor=5.

The Cargo.toml wasm32 target uses wasm-bindgen, wasm-bindgen-futures, js-sys, url, and web-sys (with Window, Location, and console features). The console_error_panic_hook crate provides readable error messages in the browser console. The clap argument parser and terminal_size crates are excluded from the wasm32 build since the browser version receives configuration through URL parameters rather than command-line flags.

What genact Cannot Do

genact has no plugin or extension system. The 22 modules are compiled into the binary, and adding a new module requires writing Rust code and rebuilding. There is no configuration file for adjusting module behavior or adding custom output patterns.

The tool does not read system information. It cannot produce output that references your real hostname, username, project name, or directory structure. Every string it prints is generated from internal templates and random data, which means a careful observer can notice that the output never references anything real from the machine it is running on.

The tool also does not support mixing modules within a single visible session. It runs one module at a time to completion (or to an interrupt), then switches to another. There is no mode that interleaves output from multiple modules simultaneously in the same terminal.

The comparison point is cmatrix, a C program that displays animated Matrix-style green characters in a terminal. cmatrix produces unmistakably fake output; genact aims to produce output that reads as plausible developer activity at a distance. cmatrix is purely visual, while genact simulates specific known developer tool output.

The tool also does not support adding time-limited interactive prompts or responses. It outputs a stream of text and does not pause for user input in its simulation. If you press Ctrl+C, it exits cleanly; otherwise it runs until --exit-after-time or --exit-after-modules stops it, or until the terminal session closes.

Building from Source, Release Profile, and Maintenance

Building from source requires a recent Rust and Cargo installation:

git clone https://github.com/svenstaro/genact.git
cd genact
cargo run --release

The release profile in Cargo.toml is configured for minimum binary size: lto is set to true for link-time optimization, opt-level is set to 'z' for size optimization, codegen-units is set to 1, and strip is set to debuginfo. The Makefile release targets additionally run upx with the --lzma flag to compress the final binary further.

Cross-compilation for Windows uses a mingw linker: RUSTFLAGS="-C linker=x86_64-w64-mingw32-gcc" with the x86_64-pc-windows-gnu target. The web build requires the Trunk tool and the wasm-bindgen toolchain.

genact is licensed under the MIT license and authored by Sven-Hendrik Haase. The current version is 1.5.1, released on 2026-01-26. The last push to the repository was on 2026-09-01. The CHANGELOG.md documents changes by version and is available in the repository root. The repository also includes a CONTRIBUTING.md and a PULL_REQUEST_TEMPLATE.md for anyone who wants to add a new module or fix a bug in an existing one.

Editorial conclusion

genact is a single-purpose tool with a clear scope: it fakes terminal activity convincingly enough to look busy, and nothing more. It is not a security or productivity tool. It is appropriate for demonstrations where a live terminal helps set the scene, or for anyone who needs a credible-looking screen to walk past. The 22 built-in modules cover common developer scenarios. New modules cannot be added without modifying the Rust source. Check the CHANGELOG.md in the repository for additions since v1.5.1, which was released on 2026-01-26.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. svenstaro/genact on GitHub