Skip to content

Advanced Patterns

Clikt has reasonable behavior by default, but is also very customizable for advanced use cases.

Command Aliases

Clikt allows commands to alias command names to sequences of tokens. This allows you to implement common patterns like allowing the user to invoke a command by typing a prefix of its name, or user-defined aliases like the way you can configure git to accept git ci as an alias for git commit.

To implement command aliases, override CliktCommand.aliases in your command. This function is called once at the start of parsing, and returns a map of aliases to the tokens that they alias to.

To implement git-style aliases:

class Repo : NoOpCliktCommand() {
    // You could load the aliases from a config file etc.
    override fun aliases(): Map<String, List<String>> = mapOf(
            "ci" to listOf("commit"),
            "cm" to listOf("commit", "-m")

class Commit: CliktCommand() {
    val message by option("-m").default("")
    override fun run() {
        echo("Committing with message: $message")

fun main(args: Array<String>) = Repo().subcommands(Commit()).main(args)
$ ./repo ci -m 'my message'
Committing with message: my message
$ ./repo cm 'my message'
Committing with message: my message

Note that aliases are not expanded recursively: none of the tokens that an alias expands to will be expanded again, even if they match another alias.

You also use this functionality to implement command prefixes:

class Tool : NoOpCliktCommand() {
    override fun aliases(): Map<String, List<String>> {
        val prefixCounts = mutableMapOf<String, Int>().withDefault { 0 }
        val prefixes = mutableMapOf<String, List<String>>()
        for (name in registeredSubcommandNames()) {
            if (name.length < 3) continue
            for (i in {
                val prefix = name.substring(0..i)
                prefixCounts[prefix] = prefixCounts.getValue(prefix) + 1
                prefixes[prefix] = listOf(name)
        return prefixes.filterKeys { prefixCounts.getValue(it) == 1 }

class Foo: CliktCommand() {
    override fun run() {
        echo("Running Foo")

class Bar: CliktCommand() {
    override fun run() {
        echo("Running Bar")

fun main(args: Array<String>) = Tool().subcommands(Foo(), Bar()).main(args)
$ ./tool ba
Running Bar

Token Normalization

To prevent ambiguities in parsing, aliases are only supported for command names. However, there’s another way to modify user input that works on more types of tokens. You can set a tokenTransformer on the command’s context that will be called for each option and command name that is input. This can be used to implement case-insensitive parsing, for example:

class Hello : CliktCommand() {
    init {
        context { tokenTransformer = { it.toLowerCase() } }

    val name by option()
    override fun run() = echo("Hello $name!")
$ ./hello --NAME=Foo
Hello Foo!

Replacing stdin and stdout

By default, functions like CliktCommand.main and option().prompt() read from and write to System.out. If you want to use clikt in an environment where the standard streams aren’t available, you can set your own implementation of CliktConsole when customizing the command context.

object MyConsole : CliktConsole {
    override fun promptForLine(prompt: String, hideInput: Boolean): String? {
        return if (hideInput) MyInputStream.readPassword()
        else MyInputStream.readLine()

    override fun print(text: String, error: Boolean) {
        if (error) MyOutputStream.writeError(prompt)
        else MyOutputStream.write(prompt)

    override val lineSeparator: String get() = "\n"

class CustomCLI : NoOpCliktCommand() {
    init { context { console = MyConsole } }

If you are using TermUI directly, you can also pass your custom console as an argument.

Command Line Argument Files (“@-files”)

Similar to javac, Clikt supports loading command line parameters from a file using the “@-file” syntax. You can pass any file path to a command prefixed with @, and the file will be expanded into the command line parameters. This can be useful on operating systems like Windows that have command line length limits.

If you create a file named cliargs with content like this:

--number 1
--name='jane doe' --age=30

You can call your command with the contents of the file like this:

$ ./tool @cliargs

Which is equivalent to calling it like this:

$ ./tool --number 1 --name='jane doe' --age=30 ./file.txt

You can use any file path after the @, and can specify multiple @-files:

$ ./tool @../config/args @C:\\Program\ Files\\Tool\\argfile

If you have any options with names that start with @, you can still use @-files, but values on the command line that match an option will be parsed as that option, rather than an @-file, so you’ll have to give your files a different name.

Preventing @-file expansion

If you want to use a value starting with @ as an argument without expanding it, you have three options:

  1. Pass it after a --, which disables expansion for everything that occurs after it.
  2. Escape it with @@. The first @ will be removed and the rest used as the argument value. For example, @@file will parse as the string @file
  3. Disable @-file expansion entirely by setting Context.expandArgumentFiles = false

File format

In argument files, normal shell quoting and escaping rules apply. Line breaks are treated as word separators, and can be used where you would normally use a space to separate parameters. Line breaks cannot occur within quotes. @-files can contain other @-file arguments, which will be expanded recursively.

An unescaped # character outside of quotes is treated as a line comment: it and the rest of the line are skipped. You can pass a literal # by escaping it with \# or quoting it with '#'.

Testing your Clikt CLI

CliktCommand.main calls exitProcess when invalid values are provided on the command line. In unit tests, you should instead call CliktCommand.parse, which throws exceptions with error details rather than printing the details and exiting the process. See the documentation on exceptions for more information.

Custom exit status codes

Clikt will normally exit your program with a status code of 0 for a normal execution, or 1 if there’s an error. If you want to use a different value, you can throw ProgramResult(statusCode). If you use CliktCommand.main, that exception will be caught and exitProcess will be called with the value of statusCode.

You could also call exitProcess yourself, but the ProgramResult has a couple of advantages:

  • ProgramResult is easier to test. Exiting the process makes unit tests difficult to run.
  • ProgramResult works on all platforms. exitProcess is only available on the JVM.

Multiplatform Support

Clikt supports the following platforms in addition to JVM:

Desktop native (Linux, Windows, and MacOS)

All functionality is supported, except the env parameter of editText and editFile, and the hideInput parameter of prompt are ignored.


All functionality is supported, except the hideInput parameter of prompt is ignored.

Browser JavaScript

The default CliktConsole only outputs to the browser’s developer console, which is probably not what you want. You can define your own CliktConsole, or you can call parse instead of main and handle output yourself.

editText and editFile are not supported. prompt is only supported if you define your own CliktConsole.