A C# / .NET 10 Native-AOT parity port of ttfx — a single-binary terminal text-effects CLI with 37 effects. Pipe text in, pick an effect:

printf 'Hello\n' | ./artifacts/ttfx wipe
fortune | ./artifacts/ttfx --random-effect

Every clip is hypa-logo.txt piped through that effect with --seed 42.

beams	binarypath	blackhole
bouncyballs	bubbles	burn
colorshift	crumble	decrypt
errorcorrect	expand	fireworks
highlight	laseretch	matrix
middleout	orbittingvolley	overflow
pour	print	rain
randomsequence	rings	scattered
slice	slide	smoke
spotlights	spray	swarm
sweep	synthgrid	thunderstorm
unstable	vhstape	waves

Regenerate with ./bin/build and tools/render_examples.py (Pillow + ffmpeg).

This is a port of a port. Every effect, the animation engine, and the CLI are ChrisBuilds' design in TerminalTextEffects (TTE). ttfx translated that work to Rust; this project translates ttfx to C# and adds nothing to the art. If you like what you see here, star the upstream projects.

Attribution details are in LICENSE and NOTICE. Effect ideas belong upstream.

This is a parity port: given the same input, config, and seed, hypa-ttfx aims for byte-identical frame output to the pinned ttfx binary (REFERENCE.md).

Verified on this project's CI / local testing:

Publishing four RIDs under a claim tested on one machine would overclaim — maths-library behavior, AOT codegen, and signal delivery can differ by architecture. The README states what has actually been measured.

./bin/test runs the full gate: unit goldens, AOT publish, CLI corpus, signal tests, and (on Linux or when reference/ttfx is present on macOS) byte-exact parity suites.

Other .NET 10+ programs consume the engine as Hypa.Ttfx:

dotnet add package Hypa.Ttfx

using Ttfx;

IReadOnlyList<string> frames = TextEffects.Render(
    "wipe",
    "Hello from .NET\n",
    new TextEffectOptions { Seed = 42 });

foreach (string frame in TextEffects.EnumerateFrames("smoke", "Hello\n", new TextEffectOptions
{
    Seed = 42,
    EffectArguments = ["--final-gradient-stops", "8A008A", "00D1FF"],
}))
{
    Console.Write(frame);
}

Render / EnumerateFrames use a virtual clock and ignore the process TTY (canvas sizes to the input). TextEffects.Run writes a live animation to a stream. Per-effect flags are the same tokens as the CLI.

The CLI is also a dotnet tool (framework-dependent; Native-AOT builds are the GitHub Release assets):

dotnet tool install -g Hypa.Ttfx.Tool
printf 'Hello\n' | ttfx wipe

./bin/build              # AOT publish to artifacts/ttfx (host RID)
./bin/build linux-x64    # cross-RID publish when toolchain is available
./bin/test
./bin/pack               # Hypa.Ttfx + Hypa.Ttfx.Tool into artifacts/nuget

This repo consumes zero NuGet packages — everything comes from Microsoft.NETCore.App. Downstream apps add Hypa.Ttfx as a package reference; that is the supported way to reuse the engine.

Version lives in Directory.Build.props. A tag vX.Y.Z (semver, optional prerelease suffix) runs .github/workflows/release.yml: macOS + Linux test gates, Native-AOT binaries for osx-arm64 / osx-x64 / linux-x64 / linux-arm64, both nupkgs, a GitHub Release, nuget.org, and GitHub Packages.

# bump <Version> in Directory.Build.props, commit, then:
git tag v0.3.1
git push origin v0.3.1

One-time nuget.org setup (Trusted Publishing — no long-lived API key):

1. On nuget.org → Trusted Publishing, add a policy for this repo, workflow file release.yml, environment release.
2. Store your nuget.org username (profile name, not email) as the NUGET_USER Actions secret.
3. Optional fallback: NUGET_API_KEY if OIDC is not available yet.

workflow_dispatch stamps a version and uploads artifacts; turn on publish only when you intend to cut the release.

<producer> | ttfx [terminal options] <effect> [effect options]

ttfx --help
ttfx <effect> --help
ttfx --random-effect        # --include-effects / --exclude-effects to filter
ttfx --print-completion bash|zsh

Terminal options go before the effect name; effect options after it. Names and defaults match ttfx / TTE.

See REFERENCE.md for the pinned ttfx and upstream TTE commits.