diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 319ca64..b3c19a8 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -2,8 +2,6 @@ name: goreleaser
 
 on:
   push:
-    branches:
-    - "!*"
     tags:
     - "v*"
 
diff --git a/examples/advanced/dynamic-config-inheritance/config/globals.yaml b/examples/advanced/dynamic-config-inheritance/config/globals.yaml
new file mode 100644
index 0000000..1c75a1f
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/config/globals.yaml
@@ -0,0 +1,5 @@
+vars:
+  namespace: eg
+
+override_with_empty: [1]
+override_with_ints: [1]
diff --git a/examples/advanced/dynamic-config-inheritance/config/ue2-globals.yaml b/examples/advanced/dynamic-config-inheritance/config/ue2-globals.yaml
new file mode 100644
index 0000000..09c73af
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/config/ue2-globals.yaml
@@ -0,0 +1,9 @@
+import:
+- globals
+
+vars:
+  region: us-east-2
+  environment: ue2
+
+override_with_empty: []
+override_with_ints: [2]
diff --git a/examples/advanced/dynamic-config-inheritance/config/ue2-prod.yaml b/examples/advanced/dynamic-config-inheritance/config/ue2-prod.yaml
new file mode 100644
index 0000000..96ad5d9
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/config/ue2-prod.yaml
@@ -0,0 +1,5 @@
+import:
+- ue2-globals
+
+vars:
+  stage: prod
diff --git a/examples/advanced/dynamic-config-inheritance/config/ue3-prod.yaml b/examples/advanced/dynamic-config-inheritance/config/ue3-prod.yaml
new file mode 100644
index 0000000..aed48ac
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/config/ue3-prod.yaml
@@ -0,0 +1,5 @@
+import:
+- ue3-globals
+
+vars:
+  stage: prod
diff --git a/examples/advanced/dynamic-config-inheritance/main.variant b/examples/advanced/dynamic-config-inheritance/main.variant
new file mode 100644
index 0000000..ca58ec7
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/main.variant
@@ -0,0 +1,48 @@
+option "config-dir" {
+  type = string
+}
+
+job "stack config" {
+  concurrency = 1
+  description = "Generate stack config in YAML format"
+
+  option "stack" {
+    type        = string
+    description = "Stack"
+    short       = "s"
+  }
+
+  variable "configs" {
+    value = flatten(concat([
+      # 1st level of imports
+      for k1, imports1 in yamldecode(file(format("%s/%s.yaml", opt.config-dir, opt.stack))): [
+        for import1 in imports1: concat([
+          # 1st level import's imports = 2nd level of imports
+          for k2, imports2 in yamldecode(file(format("%s/%s.yaml", opt.config-dir, import1))): [
+            for import2 in imports2: [
+              # 2nd level import's imports = 3rd level of imports
+              format("%s/%s.yaml", opt.config-dir, import2)
+            ]
+          ] if k2 == "import"
+        ], [
+          format("%s/%s.yaml", opt.config-dir, import1)
+        ])
+      ] if k1 == "import"
+    ], [
+      format("%s/%s.yaml", opt.config-dir, opt.stack)
+    ]))
+  }
+
+  config "all" {
+    source file {
+      paths = var.configs
+    }
+  }
+
+  exec {
+    command = "echo"
+    args = [
+      jsonencode(conf.all)
+    ]
+  }
+}
diff --git a/examples/advanced/dynamic-config-inheritance/main_test.variant b/examples/advanced/dynamic-config-inheritance/main_test.variant
new file mode 100644
index 0000000..77caba8
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/main_test.variant
@@ -0,0 +1,165 @@
+test "stack config" {
+  case "ue2-prod" {
+    stack = "ue2-prod"
+    exitstatus = 0
+    err = ""
+    namespace = "eg"
+    region = "us-east-2"
+    environment = "ue2"
+    stage = "prod"
+    override_with_empty = []
+    override_with_ints = [2]
+  }
+
+  // missing stack config
+  case "ue1-prod" {
+    stack = "ue1-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "stack config": ${abspath("main.variant")}:18,43-50: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue1-prod.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource.
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  // missing stack config import
+  case "ue3-prod" {
+    stack = "ue3-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "stack config": ${abspath("main.variant")}:21,47-54: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue3-globals.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource.
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  run "stack config" {
+    config-dir = "config"
+    stack = case.stack
+  }
+
+  assert "error" {
+    condition = run.err == case.err
+  }
+
+  assert "namespace" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.namespace, "UNDEFINED") == case.namespace) || !run.res.set
+  }
+
+  assert "region" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.region, "UNDEFINED") == case.region) || !run.res.set
+  }
+
+  assert "environment" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.environment, "UNDEFINED") == case.environment) || !run.res.set
+  }
+
+  assert "stage" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.stage, "UNDEFINED") == case.stage) || !run.res.set
+  }
+
+  assert "override_with_empty" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_empty, "UNDEFINED") == case.override_with_empty) || !run.res.set
+  }
+
+  assert "override_with_ints" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_ints, "UNDEFINED") == case.override_with_ints) || !run.res.set
+  }
+
+  assert "exitstatus" {
+    condition = (run.res.set && run.res.exitstatus == case.exitstatus) || !run.res.set
+  }
+}
+
+test "userfunc stack config" {
+  case "ue2-prod" {
+    stack = "ue2-prod"
+    exitstatus = 0
+    err = ""
+    namespace = "eg"
+    region = "us-east-2"
+    environment = "ue2"
+    stage = "prod"
+    override_with_empty = []
+    override_with_ints = [2]
+  }
+
+  // missing stack config
+  case "ue1-prod" {
+    stack = "ue1-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "userfunc stack config": ${abspath("userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue1-prod.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource..
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  // missing stack config import
+  case "ue3-prod" {
+    stack = "ue3-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "userfunc stack config": ${abspath("userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("userfunc.variant")}:6,9-16: Error in function call; Call to function "import" failed: ${abspath("userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue3-globals.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource...
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  run "userfunc stack config" {
+    config-dir = "config"
+    stack = case.stack
+  }
+
+  assert "error" {
+    condition = run.err == case.err
+  }
+
+  assert "namespace" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.namespace, "UNDEFINED") == case.namespace) || !run.res.set
+  }
+
+  assert "region" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.region, "UNDEFINED") == case.region) || !run.res.set
+  }
+
+  assert "environment" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.environment, "UNDEFINED") == case.environment) || !run.res.set
+  }
+
+  assert "stage" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.stage, "UNDEFINED") == case.stage) || !run.res.set
+  }
+
+  assert "override_with_empty" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_empty, "UNDEFINED") == case.override_with_empty) || !run.res.set
+  }
+
+  assert "override_with_ints" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_ints, "UNDEFINED") == case.override_with_ints) || !run.res.set
+  }
+
+  assert "exitstatus" {
+    condition = (run.res.set && run.res.exitstatus == case.exitstatus) || !run.res.set
+  }
+}
diff --git a/examples/advanced/dynamic-config-inheritance/userfunc.variant b/examples/advanced/dynamic-config-inheritance/userfunc.variant
new file mode 100644
index 0000000..4391ee4
--- /dev/null
+++ b/examples/advanced/dynamic-config-inheritance/userfunc.variant
@@ -0,0 +1,40 @@
+function "import" {
+  params = [config-dir, path]
+  result = flatten(concat([
+    for k, imports in yamldecode(file(format("%s/%s.yaml", config-dir, path))): [
+      for imported in imports: [
+        import(config-dir, imported)
+      ]
+    ] if k == "import"
+  ], [
+    format("%s/%s.yaml", config-dir, path)
+  ]))
+}
+
+job "userfunc stack config" {
+  concurrency = 1
+  description = "Generate stack config in YAML format"
+
+  option "stack" {
+    type        = string
+    description = "Stack"
+    short       = "s"
+  }
+
+  variable "files" {
+    value = import(opt.config-dir, opt.stack)
+  }
+
+  config "all" {
+    source file {
+      paths = var.files
+    }
+  }
+
+  exec {
+    command = "echo"
+    args = [
+      jsonencode(conf.all)
+    ]
+  }
+}
diff --git a/examples/advanced/userfunc-local-scope/config/globals.yaml b/examples/advanced/userfunc-local-scope/config/globals.yaml
new file mode 100644
index 0000000..1c75a1f
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/config/globals.yaml
@@ -0,0 +1,5 @@
+vars:
+  namespace: eg
+
+override_with_empty: [1]
+override_with_ints: [1]
diff --git a/examples/advanced/userfunc-local-scope/config/ue2-globals.yaml b/examples/advanced/userfunc-local-scope/config/ue2-globals.yaml
new file mode 100644
index 0000000..09c73af
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/config/ue2-globals.yaml
@@ -0,0 +1,9 @@
+import:
+- globals
+
+vars:
+  region: us-east-2
+  environment: ue2
+
+override_with_empty: []
+override_with_ints: [2]
diff --git a/examples/advanced/userfunc-local-scope/config/ue2-prod.yaml b/examples/advanced/userfunc-local-scope/config/ue2-prod.yaml
new file mode 100644
index 0000000..96ad5d9
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/config/ue2-prod.yaml
@@ -0,0 +1,5 @@
+import:
+- ue2-globals
+
+vars:
+  stage: prod
diff --git a/examples/advanced/userfunc-local-scope/config/ue3-prod.yaml b/examples/advanced/userfunc-local-scope/config/ue3-prod.yaml
new file mode 100644
index 0000000..aed48ac
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/config/ue3-prod.yaml
@@ -0,0 +1,5 @@
+import:
+- ue3-globals
+
+vars:
+  stage: prod
diff --git a/examples/advanced/userfunc-local-scope/main.variant b/examples/advanced/userfunc-local-scope/main.variant
new file mode 100644
index 0000000..30cb8be
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/main.variant
@@ -0,0 +1,5 @@
+import = "../dynamic-config-inheritance"
+
+job "nested" {
+  import = "../dynamic-config-inheritance"
+}
diff --git a/examples/advanced/userfunc-local-scope/main_test.variant b/examples/advanced/userfunc-local-scope/main_test.variant
new file mode 100644
index 0000000..52fae31
--- /dev/null
+++ b/examples/advanced/userfunc-local-scope/main_test.variant
@@ -0,0 +1,165 @@
+test "imported userfunc stack config" {
+  case "ue2-prod" {
+    stack = "ue2-prod"
+    exitstatus = 0
+    err = ""
+    namespace = "eg"
+    region = "us-east-2"
+    environment = "ue2"
+    stage = "prod"
+    override_with_empty = []
+    override_with_ints = [2]
+  }
+
+  // missing stack config
+  case "ue1-prod" {
+    stack = "ue1-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "userfunc stack config": ${abspath("../dynamic-config-inheritance/userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue1-prod.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource..
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  // missing stack config import
+  case "ue3-prod" {
+    stack = "ue3-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "userfunc stack config": ${abspath("../dynamic-config-inheritance/userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:6,9-16: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue3-globals.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource...
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  run "userfunc stack config" {
+    config-dir = "config"
+    stack = case.stack
+  }
+
+  assert "error" {
+    condition = run.err == case.err
+  }
+
+  assert "namespace" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.namespace, "UNDEFINED") == case.namespace) || !run.res.set
+  }
+
+  assert "region" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.region, "UNDEFINED") == case.region) || !run.res.set
+  }
+
+  assert "environment" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.environment, "UNDEFINED") == case.environment) || !run.res.set
+  }
+
+  assert "stage" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.stage, "UNDEFINED") == case.stage) || !run.res.set
+  }
+
+  assert "override_with_empty" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_empty, "UNDEFINED") == case.override_with_empty) || !run.res.set
+  }
+
+  assert "override_with_ints" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_ints, "UNDEFINED") == case.override_with_ints) || !run.res.set
+  }
+
+  assert "exitstatus" {
+    condition = (run.res.set && run.res.exitstatus == case.exitstatus) || !run.res.set
+  }
+}
+
+test "nested userfunc stack config" {
+  case "ue2-prod" {
+    stack = "ue2-prod"
+    exitstatus = 0
+    err = ""
+    namespace = "eg"
+    region = "us-east-2"
+    environment = "ue2"
+    stage = "prod"
+    override_with_empty = []
+    override_with_ints = [2]
+  }
+
+  // missing stack config
+  case "ue1-prod" {
+    stack = "ue1-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "nested userfunc stack config": ${abspath("../dynamic-config-inheritance/userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue1-prod.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource..
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  // missing stack config import
+  case "ue3-prod" {
+    stack = "ue3-prod"
+    exitstatus = 1
+    err = trimspace(<<EOS
+job "nested userfunc stack config": ${abspath("../dynamic-config-inheritance/userfunc.variant")}:25,13-20: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:6,9-16: Error in function call; Call to function "import" failed: ${abspath("../dynamic-config-inheritance/userfunc.variant")}:4,39-46: Invalid function argument; Invalid value for "path" parameter: no file exists at config/ue3-globals.yaml; this function works only with files that are distributed as part of the configuration source code, so if this file will be created by a resource in this configuration you must instead obtain this result from an attribute of that resource...
+EOS
+    )
+    namespace = "UNDEFINED"
+    region = "UNDEFINED"
+    environment = "UNDEFINED"
+    stage = "UNDEFINED"
+    override_with_empty = "UNDEFINED"
+    override_with_ints = "UNDEFINED"
+  }
+
+  run "nested userfunc stack config" {
+    config-dir = "config"
+    stack = case.stack
+  }
+
+  assert "error" {
+    condition = run.err == case.err
+  }
+
+  assert "namespace" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.namespace, "UNDEFINED") == case.namespace) || !run.res.set
+  }
+
+  assert "region" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.region, "UNDEFINED") == case.region) || !run.res.set
+  }
+
+  assert "environment" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.environment, "UNDEFINED") == case.environment) || !run.res.set
+  }
+
+  assert "stage" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).vars.stage, "UNDEFINED") == case.stage) || !run.res.set
+  }
+
+  assert "override_with_empty" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_empty, "UNDEFINED") == case.override_with_empty) || !run.res.set
+  }
+
+  assert "override_with_ints" {
+    condition = (run.res.set && try(jsondecode(run.res.stdout).override_with_ints, "UNDEFINED") == case.override_with_ints) || !run.res.set
+  }
+
+  assert "exitstatus" {
+    condition = (run.res.set && run.res.exitstatus == case.exitstatus) || !run.res.set
+  }
+}
diff --git a/examples/config/config_test.variant b/examples/config/config_test.variant
index 3eaaf54..b18f9d4 100644
--- a/examples/config/config_test.variant
+++ b/examples/config/config_test.variant
@@ -40,7 +40,7 @@ EOS
     exitstatus = 1
     out = ""
     err = trimspace(<<EOS
-job "config view": config "foo": source 1: open examples/config/conf/test.yaml: no such file or directory
+job "config view": config "foo": source 1: open ${abspath("conf/test.yaml")}: no such file or directory
 EOS
     )
   }
