How to define nested commands with clipp?

Use the `command()` function within groups and alternatives, as shown in the complex nesting example. For instance, `command("build") | command("query")` creates alternatives, and nesting them with `&` or `in_sequence` allows hierarchical structures like multi-level CLIs.

clipp or Boost.Program_options for C++ argument parsing?

clipp offers a more modern, declarative syntax and automatic documentation generation, while Boost.Program_options is more verbose but part of a widely-used library with broader ecosystem support. Choose clipp for expressiveness and self-documenting code, Boost for stability and integration with other Boost components.

How to validate input values with custom filters in clipp?

Use the `value()` function with a predicate, such as `value(is_char, "c", c)` where `is_char` is a lambda. clipp provides built-in filters for numbers and words, and custom filters can be implemented as function objects that return a boolean or subrange.

Does clipp support environment variable parsing?

No, clipp is focused solely on command line argument parsing. For environment variables, you need to handle them separately in your code, typically using standard library functions like `getenv()` or platform-specific APIs.

How to reduce compile times when using clipp?

Since clipp is header-only and template-heavy, compile times can be high. Mitigate this by using precompiled headers, limiting inclusion to specific translation units, or considering alternative parsers if compilation speed is critical.

clipp documentation generation examples

clipp can generate usage lines with `usage_lines()`, detailed documentation with `documentation()`, and man pages with `make_man_page()`. The README shows examples with formatting options, such as setting column widths and merging alternatives for cleaner output.

Open-Awesome

clipp

MITC++v1.2.3

A single-header C++11/14/17 library for expressive command line argument parsing with documentation generation.

GitHub

1.3k stars155 forks0 contributors

What is clipp?

clipp is a command line argument parsing library for modern C++ that provides a declarative, fluent API for defining complex interfaces. It solves the problem of verbose and error-prone argument handling by allowing developers to specify options, commands, and values in a readable, composable way, with automatic documentation generation.

Target Audience

C++ developers building command line tools who need robust, expressive argument parsing without external dependencies. It's especially suited for projects requiring complex CLI structures, such as multi-command applications or tools with nested options.

Value Proposition

Developers choose clipp for its single-header simplicity, powerful expressiveness, and built-in documentation generation, which together reduce boilerplate and improve maintainability compared to traditional parsing approaches.

Overview

easy to use, powerful & expressive command line argument parsing for modern C++ / single header / usage & doc generation

Use Cases

Best For

Defining multi-command CLI applications with nested alternatives
Building tools that require automatic man page or help text generation
Parsing complex argument structures with positional values and repeatable options
Creating command line interfaces with joinable flags or custom value validation
Developing C++ CLI tools without external library dependencies
Handling advanced parsing scenarios like decision trees or greedy parameters

Not Ideal For

Projects requiring integrated configuration file or environment variable parsing alongside CLI arguments
Teams prioritizing minimal binary size and fast compilation over expressive syntax
Applications that need extensive third-party library integrations or a large user community
Developers unfamiliar with modern C++ templates or declarative programming styles

Pros & Cons

Pros

Single Header Simplicity

Entire library is contained in one header file, making integration trivial without build system dependencies or external linking.

Expressive Declarative Syntax

Uses a fluent, composable DSL to define complex interfaces with groups, alternatives, and sequences, significantly reducing boilerplate code compared to traditional parsers.

Built-in Documentation Generation

Automatically generates usage lines, man pages, and help text from the interface definition, ensuring consistency and reducing manual documentation effort.

Advanced Error Handling

Provides detailed parsing results and event handlers for missing, blocked, or conflicted arguments, enabling robust error reporting and user feedback.

Cons

Compile Time Impact

As a single-header, template-heavy library, it can significantly increase compilation times and code bloat compared to pre-compiled or lighter-weight alternatives.

Limited Scope

Focuses solely on command line argument parsing without integrated support for configuration files, environment variables, or other common input sources.

Niche Ecosystem

Has fewer third-party integrations, community contributions, and learning resources compared to more established libraries like Boost.Program_options or argparse for Python.

Frequently Asked Questions

Related Projects

FTXUI

:computer: C++ Functional Terminal User Interface. :heart:

Stars10,025

Forks580

Last commit15 hours ago

cxxopts

Lightweight C++ command line option parser

Stars4,755

Forks641

Last commit7 days ago

CLI11

CLI11 is a command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface.

ImTui: Immediate Mode Text-based User Interface C++ Library

Stars3,566

Forks153

Last commit6 months ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub