Rune

• Every script sees the others

  Every Rune script on the computer is a job on one shared bus, and each job sees the others. The bus reports when a job starts, waits, fails or finishes, and when one vanishes. A script sends its own events with emit("build.done", {target: "app"}).

• Wait for what really happened

  wait for "deploy.done" where e.data.target == "live" within 10 waits for the next event that fits, and never misses one that came before the wait began or gives the same one twice. on "build.step" as s { ... } runs a block for each event while the script waits, so tests finish as soon as the thing is done.

• Commands without a shell

  A command is a list of arguments, so $ cp {src} {dst} passes each value as one argument, whatever it holds. Nothing is split, globbed or quoted a second time.

• A failure stops the script

  A failed command stops the script and shows its exit code and the end of its error output. When a step may fail on purpose, try $ gives a result you can check.

• Secrets that stay secret

  A secret prints as *** everywhere, error messages included. It can't go into a command's arguments or a text, and it reaches a program through its standard input or its environment.

• Rebuilds only what changed

  make runs a step only when its inputs, or its key such as a compiler flag, have changed since its outputs were last made. par spreads independent work over every core.

• Checked before it runs

  rune check finds every mistake in a script without running it, and rune check --json gives the same report to a tool. rune fmt lays the file out the one way and never changes what it does.

• Network and data built in

  HTTP, TLS, JSON and regular expressions are part of the language, so a deployment can check a health address or read a release file without another tool. Shared code goes in a file of its own, brought in with use.

This short script builds a Go tool only when its sources have changed, runs its tests and copies the result into dist/.

# Build the tool when its sources changed, test it, then copy it to dist/.
let version = "1.2.0"
let tool = join_path("build", "tool")
let shipped = join_path("dist", "tool-" + version)
if is_dir("build") == false { mkdir("build") }
make([tool], glob("src/**/*.go"), "release " + version, () => {
	$ go build -o {tool} ./src
})
$ go test ./src/... with timeout: 10m
if is_dir("dist") == false { mkdir("dist") }
copy_file(tool, shipped)
print("ready:", shipped)

Where to get it

On Windows, get Rune from the Microsoft Store, which adds the rune command to every terminal. On macOS, download the signed and notarised installer for Apple silicon from antisoftworks.com/rune. On Linux, install the .deb or Arch package, or unpack the tarball on a server, from antisoftworks.com/rune.

• Windows

  Microsoft Store

• macOS

  rune-1.0.2.pkg

• Linux

  rune_1.0.2_amd64.debrune-1.0.2-1-x86_64.pkg.tar.zstrune-1.0.2-linux-x86_64.tar.gz

SHA256SUMS · Changelog