@@ -52,7 +52,7 @@ EOS
     exitstatus = 1
     out = ""
     err = trimspace(<<EOS
-job "config view": config "foo": source 2: open examples/config/conf/app3.yaml: no such file or directory
+job "config view": config "foo": source 2: open ${abspath("conf/app3.yaml")}: no such file or directory
 EOS
     )
   }
diff --git a/examples/secret/secret_test.variant b/examples/secret/secret_test.variant
index b5f3d1a..b050841 100644
--- a/examples/secret/secret_test.variant
+++ b/examples/secret/secret_test.variant
@@ -29,7 +29,7 @@ EOS
     exitstatus = 1
     out = ""
     err = trimspace(<<EOS
-job "secret view": secret "foo": source 1: open examples/secret/sec/test.yaml: no such file or directory
+job "secret view": secret "foo": source 1: open ${abspath("sec/test.yaml")}: no such file or directory
 EOS
     )
   }
@@ -41,7 +41,7 @@ EOS
     exitstatus = 1
     out = ""
     err = trimspace(<<EOS
-job "secret view": secret "foo": source 2: open examples/secret/sec/app3.yaml: no such file or directory
+job "secret view": secret "foo": source 2: open ${abspath("sec/app3.yaml")}: no such file or directory
 EOS
     )
   }
