diff --git a/cmd/release/release.go b/cmd/release/release.go
index 59bb402..7680406 100644
--- a/cmd/release/release.go
+++ b/cmd/release/release.go
@@ -207,6 +207,13 @@
 		Builder: "darwin-amd64-10_15",
 	},
 	{
+		GoQuery: ">= go1.16beta1", // Go 1.16 Beta 1 is the first Go (pre-)release with the darwin/arm64 port.
+		OS:      "darwin",
+		Arch:    "arm64",
+		Race:    true,
+		Builder: "darwin-arm64-11_0-toothrot",
+	},
+	{
 		OS:        "linux",
 		Arch:      "s390x",
 		SkipTests: true,
diff --git a/cmd/releasebot/main.go b/cmd/releasebot/main.go
index f94eae3..d76f12c 100644
--- a/cmd/releasebot/main.go
+++ b/cmd/releasebot/main.go
@@ -32,6 +32,10 @@
 
 // A Target is a release target.
 type Target struct {
+	// GoQuery is a Go version query specifying the Go versions the
+	// release target applies to. Empty string means all Go versions.
+	GoQuery string
+
 	Name     string // Target name as accepted by cmd/release. For example, "linux-amd64".
 	TestOnly bool   // Run tests only; don't produce a release artifact.
 }
@@ -50,6 +54,7 @@
 	{Name: "windows-386"},
 	{Name: "windows-amd64"},
 	{Name: "darwin-amd64"},
+	{Name: "darwin-arm64", GoQuery: ">= go1.16beta1"},
 	{Name: "linux-s390x"},
 	{Name: "linux-ppc64le"},
 
@@ -88,8 +93,9 @@
 		fmt.Fprintln(os.Stderr, "need to provide a valid mode and a release name")
 		usage()
 	}
