wingetCollections
  • Auto
  • Search
  • Awesome Collections
  • Awesome Programs
  • My Favorite Collections
  • My Collections
  • Account / Settings
  • Terms of Service
  • Privacy
  • About

© 2025 winget.ragerworks.com

Loading...
Install pace using Winget - wingetCollections
  1. Go back
  2. Packages
  3. pace
pace logo

pace Azuyamat

build-tool cli golang task-runner
Use this command to install pace:
winget install --id=Azuyamat.Pace -e

Pace is a cross-platform task runner designed to streamline development workflows by defining, managing, and executing tasks with dependencies, hooks, caching, and file watching. It supports multiple platforms, including Windows, Linux, and macOS, offering consistent functionality across environments.

Key Features:

  • Dependency Management: Organize tasks in sequences, ensuring they execute in the correct order.
  • Hooks & Caching: Integrate setup/cleanup commands and utilize caching to optimize repeated executions.
  • File Watching: Automatically rerun tasks when source files change, enhancing productivity.
  • Cross-Platform Support: Functions seamlessly across Windows, Linux, and macOS.

Audience & Benefits: Ideal for developers and teams seeking efficient task automation. Pace enhances workflow efficiency by reducing manual intervention and ensuring consistent builds across different platforms. Its intuitive configuration syntax simplifies setup and maintenance.

Pace can be installed on Windows via winget:

winget install Azuyamat.Pace

This tool is perfect for anyone looking to automate tasks in a development environment, offering a robust solution that adapts to various project needs.

README

Pace

Go Version License Release Go Report Card

A cross-platform task runner and build orchestration tool. Define tasks once, run them anywhere.

Why Pace?

If you've ever wanted npm run scripts but for Go, Rust, C++, or any other language—Pace is for you. Unlike Make (which has limited Windows support) or language-specific runners, Pace works the same on Windows, Linux, and macOS with an intuitive configuration syntax.

Features

  • Cross-platform - Works on Windows, Linux, and macOS
  • Simple syntax - Human-readable .pace configuration files
  • Task dependencies - Chain tasks together with automatic ordering
  • File watching - Re-run tasks when source files change
  • Smart caching - Skip unchanged tasks based on file hashes
  • Hooks - Run setup/cleanup commands before and after tasks
  • Arguments - Pass parameters to tasks with positional or named args
  • Retry logic - Automatically retry failed tasks
  • Parallel execution - Run independent tasks concurrently

Installation

Windows (winget)

winget install Azuyamat.Pace

Linux (deb)

Download the .deb package from releases:

sudo dpkg -i pace__amd64.deb

Go

go install github.com/azuyamat/pace/cmd/pace@latest

From Releases

Download the appropriate binary for your platform from the releases page.

Quick Start

Create a config.pace file in your project root:

default "build"

task "build" {
    description "Build the project"
    command "go build -o bin/app main.go"
    before ["test"]
    inputs ["**/*.go"]
    outputs ["bin/app"]
}

hook "test" {
    description "Run tests"
    command "go test ./..."
}
Versions
1.0.7
1.0.6
Website
github.com
License
Last updated
11/19/2025
Download latest version

Run your default task:

pace run

Or run a specific task:

pace run build

Configuration

Variables

Define reusable values:

set "output" "bin/myapp"
set "version" "1.0.0"

task "build" {
    command "go build -ldflags '-X main.Version=${version}' -o ${output} ."
}

Aliases

Create shortcuts for tasks:

alias "b" "build"
alias "t" "test"
alias "d" "dev"

Now you can run:

pace run b    # same as: pace run build

Task Properties

task "example" {
    description "Example task"
    command "echo 'Hello World'"

    before ["setup"]
    after ["cleanup"]
    on_success ["notify"]
    on_failure ["alert"]

    inputs ["src/**/*.go", "go.mod"]
    outputs ["bin/app"]

    cache true
    timeout "10m"
    retry 3
    retry_delay "5s"

    working_dir "src"
    env {
        "NODE_ENV" "production"
        "DEBUG" "false"
    }

    silent false
    parallel false
    continue_on_error false
}

Arguments

Pass arguments to tasks:

task "greet" {
    args {
        required ["name"]
    }
    command "echo 'Hello, $name!'"
}

pace run greet --name=World

Or use positional arguments:

task "echo" {
    command "echo $1 $2"
}

pace run echo hello world

Hooks

Hooks are lightweight tasks for setup/cleanup:

hook "format" {
    description "Format code"
    command "gofmt -s -w ."
}

Commands

pace run [task]      # Run a task (or default task)
pace watch [task]    # Watch inputs and re-run on changes
pace list            # List all tasks and hooks
pace list --tree     # List with dependency tree
pace help [command]  # Show help

Flags

  • --dry-run - Show what would run without executing
  • --force - Ignore cache and force execution

File Watching

Watch task inputs and automatically re-run:

pace watch build

This monitors all files matching the task's inputs patterns and re-executes when changes are detected.

Caching

When cache true is set, Pace tracks:

  • Input file hashes
  • Output file hashes
  • Command string
  • Dependency results

If nothing has changed since the last run, the task is skipped. Cache data is stored in .pace-cache/.

VS Code Extension

Syntax highlighting for .pace files is available. Check the vscode-pace directory for the extension.

Examples

Multi-language Project

default "all"

task "all" {
    before ["backend", "frontend"]
    command "echo 'Build complete'"
}

task "backend" {
    command "go build -o bin/server cmd/server/main.go"
    inputs ["cmd/**/*.go", "internal/**/*.go"]
    outputs ["bin/server"]
    cache true
}

task "frontend" {
    command "npm run build"
    working_dir "frontend"
    inputs ["frontend/src/**/*"]
    outputs ["frontend/dist/**/*"]
    cache true
}

Development Workflow

task "dev" {
    description "Start development server"
    before ["generate"]
    command "go run cmd/server/main.go"
}

hook "generate" {
    command "go generate ./..."
}

task "test" {
    command "go test -v ./..."
    inputs ["**/*.go"]
    cache true
}

task "lint" {
    command "golangci-lint run"
    inputs ["**/*.go"]
}

Contributing

Contributions are welcome! This is a passion project, so new ideas and improvements are always appreciated.

License

MIT