diff --git a/examples/simple/simple_test.variant b/examples/simple/simple_test.variant
index f4427bd..c9af06e 100644
--- a/examples/simple/simple_test.variant
+++ b/examples/simple/simple_test.variant
@@ -9,7 +9,7 @@ test "app deploy" {
     namespace = "foo"
     exitstatus = 1
     err = trimspace(<<EOS
-job "app deploy": job "shell": command "bash -c     kubectl -n foo apply -f examples/simple/manifests/
+job "app deploy": job "shell": command "bash -c     kubectl -n foo apply -f ${abspath("manifests")}/
 ": exit status 1
 EOS
     )
diff --git a/main_test.go b/main_test.go
index 09e18fb..a060bd8 100644
--- a/main_test.go
+++ b/main_test.go
@@ -14,6 +14,15 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
+func abspath(p string) string {
+	ap, err := filepath.Abs(p)
+	if err != nil {
+		panic(err)
+	}
+
+	return ap
+}
+
 func TestExamples(t *testing.T) {
 	testcases := []struct {
 		subject     string
@@ -143,7 +152,7 @@ func TestExamples(t *testing.T) {
 		{
 			subject:     "import/shebang",
 			variantName: "",
-			args:        []string{"variant", "./examples/advanced/import/mycli", "foo", "bar", "HELLO"},
+			args:        []string{"variant", "./mycli", "foo", "bar", "HELLO"},
 			wd:          "./examples/advanced/import",
 			expectOut:   "HELLO\n",
 		},
@@ -174,6 +183,18 @@ func TestExamples(t *testing.T) {
 			wd:          "./examples/advanced/nested-import-global-propagation-incompatible-type",
 			expectErr:   "loading command: merging globals: imported job \"\" has incompatible option \"project-dir\": needs type of cty.Number, encountered cty.String",
 		},
+		{
+			subject:     "dynamic-config-inheritance",
+			variantName: "",
+			args:        []string{"variant", "test"},
+			wd:          abspath("./examples/advanced/dynamic-config-inheritance"),
+		},
+		{
+			subject:     "userfunc-local-scope",
+			variantName: "",
+			args:        []string{"variant", "test"},
+			wd:          abspath("./examples/advanced/userfunc-local-scope"),
+		},
 		{
 			subject:     "options",
 			variantName: "",
@@ -188,7 +209,7 @@ func TestExamples(t *testing.T) {
 		},
 		{
 			subject: "shebang",
-			args:    []string{"variant", "./test/shebang/myapp/myapp", "test", "--int1", "1", "--ints1", "1,2", "--str1", "a", "--strs1", "b,c"},
+			args:    []string{"variant", "./shebang/myapp/myapp", "test", "--int1", "1", "--ints1", "1,2", "--str1", "a", "--strs1", "b,c"},
 			wd:      "./test",
 		},
 		{
@@ -238,11 +259,28 @@ func TestExamples(t *testing.T) {
 		},
 	}
 
+	base, _ := os.Getwd()
+
 	for idx := range testcases {
 		i := idx
 		tc := testcases[i]
 
 		t.Run(fmt.Sprintf("%d: %s", i, tc.subject), func(t *testing.T) {
+			wd, err2 := filepath.Abs(tc.wd)
+			if err2 != nil {
+				t.Fatalf("determining directory: %v", err2)
+			}
+
+			if err := os.Chdir(wd); err != nil {
+				t.Fatalf("changing directory for test: %v", err)
+			}
+
+			defer func() {
+				if err := os.Chdir(base); err != nil {
+					t.Logf("changing directory back: %v", err)
+				}
+			}()
+
 			t.Logf("Running subtest: %d %s", i, tc.subject)
 
 			outRead, outWrite := io.Pipe()
@@ -260,8 +298,8 @@ func TestExamples(t *testing.T) {
 					}
 				},
 				Getwd: func() (string, error) {
-					if tc.wd != "" {
-						return tc.wd, nil
+					if wd != "" {
+						return wd, nil
 					}
 
 					return "", fmt.Errorf("Unexpected call to getw")
diff --git a/pkg/app/app.go b/pkg/app/app.go
index 8fdebc1..0b5cf78 100644
--- a/pkg/app/app.go
+++ b/pkg/app/app.go
@@ -662,7 +662,7 @@ func (app *App) execTestCase(t Test, c Case) (*Result, error) {
 		},
 	}
 
-	ctx, err := addVariables(ctx, t.Variables)
+	ctx, err := setVariables(ctx, t.Variables)
 	if err != nil {
 		return nil, err
 	}
@@ -1354,9 +1354,16 @@ func (app *App) createJobContext(cc *HCL2Config, j JobSpec, givenParams map[stri
 		}
 	}
 
-	varSpecs := append(append([]Variable{}, cc.Variables...), j.Variables...)
+	funcs := app.Funcs
+
+	if j.Name != "" && app.JobLocalFuncs != nil {
+		if fs, ok := app.JobLocalFuncs[j.Name]; ok {
+			funcs = fs
+		}
+	}
+
 	modCtx := &hcl2.EvalContext{
-		Functions: conf.Functions("."),
+		Functions: funcs,
 		Variables: map[string]cty.Value{
 			"param":   cty.ObjectVal(params),
 			"opt":     cty.ObjectVal(opts),
@@ -1401,121 +1408,79 @@ func (app *App) createJobContext(cc *HCL2Config, j JobSpec, givenParams map[stri
 		globalArgs:  globalArgs,
 	}
 
-	conf, err := app.getConfigs(confJobCtx, cc, j, "config", func(j JobSpec) []Config { return j.Configs }, nil)
-	if err != nil {
-		return nil, err
-	}
+	varSpecs := append(append([]Variable{}, cc.Variables...), j.Variables...)
+
+	getConfigs := func(j JobSpec) []Config { return j.Configs }
+	configs := append(append([]Config{}, getConfigs(cc.JobSpec)...), getConfigs(j)...)
 
-	secJobCtx := confJobCtx.WithVariable("conf", conf).Ptr()
+	getSecrets := func(j JobSpec) []Config { return j.Secrets }
+	secrets := append(append([]Config{}, getSecrets(cc.JobSpec)...), getSecrets(j)...)
 
 	secretRefsEvaluator, err := vals.New(vals.Options{CacheSize: 100})
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize vals: %w", err)
 	}
 
-	sec, err := app.getConfigs(secJobCtx, cc, j, "secret", func(j JobSpec) []Config { return j.Secrets }, func(m map[string]interface{}) (map[string]interface{}, error) {
+	g := func(m map[string]interface{}) (map[string]interface{}, error) {
 		return secretRefsEvaluator.Eval(m)
-	})
-	if err != nil {
-		return nil, err
 	}
 
-	varJobCtx := secJobCtx.WithVariable("sec", sec)
-
-	varCtx, err := addVariables(varJobCtx.evalContext, varSpecs)
+	updatedContext, err := app.addConfigsAndVariables(confJobCtx, varSpecs, configs, secrets, g)
 	if err != nil {
 		return nil, err
 	}
 
-	jobCtx := varJobCtx.WithEvalContext(varCtx).Ptr()
+	jobCtx := confJobCtx.WithEvalContext(updatedContext).Ptr()
 
 	return jobCtx, nil
 }
 
-func (app *App) getConfigs(jobCtx *JobContext, cc *HCL2Config, j JobSpec, confType string, f func(JobSpec) []Config, g func(map[string]interface{}) (map[string]interface{}, error)) (cty.Value, error) {
+//nolint:unused
+func (app *App) getConfigs(jobCtx *JobContext, confType string, confSpecs []Config, g func(map[string]interface{}) (map[string]interface{}, error)) (cty.Value, error) {
 	confCtx := jobCtx.evalContext
 
-	confSpecs := append(append([]Config{}, f(cc.JobSpec)...), f(j)...)
-
 	confFields := map[string]cty.Value{}
 
 	for confIndex := range confSpecs {
 		confSpec := confSpecs[confIndex]
-		merged := map[string]interface{}{}
-
-		for sourceIdx := range confSpec.Sources {
-			sourceSpec := confSpec.Sources[sourceIdx]
 
-			var yamlData []byte
-
-			var format string
-
-			var key string
-
-			switch sourceSpec.Type {
-			case "file":
-				var source SourceFile
-				if err := gohcl2.DecodeBody(sourceSpec.Body, confCtx, &source); err != nil {
-					return cty.NilVal, err
-				}
-
-				var err error
-
-				yamlData, err = ioutil.ReadFile(source.Path)
-				if err != nil {
-					if source.Default == nil {
-						return cty.NilVal, fmt.Errorf("%s %q: source %d: %w", confType, confSpec.Name, sourceIdx, err)
-					}
-
-					yamlData = []byte(*source.Default)
-				}
-
-				format = FormatYAML
+		v, err := app.evaluateConfig(jobCtx, confType, confSpec, confCtx, g)
+		if err != nil {
+			return cty.DynamicVal, err
+		}
 
-				if source.Key != nil {
-					key = *source.Key
-				}
-			case "job":
-				var source SourceJob
-				if err := gohcl2.DecodeBody(sourceSpec.Body, confCtx, &source); err != nil {
-					return cty.NilVal, err
-				}
+		confFields[confSpec.Name] = v
+	}
 
-				args, err := buildArgsFromExpr(jobCtx.WithEvalContext(confCtx).Ptr(), source.Args)
-				if err != nil {
-					return cty.NilVal, err
-				}
+	return cty.ObjectVal(confFields), nil
+}
 
-				res, err := app.run(jobCtx, nil, source.Name, args, false)
-				if err != nil {
-					return cty.NilVal, xerrors.Errorf("%s %q: source %d: %w", confType, confSpec.Name, sourceIdx, err)
-				}
+func (app *App) evaluateConfig(jobCtx *JobContext, confType string, confSpec Config, confCtx *hcl2.EvalContext, g func(map[string]interface{}) (map[string]interface{}, error)) (cty.Value, error) {
+	merged := map[string]interface{}{}
 
-				yamlData = []byte(res.Stdout)
+	for sourceIdx := range confSpec.Sources {
+		sourceSpec := confSpec.Sources[sourceIdx]
 
-				if source.Format != nil {
-					format = *source.Format
-				} else {
-					format = FormatYAML
-				}
+		fragments, err := app.loadConfigSource(jobCtx, confCtx, sourceSpec)
+		if err != nil {
+			return cty.DynamicVal, xerrors.Errorf("%s %q: source %d: %w", confType, confSpec.Name, sourceIdx, err)
+		}
 
-				if source.Key != nil {
-					key = *source.Key
-				}
-			default:
-				return cty.DynamicVal, fmt.Errorf("config source %q is not implemented. It must be either \"file\" or \"job\", so that it looks like `source file {` or `source file {`", sourceSpec.Type)
-			}
+		for _, f := range fragments {
+			yamlData := f.data
+			format := f.format
+			key := f.key
 
 			m := map[string]interface{}{}
 
 			switch format {
 			case FormatYAML:
 				if err := yaml.Unmarshal(yamlData, &m); err != nil {
-					return cty.NilVal, xerrors.Errorf("unmarshalling yaml: %w", err)
+					return cty.DynamicVal, xerrors.Errorf("unmarshalling yaml: %w", err)
 				}
 			case FormatText:
 				if key == "" {
-					return cty.NilVal, fmt.Errorf("`key` must be specified for `text`-formatted source at %d", sourceIdx)
+					return cty.DynamicVal, fmt.Errorf("`key` must be specified for `text`-formatted source at %d", sourceIdx)
 				}
 
 				keys := strings.Split(key, ".")
@@ -1533,102 +1498,322 @@ func (app *App) getConfigs(jobCtx *JobContext, cc *HCL2Config, j JobSpec, confTy
 
 				cur[lastKey] = string(yamlData)
 			default:
-				return cty.NilVal, fmt.Errorf("format %q is not implemented yet. It must be \"yaml\" or omitted", format)
+				return cty.DynamicVal, fmt.Errorf("format %q is not implemented yet. It must be \"yaml\" or omitted", format)
 			}
 
 			if err := mergo.Merge(&merged, m, mergo.WithOverride, mergo.WithOverwriteWithEmptyValue); err != nil {
-				return cty.NilVal, xerrors.Errorf("merging maps: %w", err)
+				return cty.DynamicVal, xerrors.Errorf("merging maps: %w", err)
 			}
 		}
+	}
 
-		if g != nil {
-			r, err := g(merged)
-			if err != nil {
-				return cty.NilVal, err
-			}
+	if g != nil {
+		r, err := g(merged)
+		if err != nil {
+			return cty.DynamicVal, err
+		}
+
+		merged = r
+	}
+
+	yamlData, err := yaml.Marshal(merged)
+	if err != nil {
+		return cty.DynamicVal, xerrors.Errorf("generating yaml: %w", err)
+	}
+
+	ty, err := ctyyaml.ImpliedType(yamlData)
+	if err != nil {
+		return cty.DynamicVal, xerrors.Errorf("determining type of %s: %w", string(yamlData), err)
+	}
+
+	v, err := ctyyaml.Unmarshal(yamlData, ty)
+	if err != nil {
+		return cty.DynamicVal, xerrors.Errorf("unmarshalling %s: %w", string(yamlData), err)
+	}
+
+	return v, nil
+}
+
+//nolint:unused
+func (app *App) addConfigsAndVariablesDeprecated(jobCtx *JobContext, varSpecs []Variable, configs []Config, secrets []Config, g func(m map[string]interface{}) (map[string]interface{}, error)) (*hcl2.EvalContext, error) {
+	conf, err := app.getConfigs(jobCtx, "config", configs, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	secJobCtx := jobCtx.WithVariable("conf", conf).Ptr()
 
-			merged = r
+	sec, err := app.getConfigs(secJobCtx, "secret", secrets, g)
+	if err != nil {
+		return nil, err
+	}
+
+	varJobCtx := secJobCtx.WithVariable("sec", sec)
+
+	varCtx, err := setVariables(varJobCtx.evalContext, varSpecs)
+	if err != nil {
+		return nil, err
+	}
+
+	return varCtx, nil
+}
+
+//nolint:gocyclo
+func (app *App) addConfigsAndVariables(jobCtx *JobContext, varSpecs []Variable, confSpecs []Config, secSpecs []Config, g func(m map[string]interface{}) (map[string]interface{}, error)) (*hcl2.EvalContext, error) {
+	ctx := jobCtx.evalContext
+
+	type node struct {
+		config   *Config
+		secret   *Config
+		variable *Variable
+		deps     map[string]struct{}
+	}
+
+	d := dag.New()
+
+	nodes := map[string]node{}
+
+	dynamicDependencyName := func(v hcl2.Traversal) *string {
+		if !v.IsRelative() && (v.RootName() == "conf" || v.RootName() == "var" || v.RootName() == "sec") {
+			if r, ok := v.SimpleSplit().Rel[0].(hcl2.TraverseAttr); ok {
+				id := fmt.Sprintf("%s.%s", v.RootName(), r.Name)
+
+				return &id
+			}
 		}
 
-		yamlData, err := yaml.Marshal(merged)
-		if err != nil {
-			return cty.NilVal, xerrors.Errorf("generating yaml: %w", err)
+		return nil
+	}
+
+	for i := range varSpecs {
+		v := varSpecs[i]
+
+		id := fmt.Sprintf("var.%s", v.Name)
+
+		depsMap := map[string]struct{}{}
+
+		var deps []string
+
+		for _, v := range v.Value.Variables() {
+			if d := dynamicDependencyName(v); d != nil {
+				depsMap[*d] = struct{}{}
+			}
 		}
 
-		ty, err := ctyyaml.ImpliedType(yamlData)
-		if err != nil {
-			return cty.DynamicVal, xerrors.Errorf("determining type of %s: %w", string(yamlData), err)
+		nodes[id] = node{
+			variable: &v,
+			deps:     depsMap,
 		}
 
-		v, err := ctyyaml.Unmarshal(yamlData, ty)
-		if err != nil {
-			return cty.DynamicVal, xerrors.Errorf("unmarshalling %s: %w", string(yamlData), err)
+		for d := range depsMap {
+			deps = append(deps, d)
 		}
 
-		confFields[confSpec.Name] = v
+		d.Add(id, dag.Dependencies(deps))
 	}
 
-	return cty.ObjectVal(confFields), nil
-}
+	for i := range confSpecs {
+		c := confSpecs[i]
 
-func addVariables(varCtx *hcl2.EvalContext, varSpecs []Variable) (*hcl2.EvalContext, error) {
-	varFields := map[string]cty.Value{}
+		id := fmt.Sprintf("conf.%s", c.Name)
 
-	for _, varSpec := range varSpecs {
-		var tpe cty.Type
+		var deps []string
 
-		tv, _ := varSpec.Type.Value(nil)
+		depsMap := map[string]struct{}{}
 
-		if !tv.IsNull() {
-			var diags hcl2.Diagnostics
+		for _, s := range c.Sources {
+			content, err := loadConfigSourceContent(s)
+			if err != nil {
+				return nil, xerrors.Errorf("loading config %s's %s source: %w", c.Name, s.Type, err)
+			}
 
-			tpe, diags = typeexpr.TypeConstraint(varSpec.Type)
-			if diags != nil {
-				return varCtx, diags
+			for _, a := range content.Attributes {
+				for _, v := range a.Expr.Variables() {
+					if d := dynamicDependencyName(v); d != nil {
+						depsMap[*d] = struct{}{}
+					}
+				}
 			}
 		}
 
-		//nolint:nestif
-		if tpe.IsListType() && tpe.ListElementType().Equals(cty.String) {
-			var v []string
-			if err := gohcl2.DecodeExpression(varSpec.Value, varCtx, &v); err != nil {
-				return varCtx, err
+		nodes[id] = node{
+			config: &c,
+			deps:   depsMap,
+		}
+
+		for d := range depsMap {
+			deps = append(deps, d)
+		}
+
+		d.Add(id, dag.Dependencies(deps))
+	}
+
+	for i := range secSpecs {
+		c := secSpecs[i]
+
+		id := fmt.Sprintf("sec.%s", c.Name)
+
+		var deps []string
+
+		depsMap := map[string]struct{}{}
+
+		for _, s := range c.Sources {
+			content, err := loadConfigSourceContent(s)
+			if err != nil {
+				return nil, xerrors.Errorf("loading config %s's %s source: %w", c.Name, s.Type, err)
 			}
 
-			if vty, err := gocty.ImpliedType(v); err != nil {
-				return varCtx, err
-			} else if vty != tpe {
-				return varCtx, fmt.Errorf("unexpected type of option. want %q, got %q", tpe.FriendlyNameForConstraint(), vty.FriendlyName())
+			for _, a := range content.Attributes {
+				for _, v := range a.Expr.Variables() {
+					if d := dynamicDependencyName(v); d != nil {
+						depsMap[*d] = struct{}{}
+					}
+				}
 			}
+		}
 
-			val, err := gocty.ToCtyValue(v, tpe)
-			if err != nil {
-				return varCtx, err
+		nodes[id] = node{
+			secret: &c,
+			deps:   depsMap,
+		}
+
+		for d := range depsMap {
+			deps = append(deps, d)
+		}
+
+		d.Add(id, dag.Dependencies(deps))
+	}
+
+	for id, node := range nodes {
+		for dep := range node.deps {
+			if _, ok := nodes[dep]; !ok {
+				return nil, fmt.Errorf("%s depends on undefined variable %s", id, dep)
 			}
+		}
+	}
 
-			varFields[varSpec.Name] = val
-		} else {
-			var v cty.Value
+	top, err := d.Sort()
+	if err != nil {
+		return nil, xerrors.Errorf("resolving dependencies among variables and configs: %w", err)
+	}
 
-			if err := gohcl2.DecodeExpression(varSpec.Value, varCtx, &v); err != nil {
-				return varCtx, err
+	varFields := map[string]cty.Value{}
+	confFields := map[string]cty.Value{}
+	secFields := map[string]cty.Value{}
+
+	//nolint:nestif
+	for _, wave := range top {
+		ctx.Variables["var"] = cty.ObjectVal(varFields)
+		ctx.Variables["conf"] = cty.ObjectVal(confFields)
+		ctx.Variables["sec"] = cty.ObjectVal(secFields)
+
+		for _, info := range wave {
+			node, ok := nodes[info.Id]
+			if !ok {
+				return nil, xerrors.Errorf("missing node %s", info.Id)
 			}
 
-			vty := v.Type()
+			if v := node.config; v != nil {
+				r, err := app.evaluateConfig(jobCtx, "config", *v, ctx, nil)
+				if err != nil {
+					return nil, err
+				}
+
+				confFields[v.Name] = r
+			} else if v := node.secret; v != nil {
+				r, err := app.evaluateConfig(jobCtx, "secret", *v, ctx, g)
+				if err != nil {
+					return nil, err
+				}
+
+				secFields[v.Name] = r
+			} else if v := node.variable; v != nil {
+				r, err := evaluateVariable(ctx, *v)
+				if err != nil {
+					return nil, err
+				}
 
-			if !tv.IsNull() && !vty.Equals(tpe) {
-				return varCtx, fmt.Errorf("unexpected type of value for variable. want %q, got %q", tpe.FriendlyNameForConstraint(), vty.FriendlyName())
+				varFields[v.Name] = r
+			} else {
+				panic(fmt.Errorf("invalid state: either config or variable must be set in node: %+v", node))
 			}
+		}
+	}
+
+	ctx.Variables["var"] = cty.ObjectVal(varFields)
+	ctx.Variables["conf"] = cty.ObjectVal(confFields)
+	ctx.Variables["sec"] = cty.ObjectVal(secFields)
+
+	return ctx, nil
+}
+
+func setVariables(varCtx *hcl2.EvalContext, varSpecs []Variable) (*hcl2.EvalContext, error) {
+	varFields := map[string]cty.Value{}
 
-			varFields[varSpec.Name] = v
+	for _, varSpec := range varSpecs {
+		val, err := evaluateVariable(varCtx, varSpec)
+		if err != nil {
+			return nil, err
 		}
 
+		varFields[varSpec.Name] = val
+
 		varCtx.Variables["var"] = cty.ObjectVal(varFields)
 	}
 
 	return varCtx, nil
 }
 
+func evaluateVariable(varCtx *hcl2.EvalContext, varSpec Variable) (cty.Value, error) {
+	var tpe cty.Type
+
+	tv, _ := varSpec.Type.Value(nil)
+
+	if !tv.IsNull() {
+		var diags hcl2.Diagnostics
+
+		tpe, diags = typeexpr.TypeConstraint(varSpec.Type)
+		if diags != nil {
+			return cty.DynamicVal, diags
+		}
+	}
+
+	//nolint:nestif
+	if tpe.IsListType() && tpe.ListElementType().Equals(cty.String) {
+		var v []string
+		if err := gohcl2.DecodeExpression(varSpec.Value, varCtx, &v); err != nil {
+			return cty.DynamicVal, err
+		}
+
+		if vty, err := gocty.ImpliedType(v); err != nil {
+			return cty.DynamicVal, err
+		} else if vty != tpe {
+			return cty.DynamicVal, fmt.Errorf("unexpected type of option. want %q, got %q", tpe.FriendlyNameForConstraint(), vty.FriendlyName())
+		}
+
+		val, err := gocty.ToCtyValue(v, tpe)
+		if err != nil {
+			return cty.DynamicVal, err
+		}
+
+		return val, nil
+	}
+
+	var v cty.Value
+
+	if err := gohcl2.DecodeExpression(varSpec.Value, varCtx, &v); err != nil {
+		return cty.DynamicVal, err
+	}
+
+	vty := v.Type()
+
+	if !tv.IsNull() && !vty.Equals(tpe) {
+		return cty.DynamicVal, fmt.Errorf("unexpected type of value for variable. want %q, got %q", tpe.FriendlyNameForConstraint(), vty.FriendlyName())
+	}
+
+	return v, nil
+}
+
 func nonEmptyExpression(x hcl2.Expression) bool {
 	if x.Range().Start == x.Range().End {
 		return false
diff --git a/pkg/app/config_sources.go b/pkg/app/config_sources.go
new file mode 100644
index 0000000..a8022b3
--- /dev/null
+++ b/pkg/app/config_sources.go
@@ -0,0 +1,178 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"reflect"
+
+	"github.com/hashicorp/hcl/v2"
+	gohcl2 "github.com/hashicorp/hcl/v2/gohcl"
+	"golang.org/x/xerrors"
+)
+
+type configFragment struct {
+	data   []byte
+	key    string
+	format string
+}
+
+func loadConfigSourceContent(sourceSpec ConfigSource) (*hcl.BodyContent, error) {
+	body := sourceSpec.Body
+
+	var val reflect.Value
+
+	switch sourceSpec.Type {
+	case "file":
+		rv := reflect.ValueOf(&SourceFile{})
+		if rv.Kind() != reflect.Ptr {
+			panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+		}
+
+		val = rv.Elem()
+	case "job":
+		rv := reflect.ValueOf(&SourceJob{})
+		if rv.Kind() != reflect.Ptr {
+			panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+		}
+
+		val = rv.Elem()
+	default:
+		return nil, fmt.Errorf("config source %q is not implemented. It must be either \"file\" or \"job\", so that it looks like `source file {` or `source file {`", sourceSpec.Type)
+	}
+
+	schema, partial := gohcl2.ImpliedBodySchema(val.Interface())
+
+	var content *hcl.BodyContent
+
+	var _ hcl.Body
+
+	var diags hcl.Diagnostics
+
+	if partial {
+		content, _, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+
+	if content == nil {
+		return nil, diags
+	}
+
+	return content, nil
+}
+
+func (app *App) loadConfigSource(jobCtx *JobContext, confCtx *hcl.EvalContext, sourceSpec ConfigSource) ([]configFragment, error) {
+	var err error
+
+	var fragments []configFragment
+
+	switch sourceSpec.Type {
+	case "file":
+		fragments, err = loadFileConfigSource(confCtx, sourceSpec)
+		if err != nil {
+			return nil, err
+		}
+	case "job":
+		fragments, err = app.loadJobConfigSource(jobCtx, confCtx, sourceSpec)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("config source %q is not implemented. It must be either \"file\" or \"job\", so that it looks like `source file {` or `source file {`", sourceSpec.Type)
+	}
+
+	return fragments, nil
+}
+
+func (app *App) loadJobConfigSource(jobCtx *JobContext, confCtx *hcl.EvalContext, sourceSpec ConfigSource) ([]configFragment, error) {
+	var source SourceJob
+	if err := gohcl2.DecodeBody(sourceSpec.Body, confCtx, &source); err != nil {
+		return nil, xerrors.Errorf("decoding job body: %w", err)
+	}
+
+	args, err := buildArgsFromExpr(jobCtx.WithEvalContext(confCtx).Ptr(), source.Args)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := app.run(jobCtx, nil, source.Name, args, false)
+	if err != nil {
+		return nil, err
+	}
+
+	yamlData := []byte(res.Stdout)
+
+	var (
+		format string
+		key    string
+	)
+
+	if source.Format != nil {
+		format = *source.Format
+	} else {
+		format = FormatYAML
+	}
+
+	if source.Key != nil {
+		key = *source.Key
+	}
+
+	fragments := []configFragment{
+		{
+			data:   yamlData,
+			key:    key,
+			format: format,
+		},
+	}
+
+	return fragments, nil
+}
+
+func loadFileConfigSource(confCtx *hcl.EvalContext, sourceSpec ConfigSource) ([]configFragment, error) {
+	var source SourceFile
+	if err := gohcl2.DecodeBody(sourceSpec.Body, confCtx, &source); err != nil {
+		return nil, err
+	}
+
+	format := FormatYAML
+
+	var key string
+
+	if source.Key != nil {
+		key = *source.Key
+	}
+
+	var paths []string
+
+	if p := source.Path; p != nil && *p != "" {
+		paths = append(paths, *p)
+	}
+
+	paths = append(paths, source.Paths...)
+
+	var fragments []configFragment
+
+	if len(paths) == 0 {
+		return nil, errors.New("either path or paths must be specified")
+	}
+
+	for _, path := range paths {
+		yamlData, err := ioutil.ReadFile(path)
+		if err != nil {
+			if source.Default == nil {
+				return nil, err
+			}
+
+			yamlData = []byte(*source.Default)
+		}
+
+		fragments = append(fragments, configFragment{
+			data:   yamlData,
+			key:    key,
+			format: format,
+		})
+	}
+
+	return fragments, nil
+}
diff --git a/pkg/app/load.go b/pkg/app/load.go
index 69f0e81..055e2f7 100644
--- a/pkg/app/load.go
+++ b/pkg/app/load.go
@@ -9,10 +9,13 @@ import (
 
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/ext/typeexpr"
+	"github.com/hashicorp/hcl/v2/ext/userfunc"
 	"github.com/hashicorp/hcl/v2/gohcl"
 	"github.com/hashicorp/hcl/v2/hclparse"
 	"github.com/variantdev/mod/pkg/depresolver"
 	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"golang.org/x/xerrors"
 
 	"github.com/mumoshu/variant2/pkg/conf"
 	fs2 "github.com/mumoshu/variant2/pkg/fs"
@@ -79,11 +82,13 @@ func (l hcl2Loader) loadSources(srcs map[string][]byte) (*configurable, map[stri
 	}, nameToFiles, nil
 }
 
-func (t *configurable) HCL2Config() (*HCL2Config, error) {
+func (t *configurable) HCL2Config() (*HCL2Config, map[string]function.Function, error) {
 	config := &HCL2Config{}
 
+	funcs := conf.Functions(".")
+
 	ctx := &hcl.EvalContext{
-		Functions: conf.Functions("."),
+		Functions: funcs,
 		Variables: map[string]cty.Value{
 			"name": cty.StringVal("Ermintrude"),
 			"age":  cty.NumberIntVal(32),
@@ -95,12 +100,27 @@ func (t *configurable) HCL2Config() (*HCL2Config, error) {
 		},
 	}
 
-	diags := gohcl.DecodeBody(t.Body, ctx, config)
+	userfuncs, remain, diags := userfunc.DecodeUserFunctions(t.Body, "function", func() *hcl.EvalContext {
+		return ctx
+	})
 	if diags.HasErrors() {
-		return config, diags
+		return config, nil, diags
+	}
+
+	for k, v := range userfuncs {
+		if _, duplicated := funcs[k]; duplicated {
+			return nil, nil, fmt.Errorf("function %q can not be overridden by a user function with the same name", k)
+		}
+
+		funcs[k] = v
 	}
 
-	return config, nil
+	diags = gohcl.DecodeBody(remain, ctx, config)
+	if diags.HasErrors() {
+		return config, nil, diags
+	}
+
+	return config, funcs, nil
 }
 
 type Instance struct {
@@ -182,11 +202,12 @@ func New(setup Setup, opts ...Option) (*App, error) {
 		return nil, err
 	}
 
-	nameToFiles, cc, err := newConfigFromSources(instance.Sources)
+	nameToFiles, cc, funcs, err := newConfigFromSources(instance.Sources)
 
 	app := &App{
 		Files: nameToFiles,
 		Trace: os.Getenv("VARIANT_TRACE"),
+		Funcs: funcs,
 	}
 
 	if err != nil {
@@ -278,19 +299,19 @@ func findVariantFiles(fs *fs2.FileSystem, cacheDir string, dirPathOrURL string)
 	return files, nil
 }
 
-func newConfigFromSources(srcs map[string][]byte) (map[string]*hcl.File, *HCL2Config, error) {
+func newConfigFromSources(srcs map[string][]byte) (map[string]*hcl.File, *HCL2Config, map[string]function.Function, error) {
 	l := &hcl2Loader{
 		Parser: hclparse.NewParser(),
 	}
 
 	c, nameToFiles, err := l.loadSources(srcs)
 	if err != nil {
-		return nameToFiles, nil, err
+		return nameToFiles, nil, nil, err
 	}
 
-	cc, err := c.HCL2Config()
+	cc, funcs, err := c.HCL2Config()
 
-	return nameToFiles, cc, err
+	return nameToFiles, cc, funcs, err
 }
 
 func newApp(app *App, cc *HCL2Config, importDir func(string) (*App, error)) (*App, error) {
@@ -301,6 +322,8 @@ func newApp(app *App, cc *HCL2Config, importDir func(string) (*App, error)) (*Ap
 	var globals []JobSpec
 
 	jobByName := map[string]JobSpec{}
+	jobLocalFuncs := map[string]map[string]function.Function{}
+
 	for _, j := range jobs {
 		jobByName[j.Name] = j
 
@@ -322,6 +345,9 @@ func newApp(app *App, cc *HCL2Config, importDir func(string) (*App, error)) (*Ap
 					return nil, err
 				}
 
+				// Do not override tests
+				a.Config.Tests = cc.Tests
+
 				importedJobs := append([]JobSpec{a.Config.JobSpec}, a.Config.Jobs...)
 				for _, importedJob := range importedJobs {
 					var newJobName string
@@ -357,6 +383,8 @@ func newApp(app *App, cc *HCL2Config, importDir func(string) (*App, error)) (*Ap
 
 					jobByName[newJobName] = importedJob
 
+					jobLocalFuncs[newJobName] = a.Funcs
+
 					if j.Name == "" && importedJob.Name == "" {
 						conf = a.Config
 					}
@@ -388,6 +416,18 @@ func newApp(app *App, cc *HCL2Config, importDir func(string) (*App, error)) (*Ap
 
 	app.JobByName = jobByName
 
+	if app.JobLocalFuncs != nil {
+		for k, v := range app.JobLocalFuncs {
+			if _, ok := jobLocalFuncs[k]; ok {
+				return nil, xerrors.Errorf("conflicting local functions: local functions for job %q is already registered", k)
+			}
+
+			jobLocalFuncs[k] = v
+		}
+	}
+
+	app.JobLocalFuncs = jobLocalFuncs
+
 	var newJobs []JobSpec
 
 	for _, j := range app.JobByName {
diff --git a/pkg/app/types.go b/pkg/app/types.go
index 41522f8..a1429a0 100644
--- a/pkg/app/types.go
+++ b/pkg/app/types.go
@@ -5,6 +5,7 @@ import (
 	"sync"
 
 	"github.com/hashicorp/hcl/v2"
+	"github.com/zclconf/go-cty/cty/function"
 
 	"github.com/mumoshu/variant2/pkg/source"
 )
@@ -22,9 +23,10 @@ type ConfigSource struct {
 }
 
 type SourceFile struct {
-	Path    string  `hcl:"path,attr"`
-	Default *string `hcl:"default,attr"`
-	Key     *string `hcl:"key,attr"`
+	Path    *string  `hcl:"path,attr"`
+	Paths   []string `hcl:"paths,optional"`
+	Default *string  `hcl:"default,attr"`
+	Key     *string  `hcl:"key,attr"`
 }
 
 type Step struct {
@@ -237,4 +239,8 @@ type App struct {
 	sourceClient *source.Client
 
 	initMu sync.Mutex
+
+	Funcs map[string]function.Function
+
+	JobLocalFuncs map[string]map[string]function.Function
 }