### Install Go without GOBIN setup

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-15_proto-v0.3.mdx

Demonstrates how to install Go using proto while skipping the automatic injection of the GOBIN environment variable.

```shell
proto install go -- --no-gobin
```

--------------------------------

### Install tools using proto install

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-07-26_proto-v0.39.mdx

Demonstrates the consolidated installation command. Running without arguments installs all tools, while providing a tool name installs only that specific tool.

```shell
# Install all tools
$ proto install

# Install a single tool
$ proto install node
```

--------------------------------

### Dockerfile with Moon Integration

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-13_v0.26.mdx

An example Dockerfile demonstrating how to integrate moon into a Docker build process. It includes steps for installing the moon CLI, setting up the workspace, installing toolchain and dependencies using `moon setup`, copying source files, building the project, pruning the workspace, and finally running the application with `moon run`.

```docker
FROM node:latest
WORKDIR /app

# Install moon binary
RUN npm install -g @moonrepo/cli

# Copy workspace skeleton
COPY ./.moon/docker/workspace .

# Install toolchain and dependencies
RUN moon setup

# Copy source files
COPY ./.moon/docker/sources .

# Build something
RUN moon run app:build

# Prune workspace
RUN moon docker prune

CMD ["moon", "run", "app:start"]
```

--------------------------------

### Proto CLI Commands for Plugin Tools

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-04-21_proto-v0.7.mdx

These shell commands demonstrate how to interact with tools managed as plugins through the proto CLI. Examples include installing a specific version, listing available remote versions, and using a tool.

```shell
$ proto install moon 1.2.0
$ proto list-remote moon
$ proto use

```

--------------------------------

### Install multiple global binaries with proto CLI

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-04-13_proto-v0.6.mdx

The `proto install-global` command now supports installing multiple global dependencies for a given tool simultaneously. This streamlines the setup process for projects requiring several global packages.

```shell
proto install-global node typescript webpack-cli
```

--------------------------------

### Enable OpenTelemetry and Install Node

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-06-18_proto-v0.58.mdx

Configure the OpenTelemetry endpoint and install Node.js using proto with the --otel flag. This exports traces and metrics to the specified endpoint.

```shell
$ export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317"
$ proto --otel install node
```

--------------------------------

### Update Dockerfile: Replace `moon setup` with `moon docker setup`

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-13_v0.26.mdx

This diff shows a critical change in Dockerfile integration for moon. The `RUN moon setup` command, which previously handled both toolchain setup and dependency installation, has been replaced by `RUN moon docker setup`. This new command is specifically designed for Docker environments to efficiently install project dependencies, improving layer caching and resolving an oversight in previous versions.

```diff
-RUN moon setup
+RUN moon docker setup
```

--------------------------------

### Install proto toolchain manager

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-09_proto.mdx

Installation scripts for setting up proto on Unix-based systems using Bash or Windows systems using PowerShell.

```bash
curl -fsSL https://moonrepo.dev/install/proto.sh | bash
```

```powershell
irm https://moonrepo.dev/install/proto.ps1 | iex
```

--------------------------------

### Using proto install with pin-latest enabled

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-09-29_proto-v0.19.mdx

Shows examples of using `proto install` when the `pin-latest` setting is active. The resolved version of the tool will be automatically pinned to the configuration defined by `pin-latest` (e.g., local `.prototools` file).

```shell
$ proto install go
$ proto install node latest
```

--------------------------------

### Setup Moon GitHub Action in CI Workflow

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-02-27_v0.25.mdx

The `moonrepo/setup-moon-action@v1` GitHub Action simplifies CI setup by globally installing the `moon` binary and caching the Moon toolchain. This action streamlines the process of preparing your environment for Moon commands in GitHub Actions.

```yaml
jobs:
  ci:
    name: 'CI'
    runs-on: 'ubuntu-latest'
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: moonrepo/setup-moon-action@v1
      - run: moon ci
```

--------------------------------

### Pkl Toolchain Configuration Example

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Sets up the Node.js toolchain configuration, including the Node version, package manager, and specific package manager versions. This example demonstrates configuring language-specific toolchain settings.

