diff --git a/.gitignore b/.gitignore
index d7efa53..6d830cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,6 +8,7 @@ bin
 
 # IDE
 .vscode
+.idea
 
 # Test binary, built with `go test -c`
 *.test
diff --git a/README.md b/README.md
index a036297..671a2ce 100644
--- a/README.md
+++ b/README.md
@@ -204,6 +204,13 @@ Usage of gherkingen [FEATURE_FILE]:
         add parallel mark (deprecated, enabled by default) (default true)
   -help
         print usage
+  -language string
+        Specifies the natural language used to describe the feature.
+        This flag is optional if language information is included in the feature file name, or if the feature is written in English.
+        The file name should be formatted as follows: <description>.<language_hint>.feature if language hint is included, or <description>.feature if it is not.
+        When provided, the 'language' flag takes precedence over the language hint from the file name. (default "en")
+  -languages
+        list supported natural feature languages
   -list
         list internal templates
   -package string
@@ -251,7 +258,7 @@ create a pull request for supporting templates for them. For this:
 3. Check: `make lint check.generate test`.
 4. Commit&Push, create a PR.
 
-## Language support
+## Programming language support
 
 Templates are very customizable, so you can even generate non-golang code. In the command-line tool specify `raw` format using `-format` flag and your template using `-template` flag:
 `gherkingen -format raw -template example.tmpl example.feature`.
diff --git a/internal/app/app.feature b/internal/app/app.feature
index b9de0e8..94fc97f 100644
--- a/internal/app/app.feature
+++ b/internal/app/app.feature
@@ -1,55 +1,56 @@
 Feature: Application command line tool
+
   Scenario Outline: User wants to generate the output in given format
     When <format> is given
     And  <feature> is provided
     Then the output should be generated
     Examples:
-    | <feature>        | <format> | <assertion> |
-    | app.feature      | go       | does        |
-    | app.feature      | json     | does        |
-    | app.feature      | raw      | does        |
-    | app.feature      | invalid  | does not    |
-    | notfound.feature | raw      | does not    |
+      | <feature>        | <format> | <assertion> |
+      | app.feature      | go       | does        |
+      | app.feature      | json     | does        |
+      | app.feature      | raw      | does        |
+      | app.feature      | invalid  | does not    |
+      | notfound.feature | raw      | does not    |
 
   Scenario Outline: User wants to see usage information
     When <flag> is provided
     Then usage should be printed
     Examples:
-    | <flag> |
-    | --help |
+      | <flag> |
+      | --help |
 
   Scenario Outline: User wants to list built-in templates
     When <flag> is provided
     Then templates should be printed
     Examples:
-    | <flag> |
-    | --list |
+      | <flag> |
+      | --list |
 
   Scenario Outline: User wants to use custom template
     When <template> is provided
     And  <feature> is provided
     Then the output should be generated
     Examples:
-    | <feature>   | <template>                      |
-    | app.feature | ../assets/std.simple.v1.go.tmpl |
-    | app.feature | @/std.simple.v1.go.tmpl         |
-  
+      | <feature>   | <template>                      |
+      | app.feature | ../assets/std.simple.v1.go.tmpl |
+      | app.feature | @/std.simple.v1.go.tmpl         |
+
   Scenario Outline: User wants to set custom package
     When <package> is provided
     Then the output should contain <package>
     Examples:
-    | <package>     |
-    | app_test      |
-    | example_test  |
-  
+      | <package>    |
+      | app_test     |
+      | example_test |
+
   Scenario Outline: User wants to generate a permanent json output
     When -format is json
     And -permanent-ids is <TheSameIDs>
     Then calling generation twice will produce the same output <TheSameIDs>
     Examples:
-    | <TheSameIDs> |
-    | true         |
-    | false        |
+      | <TheSameIDs> |
+      | true         |
+      | false        |
 
   Scenario: User provides an invalid flag
     When flag -invalid is provided
@@ -59,17 +60,17 @@ Feature: Application command line tool
     When <flag> is provided
     Then version is printed
     Examples:
-    | <flag>    |
-    | --version |
-    | -version  |
+      | <flag>    |
+      | --version |
+      | -version  |
 
   Scenario Outline: User specifies a file, but the file is not found
     When inexistent <template> is provided
     And  <feature> is provided
     Then the user receives an error
     Examples:
