diff --git a/baked_in.go b/baked_in.go
index ff860e02..73a9bccf 100644
--- a/baked_in.go
+++ b/baked_in.go
@@ -247,7 +247,7 @@ func parseOneOfParam2(s string) []string {
 	oneofValsCacheRWLock.RUnlock()
 	if !ok {
 		oneofValsCacheRWLock.Lock()
-		vals = splitParamsRegex.FindAllString(s, -1)
+		vals = splitParamsRegex().FindAllString(s, -1)
 		for i := 0; i < len(vals); i++ {
 			vals[i] = strings.Replace(vals[i], "'", "", -1)
 		}
@@ -258,15 +258,15 @@ func parseOneOfParam2(s string) []string {
 }
 
 func isURLEncoded(fl FieldLevel) bool {
-	return uRLEncodedRegex.MatchString(fl.Field().String())
+	return uRLEncodedRegex().MatchString(fl.Field().String())
 }
 
 func isHTMLEncoded(fl FieldLevel) bool {
-	return hTMLEncodedRegex.MatchString(fl.Field().String())
+	return hTMLEncodedRegex().MatchString(fl.Field().String())
 }
 
 func isHTML(fl FieldLevel) bool {
-	return hTMLRegex.MatchString(fl.Field().String())
+	return hTMLRegex().MatchString(fl.Field().String())
 }
 
 func isOneOf(fl FieldLevel) bool {
@@ -423,7 +423,7 @@ func isSSN(fl FieldLevel) bool {
 		return false
 	}
 
-	return sSNRegex.MatchString(field.String())
+	return sSNRegex().MatchString(field.String())
 }
 
 // isLongitude is the validation function for validating if the field's value is a valid longitude coordinate.
@@ -446,7 +446,7 @@ func isLongitude(fl FieldLevel) bool {
 		panic(fmt.Sprintf("Bad field type %T", field.Interface()))
 	}
 
-	return longitudeRegex.MatchString(v)
+	return longitudeRegex().MatchString(v)
 }
 
 // isLatitude is the validation function for validating if the field's value is a valid latitude coordinate.
@@ -469,7 +469,7 @@ func isLatitude(fl FieldLevel) bool {
 		panic(fmt.Sprintf("Bad field type %T", field.Interface()))
 	}
 
-	return latitudeRegex.MatchString(v)
+	return latitudeRegex().MatchString(v)
 }
 
 // isDataURI is the validation function for validating if the field's value is a valid data URI.
@@ -480,11 +480,11 @@ func isDataURI(fl FieldLevel) bool {
 		return false
 	}
 
-	if !dataURIRegex.MatchString(uri[0]) {
+	if !dataURIRegex().MatchString(uri[0]) {
 		return false
 	}
 
-	return base64Regex.MatchString(uri[1])
+	return base64Regex().MatchString(uri[1])
 }
 
 // hasMultiByteCharacter is the validation function for validating if the field's value has a multi byte character.
@@ -495,17 +495,17 @@ func hasMultiByteCharacter(fl FieldLevel) bool {
 		return true
 	}
 
-	return multibyteRegex.MatchString(field.String())
+	return multibyteRegex().MatchString(field.String())
 }
 
 // isPrintableASCII is the validation function for validating if the field's value is a valid printable ASCII character.
 func isPrintableASCII(fl FieldLevel) bool {
-	return printableASCIIRegex.MatchString(fl.Field().String())
+	return printableASCIIRegex().MatchString(fl.Field().String())
 }
 
 // isASCII is the validation function for validating if the field's value is a valid ASCII character.
 func isASCII(fl FieldLevel) bool {
-	return aSCIIRegex.MatchString(fl.Field().String())
+	return aSCIIRegex().MatchString(fl.Field().String())
 }
 
 // isUUID5 is the validation function for validating if the field's value is a valid v5 UUID.
