https://github.com/brentyi/tyro

CLI interfaces & config objects, from types
https://github.com/brentyi/tyro

argparse argument-parsing dataclasses

Last synced: 17 days ago
JSON representation

CLI interfaces & config objects, from types

• Host: GitHub
• URL: https://github.com/brentyi/tyro
• Owner: brentyi
• License: mit
• Created: 2021-10-05T08:54:08.000Z (over 4 years ago)
• Default Branch: main
• Last Pushed: 2025-05-09T13:07:26.000Z (10 months ago)
• Last Synced: 2025-05-09T13:59:51.745Z (10 months ago)
• Topics: argparse, argument-parsing, dataclasses
• Language: Python
• Homepage: https://brentyi.github.io/tyro
• Size: 71.5 MB
• Stars: 627
• Watchers: 6
• Forks: 33
• Open Issues: 16
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

• awesome-cli-frameworks - Tyro - line interfaces and configuration objects in Python. ([Python](https://www.python.org/) / Useful awesome list for Go cli)
• awesome-pydantic - Tyro - Tyro is a tool for generating command-line interfaces and configuration objects in Python. Generates CLI interfaces, populates helptext automatically from defaults, annotations and docstrings, understand nesting of `dataclasses`, `pydantic`, and `attrs` structures, and it supports subcommands and fine-grained configuration via runtime annotations. (Command-Line Interface)

README

          
# tyro



    

        

    

    

        

    

    

        

    





    Documentation

      •  

    pip install tyro



tyro.cli() is a tool for generating CLI

interfaces from type-annotated Python.

We can define configurable scripts using functions:












Or instantiate configs defined using tools like `dataclasses`, `pydantic`, and `attrs`:









Other features include helptext generation, nested structures, subcommands, and

shell completion. For examples and the API reference, see our

[documentation](https://brentyi.github.io/tyro).

### Why `tyro`?

1. **Define things once.** Standard Python type annotations, docstrings, and default values are parsed to automatically generate command-line interfaces with nice helptext.

2. **Static types.** Unlike tools dependent on dictionaries, YAML, or dynamic

   namespaces, arguments populated by `tyro` are better undestood by IDEs and

   language servers, as well as static checking tools like `pyright` and `mypy`.

3. **Modularity.** `tyro` supports hierarchical configurations, which make it

   easy to decentralize definitions, defaults, and documentation.

### In the wild

`tyro` is designed to be lightweight for throwaway scripts, while

improving maintainability for larger projects. Examples:

  

    

      

        nerfstudio-project/nerfstudio

        


      

    

    

      Open-source tools for neural radiance fields.

    

  

  

    

      

        Sea-Snell/JAXSeq

        


      

    

    Train very large language models in Jax.

  

  

    

      

        kevinzakka/obj2mjcf

        


      

    

    Interface for processing OBJ files for Mujoco.

  

  

    

      

        blurgyy/jaxngp

        


      

    

    

      CUDA-accelerated implementation of

      instant-ngp, in JAX.

    

  

  

    

      

        NVIDIAGameWorks/kaolin-wisp

        


      

    

    PyTorch library for neural fields.

  

  

    

      

        autonomousvision/sdfstudio

        


      

    

    Unified framework for surface reconstruction.

  

  

    

      

        openrlbenchmark/openrlbenchmark

        


      

    

    Collection of tracked experiments for reinforcement learning.

  

  

    

      

        vwxyzjn/cleanrl

        


      

    

    Single-file implementation of deep RL algorithms.

  

  

    

      

        pytorch-labs/LeanRL

        


      

    

    Fork of CleanRL, optimized using PyTorch 2 features.

  

  

    

      

        pytorch/torchtitan

        


      

    

    PyTorch-native platform for training generative AI models.

  

  

    

      

        KwaiVGI/LivePortrait

        


      

    

    Stitching and retargeting for portraits.

  

  

    

      

        Physical-Intelligence/openpi

        


      

    

    Open-source models for robotics.

  

  

    

      

        haosulab/ManiSkill

        


      

    

    GPU-parallelized simulation + learning for robot manipulation.

  

  

    

      

        mujocolab/mjlab

        


      

    

    Lightweight, modular abstractions for RL and sim-to-real robotics.

  

  

    

      

        amazon-far/holosoma

        


      

    

    Humanoid robotics framework for RL training and deployment.

  

  

    

      

        MalcolmMielle/bark_monitor

        


      

    

    Show your neighbor that your dog doesn't bark!

  

### Alternatives

`tyro` is opinionated. If any design decisions don't make sense, feel free to

file an issue!

You might also consider one of many alternative libraries. Some that we

like:

- [cappa](https://github.com/dancardin/cappa) offers a similar core feature

  set but with very different ergonomics. It looks polished and well-maintained!

- [cyclopts](https://github.com/BrianPugh/cyclopts) and

  [defopt](https://defopt.readthedocs.io/) has very comprehensive type

  annotation support and a heavier emphasis on subcommand generation.

- [simple-parsing](https://github.com/lebrice/SimpleParsing) and

  [jsonargparse](https://github.com/omni-us/jsonargparse) provide deeper

  integration with configuration file formats like YAML and JSON.

- [clipstick](https://github.com/sander76/clipstick), which focuses on

  simplicity + generating CLIs from Pydantic models.

- [datargs](https://github.com/roee30/datargs) provides a minimal API for

  dataclasses.

- [fire](https://github.com/google/python-fire) and

  [clize](https://github.com/epsy/clize) support arguments without type

  annotations.

There are also some options that directly extend `tyro`:

- [mininterface](https://github.com/CZ-NIC/mininterface) simultaneously generates

  GUI, TUI, web, CLI, and file-based program configuration.

- [manuscript](https://github.com/stllfe/manuscript) generates CLI interfaces from

  a simple block of configuration variables.

We also have some notes on `tyro`'s design goals and other alternatives in the

docs [here](https://brentyi.github.io/tyro/goals_and_alternatives/).