# Awesome-cli-framework

**Collection of framework to build beautiful command line interface in different languages**

[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
[![License](https://img.shields.io/badge/LICENSE-CC_BY_4.0-00a2ff)](https://creativecommons.org/licenses/by/4.0/)

## Contents
<!-- TOC -->

- [Awesome-cli-framework](#awesome-cli-framework)
    - [Contents](#contents)
    - [Bash/Shell](#bashshell)
    - [Crystal](#crystal)
    - [C++](#c)
    - [Dart](#dart)
    - [Deno](#deno)
    - [Dotnet/C\#](#dotnetc%5C)
        - [Useful awesome list for Dotnet cli](#useful-awesome-list-for-dotnet-cli)
    - [Elixir](#elixir)
    - [Fortran](#fortran)
    - [Go](#go)
        - [Useful awesome list for Go cli](#useful-awesome-list-for-go-cli)
    - [Haskell](#haskell)
    - [Java](#java)
    - [JavaScript](#javascript)
    - [Julia](#julia)
    - [Kotlin](#kotlin)
    - [Nim](#nim)
    - [Ocaml](#ocaml)
    - [PHP](#php)
    - [Purescript](#purescript)
    - [Python](#python)
    - [Ruby](#ruby)
        - [Useful awesome list for Ruby cli](#useful-awesome-list-for-ruby-cli)
    - [R](#r)
    - [Rust](#rust)
    - [Scala](#scala)
    - [Swift](#swift)
    - [V](#v)
    - [Zig](#zig)
    - [**Contributing**](#contributing)
    - [License](#license)

<!-- /TOC -->

## Bash/Shell

- [argc](https://github.com/sigoden/argc) : A bash cli framework, also a task management & automation tool (written in rust).

- [argbash](https://github.com/matejak/argbash) : Bash argument parsing code generator.

- [Bashly](https://github.com/DannyBen/bashly) : A command line application (written in Ruby) that lets you generate feature-rich bash command line tools. Bashly lets you focus on your specific code, without worrying about command line argument parsing, usage texts, error messages and other functions that are usually handled by a framework in any other programming language.

- [gum](https://github.com/charmbracelet/gum) : A tool for glamorous shell scripts 🎀 (written in go).

## [Crystal](https://crystal-lang.org/)

- [Athena Console](https://github.com/athena-framework/console) : Allows for the creation of CLI based commands.

- [OptionParser](https://crystal-lang.org/api/1.7.2/OptionParser.html) : Builtin class for command-line options processing.

## [C++](https://www.cpp-lang.net/)

- [argh!](https://github.com/adishavit/argh) : Argh! A minimalist argument handler.

- [args](https://github.com/Taywee/args) : A simple header-only C++ argument parser library. Supposed to be flexible and powerful, and attempts to be compatible with the functionality of the Python standard argparse library (though not necessarily the API).

- [CLI11](https://github.com/CLIUtils/CLI11) : A command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface.

- [cxxopt](https://github.com/jarro2783/cxxopts) : Lightweight C++ command line option parser.

- [docopt.cpp](https://github.com/docopt/docopt.cpp) : C++11 port of docopt.

- [gflags](https://github.com/gflags/gflags) : The gflags package contains a C++ library that implements commandline flags processing. It includes built-in support for standard types such as string and the ability to define flags in the source file in which they are used. Online documentation available at:

- [Lyra](https://github.com/bfgroup/Lyra) : A simple to use, composable, command line parser for C++ 11 and beyond.

## [Dart](https://dart.dev/)

- [args](https://github.com/dart-lang/args) : Parses raw command-line arguments into a set of options and values.

- [dcli](https://github.com/onepub-dev/dcli) : An API and tooling for building cross platform command line (CLI) applications and scripts using the Dart programming language.

## [Deno](https://deno.land/)

- [deno-cliffy](https://github.com/c4spar/deno-cliffy) : Command line framework for deno sauropod Including Commandline-Interfaces, Prompts, CLI-Table, Arguments Parser and more...

## [Dotnet/C\#](https://dotnet.microsoft.com/)

- [CliFX](https://github.com/Tyrrrz/CliFx) : A simple to use, yet powerful framework for building command line applications. Its primary goal is to completely take over the user input layer, allowing you to forget about infrastructural concerns and instead focus on writing your application.

- [CliWrap](https://github.com/Tyrrrz/CliWrap) : CliWrap is a library for interacting with external command line interfaces. It provides a convenient model for launching processes, redirecting input and output streams, awaiting completion, handling cancellation, and more.

- [CommandDotnet](https://github.com/bilal-fazlani/commanddotnet) : Makes it easy to build console apps as simply as you would like and as feature rich as you need.

- [CommandLine](https://github.com/commandlineparser/commandline) : The Command Line Parser Library offers CLR applications a clean and concise API for manipulating command line arguments and related tasks, such as defining switches, options and verb commands.

- [command-line-api](https://github.com/dotnet/command-line-api) : Command line parsing, invocation, and rendering of terminal output.

- [CommandLineUtils](https://github.com/natemcmaster/CommandLineUtils) : This project helps you create command line applications using .NET. It simplifies parsing arguments provided on the command line, validating user inputs, and generating help text.

- [gui.cs](https://github.com/migueldeicaza/gui.cs) : Console-based user interface toolkit for .NET applications.

- [spectre.console](https://github.com/spectreconsole/spectre.console) : A .NET 5/.NET Standard 2.0 library that makes it easier to create beautiful, cross platform, console applications.

### Useful awesome list for Dotnet cli

- [awesome-dotnet](https://github.com/quozd/awesome-dotnet/blob/master/README.md#cli) by @quozd : A collection of awesome .NET libraries, tools, frameworks, and software.

## [Elixir](https://elixir-lang.org/)

- [Owl](https://github.com/fuelen/owl) : Owl is a toolkit for writing command-line user interfaces in Elixir.

## [Fortran](https://fortran-lang.org/)

- [FLAP](https://github.com/szaghi/FLAP) : A KISS pure Fortran Library for building powerful, easy-to-use, elegant command line interfaces.

## [Go](https://go.dev/)

- [cli](https://github.com/urfave/cli) : A simple, fast, and fun package for building command line apps in Go.

- [climate](https://github.com/avamsi/climate) : Autogenerates CLIs from structs / functions (nested subcommands, global / local flags, help generation, typo suggestions, shell completion etc.)

- [Cobra](https://github.com/spf13/cobra) : Many of the most widely used Go projects are built using Cobra, such as: [Kubernetes](http://kubernetes.io/), [Hugo](http://gohugo.io), [rkt](https://github.com/coreos/rkt), [etcd](https://github.com/coreos/etcd), [Moby (former Docker)](https://github.com/moby/moby), [Docker (distribution)](https://github.com/docker/distribution), [OpenShift](https://www.openshift.com/), [Delve](https://github.com/derekparker/delve), [GopherJS](http://www.gopherjs.org/), [CockroachDB](http://www.cockroachlabs.com/), [Bleve](http://www.blevesearch.com/), [ProjectAtomic (enterprise)](http://www.projectatomic.io/), [Giant Swarm's gsctl](https://github.com/giantswarm/gsctl), [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack), [rclone](http://rclone.org/), [nehm](https://github.com/bogem/nehm), [Pouch](https://github.com/alibaba/pouch), [Istio](https://istio.io), [Prototool](https://github.com/uber/prototool), [mattermost-server](https://github.com/mattermost/mattermost-server), [Gardener](https://github.com/gardener/gardenctl), [Linkerd](https://linkerd.io/),
etc.

- [Golang Agrparse](https://github.com/akamensky/argparse) : The goal of this project is to bring ease of use and flexibility of argparse (Python) to Go.

- [go-arg](https://github.com/alexflint/go-arg) : Struct-based argument parsing in Go. 

- [Docopt Go](https://github.com/docopt/docopt.go) : docopt parses command-line arguments based on a help message. Don't write parser code: a good help message already has all the necessary information in it.

- [Mow.cli](https://github.com/jawher/mow.cli) : A versatile library for building CLI applications in Go

- [Clif](https://github.com/ukautz/clif) : Go framework for rapid command line application development.

### Useful awesome list for Go cli

- [Awesome-go](https://github.com/avelino/awesome-go) by @avelino : A curated list of awesome Go frameworks, libraries and software. Look at [Command Line](https://github.com/avelino/awesome-go#command-line)

## [Haskell](https://www.haskell.org/)

- [CmdArgs](https://github.com/ndmitchell/cmdargs) : CmdArgs is a Haskell library for defining command line parsers.

- [Docopt.hs](https://github.com/docopt/docopt.hs) : A Haskell port of python's docopt.

- [optparse-applicative](https://github.com/pcapriotti/optparse-applicative) : A haskell library for parsing options on the command line, and providing a powerful applicative interface for composing them. It takes care of reading and validating the arguments passed to the command line, handling and reporting errors, generating a usage line, a comprehensive help screen, and enabling context-sensitive bash, zsh, and fish completions.

## [Java](https://dev.java/)

- [args4j](https://github.com/kohsuke/args4j) : A small Java class library that makes it easy to parse command line options/arguments in your CLI application.

- [Apache Commons CLI](https://github.com/apache/commons-cli) : Apache Commons CLI provides a simple API for presenting, processing and validating a Command Line Interface.
- [Jcommander](https://github.com/cbeust/jcommander) : An annotation based parameter parsing framework for Java 8.

- [Jline3](https://github.com/jline/jline3) : A Java library for handling console input. People familiar with the readline/editline capabilities for modern shells (such as bash and tcsh) will find most of the command editing features of JLine to be familiar.

- [Picocli](https://github.com/remkop/picocli) : A modern framework for building powerful, user-friendly, GraalVM-enabled command line apps with ease.

## [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript)

- [Clipanion](https://github.com/arcanis/clipanion) : Official CLI framework powering both the Yarn CLI - one of the most complex command-line tool in the ecosystem - and small internal scripts. Clipanion is designed with type safety in mind, and leverages a syntax as idiomatic as possible to avoid cluttering your code with boilerplate.

- [Oclif](https://github.com/oclif/oclif) : Oclif is a framework for building CLIs in Node.js. This framework was built out of the Heroku CLI but generalized to build any custom CLI. It's designed both for single-file CLIs with a few flag options, or for very complex CLIs that have subcommands (like git or heroku).

- [Commander.js](https://github.com/tj/commander.js/) : The complete solution for node.js command-line interfaces.

- [Gluegun](https://github.com/infinitered/gluegun) : A delightful toolkit for building TypeScript-powered command-line apps.

- [Ink](https://github.com/vadimdemedes/ink) : React for interactive command-line apps. (See also [Pastel](https://github.com/vadimdemedes/pastel))

- [node-seeli](https://github.com/esatterwhite/node-seeli) : Object orientated, event driven , Interactive CLI module. Seeli aims to give you the tools to compose A command line interface the way you want it, and otherwise, stays out of your way.

- [Caporal.js](https://github.com/mattallty/Caporal.js) : A full-featured framework for building command line applications (cli) with node.js,  including help generation, colored output, verbosity control, custom logger, coercion and casting, typos suggestions, and auto-complete for bash/zsh/fish.

- [args](https://github.com/leo/args) : Toolkit for building command line interfaces.

- [Inquirer.js](https://github.com/SBoudrias/Inquirer.js) : Inquirer.js strives to be an easily embeddable and beautiful command line interface for Node.js.

- [Vorpal](https://github.com/dthree/vorpal) : Vorpal is Node's first framework for building interactive CLI applications. With a simple and powerful API, Vorpal opens the door to a new breed of rich, immersive CLI environments. **[NOT MAINTAINED]**

- [Yargs](https://github.com/yargs/yargs) : Yargs helps you build interactive command line tools, by parsing arguments and generating an elegant user interface.

- [Clerc](https://github.com/clercjs/clerc) : Clerc is a full-featured library for building CLI Apps in Node.js, Deno or Bun. It's strongly-typed, easy-to-use and flexible.

- [Termost](https://github.com/adbayb/termost): A full-featured framework to build your next command line interfaces (CLI) in a minute. Thanks to its fluent and type-safe API, you can easily express and manage your program metadata (including version and help), sub-commands, user prompts, tasks, options and flags, ... 

## [Julia](https://julialang.org/)

- [Comonicon.jl](https://github.com/comonicon/Comonicon.jl) : Your best CLI generator in JuliaLang.

## [Kotlin](https://kotlinlang.org/)

- [clikt](https://github.com/ajalt/clikt) : Multiplatform command line interface parsing for Kotlin.

- [kotlinx-cli](https://github.com/Kotlin/kotlinx-cli) : Pure Kotlin implementation of a generic CLI parser.

## [Nim](https://nim-lang.org/)

- [clapfn](https://github.com/oliverdelancey/clapfn) : A fast and simple command line argument parser for Nim.

- [cliche](https://github.com/juancarlospaco/cliche) : AutoMagic CLI argument parsing is cliche.

- [cligen](https://github.com/c-blake/cligen) : Nim library to infer/generate command-line-interfaces / option / argument parsing.

- [docopt.nim](https://github.com/docopt/docopt.nim) : Command line arguments parser that will make you smile (port of docopt to Nim).

- [loki](https://github.com/beshrkayali/loki) : A small library for writing line-oriented command interpreters in Nim.

- [nim-argparse](https://github.com/iffy/nim-argparse) : Command line argument parsing library.

- [nim-confutils](https://github.com/status-im/nim-confutils) : Simplified handling of command line options and config files.

## [Ocaml](https://ocaml.org/)

- [cmdliner](https://github.com/dbuenzli/cmdliner) : Declarative definition of command line interfaces for OCaml.

- [clap](https://github.com/rbardou/clap) : Command-Line Argument Parsing, imperative style with a consumption mechanism.

- [minicli](https://github.com/UnixJunkie/minicli) : Minimalist OCaml library for command line parsing.

## [PHP](https://www.php.net/)

- [CliFramework](https://github.com/c9s/CLIFramework) : CLIFramework is a command-line application framework, for building flexiable, simple command-line applications.

- [laravel-zero](https://github.com/laravel-zero/laravel-zero) : A micro-framework that provides an elegant starting point for your console application. It is an unofficial and customized version of Laravel optimized for building command-line applications.

- [minicli](https://github.com/minicli/minicli) : A minimalist framework for command-line applications in PHP.

- [php-cli](https://github.com/adhocore/php-cli) : PHP Console Application made easy- build great console apps with ease. Comes with Zero Dependency and Autocompletion support.

- [php-cli-tools](https://github.com/wp-cli/php-cli-tools) : A collection of tools to help with PHP command line utilities.

- [Silly](https://github.com/mnapoli/silly) : Silly CLI micro-framework based on Symfony Console.

- [Symfony/Console](https://github.com/symfony/Console) : The Console component of symfony eases the creation of beautiful and testable command line interfaces.

## [Purescript](https://www.purescript.org/)

- [Optparse](https://github.com/f-o-a-m/purescript-optparse) :  Applicative option parser.

## [Python](https://www.python.org/)

- [Argparse](https://docs.python.org/3/library/argparse.html) : Argparse is the default python module for creating command lines programs. It provides all the features you need to build a simple CLI.

- [Click](https://github.com/pallets/click) : Click is a Python package for creating beautiful command line interfaces in a composable way with as little code as necessary. It's the "Command Line Interface Creation Kit". It's highly configurable but comes with sensible defaults out of the box.

- [Cliff](https://github.com/openstack/cliff) : cliff is a framework for building command line programs. It uses setuptools entry points to provide subcommands, output formatters, and other extensions.

- [Cement](https://github.com/datafolklabs/cement) : Cement is an advanced Application Framework for Python, with a primary focus on Command Line Interfaces (CLI). Its goal is to introduce a standard, and feature-full platform for both simple and complex command line applications as well as support rapid development needs without sacrificing quality.

- [Cleo](https://github.com/python-poetry/cleo) : Cleo allows you to create beautiful and testable command-line interfaces.

- [Docopt](https://github.com/docopt/docopt) / [Docopt-NG](https://github.com/jazzband/docopt-ng) : Pythonic command line arguments parser, that will make you smile. docopt parses command-line arguments based on a help message. Don't write parser code: a good help message already has all the necessary information in it.

- [jsonargparse](https://jsonargparse.readthedocs.io/) : Implement minimal boilerplate CLIs derived from type hints and parse from command line, config files and environment variables.

- [Python-Fire](https://github.com/google/python-fire) : Python Fire is a library for automatically generating command line interfaces (CLIs) from absolutely any Python object.

- [PyCli](https://pythonhosted.org/pyCLI/) : The cli package is a framework for making simple, correct command line applications in Python. With cli, you can quickly add standard command line parsing; logging; unit and functional testing; and profiling to your CLI apps.

- [PyInquirer](https://github.com/CITGuru/PyInquirer) : PyInquirer strives to be an easily embeddable and beautiful command line interface for Python. PyInquirer wants to make it easy for existing Inquirer.js users to write immersive command line applications in Python.

- [PyFiglet](https://github.com/pwaller/pyfiglet) : Pyfiglet is a full port of FIGlet (<http://www.figlet.org/>) into pure python. It takes ASCII text and renders it in ASCII art fonts.

- [python-prompt-toolkit](https://github.com/prompt-toolkit/python-prompt-toolkit) : Library for building powerful interactive command line applications in Python.

- [Typer](https://typer.tiangolo.com/) : Library for building CLI applications that users will love using and developers will love creating. It's intended to be the FastAPI of CLIs.

## [Ruby](https://www.ruby-lang.org/)

- [dry-ruby](https://github.com/dry-rb/dry-cli) : General purpose Command Line Interface (CLI) framework for Ruby.

- [TTY](https://github.com/piotrmurach/tty) : TTY is a toolbox for developing beautiful command line clients in Ruby with a fluid interface for gathering input, querying terminal properties and displaying information.

- [Thor](https://github.com/rails/thor) : Thor is a simple and efficient tool for building self-documenting command line utilities. It removes the pain of parsing command line options, writing "USAGE:" banners, and can also be used as an alternative to the Rake build tool. The syntax is Rake-like, so it should be familiar to most Rake users.

- [Commander](https://github.com/commander-rb/commander) : The complete solution for Ruby command-line executables. Commander bridges the gap between other terminal related libraries you know and love (OptionParser, HighLine), while providing many new features, and an elegant API.

- [Clamp](https://github.com/mdub/clamp) : "Clamp" is a minimal framework for command-line utilities. It handles boring stuff like parsing the command-line, and generating help, so you can get on with making your command actually do stuff.

- [Gli](https://github.com/davetron5000/gli) : GLI allows you to create command-line app in Ruby that behaves like ```git``` in that it takes subcommands to perform a series of complex action.

### Useful awesome list for Ruby cli

- [Awesome-ruby](https://github.com/markets/awesome-ruby) by @markets : A curated list of awesome Ruby frameworks, libraries and software. Look at [#Cli builder](ttps://github.com/markets/awesome-ruby#cli-builder) and [#Cli-utilities](https://github.com/markets/awesome-ruby#cli-builder)

## [R](https://www.r-project.org/)

- [cli](https://cli.r-lib.org/) : A suite of tools to build attractive command line interfaces (CLIs), from semantic elements: headers, lists, alerts, paragraphs, etc.

## [Rust](https://www.rust-lang.org/)

- [Clap](https://github.com/clap-rs/clap) : A full featured, fast Command Line Argument Parser for Rust.

- [TUI](https://github.com/fdehau/tui-rs) : Build terminal user interfaces and dashboards using Rust.

- [StructOpt](https://github.com/TeXitoi/structopt) : Parse command line arguments by defining a struct.

- [rust-argparse](https://github.com/tailhook/rust-argparse) : The command-line argument parser library for rust.

- [Seahorse](https://github.com/ksk001100/seahorse) : A minimal CLI framework written in Rust.

- [Termion](https://lib.rs/crates/termion) : Pure Rust, bindless library for low-level handling, manipulating and reading information about terminals.

- [Starbase](https://github.com/moonrepo/starbase#components) : Framework for building performant command line applications and developer tools.

## [Scala](https://www.scala-lang.org/)

- [scopt](https://github.com/scopt/scopt) : Command line options parsing for Scala.

## [Swift](https://www.swift.org/)

- [Commander](https://github.com/kylef/Commander) : Compose beautiful command line interfaces in Swift.

- [swift-argument-parser](https://github.com/apple/swift-argument-parser) : Straightforward, type-safe argument parsing for Swift

## [V](https://vlang.io/)

- [cli](https://modules.vlang.io/cli.html) : Builtin command line option parser, that supports declarative subcommands, each having separate set of options.
- [flag](https://modules.vlang.io/flag.html): Builtin command line option parser.

## [Zig](https://ziglang.org/)

- [zig-cli](https://github.com/sam701/zig-cli): A simple package for building command line apps in Zig.

## **Contributing**

Thanks for visiting! If you have suggestions, then open an issue, or submit a PR, see: CONTRIBUTING.md. Contributions are welcome, and much appreciated !

## License

[![License](https://img.shields.io/badge/LICENSE-CC_BY_4.0-00a2ff)](https://creativecommons.org/licenses/by/4.0/)
Licensed under Creative Commons, CC BY 4.0, © [Shadawck](https://github.com/shadawck).
