rad 💯

A general purpose build tool. Concise, statically typed, batteries included. Command tasks, function tasks, and make-style tasks supported.

Jump to:

branch	status
main
next

Usage

Rad is generally used as a CLI:

$ rad <task-name> [--help]

For example, $ rad build or $ rad --log-level=info test!

It can be used as a library too :).

Rad always consumes a rad.ts file, such as the one shown here:

// rad.ts
import { Task, Tasks } from "https://deno.land/x/rad@v6.11.0/src/mod.ts";

// command/shell tasks
const format = `prettier --write`;
const test = `deno test`;

// function tasks
const compile: Task = {
  dependsOn: [format],
  fn: ({ sh, ...toolkit }) => sh("tsc"),
};
const greet = {
  fn: () => Deno.writeTextFile("/tmp/hello", "world"),
};

// make-style tasks
const transpile: Task = {
  target: "phony",
  prereqs: ["prereq1", "prereq2"],
  async onMake({ logger }, { changedPrereqs /*, prereqs */ }) {
    for await (const req of changedPrereqs) {
      logger.info(`req: ${req.path} ${req.isFile}`);
    }
  },
};

export const tasks: Tasks = {
  compile,
  format,
  greet,
  test,
};

Install

There are a few formal ways to use rad. Regardless of the route you choose, know that all strategies support using pinned versions, adherent to semver. See the releases page.

usage	install-method	install-steps
cli	`deno`	`deno install -f -A -n rad https://raw.githubusercontent.com/cdaringe/rad/v6.11.0/src/bin.ts`
cli	`docker`	`docker pull cdaringe/rad` ¹
cli	`curl`	`curl -fsSL https://raw.githubusercontent.com/cdaringe/rad/v6.11.0/assets/install.sh \| sh` (versioned) `curl -fsSL https://raw.githubusercontent.com/cdaringe/rad/main/assets/install.sh \| sh` (latest)
library	`deno`	`import * as rad from https://github.com/cdaringe/rad/blob/main/v6.11.0/mod.ts`

¹For docker users, consider making a nice shell alias

# shell profile, e.g. .bash_profile
function rad() {
  docker run --rm -v $PWD:/rad cdaringe/rad --log-level info "$@";
}

What is it

A build tool! It competes with make, npm-scripts, velociraptor, bazel, gradle, ant, gulp, or any of the other many tools out there! On various metrics, rad is subjectively better than some of the outstanding tools out there, and in some cases, not-so-much. We invite you to understand some of its core characteristics and interfaces.

rad offers:

simple, programmable task interfaces
easy to understand, declarative build steps
type-checked tasks
no quirky DSLs (make, gradle, and friends 😢). your build is code, not an arbitrary language or stringly (read: bummerly) typed script runner.
productive toolkit API for nuanced tasks that benefit from programming. see toolkit
bottom-up, make-style build targets
- fast builds, skip redundant work when inputs haven't changed
cli mode, or library mode
portability. build automation for any language or project, in many environments (*limited to Deno target architectures, for the time being. long term, we may package this in Rust)
great UX
debug-ability. 🐛 inspect your data, tasks, or even rad itself
employs a real scripting language--not bash/sh! shell languages are great for running other programs, not for plumbing data

See why not <my-favorite-build-tool>?