```pkl
node {
  version = "20.15.0"
  packageManager = "yarn"
  yarn {
    version = "4.3.1"
  }
  addEnginesConstraint = false
  inferTasksFromScripts = false
}
```

--------------------------------

### Pkl Project Configuration Example

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Defines the configuration for a project, specifying its type, language, dependencies, and build tasks. This example showcases basic Pkl syntax for defining project properties and tasks.

```pkl
type = "application"
language = "typescript"
dependsOn = List("client", "ui")

tasks {
  ["build"] {
    command = "docusaurus build"
    deps = List("^:build")
    outputs = List("build")
    options {
      interactive = true
      retryCount = 3
    }
  }
  ["typecheck"] {
    command = "tsc --build"
    inputs = new Listing {
      "@globs(sources)"
      "@globs(tests)"
      "tsconfig.json"
      "/tsconfig.options.json"
    }
  }
}
```

--------------------------------

### Install Node.js dependencies

Source: https://github.com/moonrepo/moon/blob/master/CONTRIBUTING.md

Commands to install the required Node.js runtime and package manager using proto, followed by installing project dependencies via Yarn.

```bash
proto install node
proto install yarn
yarn install
```

--------------------------------

### Implement install_global in WASM plugins

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-08-23_proto-v0.15.mdx

Example of a Rust function using the plugin_fn macro to handle global dependency installation within a WASM plugin.

```rust
#[plugin_fn]
pub fn install_global(
    Json(input): Json<InstallGlobalInput>,
) -> FnResult<Json<InstallGlobalOutput>> {
    let result = exec_command!(inherit, "npm", ["install", "--global", &input.dependency]);

    Ok(Json(InstallGlobalOutput::from_exec_command(result)))
}
```

--------------------------------

### Manage global dependencies via CLI

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-08-23_proto-v0.15.mdx

Demonstrates how to install and uninstall global dependencies using the proto command-line interface.

```shell
proto install-global node prettier

# On second thought, nevermind...
proto uninstall-global node prettier
```

--------------------------------

### Global package installation behavior

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-03-01_proto-v0.31.mdx

Illustrates the transition from proto-managed global installations to standard npm commands utilizing the shared-globals-dir configuration.

```shell
# < v0.31
proto install-global npm typescript

# >= v0.31
npm install --global typescript

# Under the hood becomes...
PREFIX=/.proto/tools/node/globals npm install --global typescript
```

--------------------------------

### Configure Package Manager Toolchain

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2025-09-01_moon-v1.40.mdx

Example configuration for a package manager toolchain within the .moon/toolchain.yml file. This defines the version and installation arguments for the tool.

```yaml
unstable_pnpm:
  version: '10.15.0'
  installArgs: ['--frozen-lockfile']
```

--------------------------------

### Using 'command' with arguments

Source: https://github.com/moonrepo/moon/blob/master/skills/debug-task/references/config-mistakes.md

Example of configuring a task with a 'command' and its arguments. Suitable for simple binary executions.

```yaml
tasks:
  lint:
    command: 'eslint'
    args:
      - '--ext'
      - '.ts,.tsx'
      - 'src/'
```

--------------------------------

### Install and run canary tool releases

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-09-11_proto-v0.17.mdx

Commands to install a tool's canary version and execute it using environment variables or configuration files.

```shell
proto install <tool> --canary
```

```shell
PROTO_BUN_VERSION=canary bun ./index.ts
```

```toml
bun = "canary"
```

--------------------------------

### Install Tooling with proto use Command

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-04-28_proto-v0.8.mdx

The `proto use` command installs all necessary tooling for the current project. It can now detect version requirements from various sources including `.prototools`, `.nvmrc`, `.dvmrc`, and `package.json` manifest settings.

```shell
# Install all the things!
$ proto use
```

--------------------------------

### Install programming language toolchains with proto

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-09_proto.mdx

Commands to install specific versions of language runtimes using the proto CLI. These commands download the requested version and add it to the system PATH.

```shell
proto install node 18
proto install go 1.20
proto install deno 1.30
```

--------------------------------

### Install Node.js without bundled npm

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-15_proto-v0.3.mdx

