diff --git a/anki-helper.yaml b/anki-helper.yaml
index 7cbec86..d17d463 100644
--- a/anki-helper.yaml
+++ b/anki-helper.yaml
@@ -79,55 +79,57 @@ actions:
         #   FieldVoiceover (unless skipVoiceover: true)
         - name: Word
           vars:
-            PRONOUN: ""
-            TENSE: _spanish-infinitive.png
+            pronoun: ""
+            tense: _spanish-infinitive.png
         - name: Explanation
           skipVoiceover: true
 
         - name: IndicativePresentYo
           vars:
-            PRONOUN: yo
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: yo
+            tense: _spanish-tense-present.jpeg
         - name: IndicativePresentTu
           vars:
-            PRONOUN: tú
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: tú
+            tense: _spanish-tense-present.jpeg
         - name: IndicativePresentEl
           vars:
-            PRONOUN: él/ella/usted
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: él/ella/usted
+            tense: _spanish-tense-present.jpeg
         - name: IndicativePresentNosotros
           vars:
-            PRONOUN: nosotros
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: nosotros
+            tense: _spanish-tense-present.jpeg
         - name: IndicativePresentVosotros
           vars:
-            PRONOUN: vosotros
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: vosotros
+            tense: _spanish-tense-present.jpeg
         - name: IndicativePresentEllos
           vars:
-            PRONOUN: ellos/ellas/ustedes
-            TENSE: _spanish-tense-present.jpeg
+            pronoun: ellos/ellas/ustedes
+            tense: _spanish-tense-present.jpeg
 
         - name: ImperativeAffirmativeTu
           vars:
-            PRONOUN: tú
-            TENSE: _spanish-tense-imperative.jpeg
+            pronoun: tú
+            tense: _spanish-tense-imperative.jpeg
         - name: ImperativeAffirmativeUsted
           vars:
-            PRONOUN: usted
-            TENSE: _spanish-tense-imperative.jpeg
+            pronoun: usted
+            tense: _spanish-tense-imperative.jpeg
 
         - name: AutoConjugationIgnore
           skipVoiceover: true
       templates:
         # For each template a distinct card template is created for each field specified in forFields
         # The following meta-variables will be substituted in name, front and back before passing them to Anki:
-        #   $$FIELD$$, $$FIELD_VOICEOVER$$
+        #   $$.Field$$, $$.FieldVoiceover$$
+        # 
+        # Additionally, variables attached to a field are available in the template as $$.Vars.varName$$.
         #
-        # Front layout is automatically wrapped with {{^$$FIELD$$}}{{/$$FIELD$$}}, so there is no need in
+        # Front layout is automatically wrapped with {{^$$.Field$$}}{{/$$.Field$$}}, so there is no need in
         # adding this manually
-        - name: "FillIn$$FIELD$$"
+        - name: "FillIn$$.Field$$"
           forFields:
             - Word
             - IndicativePresentYo
@@ -139,11 +141,11 @@ actions:
             - ImperativeAffirmativeTu
             - ImperativeAffirmativeUsted
           front: |
-            <img src="$$TENSE$$"><br><br>
+            <img src="$$.Vars.tense$$"><br><br>
             <i>{{text:Explanation}}</i><br>
-            <div>$$PRONOUN$$ <b><span class='cloze'>[&#8230;]</span></b></div>
+            <div>$$.Vars.pronoun$$ <b><span class='cloze'>[&#8230;]</span></b></div>
 
-            {{type::$$FIELD$$}}
+            {{type::$$.Field$$}}
 
             <script>
             var clozes = document.querySelectorAll(".mycloze");
@@ -165,12 +167,12 @@ actions:
             });
             </script>
           back: |
-            <img src="$$TENSE$$"><br><br>
+            <img src="$$.Vars.tense$$"><br><br>
             <i>{{text:Explanation}}</i><br>
-            <div>$$PRONOUN$$ <b><span class='cloze'>{{text:$$FIELD$$}}</span></b>{{$$FIELD_VOICEOVER$$}}</div>
+            <div>$$.Vars.pronoun$$ <b><span class='cloze'>{{text:$$.Field$$}}</span></b>{{$$.FieldVoiceover$$}}</div>
 
             <hr id=answer>