-    | <feature>   | <template> |
-    | app.feature | not_found  |
+      | <feature>   | <template> |
+      | app.feature | not_found  |
 
   Scenario: User wants to run tests in parallel
     When `scenario.feature` is given
@@ -79,3 +80,41 @@ Feature: Application command line tool
     When `-disable-go-parallel` is provided
     And `scenario.feature` is given
     Then generated code doesn't contain `t.Parallel()`
+
+  Scenario Outline: User wants to generate the output for a feature written in a specific natural language
+    When the <language> is given
+    And the <feature> is provided
+    Then the output should be generated
+    Examples:
+      | <language>  | <feature>                                      | assertion |
+      | en          | ../generator/examples/simple.feature           | does      |
+      | en-pirate   | ../generator/examples/simple.en-pirate.feature | does      |
+      | unsupported | app.feature                                    | does not  |
+
+  Scenario Outline: User wants to see all supported natural languages
+    When the <flag> is provided
+    Then the list of supported natural languages should be printed
+    Examples:
+      | <flag>      |
+      | -languages  |
+      | --languages |
+
+  Scenario: User wants to see consistent supported natural languages output
+    When the user lists supported natural languages several times
+    Then the output is the same
+
+  Scenario Outline: User wants to be able to specify the natural language of a feature in its file name
+    When the <language> is specified by the flag
+    And the <feature> is given
+    Then the output should be generated
+    Examples:
+      | <language> | <feature>                                  | assertion |
+      | en-pirate  | ./testdata/pirate.feature                  | does      |
+      |            | ./testdata/pirate.feature                  | does not  |
+      |            | ./testdata/pirate.sample.en-pirate.feature | does      |
+      | wrong      | ./testdata/pirate.sample.en-pirate.feature | does not  |
+      | en         | ./testdata/english.feature                 | does      |
+      |            | ./testdata/english.feature                 | does      |
+      |            | ./testdata/english.sample.en.feature       | does      |
+      | wrong      | ./testdata/english.sample.en.feature       | does not  |
+      |            | app.feature                                | does      |
diff --git a/internal/app/app.go b/internal/app/app.go
index 1a7666d..2ed1606 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -4,12 +4,14 @@ import (
 	"flag"
 	"io"
 	"math/rand"
+	"slices"
 	"strings"
 	"time"
 
-	"github.com/hedhyw/gherkingen/v4/internal/model"
-
+	gherkin "github.com/cucumber/gherkin/go/v28"
 	"github.com/google/uuid"
+
+	"github.com/hedhyw/gherkingen/v4/internal/model"
 )
 
 const (
@@ -17,9 +19,12 @@ const (
 	defaultTemplate          = "std.simple.v1.go.tmpl"
 	defaultDisableGoParallel = false
 	defaultOutputFormat      = model.FormatAutoDetect
+	defaultLanguage          = gherkin.DefaultDialect
 )
 
 // Run the application.
+//
+//nolint:cyclop // Looks fine to me.
 func Run(arguments []string, out io.Writer, version string) (err error) {
 	flagSet := flag.NewFlagSet(flag.CommandLine.Name(), flag.ContinueOnError)
 	flagSet.SetOutput(out)
@@ -69,6 +74,20 @@ func Run(arguments []string, out io.Writer, version string) (err error) {
 		false,
 		"print version",
 	)
+	language := flagSet.String(
+		"language",
+		defaultLanguage,
+		"Specifies the natural language used to describe the feature.\n"+
+			"This flag is optional if language information is included in the feature file name, or if the feature is written in English.\n"+
+			"The file name should be formatted as follows: <description>.<language_hint>.feature if language hint is included, "+
+			"or <description>.feature if it is not.\n"+
+			"When provided, the 'language' flag takes precedence over the language hint from the file name.",
+	)
+	listLanguages := flagSet.Bool(
+		"languages",
+		false,
+		"list supported natural feature languages",
+	)
 	if err = flagSet.Parse(arguments); err != nil {
 		return err
 	}
@@ -86,11 +105,19 @@ func Run(arguments []string, out io.Writer, version string) (err error) {
 		inputFile = flagSet.Args()[0]
 	}
 
+	if !slices.Contains(arguments, "-language") {
+		if hint := tryFromFileName(inputFile); hint != "" {
+			*language = hint
+		}
+	}
+
 	switch {
 	case *versionCmd:
 		return runVersion(out, version)
 	case *listCmd:
 		return runListTemplates(out)
+	case *listLanguages:
+		return runListFeatureLanguages(out)
 	case *helpCmd, inputFile == "":
 		return runHelp(flagSet)
 	default:
@@ -102,6 +129,7 @@ func Run(arguments []string, out io.Writer, version string) (err error) {
 			PackageName:  *packageName,
 			GoParallel:   !(*disableGoParallel),
 			GenerateUUID: newUUIDRandomGenerator(seed),
+			Language:     *language,
 		})
 	}
 }
