diff --git a/builder/config.go b/builder/config.go
index 40c6f0c9a..8db8ff8fe 100644
--- a/builder/config.go
+++ b/builder/config.go
@@ -2,6 +2,7 @@ package builder
 
 import (
 	"fmt"
+	"runtime"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -23,20 +24,37 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 		spec.OpenOCDCommands = options.OpenOCDCommands
 	}
 
-	major, minor, err := goenv.GetGorootVersion()
+	// Version range supported by TinyGo.
+	const minorMin = 19
+	const minorMax = 23
+
+	// Check that we support this Go toolchain version.
+	gorootMajor, gorootMinor, err := goenv.GetGorootVersion()
 	if err != nil {
 		return nil, err
 	}
-	if major != 1 || minor < 19 || minor > 23 {
+	if gorootMajor != 1 || gorootMinor < minorMin || gorootMinor > minorMax {
 		// Note: when this gets updated, also update the Go compatibility matrix:
 		// https://github.com/tinygo-org/tinygo-site/blob/dev/content/docs/reference/go-compat-matrix.md
-		return nil, fmt.Errorf("requires go version 1.19 through 1.23, got go%d.%d", major, minor)
+		return nil, fmt.Errorf("requires go version 1.19 through 1.23, got go%d.%d", gorootMajor, gorootMinor)
+	}
+
+	// Check that the Go toolchain version isn't too new, if we haven't been
+	// compiled with the latest Go version.
+	// This may be a bit too aggressive: if the newer version doesn't change the
+	// Go language we will most likely be able to compile it.
+	buildMajor, buildMinor, err := goenv.Parse(runtime.Version())
+	if err != nil {
+		return nil, err
+	}
+	if buildMajor != 1 || buildMinor < gorootMinor {
+		return nil, fmt.Errorf("cannot compile with Go toolchain version go%d.%d (TinyGo was built using toolchain version %s)", gorootMajor, gorootMinor, runtime.Version())
 	}
 
 	return &compileopts.Config{
 		Options:        options,
 		Target:         spec,
-		GoMinorVersion: minor,
+		GoMinorVersion: gorootMinor,
 		TestConfig:     options.TestConfig,
 	}, nil
 }
diff --git a/goenv/version.go b/goenv/version.go
index 1db5a630a..cdfa278bd 100644
--- a/goenv/version.go
+++ b/goenv/version.go
@@ -34,19 +34,25 @@ func GetGorootVersion() (major, minor int, err error) {
 	if err != nil {
 		return 0, 0, err
 	}
+	return Parse(s)
+}
 
-	if s == "" || s[:2] != "go" {
+// Parse parses the Go version (like "go1.3.2") in the parameter and return the
+// major and minor version: 1 and 3 in this example. If there is an error, (0,
+// 0) and an error will be returned.
+func Parse(version string) (major, minor int, err error) {
+	if version == "" || version[:2] != "go" {
 		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
 	}
 
-	parts := strings.Split(s[2:], ".")
+	parts := strings.Split(version[2:], ".")
 	if len(parts) < 2 {
 		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
 	}
 
 	// Ignore the errors, we don't really handle errors here anyway.
 	var trailing string
-	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
+	n, err := fmt.Sscanf(version, "go%d.%d%s", &major, &minor, &trailing)
 	if n == 2 && err == io.EOF {
 		// Means there were no trailing characters (i.e., not an alpha/beta)
 		err = nil