-            {{type::$$FIELD$$}}
+            {{type::$$.Field$$}}
 
             <script>
             var clozes = document.querySelectorAll(".mycloze");
diff --git a/ankihelper/helper.go b/ankihelper/helper.go
index 4612249..999e3e0 100644
--- a/ankihelper/helper.go
+++ b/ankihelper/helper.go
@@ -8,6 +8,7 @@ import (
 	"anki-rest-enhancer/util/execx"
 	"anki-rest-enhancer/util/iox"
 	"anki-rest-enhancer/util/stringx"
+	"anki-rest-enhancer/util/templatex"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -255,38 +256,35 @@ func (h Helper) createNoteType(conf ankihelperconf.AnkiNoteType) error {
 	fieldNames = append(fieldNames, voiceoverFields...)
 
 	templates := make([]ankiconnect.CreateModelCardTemplate, 0, len(conf.Templates))
-	for _, template := range conf.Templates {
-		for _, field := range template.ForFields {
-			names := h.fieldNames(field)
-			substitutions := stringx.RemoveEmptyValuesInPlace(map[string]string{
-				"FIELD":           names.Field,
-				"FIELD_VOICEOVER": names.FieldVoiceover,
-			})
-			for name, val := range field.Vars {
-				if _, ok := substitutions[name]; ok {
-					return errorx.IllegalState.New("custom variable %q collides with a default variable in template %q", name, template.Name)
-				}
-				substitutions[name] = val
+	for tmplIdx, cardTemplate := range conf.Templates {
+		for _, field := range cardTemplate.ForFields {
+			const voiceoverSuffix = "Voiceover"
+			substitutions := map[string]any{
+				"Field": field.Name,
+				"Vars":  field.Vars,
+			}
+			if !field.SkipVoiceover {
+				substitutions["FieldVoiceover"] = field.Name + voiceoverSuffix
 			}
 
-			templateName, err := substituteVariables(template.Name, substitutions)
+			cardTemplateName, err := templatex.Execute(cardTemplate.Name, substitutions)
 			if err != nil {
-				return errorx.Decorate(err, "failed to build card template name for template %q and field %q", template.Name, field.Name)
+				return errorx.Decorate(err, "failed to build card template name for template #%d and field %q", tmplIdx, field.Name)
 			}
-			if err := ankihelperconf.ValidateName(templateName); err != nil {
-				return errorx.Decorate(err, "got invalid template name after variables substitution: %s", templateName)
+			if err := ankihelperconf.ValidateName(cardTemplateName); err != nil {
+				return errorx.Decorate(err, "got invalid template name after variables substitution: %s", cardTemplateName)
 			}
-			front, err := substituteVariables(template.Front, substitutions)
+			front, err := templatex.Execute(cardTemplate.Front, substitutions)
 			if err != nil {
-				return errorx.Decorate(err, "failed to build card template front for %q and field %q", template.Name, field.Name)
+				return errorx.Decorate(err, "failed to build card template front for template #%d and field %q", tmplIdx, field.Name)
 			}
-			back, err := substituteVariables(template.Back, substitutions)
+			back, err := templatex.Execute(cardTemplate.Back, substitutions)
 			if err != nil {
-				return errorx.Decorate(err, "failed to build card template back for %q and field %q", template.Name, field.Name)
+				return errorx.Decorate(err, "failed to build card template back for template #%d and field %q", tmplIdx, field.Name)
 			}
 
 			templates = append(templates, ankiconnect.CreateModelCardTemplate{
-				Name:  templateName,
+				Name:  cardTemplateName,
 				Front: fmt.Sprintf("{{#%s}}\n%s\n{{/%s}}", field.Name, front, field.Name),
 				Back:  back,
 			})
diff --git a/ankihelper/helper_test.go b/ankihelper/helper_test.go
index 415d1d7..3a34c50 100644
--- a/ankihelper/helper_test.go
+++ b/ankihelper/helper_test.go
@@ -9,6 +9,7 @@ import (
 	"anki-rest-enhancer/azuretts/azurettsmock"
 	"github.com/stretchr/testify/suite"
 	"testing"
+	"text/template"
 )
 
 func TestEnhancer(t *testing.T) {
@@ -50,7 +51,7 @@ func (s *EnhancerSuite) TestNoteTypeCreation_AlreadyExists() {
 	actions := ankihelperconf.Actions{NoteTypes: []ankihelperconf.AnkiNoteType{{
 		Name:      modelName,
 		Fields:    []ankihelperconf.AnkiNoteField{{Name: "Foo"}, {Name: "Bar"}},
-		Templates: []ankihelperconf.AnkiCardTemplate{{Name: "Card1", ForFields: []ankihelperconf.AnkiNoteField{{Name: "foo"}}}},
+		Templates: []ankihelperconf.AnkiCardTemplate{{Name: s.mustParse("Card1"), ForFields: []ankihelperconf.AnkiNoteField{{Name: "foo"}}}},
 	}}}
 
 	// when:
@@ -82,10 +83,10 @@ func (s *EnhancerSuite) TestNoteTypeCreation_CreateNewWithVoiceover() {
 		CSS:    ".foo { font-size: large; }",
 		Fields: []ankihelperconf.AnkiNoteField{fieldName},
 		Templates: []ankihelperconf.AnkiCardTemplate{{
-			Name:      "WordTemplate",
+			Name:      s.mustParse("WordTemplate"),
 			ForFields: []ankihelperconf.AnkiNoteField{fieldName},
-			Front:     "$TITLE$: {{ $FIELD$ }}$MY_EMPTY_FIELD$",
-			Back:      "{{ $FIELD_VOICEOVER$ }}",
+			Front:     s.mustParse("$$.Vars.TITLE$$: {{ $$.Field$$ }}$$.Vars.MY_EMPTY_FIELD$$"),
+			Back:      s.mustParse("{{ $$.FieldVoiceover$$ }}"),
 		}},
 	}}}
 	expectedModel := ankiconnect.CreateModelParams{
@@ -131,10 +132,10 @@ func (s *EnhancerSuite) TestNoteTypeCreation_CreateNewWithNoVoiceover() {
 		CSS:    css,
 		Fields: []ankihelperconf.AnkiNoteField{fieldComment},
 		Templates: []ankihelperconf.AnkiCardTemplate{{
-			Name:      "CommentTemplate",
+			Name:      s.mustParse("CommentTemplate"),
 			ForFields: []ankihelperconf.AnkiNoteField{fieldComment},
-			Front:     "Field Name: $FIELD$",
-			Back:      "Field Conent: {{ $FIELD$ }}",
+			Front:     s.mustParse("Field Name: $$.Field$$"),
+			Back:      s.mustParse("Field Conent: {{ $$.Field$$ }}"),
 		}},
 	}}}
 	expectedModel := ankiconnect.CreateModelParams{
@@ -272,3 +273,9 @@ func (s *EnhancerSuite) TestTTSGeneration_SingleErrorIsIgnored() {
 	s.Require().NoError(err)
 	s.Require().Equal(expectedUpdates, noteUpdates)
 }
+
+func (s *EnhancerSuite) mustParse(text string) *template.Template {
+	parsed, err := ankihelperconf.ParseTextTemplate("test", text)
+	s.Require().NoError(err)
+	return parsed
+}
diff --git a/ankihelper/template.go b/ankihelper/template.go
deleted file mode 100644
index a3b6e54..0000000
--- a/ankihelper/template.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package ankihelper
-
-import (
-	"github.com/joomcode/errorx"
-	"strings"
-)
-
-// substituteVariables implements a dummy template substitution -- it substitutes variable references like $VAR_NAME$.
-// If there are dollar signs in the template that should not be confused with variable reference, use more
-// consecutive dollar signs, e.g.
-//	substituteVariables("$$FOO$$ $FOO$", map[string]string{"FOO": "bar"}) // returns "bar $FOO$".
-//
-// NOTE: variable reference delimiter is determined as the longest sequence of consecutive dollar signs in the string.
-// Thus, templates with a dollar sign adjacent to a variable reference are not supported.
-//
-// If template contains a dollar sign, it's expected to contain at least one variable reference. To avoid confusion,
-// consider using implicit $$EMPTY$$ variable to make sure it doesn't break.
-func substituteVariables(template string, substitutions map[string]string) (string, error) {
-	// Determine variable reference delimiter
-	maxDelimiterLength := longestCharSubsequenceLength(template, '$')
-	if maxDelimiterLength == 0 {
-		// template doesn't reference any variables, nothing to substitute
-		return template, nil
-	}
-	delimiter := strings.Repeat("$", maxDelimiterLength)
-
-	// Substitute variables
-	var result strings.Builder
-	for {
-		openingDelIdx := strings.Index(template, delimiter)
-		if openingDelIdx == -1 {
-			break
-		}
-		varNameIdx := openingDelIdx + len(delimiter)
-		varNameLen := strings.Index(template[varNameIdx:], delimiter)
-		if varNameLen == -1 {
-			return "", errorx.IllegalFormat.New("No closing %q delimiter", delimiter)
-		}
-		closingDelIdx := varNameIdx + varNameLen
-
-		varName := template[varNameIdx:closingDelIdx]
-		varVal, ok := substitutions[varName]
-		if !ok {
-			switch varName {
-			case "EMPTY":
-				// this is a special implicitly declared variable to be used in templates without variable references
-				// that contain dollar signs.
-				varVal, ok = "", true
-			default:
-				return "", errorx.IllegalFormat.New("Variable %q is not defined", varName)
-			}
-		}
-
-		// write text preceding the variable reference
-		result.WriteString(template[:openingDelIdx])
-		// substitute variable
-		result.WriteString(varVal)
-		// shift template
-		template = template[closingDelIdx+len(delimiter):]
-	}
-	result.WriteString(template) // write remaining template text without variables
-	return result.String(), nil
-}
-
-func longestCharSubsequenceLength(str string, char rune) int {
-	maxSeqLength := 0
-	curSeqLength := 0
-	for _, curChar := range str {
-		if curChar == char {
-			curSeqLength++
-		} else {
-			if curSeqLength > maxSeqLength {
-				maxSeqLength = curSeqLength
-			}
-			curSeqLength = 0
-		}
-	}
-	if curSeqLength > maxSeqLength {
-		maxSeqLength = curSeqLength
-	}
-	return maxSeqLength
-}
diff --git a/ankihelper/template_test.go b/ankihelper/template_test.go
deleted file mode 100644
index 175ca22..0000000
--- a/ankihelper/template_test.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package ankihelper
-
-import (
-	"fmt"
-	"github.com/joomcode/errorx"
-	"github.com/stretchr/testify/require"
-	"testing"
-)
-
-func TestSubstituteVariables_MalformedTemplates(t *testing.T) {
-	vars := map[string]string{
-		"FOO": "biba",
-		"BAR": "kuka",
-	}
-	invalidTemplates := []string{
-		"single dollar sign $ in a string is ambiguous",
-		"reference $FOO$ with less dollars than specified somewhere $$ else",
-		"undefined $$VARIABLE$$ reference is invalid",
-	}
-
-	for i, template := range invalidTemplates {
-		t.Run(fmt.Sprintf("Template_%02d", i), func(t *testing.T) {
-			// when:
-			_, err := substituteVariables(template, vars)
-
-			// then:
-			require.Error(t, err)
-			require.True(t, errorx.IsOfType(err, errorx.IllegalFormat), "expected malformed_format but got %+v", err)
-		})
-	}
-}
-
-func TestSubstituteVariables_ValidTemplates(t *testing.T) {
-	type vars = map[string]string
-	testCases := []struct {
-		tmpl   string
-		vars   vars
-		expect string
-	}{
-		{tmpl: "empty template", vars: nil, expect: "empty template"},
-		{tmpl: "$$EMPTY$$template with $ sign", vars: nil, expect: "template with $ sign"}, // EMPTY should be automatically added
-		{tmpl: "overridden $$EMPTY$$ value", vars: vars{"EMPTY": "empty"}, expect: "overridden empty value"},
-		{tmpl: "$FOO$ and $bar$", vars: vars{"FOO": "pupa", "bar": "lupa"}, expect: "pupa and lupa"},
-		{tmpl: "$$FOO$$ $bar$", vars: vars{"FOO": "my foo"}, expect: "my foo $bar$"},
-		{tmpl: "reference $$IN$$ the $$MIDDLE$$ of template", vars: vars{"IN": "in", "MIDDLE": "mid"}, expect: "reference in the mid of template"},
-	}
-
-	for i, test := range testCases {
-		t.Run(fmt.Sprintf("Test_%d", i), func(t *testing.T) {
-			// when:
-			result, err := substituteVariables(test.tmpl, test.vars)
-
-			// then:
-			require.NoError(t, err)
-			require.Equal(t, test.expect, result)
-		})
-	}
-}
diff --git a/ankihelperconf/config.go b/ankihelperconf/config.go
index baa857b..b7b0c33 100644
--- a/ankihelperconf/config.go
+++ b/ankihelperconf/config.go
@@ -67,10 +67,10 @@ type AnkiNoteType struct {
 type AnkiNoteField YAMLAnkiNoteField
 
 type AnkiCardTemplate struct {
-	Name      string
+	Name      *template.Template
 	ForFields []AnkiNoteField
-	Front     string
-	Back      string
+	Front     *template.Template
+	Back      *template.Template
 }
 
 type NotesOrganizationRule struct {
diff --git a/ankihelperconf/templates.go b/ankihelperconf/templates.go
new file mode 100644
index 0000000..deff01a
--- /dev/null
+++ b/ankihelperconf/templates.go
@@ -0,0 +1,12 @@
+package ankihelperconf
+
+import "text/template"
+
+const (
+	templateOpen  = "$$"
+	templateClose = "$$"
+)
+
+func ParseTextTemplate(name string, text string) (*template.Template, error) {
+	return template.New(name).Delims(templateOpen, templateClose).Parse(text)
+}
diff --git a/ankihelperconf/yaml.go b/ankihelperconf/yaml.go
index fa5013d..9a035ac 100644
--- a/ankihelperconf/yaml.go
+++ b/ankihelperconf/yaml.go
@@ -12,15 +12,9 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
-	"text/template"
 	"time"
 )
 
-const (
-	templateOpen  = "$$"
-	templateClose = "$$"
-)
-
 type YAML struct {
 	Anki    YAMLAnki    `yaml:"anki"`
 	Azure   YAMLAzure   `yaml:"azure"`
@@ -428,11 +422,24 @@ func (t YAMLAnkiCardTemplate) Parse(fieldsByName map[string]AnkiNoteField) (Anki
 		fields = append(fields, field)
 	}
 
+	name, err := ParseTextTemplate("CardTemplateName", t.Name)
+	if err != nil {
+		return AnkiCardTemplate{}, errorx.IllegalFormat.Wrap(err, "failed to parse template of card template name")
+	}
+	front, err := ParseTextTemplate("CardTemplateFront", t.Front)
+	if err != nil {
+		return AnkiCardTemplate{}, errorx.IllegalFormat.Wrap(err, "failed to parse template of card template front")
+	}
+	back, err := ParseTextTemplate("CardTemplateBack", t.Back)
+	if err != nil {
+		return AnkiCardTemplate{}, errorx.IllegalFormat.Wrap(err, "failed to parse template of card template back")
+	}
+
 	return AnkiCardTemplate{
-		Name:      t.Name,
+		Name:      name,
 		ForFields: fields,
-		Front:     t.Front,
-		Back:      t.Back,
+		Front:     front,
+		Back:      back,
 	}, nil
 }
 
@@ -521,9 +528,7 @@ func (e YAMLNotesPopulationExec) Parse(configDir string) (NoteProcessingExec, er
 	var args []NoteProcessingExecArg
 	for i, arg := range e.Args {
 		if strings.Contains(arg, templateOpen) && strings.Contains(arg, templateClose) {
-			parsed, err := template.New(fmt.Sprintf("arg#%d", i)).
-				Delims(templateOpen, templateClose).
-				Parse(arg)
+			parsed, err := ParseTextTemplate(fmt.Sprintf("arg#%d", i), arg)
 			if err != nil {
 				return NoteProcessingExec{}, errorx.IllegalFormat.Wrap(err, "failed to parse exec argument #%d", i)
 			}
diff --git a/util/templatex/templatex.go b/util/templatex/templatex.go
new file mode 100644
index 0000000..6d7c940
--- /dev/null
+++ b/util/templatex/templatex.go
@@ -0,0 +1,14 @@
+package templatex
+
+import (
+	"strings"
+	"text/template"
+)
+
+func Execute(tmpl *template.Template, data any) (string, error) {
+	var result strings.Builder
+	if err := tmpl.Execute(&result, data); err != nil {
+		return "", err
+	}
+	return result.String(), nil
+}