diff --git a/README.md b/README.md
index bf110a0..714506a 100644
--- a/README.md
+++ b/README.md
@@ -26,9 +26,11 @@ web-router uses the following environment variables:
 - `VROUTER_DEFAULT_CHANNEL` —  The default channel name. E.g. - "stable".
 - `VROUTER_SHOW_LATEST_CHANNEL` —  Whether to show the 'latest' channel in the menu (default - `false`).
 - `VROUTER_URL_VALIDATION` — Whether to use URL checking before redirect (use false on test environments or protected with authentication).
-- `VROUTER_I18N_TYPE` — Localization method. Can be `domain` or `location` (default - `location`).
+- `VROUTER_DOMAIN_MAP` — JSON structure to map language to domain. Example: '{"en" : "global.company.com", "cn" : "company.cn"}'
+- `VROUTER_I18N_TYPE` — Localization method. Can be `domain`, `location` or `separate-domain` (default - `location`).
   - `location` - Versioned pages URL is like `/<LANGUAGE><VROUTER_LOCATIONVERSIONS>/`. E.g `/en/documentation/`.
   - `domain` - Versioned pages URL is like `<LANGUAGE>.somedomain/<VROUTER_LOCATIONVERSIONS>/`. E.g `ru.product.my/documentation/`.
+  - `separate-domain` - Use a separate domain for each language. Fill the `VROUTER_DOMAIN_MAP` value to use this mode.
 
 ### Templates
 