Demonstrates how to install Node.js using proto while explicitly disabling the automatic installation of the bundled npm version.

```shell
proto install node -- --no-bundled-npm
```

--------------------------------

### Script for Managing Server and Tests

Source: https://github.com/moonrepo/moon/blob/master/skills/debug-task/references/config-mistakes.md

Use a script to start a server, wait for it to be ready, run tests, and then shut down the server. This avoids dependency issues with persistent tasks.

```yaml
tasks:
  integration-test:
    script: 'start-server-and-test "vite dev" http://localhost:3000 "cypress run"'
```

--------------------------------

### Configure global dependency arguments in TOML

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-08-23_proto-v0.15.mdx

Shows how to define installation and uninstallation arguments for global dependencies within a plugin's TOML configuration file.

```toml
[globals]
install-args = ["install", "--global", "{dependency}"]
uninstall-args = ["uninstall", "--global", "{dependency}"]
```

--------------------------------

### Install Poetry with Proto

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2025-02-25_proto-v0.47.mdx

This shell command shows how to install the Poetry tool using the proto package manager. It's a straightforward command to add Poetry to your project's managed tools.

```shell
$ proto install poetry
```

--------------------------------

### Install Python using proto

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-09-11_proto-v0.17.mdx

Installs the Python language runtime using the proto CLI. This feature is currently experimental and relies on pre-built binaries or pyenv.

```shell
proto install python
```

--------------------------------

### Configure Project-Relative Outputs

Source: https://github.com/moonrepo/moon/blob/master/skills/debug-task/references/cache-issues.md

Example of a project-relative output path configuration. Ensure this matches where your build tool actually writes files.

```yaml
outputs:
  - 'dist' # relative to project root
```

--------------------------------

### Execute proto command with plugin

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-07-07_proto-v0.12.mdx

Demonstrates the command-line usage for installing a tool managed by a custom WASM plugin.

```shell
proto install my-plugin
```

--------------------------------

### Configure Cargo and NPM Backends in .prototools

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-05-12_proto-v0.57.mdx

Use the `cargo:` and `npm:` prefixes in your `.prototools` file to specify tools installed from the respective registries.

```toml
"cargo:cargo-dist" = "0.31"
"npm:typescript" = "6"
```

--------------------------------

### Install Moon CLI via proto

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-01-26_moon-v2-rc.mdx

Installs the specific release candidate version of the moon CLI using the proto tool manager. Requires proto version 0.54.1 or higher.

```shell
$ proto install moon 2.0.0-rc.4
```

--------------------------------

### Define Pkl Configuration Variables and Tasks

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Examples of defining variables with default values and configuring tasks in Pkl. Note the use of backticks to escape reserved keywords like 'local'.

```pkl
variables {
  ["age"] {
    type = "number"
    prompt = "Age?"
    defaultValue = 0
}

tasks {
  ["example"] {
    `local` = true
    # Or
    preset = "server"
  }
}
```

--------------------------------

### Pkl Advanced Example: Dynamic Build Tasks with Loops

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Demonstrates advanced Pkl features by using a loop to generate build tasks for different operating systems. This highlights Pkl's programmability for creating dynamic configurations.

```pkl
tasks {
  for (_os in List("linux", "macos", "windows")) {
    ["build-(_os)"] {
      command = "cargo"
      args = List(
        "--target",
        if (_os == "linux") "x86_64-unknown-linux-gnu"
          else if (_os == "macos") "x86_64-apple-darwin"
          else "i686-pc-windows-msvc",
        "--verbose"
      )
      options {
        os = _os
      }
    }
  }
}
```

--------------------------------

### Diagnose Proto Installation Issues

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-06-16_proto-v0.37.mdx

The `proto diagnose` command (or `doctor`) checks your Proto installation for common issues, such as incorrect PATH ordering for bin and shims directories, and missing environment variables like PROTO_HOME. It provides specific error messages and suggested resolutions to help users fix their setup.