@@ -555,52 +555,52 @@ func isULID(fl FieldLevel) bool {
 
 // isMD4 is the validation function for validating if the field's value is a valid MD4.
 func isMD4(fl FieldLevel) bool {
-	return md4Regex.MatchString(fl.Field().String())
+	return md4Regex().MatchString(fl.Field().String())
 }
 
 // isMD5 is the validation function for validating if the field's value is a valid MD5.
 func isMD5(fl FieldLevel) bool {
-	return md5Regex.MatchString(fl.Field().String())
+	return md5Regex().MatchString(fl.Field().String())
 }
 
 // isSHA256 is the validation function for validating if the field's value is a valid SHA256.
 func isSHA256(fl FieldLevel) bool {
-	return sha256Regex.MatchString(fl.Field().String())
+	return sha256Regex().MatchString(fl.Field().String())
 }
 
 // isSHA384 is the validation function for validating if the field's value is a valid SHA384.
 func isSHA384(fl FieldLevel) bool {
-	return sha384Regex.MatchString(fl.Field().String())
+	return sha384Regex().MatchString(fl.Field().String())
 }
 
 // isSHA512 is the validation function for validating if the field's value is a valid SHA512.
 func isSHA512(fl FieldLevel) bool {
-	return sha512Regex.MatchString(fl.Field().String())
+	return sha512Regex().MatchString(fl.Field().String())
 }
 
 // isRIPEMD128 is the validation function for validating if the field's value is a valid PIPEMD128.
 func isRIPEMD128(fl FieldLevel) bool {
-	return ripemd128Regex.MatchString(fl.Field().String())
+	return ripemd128Regex().MatchString(fl.Field().String())
 }
 
 // isRIPEMD160 is the validation function for validating if the field's value is a valid PIPEMD160.
 func isRIPEMD160(fl FieldLevel) bool {
-	return ripemd160Regex.MatchString(fl.Field().String())
+	return ripemd160Regex().MatchString(fl.Field().String())
 }
 
 // isTIGER128 is the validation function for validating if the field's value is a valid TIGER128.
 func isTIGER128(fl FieldLevel) bool {
-	return tiger128Regex.MatchString(fl.Field().String())
+	return tiger128Regex().MatchString(fl.Field().String())
 }
 
 // isTIGER160 is the validation function for validating if the field's value is a valid TIGER160.
 func isTIGER160(fl FieldLevel) bool {
-	return tiger160Regex.MatchString(fl.Field().String())
+	return tiger160Regex().MatchString(fl.Field().String())
 }
 
 // isTIGER192 is the validation function for validating if the field's value is a valid isTIGER192.
 func isTIGER192(fl FieldLevel) bool {
-	return tiger192Regex.MatchString(fl.Field().String())
+	return tiger192Regex().MatchString(fl.Field().String())
 }
 
 // isISBN is the validation function for validating if the field's value is a valid v10 or v13 ISBN.
@@ -612,7 +612,7 @@ func isISBN(fl FieldLevel) bool {
 func isISBN13(fl FieldLevel) bool {
 	s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 4), " ", "", 4)
 
-	if !iSBN13Regex.MatchString(s) {
+	if !iSBN13Regex().MatchString(s) {
 		return false
 	}
 
@@ -632,7 +632,7 @@ func isISBN13(fl FieldLevel) bool {
 func isISBN10(fl FieldLevel) bool {
 	s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 3), " ", "", 3)
 
-	if !iSBN10Regex.MatchString(s) {
+	if !iSBN10Regex().MatchString(s) {
 		return false
 	}
 
@@ -656,7 +656,7 @@ func isISBN10(fl FieldLevel) bool {
 func isISSN(fl FieldLevel) bool {
 	s := fl.Field().String()
 
-	if !iSSNRegex.MatchString(s) {
+	if !iSSNRegex().MatchString(s) {
 		return false
 	}
 	s = strings.ReplaceAll(s, "-", "")
@@ -682,14 +682,14 @@ func isISSN(fl FieldLevel) bool {
 func isEthereumAddress(fl FieldLevel) bool {
 	address := fl.Field().String()
 
-	return ethAddressRegex.MatchString(address)
+	return ethAddressRegex().MatchString(address)
 }
 
 // isEthereumAddressChecksum is the validation function for validating if the field's value is a valid checksumed Ethereum address.
 func isEthereumAddressChecksum(fl FieldLevel) bool {
 	address := fl.Field().String()
 
-	if !ethAddressRegex.MatchString(address) {
+	if !ethAddressRegex().MatchString(address) {
 		return false
 	}
 	// Checksum validation. Reference: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md
@@ -715,7 +715,7 @@ func isEthereumAddressChecksum(fl FieldLevel) bool {
 func isBitcoinAddress(fl FieldLevel) bool {
 	address := fl.Field().String()
 
-	if !btcAddressRegex.MatchString(address) {
+	if !btcAddressRegex().MatchString(address) {
 		return false
 	}
 
@@ -752,7 +752,7 @@ func isBitcoinAddress(fl FieldLevel) bool {
 func isBitcoinBech32Address(fl FieldLevel) bool {
 	address := fl.Field().String()
 
-	if !btcLowerAddressRegexBech32.MatchString(address) && !btcUpperAddressRegexBech32.MatchString(address) {
+	if !btcLowerAddressRegexBech32().MatchString(address) && !btcUpperAddressRegexBech32().MatchString(address) {
 		return false
 	}
 
@@ -1402,17 +1402,17 @@ func isPostcodeByIso3166Alpha2Field(fl FieldLevel) bool {
 
 // isBase64 is the validation function for validating if the current field's value is a valid base 64.
 func isBase64(fl FieldLevel) bool {
-	return base64Regex.MatchString(fl.Field().String())
+	return base64Regex().MatchString(fl.Field().String())
 }
 
 // isBase64URL is the validation function for validating if the current field's value is a valid base64 URL safe string.
 func isBase64URL(fl FieldLevel) bool {
-	return base64URLRegex.MatchString(fl.Field().String())
+	return base64URLRegex().MatchString(fl.Field().String())
 }
 
 // isBase64RawURL is the validation function for validating if the current field's value is a valid base64 URL safe string without '=' padding.
 func isBase64RawURL(fl FieldLevel) bool {
-	return base64RawURLRegex.MatchString(fl.Field().String())
+	return base64RawURLRegex().MatchString(fl.Field().String())
 }
 
 // isURI is the validation function for validating if the current field's value is a valid URI.
@@ -1658,42 +1658,42 @@ func isFilePath(fl FieldLevel) bool {
 
 // isE164 is the validation function for validating if the current field's value is a valid e.164 formatted phone number.
 func isE164(fl FieldLevel) bool {
-	return e164Regex.MatchString(fl.Field().String())
+	return e164Regex().MatchString(fl.Field().String())
 }
 
 // isEmail is the validation function for validating if the current field's value is a valid email address.
 func isEmail(fl FieldLevel) bool {
-	return emailRegex.MatchString(fl.Field().String())
+	return emailRegex().MatchString(fl.Field().String())
 }
 
 // isHSLA is the validation function for validating if the current field's value is a valid HSLA color.
 func isHSLA(fl FieldLevel) bool {
-	return hslaRegex.MatchString(fl.Field().String())
+	return hslaRegex().MatchString(fl.Field().String())
 }
 
 // isHSL is the validation function for validating if the current field's value is a valid HSL color.
 func isHSL(fl FieldLevel) bool {
-	return hslRegex.MatchString(fl.Field().String())
+	return hslRegex().MatchString(fl.Field().String())
 }
 
 // isRGBA is the validation function for validating if the current field's value is a valid RGBA color.
 func isRGBA(fl FieldLevel) bool {
-	return rgbaRegex.MatchString(fl.Field().String())
+	return rgbaRegex().MatchString(fl.Field().String())
 }
 
 // isRGB is the validation function for validating if the current field's value is a valid RGB color.
 func isRGB(fl FieldLevel) bool {
-	return rgbRegex.MatchString(fl.Field().String())
+	return rgbRegex().MatchString(fl.Field().String())
 }
 
 // isHEXColor is the validation function for validating if the current field's value is a valid HEX color.
 func isHEXColor(fl FieldLevel) bool {
-	return hexColorRegex.MatchString(fl.Field().String())
+	return hexColorRegex().MatchString(fl.Field().String())
 }
 
 // isHexadecimal is the validation function for validating if the current field's value is a valid hexadecimal.
 func isHexadecimal(fl FieldLevel) bool {
-	return hexadecimalRegex.MatchString(fl.Field().String())
+	return hexadecimalRegex().MatchString(fl.Field().String())
 }
 
 // isNumber is the validation function for validating if the current field's value is a valid number.
@@ -1702,7 +1702,7 @@ func isNumber(fl FieldLevel) bool {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
 		return true
 	default:
-		return numberRegex.MatchString(fl.Field().String())
+		return numberRegex().MatchString(fl.Field().String())
 	}
 }
 
@@ -1712,28 +1712,28 @@ func isNumeric(fl FieldLevel) bool {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
 		return true
 	default:
-		return numericRegex.MatchString(fl.Field().String())
+		return numericRegex().MatchString(fl.Field().String())
 	}
 }
 
 // isAlphanum is the validation function for validating if the current field's value is a valid alphanumeric value.
 func isAlphanum(fl FieldLevel) bool {
-	return alphaNumericRegex.MatchString(fl.Field().String())
+	return alphaNumericRegex().MatchString(fl.Field().String())
 }
 
 // isAlpha is the validation function for validating if the current field's value is a valid alpha value.
 func isAlpha(fl FieldLevel) bool {
-	return alphaRegex.MatchString(fl.Field().String())
+	return alphaRegex().MatchString(fl.Field().String())
 }
 
 // isAlphanumUnicode is the validation function for validating if the current field's value is a valid alphanumeric unicode value.
 func isAlphanumUnicode(fl FieldLevel) bool {
-	return alphaUnicodeNumericRegex.MatchString(fl.Field().String())
+	return alphaUnicodeNumericRegex().MatchString(fl.Field().String())
 }
 
 // isAlphaUnicode is the validation function for validating if the current field's value is a valid alpha unicode value.
 func isAlphaUnicode(fl FieldLevel) bool {
-	return alphaUnicodeRegex.MatchString(fl.Field().String())
+	return alphaUnicodeRegex().MatchString(fl.Field().String())
 }
 
 // isBoolean is the validation function for validating if the current field's value is a valid boolean value or can be safely converted to a boolean value.
@@ -2556,11 +2556,11 @@ func isIP6Addr(fl FieldLevel) bool {
 }
 
 func isHostnameRFC952(fl FieldLevel) bool {
-	return hostnameRegexRFC952.MatchString(fl.Field().String())
+	return hostnameRegexRFC952().MatchString(fl.Field().String())
 }
 
 func isHostnameRFC1123(fl FieldLevel) bool {
-	return hostnameRegexRFC1123.MatchString(fl.Field().String())
+	return hostnameRegexRFC1123().MatchString(fl.Field().String())
 }
 
 func isFQDN(fl FieldLevel) bool {
@@ -2570,7 +2570,7 @@ func isFQDN(fl FieldLevel) bool {
 		return false
 	}
 
-	return fqdnRegexRFC1123.MatchString(val)
+	return fqdnRegexRFC1123().MatchString(val)
 }
 
 // isDir is the validation function for validating if the current field's value is a valid existing directory.
@@ -2669,7 +2669,7 @@ func isJSON(fl FieldLevel) bool {
 
 // isJWT is the validation function for validating if the current field's value is a valid JWT string.
 func isJWT(fl FieldLevel) bool {
-	return jWTRegex.MatchString(fl.Field().String())
+	return jWTRegex().MatchString(fl.Field().String())
 }
 
 // isHostnamePort validates a <dns>:<port> combination for fields typically used for socket address.
@@ -2688,7 +2688,7 @@ func isHostnamePort(fl FieldLevel) bool {
 
 	// If host is specified, it should match a DNS name
 	if host != "" {
-		return hostnameRegexRFC1123.MatchString(host)
+		return hostnameRegexRFC1123().MatchString(host)
 	}
 	return true
 }
@@ -2835,21 +2835,21 @@ func isBCP47LanguageTag(fl FieldLevel) bool {
 func isIsoBicFormat(fl FieldLevel) bool {
 	bicString := fl.Field().String()
 
-	return bicRegex.MatchString(bicString)
+	return bicRegex().MatchString(bicString)
 }
 
 // isSemverFormat is the validation function for validating if the current field's value is a valid semver version, defined in Semantic Versioning 2.0.0
 func isSemverFormat(fl FieldLevel) bool {
 	semverString := fl.Field().String()
 
-	return semverRegex.MatchString(semverString)
+	return semverRegex().MatchString(semverString)
 }
 
 // isCveFormat is the validation function for validating if the current field's value is a valid cve id, defined in CVE mitre org
 func isCveFormat(fl FieldLevel) bool {
 	cveString := fl.Field().String()
 
-	return cveRegex.MatchString(cveString)
+	return cveRegex().MatchString(cveString)
 }
 
 // isDnsRFC1035LabelFormat is the validation function
@@ -2857,7 +2857,7 @@ func isCveFormat(fl FieldLevel) bool {
 // a valid dns RFC 1035 label, defined in RFC 1035.
 func isDnsRFC1035LabelFormat(fl FieldLevel) bool {
 	val := fl.Field().String()
-	return dnsRegexRFC1035Label.MatchString(val)
+	return dnsRegexRFC1035Label().MatchString(val)
 }
 
 // digitsHaveLuhnChecksum returns true if and only if the last element of the given digits slice is the Luhn checksum of the previous elements
@@ -2886,7 +2886,7 @@ func digitsHaveLuhnChecksum(digits []string) bool {
 // isMongoDB is the validation function for validating if the current field's value is valid mongoDB objectID
 func isMongoDB(fl FieldLevel) bool {
 	val := fl.Field().String()
-	return mongodbRegex.MatchString(val)
+	return mongodbRegex().MatchString(val)
 }
 
 // isSpiceDB is the validation function for validating if the current field's value is valid for use with Authzed SpiceDB in the indicated way
@@ -2896,11 +2896,11 @@ func isSpiceDB(fl FieldLevel) bool {
 
 	switch param {
 	case "permission":
-		return spicedbPermissionRegex.MatchString(val)
+		return spicedbPermissionRegex().MatchString(val)
 	case "type":
-		return spicedbTypeRegex.MatchString(val)
+		return spicedbTypeRegex().MatchString(val)
 	case "id", "":
-		return spicedbIDRegex.MatchString(val)
+		return spicedbIDRegex().MatchString(val)
 	}
 
 	panic("Unrecognized parameter: " + param)
@@ -2952,5 +2952,5 @@ func hasLuhnChecksum(fl FieldLevel) bool {
 // isCron is the validation function for validating if the current field's value is a valid cron expression
 func isCron(fl FieldLevel) bool {
 	cronString := fl.Field().String()
-	return cronRegex.MatchString(cronString)
+	return cronRegex().MatchString(cronString)
 }
diff --git a/regexes.go b/regexes.go
index af98d8da..c2b6c07c 100644
--- a/regexes.go
+++ b/regexes.go
@@ -1,6 +1,8 @@
 package validator
 
-import "regexp"
+import (
+	"regexp"
+)
 
 const (
 	alphaRegexString                 = "^[a-zA-Z]+$"
@@ -74,72 +76,82 @@ const (
 	spicedbTypeRegexString           = "^([a-z][a-z0-9_]{1,61}[a-z0-9]/)?[a-z][a-z0-9_]{1,62}[a-z0-9]$"
 )
 
+func lazyRegexCompile(str string) func() *regexp.Regexp {
+	var regex *regexp.Regexp
+	return func() *regexp.Regexp {
+		if regex == nil {
+			regex = regexp.MustCompile(str)
+		}
+		return regex
+	}
+}
+
 var (
-	alphaRegex                 = regexp.MustCompile(alphaRegexString)
-	alphaNumericRegex          = regexp.MustCompile(alphaNumericRegexString)
-	alphaUnicodeRegex          = regexp.MustCompile(alphaUnicodeRegexString)
-	alphaUnicodeNumericRegex   = regexp.MustCompile(alphaUnicodeNumericRegexString)
-	numericRegex               = regexp.MustCompile(numericRegexString)
-	numberRegex                = regexp.MustCompile(numberRegexString)
-	hexadecimalRegex           = regexp.MustCompile(hexadecimalRegexString)
-	hexColorRegex              = regexp.MustCompile(hexColorRegexString)
-	rgbRegex                   = regexp.MustCompile(rgbRegexString)
-	rgbaRegex                  = regexp.MustCompile(rgbaRegexString)
-	hslRegex                   = regexp.MustCompile(hslRegexString)
-	hslaRegex                  = regexp.MustCompile(hslaRegexString)
-	e164Regex                  = regexp.MustCompile(e164RegexString)
-	emailRegex                 = regexp.MustCompile(emailRegexString)
-	base64Regex                = regexp.MustCompile(base64RegexString)
-	base64URLRegex             = regexp.MustCompile(base64URLRegexString)
-	base64RawURLRegex          = regexp.MustCompile(base64RawURLRegexString)
-	iSBN10Regex                = regexp.MustCompile(iSBN10RegexString)
-	iSBN13Regex                = regexp.MustCompile(iSBN13RegexString)
-	iSSNRegex                  = regexp.MustCompile(iSSNRegexString)
-	uUID3Regex                 = regexp.MustCompile(uUID3RegexString)
-	uUID4Regex                 = regexp.MustCompile(uUID4RegexString)
-	uUID5Regex                 = regexp.MustCompile(uUID5RegexString)
-	uUIDRegex                  = regexp.MustCompile(uUIDRegexString)
-	uUID3RFC4122Regex          = regexp.MustCompile(uUID3RFC4122RegexString)
-	uUID4RFC4122Regex          = regexp.MustCompile(uUID4RFC4122RegexString)
-	uUID5RFC4122Regex          = regexp.MustCompile(uUID5RFC4122RegexString)
-	uUIDRFC4122Regex           = regexp.MustCompile(uUIDRFC4122RegexString)
-	uLIDRegex                  = regexp.MustCompile(uLIDRegexString)
-	md4Regex                   = regexp.MustCompile(md4RegexString)
-	md5Regex                   = regexp.MustCompile(md5RegexString)
-	sha256Regex                = regexp.MustCompile(sha256RegexString)
-	sha384Regex                = regexp.MustCompile(sha384RegexString)
-	sha512Regex                = regexp.MustCompile(sha512RegexString)
-	ripemd128Regex             = regexp.MustCompile(ripemd128RegexString)
-	ripemd160Regex             = regexp.MustCompile(ripemd160RegexString)
-	tiger128Regex              = regexp.MustCompile(tiger128RegexString)
-	tiger160Regex              = regexp.MustCompile(tiger160RegexString)
-	tiger192Regex              = regexp.MustCompile(tiger192RegexString)
-	aSCIIRegex                 = regexp.MustCompile(aSCIIRegexString)
-	printableASCIIRegex        = regexp.MustCompile(printableASCIIRegexString)
-	multibyteRegex             = regexp.MustCompile(multibyteRegexString)
-	dataURIRegex               = regexp.MustCompile(dataURIRegexString)
-	latitudeRegex              = regexp.MustCompile(latitudeRegexString)
-	longitudeRegex             = regexp.MustCompile(longitudeRegexString)
-	sSNRegex                   = regexp.MustCompile(sSNRegexString)
-	hostnameRegexRFC952        = regexp.MustCompile(hostnameRegexStringRFC952)
-	hostnameRegexRFC1123       = regexp.MustCompile(hostnameRegexStringRFC1123)
-	fqdnRegexRFC1123           = regexp.MustCompile(fqdnRegexStringRFC1123)
-	btcAddressRegex            = regexp.MustCompile(btcAddressRegexString)
-	btcUpperAddressRegexBech32 = regexp.MustCompile(btcAddressUpperRegexStringBech32)
-	btcLowerAddressRegexBech32 = regexp.MustCompile(btcAddressLowerRegexStringBech32)
-	ethAddressRegex            = regexp.MustCompile(ethAddressRegexString)
-	uRLEncodedRegex            = regexp.MustCompile(uRLEncodedRegexString)
-	hTMLEncodedRegex           = regexp.MustCompile(hTMLEncodedRegexString)
-	hTMLRegex                  = regexp.MustCompile(hTMLRegexString)
-	jWTRegex                   = regexp.MustCompile(jWTRegexString)
-	splitParamsRegex           = regexp.MustCompile(splitParamsRegexString)
-	bicRegex                   = regexp.MustCompile(bicRegexString)
-	semverRegex                = regexp.MustCompile(semverRegexString)
-	dnsRegexRFC1035Label       = regexp.MustCompile(dnsRegexStringRFC1035Label)
-	cveRegex                   = regexp.MustCompile(cveRegexString)
-	mongodbRegex               = regexp.MustCompile(mongodbRegexString)
-	cronRegex                  = regexp.MustCompile(cronRegexString)
-	spicedbIDRegex             = regexp.MustCompile(spicedbIDRegexString)
-	spicedbPermissionRegex     = regexp.MustCompile(spicedbPermissionRegexString)
-	spicedbTypeRegex           = regexp.MustCompile(spicedbTypeRegexString)
+	alphaRegex                 = lazyRegexCompile(alphaRegexString)
+	alphaNumericRegex          = lazyRegexCompile(alphaNumericRegexString)
+	alphaUnicodeRegex          = lazyRegexCompile(alphaUnicodeRegexString)
+	alphaUnicodeNumericRegex   = lazyRegexCompile(alphaUnicodeNumericRegexString)
+	numericRegex               = lazyRegexCompile(numericRegexString)
+	numberRegex                = lazyRegexCompile(numberRegexString)
+	hexadecimalRegex           = lazyRegexCompile(hexadecimalRegexString)
+	hexColorRegex              = lazyRegexCompile(hexColorRegexString)
+	rgbRegex                   = lazyRegexCompile(rgbRegexString)
+	rgbaRegex                  = lazyRegexCompile(rgbaRegexString)
+	hslRegex                   = lazyRegexCompile(hslRegexString)
+	hslaRegex                  = lazyRegexCompile(hslaRegexString)
+	e164Regex                  = lazyRegexCompile(e164RegexString)
+	emailRegex                 = lazyRegexCompile(emailRegexString)
+	base64Regex                = lazyRegexCompile(base64RegexString)
+	base64URLRegex             = lazyRegexCompile(base64URLRegexString)
+	base64RawURLRegex          = lazyRegexCompile(base64RawURLRegexString)
+	iSBN10Regex                = lazyRegexCompile(iSBN10RegexString)
+	iSBN13Regex                = lazyRegexCompile(iSBN13RegexString)
+	iSSNRegex                  = lazyRegexCompile(iSSNRegexString)
+	uUID3Regex                 = lazyRegexCompile(uUID3RegexString)
+	uUID4Regex                 = lazyRegexCompile(uUID4RegexString)
+	uUID5Regex                 = lazyRegexCompile(uUID5RegexString)
+	uUIDRegex                  = lazyRegexCompile(uUIDRegexString)
+	uUID3RFC4122Regex          = lazyRegexCompile(uUID3RFC4122RegexString)
+	uUID4RFC4122Regex          = lazyRegexCompile(uUID4RFC4122RegexString)
+	uUID5RFC4122Regex          = lazyRegexCompile(uUID5RFC4122RegexString)
+	uUIDRFC4122Regex           = lazyRegexCompile(uUIDRFC4122RegexString)
+	uLIDRegex                  = lazyRegexCompile(uLIDRegexString)
+	md4Regex                   = lazyRegexCompile(md4RegexString)
+	md5Regex                   = lazyRegexCompile(md5RegexString)
+	sha256Regex                = lazyRegexCompile(sha256RegexString)
+	sha384Regex                = lazyRegexCompile(sha384RegexString)
+	sha512Regex                = lazyRegexCompile(sha512RegexString)
+	ripemd128Regex             = lazyRegexCompile(ripemd128RegexString)
+	ripemd160Regex             = lazyRegexCompile(ripemd160RegexString)
+	tiger128Regex              = lazyRegexCompile(tiger128RegexString)
+	tiger160Regex              = lazyRegexCompile(tiger160RegexString)
+	tiger192Regex              = lazyRegexCompile(tiger192RegexString)
+	aSCIIRegex                 = lazyRegexCompile(aSCIIRegexString)
+	printableASCIIRegex        = lazyRegexCompile(printableASCIIRegexString)
+	multibyteRegex             = lazyRegexCompile(multibyteRegexString)
+	dataURIRegex               = lazyRegexCompile(dataURIRegexString)
+	latitudeRegex              = lazyRegexCompile(latitudeRegexString)
+	longitudeRegex             = lazyRegexCompile(longitudeRegexString)
+	sSNRegex                   = lazyRegexCompile(sSNRegexString)
+	hostnameRegexRFC952        = lazyRegexCompile(hostnameRegexStringRFC952)
+	hostnameRegexRFC1123       = lazyRegexCompile(hostnameRegexStringRFC1123)
+	fqdnRegexRFC1123           = lazyRegexCompile(fqdnRegexStringRFC1123)
+	btcAddressRegex            = lazyRegexCompile(btcAddressRegexString)
+	btcUpperAddressRegexBech32 = lazyRegexCompile(btcAddressUpperRegexStringBech32)
+	btcLowerAddressRegexBech32 = lazyRegexCompile(btcAddressLowerRegexStringBech32)
+	ethAddressRegex            = lazyRegexCompile(ethAddressRegexString)
+	uRLEncodedRegex            = lazyRegexCompile(uRLEncodedRegexString)
+	hTMLEncodedRegex           = lazyRegexCompile(hTMLEncodedRegexString)
+	hTMLRegex                  = lazyRegexCompile(hTMLRegexString)
+	jWTRegex                   = lazyRegexCompile(jWTRegexString)
+	splitParamsRegex           = lazyRegexCompile(splitParamsRegexString)
+	bicRegex                   = lazyRegexCompile(bicRegexString)
+	semverRegex                = lazyRegexCompile(semverRegexString)
+	dnsRegexRFC1035Label       = lazyRegexCompile(dnsRegexStringRFC1035Label)
+	cveRegex                   = lazyRegexCompile(cveRegexString)
+	mongodbRegex               = lazyRegexCompile(mongodbRegexString)
+	cronRegex                  = lazyRegexCompile(cronRegexString)
+	spicedbIDRegex             = lazyRegexCompile(spicedbIDRegexString)
+	spicedbPermissionRegex     = lazyRegexCompile(spicedbPermissionRegexString)
+	spicedbTypeRegex           = lazyRegexCompile(spicedbTypeRegexString)
 )
diff --git a/util.go b/util.go
index 16851593..eb8c5381 100644
--- a/util.go
+++ b/util.go
@@ -297,7 +297,8 @@ func panicIf(err error) {
 
 // Checks if field value matches regex. If fl.Field can be cast to Stringer, it uses the Stringer interfaces
 // String() return value. Otherwise, it uses fl.Field's String() value.
-func fieldMatchesRegexByStringerValOrString(regex *regexp.Regexp, fl FieldLevel) bool {
+func fieldMatchesRegexByStringerValOrString(regexFn func() *regexp.Regexp, fl FieldLevel) bool {
+	regex := regexFn()
 	switch fl.Field().Kind() {
 	case reflect.String:
 		return regex.MatchString(fl.Field().String())