diff --git a/make_tool.cue b/make_tool.cue
index 70e1ce0..50e11d7 100644
--- a/make_tool.cue
+++ b/make_tool.cue
@@ -4,14 +4,22 @@ import (
 	"tool/exec"
 	"strings"
 	"tool/file"
-	"tool/cli"
 	"list"
+	// "tool/cli"
+	// "encoding/json"
 )
 
-whencuefmtimports: cli.Print
+#vars: {
+	rootdir: string
+	testdir: string
+	gitver:  string
+	version: string
+	ldflags: string
+	latest:  string
+}
 
 meta: {
-	vars: {
+	vars: #vars & {
 		rootdir: strings.TrimSpace(_commands.reporoot.stdout)
 		testdir: "\(rootdir)/test"
 		gitver:  strings.TrimSpace(_commands.gitver.stdout)
@@ -42,89 +50,83 @@ meta: {
 	}
 }
 
-command: build: {
-	cfg: meta
+task: build: {
+	vars: #vars
+
+	OutFile: *"xtemplate" | string
 
 	gobuild: exec.Run & {
-		OutFile: string | *"xtemplate"
 		env: {[string]: string}
-		cmd: ["go", "build", "-ldflags", cfg.vars.ldflags, "-buildmode", "exe", "-o", OutFile, "./cmd"]
-		dir:     cfg.vars.rootdir
+		cmd: ["go", "build", "-ldflags", vars.ldflags, "-buildmode", "exe", "-o", OutFile, "./cmd"]
+		dir:     vars.rootdir
 		success: true
 	}
 }
 
-command: run: {
-	cfg: meta
+task: run: {
+	vars: #vars
 
-	gobuild: command.build & {gobuild: {OutFile: "\(cfg.vars.testdir)/xtemplate"}}
-	rmdataw: file.RemoveAll & {path: "\(cfg.vars.testdir)/dataw"}
-	mkdataw: file.Mkdir & {path: "\(cfg.vars.testdir)/dataw", $dep: rmdataw.$done}
-	mklog: file.Create & {filename: "\(cfg.vars.testdir)/xtemplate.log", contents: ""}
+	gobuild: task.build & {"vars": vars, OutFile: "\(vars.testdir)/xtemplate"}
+	rmdataw: file.RemoveAll & {path: "\(vars.testdir)/dataw"}
+	mkdataw: file.Mkdir & {path: "\(vars.testdir)/dataw", $dep: rmdataw.$done}
+	mklog: file.Create & {filename: "\(vars.testdir)/xtemplate.log", contents: ""}
 
 	ready: exec.Run & {
 		$dep: mklog.$done
 		cmd: ["bash", "-c", "grep -q 'starting server' <(tail -f xtemplate.log)"]
-		dir: cfg.vars.testdir
+		dir: vars.testdir
 	}
 
 	start: exec.Run & {
 		$dep: mkdataw.$done && mklog.$done && gobuild.$done
 		cmd: ["bash", "-c", "./xtemplate --loglevel -4 -d DB:sql:sqlite3:file:./dataw/test.sqlite -d FS:fs:./data --config-file config.json >xtemplate.log 2>&1"]
-		dir: cfg.vars.testdir
+		dir: vars.testdir
 	}
 }
 
-command: test: {
-	cfg: meta
+task: test: {
+	vars: #vars
+
+	port: int | *8080
 
-	list: file.Glob & {glob: "\(cfg.vars.testdir)/tests/*.hurl"}
+	list: file.Glob & {glob: "\(vars.testdir)/tests/*.hurl"}
 	hurl: exec.Run & {
-		port: int | *8080
 		cmd: ["hurl", "--continue-on-error", "--test", "--report-html", "report", "--connect-to", "localhost:8080:localhost:\(port)"] + list.files
-		dir: cfg.vars.testdir
+		dir: vars.testdir
 	}
 }
 
-command: gotest: {
-	cfg: meta
+task: gotest: {
+	vars: #vars
 
 	gotest: exec.Run & {
 		cmd: "go test -v ./..."
-		dir: cfg.vars.rootdir
+		dir: vars.rootdir
 	}
 }
 
-command: run_test: {
-	run: command.run & {start: mustSucceed: false}
-
-	test: command.test & {hurl: {$dep: run.ready.$done}}
-
-	kill: exec.Run & {$dep: test.hurl.$done, cmd: "pkill xtemplate"} // better way?
-}
-
-command: dist: {
-	cfg: meta
+task: dist: {
+	vars: #vars
 
-	rmdist: file.RemoveAll & {path: "\(cfg.vars.rootdir)/dist"}
+	rmdist: file.RemoveAll & {path: "\(vars.rootdir)/dist"}
 
 	oses: ["linux", "darwin", "windows"]
-	arches: ["amd64"]
+	arches: ["amd64", "arm64"]
 	matrix: [for os in oses for arch in arches {GOOS: os, GOARCH: arch}]
 
 	for env in matrix {
 		(env.GOOS + "_" + env.GOARCH): {
-			dir: "\(cfg.vars.rootdir)/dist/xtemplate-\(env.GOARCH)-\(env.GOOS)"
+			dir: "\(vars.rootdir)/dist/xtemplate-\(env.GOARCH)-\(env.GOOS)"
 			exe: string | *"xtemplate"
 			if env.GOOS == "windows" {
 				exe: "xtemplate.exe"
 			}
 
 			mkdir: file.MkdirAll & {path: dir, $dep: rmdist.$done}
-			build: command.build.gobuild & {env: env, OutFile: "\(dir)/\(exe)", $dep: mkdir.$done}
+			build: task.build.gobuild & {"vars": vars, "env": env, OutFile: "\(dir)/\(exe)", $dep: mkdir.$done}
 			cp: exec.Run & {cmd: ["cp", "README.md", "LICENSE", "\(dir)"], $dep: mkdir.$done}
-			// tar: exec.Run & {cmd: ["tar", "czf", "\(dir)_\(cfg.vars.version).tar.gz", "-C", dir, "."], $dep: cp.$done && build.$done}
-			zip: exec.Run & {cmd: ["zip", "-jqr6", "\(dir)_\(cfg.vars.version).zip", dir], $dep: cp.$done && build.$done}
+			// tar: exec.Run & {cmd: ["tar", "czf", "\(dir)_\(vars.version).tar.gz", "-C", dir, "."], $dep: cp.$done && build.$done}
+			zip: exec.Run & {cmd: ["zip", "-jqr6", "\(dir)_\(vars.version).zip", dir], $dep: cp.$done && build.$done}
 			// rm: file.RemoveAll & {path: dir, $dep: zip.$done}
 		}
 	}
@@ -132,51 +134,69 @@ command: dist: {
 	wait: {$dep: and([for name, step in command.dist if name =~ "_" {step.$done}])}
 }
 
-command: test_docker: {
-	cfg: meta
+task: test_docker: {
+	vars: #vars
 
 	build: exec.Run & {
-		cmd: ["docker", "build", "-t", "xtemplate-test", "--target", "test", "--build-arg", "LDFLAGS=\(cfg.vars.ldflags)", "."]
-		dir: cfg.vars.rootdir
+		cmd: ["docker", "build", "-t", "xtemplate-test", "--target", "test", "--build-arg", "LDFLAGS=\(vars.ldflags)", "."]
+		dir: vars.rootdir
 	}
 	run: exec.Run & {
-		cmd: ["bash", "-c", "docker run -d --rm --name xtemplate-test -p 8081:80 xtemplate-test"]
+		cmd:  "docker run -d --rm --name xtemplate-test -p 8081:80 xtemplate-test"
 		$dep: build.$done
 	}
 	ready: exec.Run & {
 		cmd: ["bash", "-c", "grep -q 'starting server' <(docker logs -f xtemplate-test)"]
 		$dep: run.$done
 	}
-	test: command.test & {hurl: {port: 8081, $dep: ready.$done}}
+	test: task.test & {port: 8081, hurl: $dep: ready.$done}
 	stop: exec.Run & {cmd: "docker stop xtemplate-test", $dep: test.hurl.$done} // be nice if we can always run this even if previous steps fail
 }
 
-command: build_docker: {
-	cfg: meta
+task: build_docker: {
+	vars: #vars
 
-	tags: [...string] | *["infogulch/xtemplate:\(cfg.vars.version)"]
-	if cfg.vars.version == cfg.vars.latest {
-		tags: ["infogulch/xtemplate:\(cfg.vars.version)", "infogulch/xtemplate:latest"]
+	_latest: [...string] | *[]
+	if vars.version == vars.latest {
+		_latest: ["infogulch/xtemplate:latest"]
 	}
+	tags: ["infogulch/xtemplate:\(vars.version)"] + _latest
 
 	build: exec.Run & {
-		cmd: ["docker", "build"] + list.FlattenN([for t in tags {["-t", t]}], 1) + ["--build-arg", "LDFLAGS=\(cfg.vars.ldflags)", "."]
-		dir: cfg.vars.rootdir
+		cmd: ["docker", "build"] + list.FlattenN([for t in tags {["-t", t]}], 1) + ["--build-arg", "LDFLAGS=\(vars.ldflags)", "."]
+		dir: vars.rootdir
 	}
 }
 
+command: {
+	for k, t in task {
+		(k): {cfg: meta, vars: cfg.vars, t}
+	}
+}
+
+command: run_test: {
+	cfg: meta
+
+	run: task.run & {"vars": cfg.vars, start: mustSucceed: false}
+	test: task.test & {"vars": cfg.vars, hurl: $dep: run.ready.$done}
+	kill: exec.Run & {$dep: test.hurl.$done, cmd: "pkill xtemplate"} // better way?
+}
+
 command: ci: {
-	gotest:   command.gotest
-	run_test: command.run_test
+	cfg: meta
 
-	dist: command.dist & {rmdist: $dep: run_test.kill.$done}
+	gotest: task.gotest & {"vars": cfg.vars}
 
-	test_docker: command.test_docker
+	run: task.run & {"vars": cfg.vars, start: mustSucceed: false}
+	test: task.test & {"vars": cfg.vars, hurl: $dep: run.ready.$done}
+	kill: exec.Run & {cmd: "pkill xtemplate", $dep: test.hurl.$done} // better way?
 
-	build_docker: command.build_docker & {build: $dep: test_docker.stop.$done}
+	dist: task.dist & {"vars": cfg.vars, rmdist: $dep: kill.$done}
 
+	test_docker: task.test_docker & {"vars": cfg.vars}
+	build_docker: task.build_docker & {"vars": cfg.vars, build: $dep: test_docker.stop.$done}
 	push: exec.Run & {
-		cmd: ["docker", "push"] + build_docker.tags
+		cmd: ["echo", "docker", "push"] + build_docker.tags
 		$dep: build_docker.build.$done
 	}
 }