```shell
$ proto diagnose

Shell: zsh
Shell profile: ~/.zshrc

Errors
  Issue: Bin directory (~/.proto/bin) was found BEFORE the shims directory (~/.proto/shims) on PATH
  Resolution: Ensure the shims path comes before the bin path in your shell

Warnings
  Issue: Missing PROTO_HOME environment variable (Will default to ~/.proto if not defined)
  Resolution: Export PROTO_HOME="$HOME/.proto" from your shell
```

--------------------------------

### Contextual tool execution and project configuration

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-09_proto.mdx

Demonstrates running tools with version detection and defining project-specific tool versions using the .prototools configuration file.

```shell
# Will detect a version before running
bun run ./script.ts
```

```toml
node = "18.12.0"
yarn = "3.3.0"
```

```shell
# Install all the things!
proto use
```

--------------------------------

### Applying Filters for Data Transformation in Moon Templating

Source: https://github.com/moonrepo/moon/blob/master/crates/cli/tests/__fixtures__/generator/templates/vars/control.txt

Demonstrates the use of filters to transform data within templates. Examples include string manipulation (upper), arithmetic operations, and checking collection length.

```moon-template
{{ stringNotEmpty | upper }}
{{ numberReqNotEmpty * 2 }}
{{ enum | length }}
```

--------------------------------

### Execute tasks with default project

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-02-18_moon-v2.0.mdx

Demonstrates how the default project setting simplifies command execution by omitting the project prefix.

```shell
# Before
$ moon run app:build

# After
$ moon run build
$ moonx build
```

--------------------------------

### Generate Trace Profile for Deep Analysis

Source: https://github.com/moonrepo/moon/blob/master/skills/debug-task/references/decision-tree.md

Generate a trace profile for a task to pinpoint exact time spent in various stages like toolchain setup, dependency installation, and process execution. This requires the `--dump` and `--force` flags.

```bash
moon run <project>:<task> --dump --force
```

--------------------------------

### Execute Download Extension with URL

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-01-26_moon-v1.20.mdx

Demonstrates how to use the built-in 'download' extension to fetch a file from a given URL into the current moon workspace. This requires the moon CLI to be installed and configured.

```shell
moon ext download -- --url https://github.com/moonrepo/proto/releases/latest/download/proto_cli-aarch64-apple-darwin.tar.xz
```

--------------------------------

### Generate Dockerfile with moon docker file

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-07-14_moon-v1.27.mdx

This Dockerfile is generated using the `moon docker file` command. It showcases a multi-staged build process for a project, including base setup, scaffolding, dependency installation, building, and running the application, leveraging moon's capabilities within Docker.

```docker
#### BASE STAGE
#### Installs moon.

FROM node:latest AS base
WORKDIR /app

# Install moon binary
RUN curl -fsSL https://moonrepo.dev/install/moon.sh | bash
ENV PATH="/root/.moon/bin:$PATH"

#### SKELETON STAGE
#### Scaffolds repository skeleton structures.

FROM base AS skeleton

# Copy entire repository and scaffold
COPY . .
RUN moon docker scaffold website

#### BUILD STAGE
#### Builds the project.

FROM base AS build

# Copy toolchain
COPY --from=skeleton /root/.proto /root/.proto

# Copy workspace configs
COPY --from=skeleton /app/.moon/docker/workspace .

# Install dependencies
RUN moon docker setup

# Copy project sources
COPY --from=skeleton /app/.moon/docker/sources .

# Build the project
RUN moon run website:build

# Prune extraneous dependencies
RUN moon docker prune

#### START STAGE
#### Runs the project.

FROM base AS start

# Copy built sources
COPY --from=build /root/.proto /root/.proto
COPY --from=build /app /app

CMD moon run website:start
```

--------------------------------

### Initialize and build project environment

Source: https://github.com/moonrepo/moon/blob/master/CONTRIBUTING.md

Commands to initialize the repository and build the Rust binary using the Just task runner.

```bash
just init
just build
```

--------------------------------

### Configure Project Platform and Tasks for Bun

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-11-20_moon-v1.17.mdx

This example demonstrates how to set the default platform to 'bun' for a project and configure specific tasks to use Bun commands. It also shows how to explicitly set the platform for individual tasks if needed.