diff --git a/cmd/v-router/common.go b/cmd/v-router/common.go
index f848955..bbb120f 100644
--- a/cmd/v-router/common.go
+++ b/cmd/v-router/common.go
@@ -2,7 +2,9 @@ package main
 
 import (
 	"crypto/tls"
+	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	log "github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v3"
@@ -32,6 +34,7 @@ type GlobalConfigType struct {
 	LocationVersions  string `default:"/documentation" split_words:"true"`
 	I18nType          string `default:"domain" split_words:"true"`
 	UrlValidation     bool   `default:"false" split_words:"true"`
+	DomainMap         string `default:"" split_words:"true"`
 }
 
 type ChannelType struct {
@@ -79,15 +82,29 @@ type versionMenuItems struct {
 }
 
 var ReleasesStatus ReleasesStatusType
+var DomainMap map[string]string
 
 var channelsListReverseStability = []string{"rock-solid", "stable", "ea", "beta", "alpha"}
+var i18nTypes = []string{"domain", "location", "separate-domain"}
+
+// Сhecks if a string is present in a slice.
+func contains(s []string, str string) bool {
+	for _, v := range s {
+		if v == str {
+			return true
+		}
+	}
+
+	return false
+}
 
 func ValidateConfig() {
-	if GlobalConfig.I18nType != "domain" && GlobalConfig.I18nType != "location" {
-		log.Fatalln(fmt.Sprintf("Unknown localization method specified (%s). It can be 'domain' or 'location'.", GlobalConfig.I18nType))
+	if !contains(i18nTypes, GlobalConfig.I18nType) {
+		log.Fatalln(fmt.Sprintf("Unknown localization method specified (%s). It must be one of the following: %s.", GlobalConfig.I18nType, strings.Join(i18nTypes, ", ")))
 	}
 	// Check template directory
-	if GlobalConfig.I18nType == "domain" {
+	switch GlobalConfig.I18nType {
+	case "domain":
 		if fi, err := os.Stat(getRootFilesPath() + GlobalConfig.PathTpls); err == nil {
 			if !fi.IsDir() {
 				log.Fatalln(fmt.Sprintf("Incorrect path for templates. The '%s%s' path is not a directory", getRootFilesPath(), GlobalConfig.PathTpls))
@@ -95,7 +112,12 @@ func ValidateConfig() {
 		} else {
 			log.Fatalln(fmt.Sprintf("Template directory '%s%s' doesn't exist", getRootFilesPath(), GlobalConfig.PathTpls))
 		}
+	case "separate-domain":
+		if err := getDomainMap(); err != nil {
+			log.Fatal(err.Error())
+		}
 	}
+
 	// Check channels file
 	if _, err := os.Stat(GlobalConfig.PathChannelsFile); err != nil {
 		if os.IsNotExist(err) {
@@ -118,6 +140,9 @@ func printConfiguration() {
 	log.Infoln(fmt.Sprintf("Templates directory: %s%s", getRootFilesPath(), GlobalConfig.PathTpls))
 	log.Infoln(fmt.Sprintf("URL location for versions: %s", GlobalConfig.LocationVersions))
 	log.Infoln(fmt.Sprintf("Localization method: %s", GlobalConfig.I18nType))
+	if GlobalConfig.I18nType == "separate-domain" {
+		log.Infoln(fmt.Sprintf("Domain map: %s", DomainMap))
+	}
 	log.Infoln(fmt.Sprintf("Default group: %s", GlobalConfig.DefaultGroup))
 	log.Infoln(fmt.Sprintf("Default channel: %s", GlobalConfig.DefaultChannel))
 	log.Infoln(fmt.Sprintf("Show the 'latest' channel: %v", GlobalConfig.ShowLatestChannel))
@@ -457,19 +482,28 @@ func getCurrentPageURL(r *http.Request) (result string) {
 // E.g /documentation/v1.2.3/reference/build_process.html
 func getCurrentLang(r *http.Request) (result string) {
 	result = "en"
-	originalURI, err := url.Parse(r.Header.Get("x-original-uri"))
-	if err != nil {
-		return
-	}
 
-	if originalURI.Path == "/404.html" {
-		return
-	}
+	switch GlobalConfig.I18nType {
+	case "separate-domain":
+		return getLanguageFromDomainMap(r.Host)
+	case "domain":
+		return getLanguageFromDomain(r.Host)
+	case "location":
 
-	re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/.+$", GlobalConfig.LocationVersions))
-	res := re.FindStringSubmatch(originalURI.Path)
-	if res != nil {
-		result = res[1]
+		originalURI, err := url.Parse(r.Header.Get("x-original-uri"))
+		if err != nil {
+			return
+		}
+
+		if originalURI.Path == "/404.html" {
+			return
+		}
+
+		re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/.+$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(originalURI.Path)
+		if res != nil {
+			result = res[1]
+		}
 	}
 	return
 
@@ -500,21 +534,32 @@ func getDocPageURLRelative(r *http.Request, useURI bool) (result string) {
 	}
 	URLtoParse = originalURI.Path
 
-	re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)(%s/[^/]+)?/(.*)$", GlobalConfig.LocationVersions))
-	res := re.FindStringSubmatch(URLtoParse)
-	if res != nil {
-		if len(res[2]) > 0 {
-			result = res[3]
-		} else {
-			result = fmt.Sprintf("%s/%s", res[2], res[3])
+	if GlobalConfig.I18nType == "location" {
+		re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)(%s/[^/]+)?/(.*)$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(URLtoParse)
+		if res != nil {
+			if len(res[2]) > 0 {
+				result = res[3]
+			} else {
+				result = fmt.Sprintf("%s/%s", res[2], res[3])
+			}
+		}
+	} else {
+		re := regexp.MustCompile(fmt.Sprintf("^%s/[^/]+/(.*)$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(URLtoParse)
+		if res != nil {
+			result = res[1]
 		}
 	}
+
 	return
 }
 
 // Get version URL page belongs to if request came from concrete documentation version, otherwise empty.
 // E.g for the /documentation/v1.2.3-plus-fix5/reference/build_process.html return "v1.2.3-plus-fix5".
 func getVersionURL(r *http.Request) (result string) {
+	var re *regexp.Regexp
+
 	URLtoParse := ""
 	originalURI, err := url.Parse(r.Header.Get("x-original-uri"))
 
@@ -532,10 +577,18 @@ func getVersionURL(r *http.Request) (result string) {
 		URLtoParse = originalURI.Path
 	}
 
-	re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/([^/]+)/?.*$", GlobalConfig.LocationVersions))
-	res := re.FindStringSubmatch(URLtoParse)
-	if res != nil {
-		result = res[2]
+	if GlobalConfig.I18nType == "location" {
+		re = regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/([^/]+)/?.*$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(URLtoParse)
+		if res != nil {
+			result = res[2]
+		}
+	} else {
+		re = regexp.MustCompile(fmt.Sprintf("^%s/([^/]+)/?.*$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(URLtoParse)
+		if res != nil {
+			result = res[1]
+		}
 	}
 
 	return strings.TrimPrefix(result, "/")
@@ -661,3 +714,33 @@ func updateReleasesStatus() error {
 	}
 	return fmt.Errorf("failed to decode channels file %s", GlobalConfig.PathChannelsFile)
 }
+
+func getDomainMap() error {
+	if len(GlobalConfig.DomainMap) == 0 {
+		return errors.New("Domain map is empty. Use the VROUTER_DOMAIN_MAP environment variable to specify a domain map.")
+	}
+
+	DomainMapRaw, err := base64.StdEncoding.DecodeString(GlobalConfig.DomainMap)
+
+	if err != nil {
+		return errors.New("Can't decode domain map content (the VROUTER_DOMAIN_MAP environment variable)")
+	}
+	log.Debugf("Domain map decoded string: %v", string(DomainMapRaw))
+
+	err = json.Unmarshal(DomainMapRaw, &DomainMap)
+	if err != nil {
+		return errors.New("Can't unmarshal domain map JSON structure (the VROUTER_DOMAIN_MAP environment variable)")
+	}
+
+	// Check DomainMap for empty key/values
+	for lang, domain := range DomainMap {
+		if len(lang) == 0 {
+			return errors.New("Incorrect domain map structure: one of the key is empty")
+		}
+		if len(domain) == 0 {
+			return errors.New("Incorrect domain map structure: one of the value is empty")
+		}
+	}
+
+	return nil
+}
diff --git a/cmd/v-router/handlers.go b/cmd/v-router/handlers.go
index 52cd553..3256a31 100644
--- a/cmd/v-router/handlers.go
+++ b/cmd/v-router/handlers.go
@@ -48,7 +48,7 @@ func groupHandler(w http.ResponseWriter, r *http.Request) {
 	log.Debugln("Use handler - groupHandler")
 
 	vars := mux.Vars(r)
-	if len(vars["lang"]) > 0 {
+	if len(vars["lang"]) > 0 && GlobalConfig.I18nType == "location" {
 		langPrefix = fmt.Sprintf("/%s", vars["lang"])
 	}
 
@@ -65,22 +65,31 @@ func groupHandler(w http.ResponseWriter, r *http.Request) {
 // Temporarily redirect to specific version
 func groupChannelHandler(w http.ResponseWriter, r *http.Request) {
 	var version, URLToRedirect, langPrefix string
+	var re *regexp.Regexp
 	var err error
 
 	log.Debugln("Use handler - groupChannelHandler")
 
 	pageURLRelative := "/"
 	vars := mux.Vars(r)
-	if len(vars["lang"]) > 0 {
+	if len(vars["lang"]) > 0 && GlobalConfig.I18nType == "location" {
 		langPrefix = fmt.Sprintf("/%s", vars["lang"])
 	}
 
 	_ = updateReleasesStatus()
 
-	re := regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/[^/]+/(.+)$", GlobalConfig.LocationVersions))
-	res := re.FindStringSubmatch(r.URL.RequestURI())
-	if res != nil {
-		pageURLRelative = res[2]
+	if GlobalConfig.I18nType == "location" {
+		re = regexp.MustCompile(fmt.Sprintf("^/(ru|en)%s/[^/]+/(.+)$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(r.URL.RequestURI())
+		if res != nil {
+			pageURLRelative = res[2]
+		}
+	} else {
+		re = regexp.MustCompile(fmt.Sprintf("^%s/[^/]+/(.+)$", GlobalConfig.LocationVersions))
+		res := re.FindStringSubmatch(r.URL.RequestURI())
+		if res != nil {
+			pageURLRelative = res[1]
+		}
 	}
 
 	version, err = getVersionFromChannelAndGroup(&ReleasesStatus, vars["channel"], vars["group"])
@@ -104,6 +113,7 @@ func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
 
 // Render templates
 func templateHandler(w http.ResponseWriter, r *http.Request) {
+	var tplPath string
 	if err := updateReleasesStatus(); err != nil {
 		log.Println(err)
 	}
@@ -123,8 +133,18 @@ func templateHandler(w http.ResponseWriter, r *http.Request) {
 
 	_ = templateData.getVersionMenuData(r)
 
-	tplPath := getRootFilesPath() + r.URL.Path
-
+	switch GlobalConfig.I18nType {
+	case "location":
+		tplPath = getRootFilesPath() + r.URL.Path
+	case "separate-domain":
+		language := getLanguageFromDomainMap(r.Host)
+		log.Debugf("Detected %s language for the %s domain", language, r.Host)
+		tplPath = fmt.Sprintf("%s/%s%s", getRootFilesPath(), language, r.URL.Path)
+	case "domain":
+		language := getLanguageFromDomain(r.Host)
+		log.Debugf("Detected %s language for the %s domain", language, r.Host)
+		tplPath = fmt.Sprintf("%s/%s%s", getRootFilesPath(), language, r.URL.Path)
+	}
 	templateContent, err := ioutil.ReadFile(tplPath)
 	if err != nil {
 		log.Errorf("Can't read the template file %s: %s ", tplPath, err.Error())
@@ -141,6 +161,38 @@ func templateHandler(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func getLanguageFromDomainMap(input string) string {
+	result := ""
+	host := strings.Split(input, ":")[0]
+	for lang, domain := range DomainMap {
+		// Get the first value from the map, to use as the default.
+		if result == "" {
+			result = lang
+		}
+
+		if host == domain || host == "www."+domain {
+			return lang
+		}
+	}
+
+	return result
+}
+
+func getLanguageFromDomain(input string) string {
+	// Use en as the default language.
+	result := "en"
+
+	host := strings.Split(input, ":")[0]
+
+	if strings.HasPrefix(host, "ru.") || strings.HasPrefix(host, "www.ru.") {
+		result = "ru"
+	} else {
+		result = "en"
+	}
+
+	return result
+}
+
 func serveFilesHandler(fs http.FileSystem) http.Handler {
 	fsh := http.FileServer(fs)
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -179,7 +231,7 @@ func rootDocHandler(w http.ResponseWriter, r *http.Request) {
 	log.Debugln("Use handler - rootDocHandler")
 
 	vars := mux.Vars(r)
-	if len(vars["lang"]) > 0 {
+	if len(vars["lang"]) > 0 && GlobalConfig.I18nType == "location" {
 		langPrefix = fmt.Sprintf("/%s", vars["lang"])
 	}
 
@@ -199,12 +251,20 @@ func rootDocHandler(w http.ResponseWriter, r *http.Request) {
 
 // Redirect to root documentation if request not matches any location (override 404 response)
 func notFoundHandler(w http.ResponseWriter, r *http.Request) {
+	var re *regexp.Regexp
 	lang := "en"
 
-	re := regexp.MustCompile(`^/(ru|en)/.*$`)
-	res := re.FindStringSubmatch(r.URL.RequestURI())
-	if res != nil {
-		lang = res[1]
+	switch GlobalConfig.I18nType {
+	case "location":
+		re = regexp.MustCompile(`^/(ru|en)/.*$`)
+		res := re.FindStringSubmatch(r.URL.RequestURI())
+		if res != nil {
+			lang = res[1]
+		}
+	case "separate-domain":
+		lang = getLanguageFromDomainMap(r.Host)
+	case "domain":
+		lang = getLanguageFromDomain(r.Host)
 	}
 
 	w.WriteHeader(http.StatusNotFound)
@@ -228,10 +288,9 @@ func notFoundHandler(w http.ResponseWriter, r *http.Request) {
 ">
 <div class="content">
     <div style="margin-top: 100px; width: 100%; width: 80%; margin-left: 50px;">
-        <h1 class="docs__title">Page not found</h1>
+        <h1 class="docs__title">There was a glitch, try in a few seconds...</h1>
         <div class="post-content">
-            <p>Sorry, the page you were looking for does not exist.</p>
-            <p>Try searching for it or check the URL to see if it looks correct.</p>
+            <p>Sorry, maybe we are already investigating the problem and will fix it soon.</p>
         </div>
     </div>
 </div>
diff --git a/cmd/v-router/log.go b/cmd/v-router/log.go
index ad76a6f..474dfa3 100644
--- a/cmd/v-router/log.go
+++ b/cmd/v-router/log.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	log "github.com/sirupsen/logrus"
 	"net/http"
-    "regexp"
-    "strings"
+	"regexp"
+	"strings"
 	"time"
 )
 
@@ -80,8 +80,8 @@ func LoggingMiddleware(next http.Handler) http.Handler {
 
 func logHTTPReq(w *responseWriter, r *http.Request, startTime time.Time) {
 	if skip, _ := regexp.MatchString("^/health[/]?$", r.URL.Path); skip {
-        return
-    }
+		return
+	}
 	log.Tracef("%+v", r)
 	if skipHTTPRequestLogging(r) {
 		return