diff --git a/internal/app/app_test.go b/internal/app/app_test.go
index d39e6ba..bf531d2 100644
--- a/internal/app/app_test.go
+++ b/internal/app/app_test.go
@@ -1,13 +1,15 @@
+//nolint:goconst // These are auto generated tests.
 package app_test
 
 import (
 	"bytes"
 	"testing"
 
-	"github.com/hedhyw/gherkingen/v4/internal/app"
-
+	gherkin "github.com/cucumber/gherkin/go/v28"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/hedhyw/gherkingen/v4/internal/app"
 )
 
 const testVersion = "0.0.1"
@@ -121,6 +123,126 @@ func TestApplicationCommandLineTool(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("User wants to generate the output for a feature written in a specific natural language", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Language  string `field:"<language>"`
+			Feature   string `field:"<feature>"`
+			Assertion string `field:"assertion"`
+		}
+
+		testCases := map[string]testCase{
+			"en_../generator/examples/simple.feature_does":                  {"en", "../generator/examples/simple.feature", "does"},
+			"en-pirate_../generator/examples/simple.en-pirate.feature_does": {"en-pirate", "../generator/examples/simple.en-pirate.feature", "does"},
+			"unsupported_app.feature_does_not":                              {"unsupported", "app.feature", "does not"},
+		}
+
+		for name, testCase := range testCases {
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				// When the <language> is given.
+				arguments := []string{
+					"-language",
+					testCase.Language,
+				}
+
+				// And the <feature> is provided.
+				arguments = append(arguments, testCase.Feature)
+
+				// Then the output should be generated.
+				runApp(t, arguments, testCase.Assertion == "does")
+			})
+		}
+	})
+
+	t.Run("User wants to see all supported natural languages", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Flag string `field:"<flag>"`
+		}
+
+		testCases := map[string]testCase{
+			"-languages":  {"-languages"},
+			"--languages": {"--languages"},
+		}
+
+		for name, testCase := range testCases {
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				// When the <flag> is provided.
+				arguments := []string{testCase.Flag}
+
+				// Then the list of supported natural languages should be printed.
+				out := runApp(t, arguments, true)
+
+				dialectProvider := gherkin.DialectsBuiltin()
+				dialect := dialectProvider.GetDialect(gherkin.DefaultDialect)
+
+				assert.Contains(t, out, dialect.Name)
+				assert.Contains(t, out, dialect.Language)
+				assert.Contains(t, out, dialect.Native)
+			})
+		}
+	})
+
+	t.Run("User wants to see consistent supported natural languages output", func(t *testing.T) {
+		t.Parallel()
+
+		// When the user lists supported natural languages several times.
+		arguments := []string{"-languages"}
+
+		out1 := runApp(t, arguments, true)
+		out2 := runApp(t, arguments, true)
+
+		// Then the output is the same.
+		assert.Equal(t, out1, out2)
+	})
+
+	t.Run("User wants to be able to specify the natural language of a feature in its file name", func(t *testing.T) {
+		t.Parallel()
+
+		type testCase struct {
+			Language  string `field:"<language>"`
+			Feature   string `field:"<feature>"`
+			Assertion string `field:"assertion"`
+		}
+
+		testCases := map[string]testCase{
+			"en-pirate_./testdata/pirate.feature_does":                  {"en-pirate", "./testdata/pirate.feature", "does"},
+			"_./testdata/pirate.feature_does_not":                       {"", "./testdata/pirate.feature", "does not"},
+			"_./testdata/pirate.sample.en-pirate.feature_does":          {"", "./testdata/pirate.sample.en-pirate.feature", "does"},
+			"wrong_./testdata/pirate.sample.en-pirate.feature_does_not": {"wrong", "./testdata/pirate.sample.en-pirate.feature", "does not"},
+			"en_./testdata/english.feature_does":                        {"en", "./testdata/english.feature", "does"},
+			"_./testdata/english.feature_does":                          {"", "./testdata/english.feature", "does"},
+			"_./testdata/english.sample.en.feature_does":                {"", "./testdata/english.sample.en.feature", "does"},
+			"wrong_./testdata/english.sample.en.feature_does_not":       {"wrong", "./testdata/english.sample.en.feature", "does not"},
+			"_app.feature_does":                                         {"", "app.feature", "does"},
+		}
+
+		for name, testCase := range testCases {
+			t.Run(name, func(t *testing.T) {
+				t.Parallel()
+
+				var arguments []string
+
+				// When the <language> is specified by the flag.
+				if testCase.Language != "" {
+					arguments = append(arguments, "-language", testCase.Language)
+				}
+
+				// And the <feature> is given.
+				arguments = append(arguments, testCase.Feature)
+
+				// Then the output should be generated.
+				runApp(t, arguments, testCase.Assertion == "does")
+			})
+		}
+	})
 }
 
 func TestApplicationCommandLineToolCustom(t *testing.T) {
diff --git a/internal/app/generator.go b/internal/app/generator.go
index d38eb30..3828237 100644
--- a/internal/app/generator.go
+++ b/internal/app/generator.go
@@ -21,6 +21,7 @@ type appArgs struct {
 	PackageName  string
 	GoParallel   bool
 	GenerateUUID func() string
+	Language     string
 }
 
 func runGenerator(
@@ -51,6 +52,7 @@ func runGenerator(
 		PackageName:    args.PackageName,
 		Plugin:         multiplugin.New(goPlugin),
 		GenerateUUID:   args.GenerateUUID,
+		Language:       args.Language,
 	})
 	if err != nil {
 		return err
diff --git a/internal/app/language.go b/internal/app/language.go
new file mode 100644
index 0000000..2c49a96
--- /dev/null
+++ b/internal/app/language.go
@@ -0,0 +1,67 @@
+package app
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+	"slices"
+	"strings"
+
+	gherkin "github.com/cucumber/gherkin/go/v28"
+	"github.com/hedhyw/semerr/pkg/v1/semerr"
+)
+
+func runListFeatureLanguages(out io.Writer) error {
+	languages, err := featureLanguages()
+	if err != nil {
+		return fmt.Errorf("getting feature languages: %w", err)
+	}
+
+	slices.SortFunc(languages, func(a, b *gherkin.Dialect) int {
+		return strings.Compare(a.Language, b.Language)
+	})
+
+	for _, lang := range languages {
+		fmt.Fprintf(out, "%s\t%s\t%s\n", lang.Language, lang.Name, lang.Native)
+	}
+
+	return nil
+}
+
+func featureLanguages() ([]*gherkin.Dialect, error) {
+	dialectProvider := gherkin.DialectsBuiltin()
+
+	v := reflect.ValueOf(dialectProvider)
+
+	if v.Kind() != reflect.Map {
+		return nil, semerr.Error("parsing builtin dialects: unexpected type")
+	}
+
+	dialects := make([]*gherkin.Dialect, 0, len(v.MapKeys()))
+
+	for _, key := range v.MapKeys() {
+		dialect := dialectProvider.GetDialect(key.String())
+
+		if dialect == nil {
+			continue
+		}
+
+		dialects = append(dialects, dialect)
+	}
+
+	return dialects, nil
+}
+
+func tryFromFileName(fileName string) string {
+	i := strings.LastIndexAny(fileName, "/\\")
+
+	lastPart := fileName[i+1:]
+
+	parts := strings.Split(lastPart, ".")
+
+	if len(parts) <= 2 {
+		return ""
+	}
+
+	return parts[len(parts)-2]
+}
diff --git a/internal/app/testdata/english.feature b/internal/app/testdata/english.feature
new file mode 100644
index 0000000..7dc2b3f
--- /dev/null
+++ b/internal/app/testdata/english.feature
@@ -0,0 +1,7 @@
+Feature: Guess the word
+
+  The word guess game is a turn-based game for two players.
+  The Maker makes a word for the Breaker to guess. The game
+  is over when the Breaker guesses the Maker's word.
+
+  Example: Maker starts a game
diff --git a/internal/app/testdata/english.sample.en.feature b/internal/app/testdata/english.sample.en.feature
new file mode 100644
index 0000000..7dc2b3f
--- /dev/null
+++ b/internal/app/testdata/english.sample.en.feature
@@ -0,0 +1,7 @@
+Feature: Guess the word
+
+  The word guess game is a turn-based game for two players.
+  The Maker makes a word for the Breaker to guess. The game
+  is over when the Breaker guesses the Maker's word.
+
+  Example: Maker starts a game
diff --git a/internal/app/testdata/pirate.feature b/internal/app/testdata/pirate.feature
new file mode 100644
index 0000000..909eb9a
--- /dev/null
+++ b/internal/app/testdata/pirate.feature
@@ -0,0 +1,8 @@
+Ahoy matey!: Guessin' the Word!
+
+  This be a game o' guessin' words, turn-based and for two scallywags only!
+  The Maker, a cunning buccaneer, chooses a secret word for the Breaker to decipher.
+  The Breaker, a sharp wit, tries to guess the Maker's hidden word.
+  The game be done when the Breaker shouts out the right word!
+
+  Heave to: The Maker starts a game!
diff --git a/internal/app/testdata/pirate.sample.en-pirate.feature b/internal/app/testdata/pirate.sample.en-pirate.feature
new file mode 100644
index 0000000..909eb9a
--- /dev/null
+++ b/internal/app/testdata/pirate.sample.en-pirate.feature
@@ -0,0 +1,8 @@
+Ahoy matey!: Guessin' the Word!
+
+  This be a game o' guessin' words, turn-based and for two scallywags only!
+  The Maker, a cunning buccaneer, chooses a secret word for the Breaker to decipher.
+  The Breaker, a sharp wit, tries to guess the Maker's hidden word.
+  The game be done when the Breaker shouts out the right word!
+
+  Heave to: The Maker starts a game!
diff --git a/internal/generator/examples/simple.en-pirate.feature b/internal/generator/examples/simple.en-pirate.feature
new file mode 100644
index 0000000..909eb9a
--- /dev/null
+++ b/internal/generator/examples/simple.en-pirate.feature
@@ -0,0 +1,8 @@
+Ahoy matey!: Guessin' the Word!
+
+  This be a game o' guessin' words, turn-based and for two scallywags only!
+  The Maker, a cunning buccaneer, chooses a secret word for the Breaker to decipher.
+  The Breaker, a sharp wit, tries to guess the Maker's hidden word.
+  The game be done when the Breaker shouts out the right word!
+
+  Heave to: The Maker starts a game!
diff --git a/internal/generator/examples/simple/simple.en-pirate.feature_test.go b/internal/generator/examples/simple/simple.en-pirate.feature_test.go
new file mode 100644
index 0000000..1af1406
--- /dev/null
+++ b/internal/generator/examples/simple/simple.en-pirate.feature_test.go
@@ -0,0 +1,21 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestGuessinTheWord(t *testing.T) {
+	t.Parallel()
+
+	/*
+		This be a game o' guessin' words, turn-based and for two scallywags only!
+		The Maker, a cunning buccaneer, chooses a secret word for the Breaker to decipher.
+		The Breaker, a sharp wit, tries to guess the Maker's hidden word.
+		The game be done when the Breaker shouts out the right word!
+	*/
+
+	t.Run("The Maker starts a game!", func(t *testing.T) {
+		t.Parallel()
+
+	})
+}
diff --git a/internal/generator/examples/simpleparallel/simple.en-pirate.feature_test.go b/internal/generator/examples/simpleparallel/simple.en-pirate.feature_test.go
new file mode 100644
index 0000000..1af1406
--- /dev/null
+++ b/internal/generator/examples/simpleparallel/simple.en-pirate.feature_test.go
@@ -0,0 +1,21 @@
+package examples_test
+
+import (
+	"testing"
+)
+
+func TestGuessinTheWord(t *testing.T) {
+	t.Parallel()
+
+	/*
+		This be a game o' guessin' words, turn-based and for two scallywags only!
+		The Maker, a cunning buccaneer, chooses a secret word for the Breaker to decipher.
+		The Breaker, a sharp wit, tries to guess the Maker's hidden word.
+		The game be done when the Breaker shouts out the right word!
+	*/
+
+	t.Run("The Maker starts a game!", func(t *testing.T) {
+		t.Parallel()
+
+	})
+}
diff --git a/internal/generator/generator.go b/internal/generator/generator.go
index 7d3f15a..faf9660 100644
--- a/internal/generator/generator.go
+++ b/internal/generator/generator.go
@@ -5,11 +5,11 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/hedhyw/gherkingen/v4/internal/docplugin"
-	"github.com/hedhyw/gherkingen/v4/internal/model"
-
 	gherkin "github.com/cucumber/gherkin/go/v28"
 	"github.com/hedhyw/semerr/pkg/v1/semerr"
+
+	"github.com/hedhyw/gherkingen/v4/internal/docplugin"
+	"github.com/hedhyw/gherkingen/v4/internal/model"
 )
 
 // Args contains required arguments for Generate.