```yaml
# Default platform for all tasks (optional)
platform: 'bun'

tasks:
  dev:
    command: 'bun run dev'
  test:
    command: 'bun test'
  lint:
    command: 'eslint .'
    # Only required for npm packages (if not defined above)
    platform: 'bun'
```

--------------------------------

### Install moon CLI with Bash

Source: https://github.com/moonrepo/moon/blob/master/packages/cli/README.md

Installs the moon CLI using a curl command to download and execute a bash script. This is a common method for installing command-line tools.

```shell
curl -fsSL https://moonrepo.dev/install/moon.sh | bash
```

--------------------------------

### Install Moon v2 Beta with Proto

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-01-13_moon-v2-beta.mdx

Installs the beta version of Moon v2 using the proto package manager. Ensure proto is installed and updated to version 0.54.1 or higher.

```shell
$ proto install moon 2.0.0-beta.1
```

--------------------------------

### List installed global binaries with proto CLI

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-04-13_proto-v0.6.mdx

The `proto list-global` command displays all global dependencies currently installed for a specified tool. This helps users track and manage their global package installations.

```shell
proto list-global node
```

--------------------------------

### Display tool information via CLI

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-11-16_proto-v0.23.mdx

Demonstrates the usage of the new 'proto tool info' command to retrieve inventory and plugin details for a specific tool. This command provides paths for stores, executables, and plugin sources.

```bash
$ proto tool info node
```

--------------------------------