+	releaseVersion := flag.Arg(0)
 	for _, target := range strings.Fields(*skipTestFlag) {
-		if t, ok := releaseTarget(target); !ok {
+		if t, ok := releaseTarget(target, releaseVersion); !ok {
 			fmt.Fprintf(os.Stderr, "target %q in -skip-test=%q is not a known target\n", target, *skipTestFlag)
 			usage()
 		} else if !t.TestOnly {
@@ -108,13 +114,11 @@
 	loadGithubAuth()
 	loadGCSAuth()
 
-	release := flag.Arg(0)
-
 	w := &Work{
 		Prepare:     *modeFlag == "prepare",
-		Version:     release,
-		BetaRelease: strings.Contains(release, "beta"),
-		RCRelease:   strings.Contains(release, "rc"),
+		Version:     releaseVersion,
+		BetaRelease: strings.Contains(releaseVersion, "beta"),
+		RCRelease:   strings.Contains(releaseVersion, "rc"),
 		Security:    *security,
 	}
 
@@ -147,6 +151,9 @@
 		log.Fatalf("cannot understand version %q", w.Version)
 	}
 
+	// Select release targets for this Go version.
+	w.ReleaseTargets = matchTargets(w.Version)
+
 	// Find milestones.
 	var err error
 	w.Milestone, err = getMilestone(w.Version)
@@ -244,14 +251,15 @@
 	RCRelease   bool
 	Security    bool // cut a security release from the internal Gerrit
 
-	ReleaseIssue  int    // Release status issue number
-	ReleaseBranch string // "master" for beta releases
-	Dir           string // work directory ($HOME/go-releasebot-work/<release>)
-	StagingDir    string // staging directory (a temporary directory inside <work>/release-staging)
-	Errors        []string
-	ReleaseBinary string
-	Version       string
-	VersionCommit string
+	ReleaseIssue   int    // Release status issue number
+	ReleaseBranch  string // "master" for beta releases
+	Dir            string // work directory ($HOME/go-releasebot-work/<release>)
+	StagingDir     string // staging directory (a temporary directory inside <work>/release-staging)
+	Errors         []string
+	ReleaseBinary  string
+	ReleaseTargets []Target // Selected release targets for this release.
+	Version        string
+	VersionCommit  string
 
 	releaseMu   sync.Mutex
 	ReleaseInfo map[string]*ReleaseInfo // map and info protected by releaseMu
@@ -560,7 +568,7 @@
 	// TODO: print sha256
 	w.releaseMu.Lock()
 	defer w.releaseMu.Unlock()
-	for _, target := range releaseTargets {
+	for _, target := range w.ReleaseTargets {
 		fmt.Fprintf(md, "- %s", mdEscape(target.Name))
 		if target.TestOnly {
 			fmt.Fprintf(md, " (test only)")
@@ -671,7 +679,7 @@
 	}
 
 	var wg sync.WaitGroup
-	for _, target := range releaseTargets {
+	for _, target := range w.ReleaseTargets {
 		w.releaseMu.Lock()
 		w.ReleaseInfo[target.Name] = new(ReleaseInfo)
 		w.releaseMu.Unlock()
@@ -706,7 +714,7 @@
 
 	// Check for release errors and stop if any.
 	w.releaseMu.Lock()
-	for _, target := range releaseTargets {
+	for _, target := range w.ReleaseTargets {
 		for _, out := range w.ReleaseInfo[target.Name].Outputs {
 			if out.Error != "" || len(w.Errors) > 0 {
 				w.logError("RELEASE BUILD FAILED\n")
@@ -889,12 +897,43 @@
 	}
 }
 
-// releaseTarget returns a release target with the specified name.
-func releaseTarget(name string) (_ Target, ok bool) {
+// releaseTarget returns a release target with the specified name
+// for the specified Go version.
+func releaseTarget(name, goVer string) (_ Target, ok bool) {
 	for _, t := range releaseTargets {
+		if !match(t.GoQuery, goVer) {
+			continue
+		}
 		if t.Name == name {
 			return t, true
 		}
 	}
 	return Target{}, false
 }
+
+// matchTargets selects release targets that have a matching
+// GoQuery value for the specified Go version.
+func matchTargets(goVer string) (matched []Target) {
+	for _, t := range releaseTargets {
+		if !match(t.GoQuery, goVer) {
+			continue
+		}
+		matched = append(matched, t)
+	}
+	return matched
+}
+
+// match reports whether the Go version goVer matches the provided version query.
+// The empty query matches all Go versions.
+// match panics if given a query that it doesn't support.
+func match(query, goVer string) bool {
+	// TODO(golang.org/issue/40558): This should help inform the API for a Go version parser.
+	switch query {
+	case "": // A special case to make the zero Target.GoQuery value useful.
+		return true
+	case ">= go1.16beta1":
+		return !strings.HasPrefix(goVer, "go1.15") && !strings.HasPrefix(goVer, "go1.14")
+	default:
+		panic(fmt.Errorf("match: query %q is not supported", query))
+	}
+}
diff --git a/cmd/releasebot/main_test.go b/cmd/releasebot/main_test.go
new file mode 100644
index 0000000..5c83bdd
--- /dev/null
+++ b/cmd/releasebot/main_test.go
@@ -0,0 +1,87 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestTargetSelectionPerGoVersion(t *testing.T) {
+	targetNames := func(targets []Target) (names []string) {
+		for _, t := range targets {
+			names = append(names, t.Name)
+		}
+		return names
+	}
+
+	for _, tc := range []struct {
+		goVer []string // Go versions to test.
+		want  []string // Expected release targets.
+	}{
+		{
+			goVer: []string{"go1.16beta1", "go1.16rc1", "go1.16", "go1.16.1"},
+			want: []string{
+				"src",
+				"linux-386",
+				"linux-armv6l",
+				"linux-amd64",
+				"linux-arm64",
+				"freebsd-386",
+				"freebsd-amd64",
+				"windows-386",
+				"windows-amd64",
+				"darwin-amd64",
+				"darwin-arm64", // New to Go 1.16.
+				"linux-s390x",
+				"linux-ppc64le",
+				"linux-amd64-longtest",
+				"windows-amd64-longtest",
+			},
+		},
+		{
+			goVer: []string{"go1.15.7", "go1.14.14"},
+			want: []string{
+				"src",
+				"linux-386",
+				"linux-armv6l",
+				"linux-amd64",
+				"linux-arm64",
+				"freebsd-386",
+				"freebsd-amd64",
+				"windows-386",
+				"windows-amd64",
+				"darwin-amd64",
+				"linux-s390x",
+				"linux-ppc64le",
+				"linux-amd64-longtest",
+				"windows-amd64-longtest",
+			},
+		},
+	} {
+		for _, goVer := range tc.goVer {
+			t.Run(goVer, func(t *testing.T) {
+				got := matchTargets(goVer)
+				if diff := cmp.Diff(tc.want, targetNames(got)); diff != "" {
+					t.Errorf("release target mismatch (-want +got):\n%s", diff)
+				}
+			})
+		}
+	}
+}
+
+func TestAllQueriesSupported(t *testing.T) {
+	for _, r := range releaseTargets {
+		t.Run(r.Name, func(t *testing.T) {
+			defer func() {
+				if err := recover(); err != nil {
+					t.Errorf("target %s uses an unsupported version query:\n%v", r.Name, err)
+				}
+			}()
+			match(r.GoQuery, "go1.15.7") // Shouldn't panic for any r.GoQuery.
+		})
+	}
+}