diff --git a/tour/app.yaml b/tour/app.yaml
index 2ab1a65..7713a59 100644
--- a/tour/app.yaml
+++ b/tour/app.yaml
@@ -1,5 +1,5 @@
 service: tour
-runtime: go115
+runtime: go116
 main: ./tour
 
 env_variables:
diff --git a/tour/appengine.go b/tour/appengine.go
index 0f02356..697cf97 100644
--- a/tour/appengine.go
+++ b/tour/appengine.go
@@ -12,7 +12,6 @@
 	"log"
 	"net/http"
 	"os"
-	"path/filepath"
 
 	_ "golang.org/x/tools/playground"
 	"golang.org/x/website/internal/webtest"
@@ -23,16 +22,14 @@
 	socketAddr = gaeSocketAddr
 	analyticsHTML = template.HTML(os.Getenv("TOUR_ANALYTICS"))
 
-	root := "tour"
-
-	if err := initTour(root, "HTTPTransport"); err != nil {
+	if err := initTour("HTTPTransport"); err != nil {
 		log.Fatal(err)
 	}
 
 	http.Handle("/", hstsHandler(rootHandler))
 	http.Handle("/lesson/", hstsHandler(lessonHandler))
 
-	registerStatic(root)
+	registerStatic()
 
 	port := os.Getenv("PORT")
 	if port == "" {
@@ -40,7 +37,7 @@
 	}
 
 	h := webtest.HandlerWithCheck(http.DefaultServeMux, "/_readycheck",
-		filepath.Join(root, "testdata/*.txt"))
+		"tour/testdata/*.txt")
 
 	log.Fatal(http.ListenAndServe(":"+port, h))
 }
diff --git a/tour/local.go b/tour/local.go
index 5268814..f2a5513 100644
--- a/tour/local.go
+++ b/tour/local.go
@@ -5,20 +5,17 @@
 package main
 
 import (
-	"encoding/json"
 	"flag"
-	"go/build"
 	"html/template"
 	"io"
+	"io/fs"
 	"log"
 	"net"
 	"net/http"
 	"net/url"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"runtime"
-	"runtime/debug"
 	"strings"
 	"time"
 
@@ -39,54 +36,6 @@
 	httpAddr string
 )
 
-// isRoot reports whether path is the root directory of the tour tree.
-// To be the root, it must have content and template subdirectories.
-func isRoot(path string) bool {
-	_, err := os.Stat(filepath.Join(path, "content", "welcome.article"))
-	if err == nil {
-		_, err = os.Stat(filepath.Join(path, "template", "index.tmpl"))
-	}
-	return err == nil
-}
-
-// findRoot is a best-effort attempt to find a tour directory
-// that contains the files it needs. It may not always work.
-//
-// TODO: Delete after Go 1.17 is out and we can just use embed; see CL 291849.
-func findRoot() (string, bool) {
-	// Try finding the golang.org/x/website/tour package in the
-	// legacy GOPATH mode workspace or in build list.
-	p, err := build.Import("golang.org/x/website/tour", "", build.FindOnly)
-	if err == nil && isRoot(p.Dir) {
-		return p.Dir, true
-	}
-	// If that didn't work, perhaps we're not inside any module
-	// and the binary was built in module mode (e.g., 'go install
-	// golang.org/x/website/tour@latest' or 'go get golang.org/x/website/tour'
-	// outside a module).
-	// If that's the case, find out what version it is,
-	// and access its content from the module cache.
-	if info, ok := debug.ReadBuildInfo(); ok &&
-		info.Main.Path == "golang.org/x/website" &&
-		info.Main.Replace == nil &&
-		info.Main.Version != "(devel)" {
-		// Make some assumptions for brevity:
-		// • the 'go' binary is in $PATH
-		// • the main module isn't replaced
-		// • the version isn't "(devel)"
-		// They should hold for the use cases we care about, until this
-		// entire mechanism is obsoleted by file embedding.
-		out, execError := exec.Command("go", "mod", "download", "-json", "--", "golang.org/x/website@"+info.Main.Version).Output()
-		var websiteRoot struct{ Dir string }
-		jsonError := json.Unmarshal(out, &websiteRoot)
-		tourDir := filepath.Join(websiteRoot.Dir, "tour")
-		if execError == nil && jsonError == nil && isRoot(tourDir) {
-			return tourDir, true
-		}
-	}
-	return "", false
-}
-
 func main() {
 	flag.Parse()
 
@@ -96,14 +45,6 @@
 		return
 	}
 