### Pkl Advanced Example: Sharing Inputs with Local Variables

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Illustrates the use of `local` variables in Pkl to share common inputs across multiple tasks, such as test and lint tasks. This promotes DRY (Don't Repeat Yourself) principles in configuration.

```pkl
local _sharedInputs = List("src/**/*")

tasks {
  ["test"] {
    // ...
    inputs = List("tests/**/*") + _sharedInputs
  }
  ["lint"] {
    // ...
    inputs = List("**/*.graphql") + _sharedInputs
  }
}
```

--------------------------------

### Install Moon CLI via shell scripts

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-01-26_moon-v2-rc.mdx

Installs the moon CLI directly using platform-specific shell scripts for Unix and Windows environments.

```shell
# Unix
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/moonrepo/moon/releases/download/v2.0.0-rc.4/moon_cli-installer.sh | sh

# Windows
powershell -ExecutionPolicy Bypass -c "irm https://github.com/moonrepo/moon/releases/download/v2.0.0-rc.4/moon_cli-installer.ps1 | iex"
```

--------------------------------

### Configure uv pip with custom arguments

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-06-01-moon-v2.3.mdx

Customize the behavior of uv pip by specifying arguments for install, sync, and venv operations in .moon/toolchains.yml. Use unstable_pip for install args and unstable_uv for sync/venv args.

```yaml
unstable_python:
  packageManager: 'uv-pip'

unstable_pip:
  installArgs: ['--group', 'dev']

unstable_uv:
  syncArgs: ['--check']
  venvArgs: ['--clear']
```

--------------------------------

### Pkl Workspace Configuration Example

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Configures the workspace settings, including project globs, source directories, and the default version control branch. This snippet illustrates how to define project discovery and VCS settings in Pkl.

```pkl
projects {
  globs = List("apps/*", "packages/*")
  sources {
    ["root"] = "."
  }
}

vcs {
  defaultBranch = "master"
}
```

--------------------------------

### Enable Pkl Configuration via CLI

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-10-07_moon-v1.29.mdx

Commands to enable experimental Pkl support in Moon using command-line flags or environment variables.

```shell
$ moon check --all --experimentPklConfig
# Or
$ MOON_EXPERIMENT_PKL_CONFIG=true moon check --all
```

--------------------------------

### Configure Rust components and targets in moon

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-10-30_moon-v1.16.mdx

Enables the installation of specific Rust components and compilation targets within the moon toolchain configuration. These are automatically installed during the pipeline execution.

```yaml
rust:
  version: '1.73.0'
  components:
    - 'clippy'
    - 'rust-analyzer'
  targets:
    - 'wasm32-wasi'
```

--------------------------------

### Execute tasks using MQL queries

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-04-24_moon-v1.3.mdx

Demonstrates how to use the moon run command combined with MQL queries to filter projects by platform, type, or language for parallel task execution.

```shell
moon run :build --query "taskPlatform=node && projectType=library"
moon run :lint :test --query "language=rust"
```

--------------------------------

### Install moon CLI with npm/yarn/pnpm

Source: https://github.com/moonrepo/moon/blob/master/packages/cli/README.md

Installs the moon CLI as a development dependency using package managers like yarn. This integrates the CLI into your project's development environment.

```shell
yarn add --dev @moonrepo/cli
```

--------------------------------

### Configure proto version pinning

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2024-03-01_proto-v0.31.mdx

Demonstrates how to use the --pin argument to specify local or global scope for tool versions, and the --resolve flag to ensure semantic versioning.

```shell
$ proto install node --pin # global
$ proto install node --pin global
$ proto install node --pin local
$ proto pin node 1 # 1
$ proto pin node 1 --resolve # 1.2.3
```

--------------------------------

### Quick Fix for Cache Issues

Source: https://github.com/moonrepo/moon/blob/master/skills/debug-task/references/cache-issues.md

Force a successful run, verify archive creation, and test cache hydration.

```bash
# 1. Clear cache and force a successful run
moon run <project>:<task> --force

# 2. Verify the archive was created
ls .moon/cache/outputs/

# 3. Run again without --force to test hydration
moon run <project>:<task>

# 4. Check if output files appeared
ls <project>/dist/  # or whatever the output directory is
```

--------------------------------

### Task Hash Manifest Example

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-13_v0.26.mdx

An example JSON output from the `moon query hash` command. It displays the command and arguments used for a task, along with other relevant inputs that contribute to the task's unique hash.

```json
{
  "command": "build",
  "args": ["./build"]
  // ...
}
```

--------------------------------

### Install Moon v2 Beta via Shell Scripts

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-01-13_moon-v2-beta.mdx

Provides experimental shell scripts for installing the Moon v2 beta. Use with caution as these scripts have not been thoroughly tested. One script is for Unix-like systems and the other for Windows.

```shell
# Unix
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/moonrepo/moon/releases/download/v2.0.0-beta.0/moon_cli-installer.sh | sh
```

```powershell
# Windows
powershell -ExecutionPolicy Bypass -c "irm https://github.com/moonrepo/moon/releases/download/v2.0.0-beta.0/moon_cli-installer.ps1 | iex"
```

--------------------------------

### Enable async graph building in workspace configuration

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2026-04-13_moon-v2.2.mdx

Add this configuration to your .moon/workspace.yml file to activate the experimental async graph builder.

```yaml
experiments:
  asyncGraphBuilding: true
```

--------------------------------

### Configure tool-specific settings in .prototools

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-12-07_proto-v0.24.mdx

Shows how to define tool-specific configurations using the [tools.<name>] table, allowing granular control over individual plugin behaviors like Go and Node.js settings.

```toml
[tools.go]
gobin = false

[tools.node]
intercept-globals = false
```

--------------------------------

### Initialize Rust Project with moon init

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-05-08_moon-v1.5.mdx

Initializes a new Rust project within a moon workspace. Prompts to install Rust if not present, or installs it automatically if a Cargo.toml is detected when using --yes.

```shell
$ moon init --tool rust
```

--------------------------------

### Configure Bun Toolchain in .moon/toolchain.yml

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-11-20_moon-v1.17.mdx

This configuration enables Bun support within Moon, allowing for automatic downloads, dependency installation via `bun install`, and usage of `bunx` for package execution. It also supports syncing project workspace dependencies.

```yaml
bun:
  version: '1.0.13'
  syncProjectWorkspaceDependencies: true
```

--------------------------------

### Hash Difference Output Example

Source: https://github.com/moonrepo/moon/blob/master/website/blog/2023-03-13_v0.26.mdx

An example of the output produced by the `moon query hash-diff` command. It highlights the specific additions and removals in the task's inputs or sources between the two compared hashes, presented in a format familiar to users of `git diff`.

```diff
{
	"command": "build",
	"args": [
+
		"./dist"
-
		"./build"
	],
	...
}
```