casey/just

Features

• Dependency Graph Runners - Constructs a directed acyclic graph of tasks to ensure prerequisites are executed in the correct order.
• Task Runners - Standardizes and simplifies the execution of common development commands across different projects and team environments.
• Workflow Orchestrators - Manages complex build, test, and deployment pipelines by defining dependencies and execution order for project tasks.
• Cross-Platform Scripting Tools - Enables writing and running project-specific tasks that behave consistently across Windows, macOS, and Linux.
• Task Dependency Management - Controls task execution order by defining dependencies that ensure setup tasks run exactly once.
• Cross-Platform Scripting Runtimes - A shell-agnostic execution layer that standardizes command execution and environment management across different operating systems.
• Interactive Task Runners - Task runner allows choosing and executing recipes interactively using a fuzzy finder or custom chooser tool for quick navigation and execution of available tasks.
• Subprocess Orchestrators - Spawns external shell processes while managing environment context and signal propagation.
• Task Parameterization - Creates reusable tasks that accept dynamic input through default values and command-line overrides.
• Build Automation - Command and recipe runner for build automation.
• Developer Tools - Command runner for project-specific tasks.
• Developer Utilities - Task runner for project-specific commands.
• Development Environments - Modern command runner designed as a simpler alternative to Make.
• Development Tools - Command runner for project-specific tasks.
• Development Utilities - Command runner for automating project tasks.
• make - Listed in the “make” section of the Awesome Alternatives In Rust awesome list.
• Built-in Task Functions - Accesses built-in functions to retrieve system information and perform filesystem operations within task logic.
• Script Interpreters - Executes task bodies using various interpreters like Python or Bash via shebang lines.
• Argument Injection Utilities - Maps command-line arguments to internal recipe parameters by injecting values into the execution environment.
• Command Execution Utilities - Task runner stores the results of shell commands into variables using backticks while automatically removing extra indentation to keep configuration files clean and easy to read.
• Custom Task Functions - Creates custom, reusable functions to encapsulate logic and simplify complex expressions.
• Default Task Specifications - Supports specifying default tasks to execute when no arguments are provided.
• Environment Variable Exporters - Exports defined variables as environment variables accessible to all executed recipes and sub-commands.
• Shell Completion Generators - Generates scripts for command-line shells to enable tab-completion for task names and arguments.
• Configuration Parsers - Parses hierarchical configuration files by resolving imports and modules into a unified internal representation.
• Environment Configuration Managers - Loads and manages environment variables and project-specific settings to ensure tasks run in the correct context.
• Environment Variable Loaders - Supports loading environment variables from external files with options for custom paths and variable overriding.
• Expression Composition - Combines values using operators and concatenation to dynamically generate data for task arguments.
• Multi-Task Invocation - Enables executing multiple tasks in a single command-line call.
• Positional Argument Handlers - Allows passing recipe arguments as positional parameters to commands for index-based access.
• Subdirectory Task Invocation - Executes tasks defined in subdirectories using path-based command-line syntax.
• Task Discovery - Displays available tasks with customizable formatting and filtering to help users discover commands.
• Task Metadata - Attaches declarative properties to recipes to modify execution behavior such as concurrency or platform constraints.
• Task Metadata Annotators - Task runner applies metadata to recipes and modules to control execution behavior, such as requiring user confirmation, restricting tasks to specific platforms, or setting environment variables.
• Task Runner Utilities - Task runner categorizes related recipes into named collections to improve readability and simplify navigation when viewing available commands within the command line interface.
• Workflow Logic Engines - Task runner defines if-else expressions to dynamically set variables or control output based on equality, inequality, or regular expression matching to handle different scenarios during execution.
• Modular Architecture Patterns - Task runner organizes complex projects by splitting logic into submodules, allowing for namespaced recipe access and isolated configuration settings for each module.

Star history