@@ -20,16 +20,23 @@ type Args struct {
 	PackageName    string
 	Plugin         docplugin.Plugin
 	GenerateUUID   func() string
+	Language       string
 }
 
 // Generate generates output consider template from gherkin source.
 func Generate(args Args) (out []byte, err error) {
-	gherkinDocument, err := gherkin.ParseGherkinDocument(
+	dialect, err := getDialect(args.Language)
+	if err != nil {
+		return nil, fmt.Errorf("getting dialect: %w", err)
+	}
+
+	gherkinDocument, err := gherkin.ParseGherkinDocumentForLanguage(
 		bytes.NewReader(args.InputSource),
+		dialect.Language,
 		args.GenerateUUID,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("parse document: %w", err)
+		return nil, fmt.Errorf("parsing document: %w", err)
 	}
 
 	if args.PackageName == "" {
@@ -64,3 +71,17 @@ func Generate(args Args) (out []byte, err error) {
 
 	return out, nil
 }
+
+func getDialect(language string) (*gherkin.Dialect, error) {
+	if language == "" {
+		language = gherkin.DefaultDialect
+	}
+
+	dialect := gherkin.DialectsBuiltin().GetDialect(language)
+
+	if dialect == nil {
+		return nil, semerr.Error("language is not supported: " + language)
+	}
+
+	return dialect, nil
+}
diff --git a/internal/generator/generator_test.en-lol.feature b/internal/generator/generator_test.en-lol.feature
new file mode 100644
index 0000000..8b545c4
--- /dev/null
+++ b/internal/generator/generator_test.en-lol.feature
@@ -0,0 +1,8 @@
+OH HAI: Guess da word
+  MISHUN SRSLY: <main_player> startz da game
+    WEN the <main_player> startz da game at start_date
+    DEN the <main_player> waitz fur a frand <oponent_player> to join
+    EXAMPLZ:
+    | <main_player> | <oponent_player> |
+    | Mark          | Alex             |
+    | Ivan          | Duong            |
diff --git a/internal/generator/generator_test.feature b/internal/generator/generator_test.en.feature
similarity index 78%
rename from internal/generator/generator_test.feature
rename to internal/generator/generator_test.en.feature
index de77b07..52085fc 100644
--- a/internal/generator/generator_test.feature
+++ b/internal/generator/generator_test.en.feature
@@ -1,7 +1,7 @@
 Feature: Guess the word
   Scenario Outline: <main_player> starts a game
     When the <main_player> starts a game at start_date
-    Then the <main_player> waits for a <oponent_player> to join
+    Then the <main_player> waits for a friend <oponent_player> to join
     Examples:
     | <main_player> | <oponent_player> |
     | Mark          | Alex             |
diff --git a/internal/generator/generator_test.go b/internal/generator/generator_test.go
index 6f9e6f4..83c3f9a 100644
--- a/internal/generator/generator_test.go
+++ b/internal/generator/generator_test.go
@@ -11,52 +11,86 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-//go:embed generator_test.feature
-var exampleFeature []byte
+var (
+	//go:embed generator_test.en.feature
+	exampleFeatureEnglish []byte
+
+	//go:embed generator_test.en-lol.feature
+	exampleFeatureLOLCAT []byte
+)
+
+func TestGenerate(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		Language string
+	}{{
+		Language: "English",
+	}, {
+		Language: "LOLCAT",
+	}}
+
+	for _, tc := range testCases {
+		t.Run(tc.Language, func(t *testing.T) {
+			t.Parallel()
+
+			args := generator.Args{
+				Format:         model.FormatGo,
+				InputSource:    scenarioIn(t, tc.Language),
+				TemplateSource: []byte(``),
+				PackageName:    "generated_test",
+				Plugin:         requireNewPlugin(t),
+				GenerateUUID:   uuid.NewString,
+				Language:       language(t, tc.Language),
+			}
+
+			_, err := generator.Generate(args)
+
+			assert.NoError(t, err)
+		})
+	}
+}
 
 func TestGenerateFailed(t *testing.T) {
 	t.Parallel()
 
 	testCases := []struct {
-		Name    string
+		Reason  string
 		Prepare func(args *generator.Args)
-		OK      bool
 	}{{
-		OK:      true,
-		Name:    "ok",
-		Prepare: func(*generator.Args) {},
-	}, {
-		OK:   false,
-		Name: "invalid_format",
+		Reason: "invalid_format",
 		Prepare: func(args *generator.Args) {
 			args.Format = "invalid"
 		},
 	}, {
-		Name: "invalid_source",
+		Reason: "invalid_source",
 		Prepare: func(args *generator.Args) {
 			args.InputSource = []byte("INVALID")
 		},
 	}, {
-		OK:   false,
-		Name: "invalid_template",
+		Reason: "invalid_template",
 		Prepare: func(args *generator.Args) {
 			args.TemplateSource = []byte(`{{ .Unknown }}`)
 		},
 	}, {
-		OK:   false,
-		Name: "no_package",
+		Reason: "no_package",
 		Prepare: func(args *generator.Args) {
 			args.PackageName = ""
 		},
+	}, {
+		Reason: "unsupported_language",
+		Prepare: func(args *generator.Args) {
+			args.Language = "unsupported"
+		},
 	}}
 
 	for _, testCase := range testCases {
-		t.Run(testCase.Name, func(t *testing.T) {
+		t.Run(testCase.Reason, func(t *testing.T) {
 			t.Parallel()
 
 			args := generator.Args{
 				Format:         model.FormatGo,
-				InputSource:    exampleFeature,
+				InputSource:    scenarioIn(t, defaultLanguage),
 				TemplateSource: []byte(``),
 				PackageName:    "generated_test",
 				Plugin:         requireNewPlugin(t),
@@ -66,11 +100,40 @@ func TestGenerateFailed(t *testing.T) {
 			testCase.Prepare(&args)
 
 			_, err := generator.Generate(args)
-			if testCase.OK {
-				assert.NoError(t, err)
-			} else {
-				assert.Error(t, err)
-			}
+
+			assert.Error(t, err)
 		})
 	}
 }
+
+const defaultLanguage = "English"
+
+func scenarioIn(tb testing.TB, language string) []byte {
+	tb.Helper()
+
+	switch language {
+	case "English":
+		return exampleFeatureEnglish
+	case "LOLCAT":
+		return exampleFeatureLOLCAT
+	default:
+		tb.Fatalf("unexpected language: %s", language)
+
+		return nil
+	}
+}
+
+func language(tb testing.TB, name string) string {
+	tb.Helper()
+
+	switch name {
+	case "English":
+		return "en"
+	case "LOLCAT":
+		return "en-lol"
+	default:
+		tb.Fatalf("unexpected language name: %s", name)
+
+		return ""
+	}
+}
diff --git a/internal/generator/golang_test.go b/internal/generator/golang_test.go
index da071eb..8634b87 100644
--- a/internal/generator/golang_test.go
+++ b/internal/generator/golang_test.go
@@ -23,7 +23,7 @@ func TestGenerateGo(t *testing.T) {
 
 	gotDataGo, err := generator.Generate(generator.Args{
 		Format:         model.FormatGo,
-		InputSource:    exampleFeature,
+		InputSource:    exampleFeatureEnglish,
 		TemplateSource: []byte(exampleTemplate),
 		PackageName:    "generated_test",
 		Plugin:         requireNewPlugin(t),
@@ -44,7 +44,7 @@ func TestGenerateGoFormattingFailed(t *testing.T) {
 
 	_, err := generator.Generate(generator.Args{
 		Format:         model.FormatGo,
-		InputSource:    exampleFeature,
+		InputSource:    exampleFeatureEnglish,
 		TemplateSource: []byte("-"),
 		PackageName:    "generated_test",
 		Plugin:         requireNewPlugin(t),
@@ -73,7 +73,7 @@ func TestGenerateAssetTemplatesShouldNotFail(t *testing.T) {
 
 			_, err = generator.Generate(generator.Args{
 				Format:         model.FormatGo,
-				InputSource:    exampleFeature,
+				InputSource:    exampleFeatureEnglish,
 				TemplateSource: tmplData,
 				PackageName:    "generated_test",
 				Plugin:         requireNewPlugin(t),
diff --git a/internal/generator/json_test.go b/internal/generator/json_test.go
index 46dcb47..609528f 100644
--- a/internal/generator/json_test.go
+++ b/internal/generator/json_test.go
@@ -16,7 +16,7 @@ func TestGenerateJSON(t *testing.T) {
 
 	gotDataJSON, err := generator.Generate(generator.Args{
 		Format:         model.FormatJSON,
-		InputSource:    exampleFeature,
+		InputSource:    exampleFeatureEnglish,
 		TemplateSource: nil,
 		PackageName:    "example_json",
 		Plugin:         requireNewPlugin(t),
diff --git a/internal/generator/raw_test.go b/internal/generator/raw_test.go
index 8207e6a..6ce365f 100644
--- a/internal/generator/raw_test.go
+++ b/internal/generator/raw_test.go
@@ -114,7 +114,7 @@ func TestGenerateRaw(t *testing.T) {
 
 			gotDataRaw, err := generator.Generate(generator.Args{
 				Format:         model.FormatRaw,
-				InputSource:    exampleFeature,
+				InputSource:    exampleFeatureEnglish,
 				TemplateSource: []byte(testCase.Template),
 				PackageName:    "generated_test.go",
 				Plugin:         requireNewPlugin(t),
@@ -132,7 +132,7 @@ func TestGenerateRawFailed(t *testing.T) {
 
 	_, err := generator.Generate(generator.Args{
 		Format:         model.FormatRaw,
-		InputSource:    exampleFeature,
+		InputSource:    exampleFeatureEnglish,
 		TemplateSource: []byte("{{"),
 		PackageName:    "generated_test.go",
 		Plugin:         requireNewPlugin(t),
diff --git a/scripts/examples.sh b/scripts/examples.sh
index cf4b47e..d9ed877 100755
--- a/scripts/examples.sh
+++ b/scripts/examples.sh
@@ -1,21 +1,33 @@
 #!/bin/sh
 
 for f in internal/generator/examples/*.feature; do
-  dir=$(dirname $f)
-  base=$(basename $f)
+  dir=$(dirname "$f")
+  base=$(basename "$f")
+  name=$(basename "$f" .feature)
+  language="en" # The default language.
+
+  # Check if the file name contains a hint about a specific language.
+  case "$name" in
+    *.*)
+        language=$(echo "$name" | awk -F'.' '{print $NF}')
+    ;;
+  esac
+
   go run cmd/gherkingen/main.go \
     -package examples_test \
     -permanent-ids \
     -format go \
     -go-parallel \
     -template "@/std.simple.v1.go.tmpl" \
-    $f \
-    > ${dir}/simpleparallel/${base}_test.go
+    -language "$language" \
+    "$f" \
+    > "${dir}"/simpleparallel/"${base}"_test.go
   go run cmd/gherkingen/main.go \
     -package examples_test \
     -permanent-ids \
     -format go \
     -template "@/std.simple.v1.go.tmpl" \
-    $f \
-    > ${dir}/simple/${base}_test.go
+    -language "$language" \
+    "$f" \
+    > "${dir}"/simple/"${base}"_test.go
 done