-	// find and serve the go tour files
-	root, ok := findRoot()
-	if !ok {
-		log.Fatalln("Couldn't find files for the Go tour. Try reinstalling it.")
-	}
-
-	log.Println("Serving content from", root)
-
 	host, port, err := net.SplitHostPort(*httpListen)
 	if err != nil {
 		log.Fatal(err)
@@ -116,7 +57,7 @@
 	}
 	httpAddr = host + ":" + port
 
-	if err := initTour(root, "SocketTransport"); err != nil {
+	if err := initTour("SocketTransport"); err != nil {
 		log.Fatal(err)
 	}
 
@@ -126,10 +67,10 @@
 	origin := &url.URL{Scheme: "http", Host: host + ":" + port}
 	http.Handle(socketPath, socket.NewHandler(origin))
 
-	registerStatic(root)
+	registerStatic()
 
 	h := webtest.HandlerWithCheck(http.DefaultServeMux, "/_readycheck",
-		filepath.Join(root, "testdata/*.txt"))
+		"tour/testdata/*.txt")
 
 	go func() {
 		url := "http://" + httpAddr
@@ -144,13 +85,20 @@
 
 // registerStatic registers handlers to serve static content
 // from the directory root.
-func registerStatic(root string) {
-	http.Handle("/favicon.ico", http.FileServer(http.Dir(filepath.Join(root, "static", "img"))))
-	static := http.FileServer(http.Dir(root))
+func registerStatic() {
+	http.Handle("/favicon.ico", http.FileServer(http.FS(must(fs.Sub(root, "static/img")))))
+	static := http.FileServer(http.FS(root))
 	http.Handle("/content/img/", static)
 	http.Handle("/static/", static)
 }
 
+func must(fsys fs.FS, err error) fs.FS {
+	if err != nil {
+		panic(err)
+	}
+	return fsys
+}
+
 // rootHandler returns a handler for all the requests except the ones for lessons.
 func rootHandler(w http.ResponseWriter, r *http.Request) {
 	if err := renderUI(w); err != nil {
diff --git a/tour/server_test.go b/tour/server_test.go
index acc6ee3..4d4ab96 100644
--- a/tour/server_test.go
+++ b/tour/server_test.go
@@ -13,12 +13,12 @@
 )
 
 func TestWeb(t *testing.T) {
-	if err := initTour(".", "SocketTransport"); err != nil {
+	if err := initTour("SocketTransport"); err != nil {
 		log.Fatal(err)
 	}
 	http.HandleFunc("/", rootHandler)
 	http.HandleFunc("/lesson/", lessonHandler)
-	registerStatic(".")
+	registerStatic()
 
 	webtest.TestHandler(t, "testdata/*.txt", http.DefaultServeMux)
 }
diff --git a/tour/tour.go b/tour/tour.go
index 3534d41..542d26c 100644
--- a/tour/tour.go
+++ b/tour/tour.go
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main // import "golang.org/x/website/tour"
+package main
 
 import (
 	"bytes"
 	"crypto/sha1"
+	"embed"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"html/template"
 	"io"
-	"io/ioutil"
 	"net/http"
-	"os"
+	"path"
 	"path/filepath"
 	"strings"
 	"time"
@@ -29,28 +29,29 @@
 	lessonNotFound = fmt.Errorf("lesson not found")
 )
 
-// initTour loads tour.article and the relevant HTML templates from the given
-// tour root, and renders the template to the tourContent global variable.
-func initTour(root, transport string) error {
+var (
+	//go:embed content static template
+	root embed.FS
+)
+
+// initTour loads tour.article and the relevant HTML templates from root.
+func initTour(transport string) error {
 	// Make sure playground is enabled before rendering.
 	present.PlayEnabled = true
 
 	// Set up templates.
-	action := filepath.Join(root, "template", "action.tmpl")
-	tmpl, err := present.Template().ParseFiles(action)
+	tmpl, err := present.Template().ParseFS(root, "template/action.tmpl")
 	if err != nil {
 		return fmt.Errorf("parse templates: %v", err)
 	}
 
 	// Init lessons.
-	contentPath := filepath.Join(root, "content")
-	if err := initLessons(tmpl, contentPath); err != nil {
+	if err := initLessons(tmpl); err != nil {
 		return fmt.Errorf("init lessons: %v", err)
 	}
 
-	// Init UI
-	index := filepath.Join(root, "template", "index.tmpl")
-	ui, err := template.ParseFiles(index)
+	// Init UI.
+	ui, err := template.ParseFS(root, "template/index.tmpl")
 	if err != nil {
 		return fmt.Errorf("parse index.tmpl: %v", err)
 	}
@@ -67,29 +68,25 @@
 	}
 	uiContent = buf.Bytes()
 
-	return initScript(root)
+	return initScript()
 }
 
-// initLessonss finds all the lessons in the passed directory, renders them,
+// initLessonss finds all the lessons in the content directory, renders them,
 // using the given template and saves the content in the lessons map.
-func initLessons(tmpl *template.Template, content string) error {
-	dir, err := os.Open(content)
-	if err != nil {
-		return err
-	}
-	files, err := dir.Readdirnames(0)
+func initLessons(tmpl *template.Template) error {
+	files, err := root.ReadDir("content")
 	if err != nil {
 		return err
 	}
 	for _, f := range files {
-		if filepath.Ext(f) != ".article" {
+		if path.Ext(f.Name()) != ".article" {
 			continue
 		}
-		content, err := parseLesson(tmpl, filepath.Join(content, f))
+		content, err := parseLesson(path.Join("content", f.Name()), tmpl)
 		if err != nil {
-			return fmt.Errorf("parsing %v: %v", f, err)
+			return fmt.Errorf("parsing %v: %v", f.Name(), err)
 		}
-		name := strings.TrimSuffix(f, ".article")
+		name := strings.TrimSuffix(f.Name(), ".article")
 		lessons[name] = content
 	}
 	return nil
@@ -116,15 +113,20 @@
 	Pages       []Page
 }
 
-// parseLesson parses and returns a lesson content given its name and
-// the template to render it.
-func parseLesson(tmpl *template.Template, path string) ([]byte, error) {
-	f, err := os.Open(path)
+// parseLesson parses and returns a lesson content given its path
+// relative to root ('/'-separated) and the template to render it.
+func parseLesson(path string, tmpl *template.Template) ([]byte, error) {
+	f, err := root.Open(path)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
-	doc, err := present.Parse(prepContent(f), path, 0)
+	ctx := &present.Context{
+		ReadFile: func(filename string) ([]byte, error) {
+			return root.ReadFile(filepath.ToSlash(filename))
+		},
+	}
+	doc, err := ctx.Parse(prepContent(f), filepath.FromSlash(path), 0)
 	if err != nil {
 		return nil, err
 	}
@@ -225,7 +227,7 @@
 
 // initScript concatenates all the javascript files needed to render
 // the tour UI and serves the result on /script.js.
-func initScript(root string) error {
+func initScript() error {
 	modTime := time.Now()
 	b := new(bytes.Buffer)
 
@@ -251,9 +253,9 @@
 	}
 
 	for _, file := range files {
-		f, err := ioutil.ReadFile(filepath.Join(root, file))
+		f, err := root.ReadFile(file)
 		if err != nil {
-			return fmt.Errorf("couldn't open %v: %v", file, err)
+			return fmt.Errorf("couldn't read %v: %v", file, err)
 		}
 		_, err = b.Write(f)
 		if err != nil {