diff --git a/cmd/golangorg/codewalk.go b/cmd/golangorg/codewalk.go
index a7fdafa..b571343 100644
--- a/cmd/golangorg/codewalk.go
+++ b/cmd/golangorg/codewalk.go
@@ -21,6 +21,7 @@
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"log"
 	"net/http"
 	"os"
@@ -33,7 +34,6 @@
 	"unicode/utf8"
 
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 var codewalkHTML, codewalkdirHTML *template.Template
@@ -50,7 +50,7 @@
 	}
 
 	// If directory exists, serve list of code walks.
-	dir, err := fs.Lstat(abspath)
+	dir, err := fs.Stat(fsys, toFS(abspath))
 	if err == nil && dir.IsDir() {
 		codewalkDir(w, r, relpath, abspath)
 		return
@@ -146,7 +146,7 @@
 
 // loadCodewalk reads a codewalk from the named XML file.
 func loadCodewalk(filename string) (*Codewalk, error) {
-	f, err := fs.Open(filename)
+	f, err := fsys.Open(toFS(filename))
 	if err != nil {
 		return nil, err
 	}
@@ -167,7 +167,7 @@
 			i = len(st.Src)
 		}
 		filename := st.Src[0:i]
-		data, err := vfs.ReadFile(fs, filename)
+		data, err := fs.ReadFile(fsys, toFS(filename))
 		if err != nil {
 			st.Err = err
 			continue
@@ -214,7 +214,7 @@
 		Title string
 	}
 
-	dir, err := fs.ReadDir(abspath)
+	dir, err := fs.ReadDir(fsys, toFS(abspath))
 	if err != nil {
 		log.Print(err)
 		pres.ServeError(w, r, relpath, err)
@@ -248,7 +248,7 @@
 // the usual godoc HTML wrapper.
 func codewalkFileprint(w http.ResponseWriter, r *http.Request, f string) {
 	abspath := f
-	data, err := vfs.ReadFile(fs, abspath)
+	data, err := fs.ReadFile(fsys, toFS(abspath))
 	if err != nil {
 		log.Print(err)
 		pres.ServeError(w, r, f, err)
diff --git a/cmd/golangorg/handlers.go b/cmd/golangorg/handlers.go
index c1919c9..c7125c0 100644
--- a/cmd/golangorg/handlers.go
+++ b/cmd/golangorg/handlers.go
@@ -10,23 +10,32 @@
 import (
 	"encoding/json"
 	"go/format"
+	"io/fs"
 	"log"
 	"net/http"
+	pathpkg "path"
 	"strings"
 	"text/template"
 
 	"golang.org/x/website/internal/env"
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
 	"golang.org/x/website/internal/history"
 	"golang.org/x/website/internal/redirect"
 )
 
 var (
 	pres *godoc.Presentation
-	fs   = vfs.NameSpace{}
+	fsys fs.FS
 )
 
+// toFS returns the io/fs name for path (no leading slash).
+func toFS(path string) string {
+	if path == "/" {
+		return "."
+	}
+	return pathpkg.Clean(strings.TrimPrefix(path, "/"))
+}
+
 // hostEnforcerHandler redirects requests to "http://foo.golang.org/bar"
 // to "https://golang.org/bar".
 // It permits requests to the host "godoc-test.golang.org" for testing and
@@ -100,7 +109,7 @@
 
 	// use underlying file system fs to read the template file
 	// (cannot use template ParseFile functions directly)
-	data, err := vfs.ReadFile(fs, path)
+	data, err := fs.ReadFile(fsys, toFS(path))
 	if err != nil {
 		log.Fatal("readTemplate: ", err)
 	}
diff --git a/cmd/golangorg/main.go b/cmd/golangorg/main.go
index 60f0294..14abaf6 100644
--- a/cmd/golangorg/main.go
+++ b/cmd/golangorg/main.go
@@ -23,6 +23,7 @@
 import (
 	"flag"
 	"fmt"
+	"io/fs"
 	"log"
 	"net/http"
 	"os"
@@ -31,8 +32,6 @@
 
 	"golang.org/x/website"
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
-	"golang.org/x/website/internal/godoc/vfs/gatefs"
 )
 
 var (
@@ -75,23 +74,16 @@
 		usage()
 	}
 
-	fsGate := make(chan bool, 20)
-
-	// Determine file system to use.
-	rootfs := gatefs.New(vfs.OS(*goroot), fsGate)
-	fs.Bind("/", rootfs, "/", vfs.BindReplace)
-
-	// Try serving files from _content before trying the main
-	// go repository. This lets us update some documentation outside the
-	// Go release cycle. This includes root.html, which redirects to "/".
-	// See golang.org/issue/29206.
+	// Serve files from _content, falling back to GOROOT.
+	var content fs.FS
 	if *templateDir != "" {
-		fs.Bind("/", vfs.OS(*templateDir), "/", vfs.BindBefore)
+		content = os.DirFS(*templateDir)
 	} else {
-		fs.Bind("/", vfs.FromFS(website.Content), "/", vfs.BindBefore)
+		content = website.Content
 	}
+	fsys = unionFS{content, os.DirFS(*goroot)}
 
-	corpus := godoc.NewCorpus(fs)
+	corpus := godoc.NewCorpus(fsys)
 	corpus.Verbose = *verbose
 	if err := corpus.Init(); err != nil {
 		log.Fatal(err)
@@ -118,7 +110,6 @@
 		log.Printf("\tversion = %s", runtime.Version())
 		log.Printf("\taddress = %s", *httpAddr)
 		log.Printf("\tgoroot = %s", *goroot)
-		fs.Fprint(os.Stderr)
 		handler = loggingHandler(handler)
 	}
 
@@ -128,3 +119,65 @@
 		log.Fatalf("ListenAndServe %s: %v", *httpAddr, err)
 	}
 }
+
+var _ fs.ReadDirFS = unionFS{}
+
+// A unionFS is an FS presenting the union of the file systems in the slice.
+// If multiple file systems provide a particular file, Open uses the FS listed earlier in the slice.
+// If multiple file systems provide a particular directory, ReadDir presents the
+// concatenation of all the directories listed in the slice (with duplicates removed).
+type unionFS []fs.FS
+
+func (fsys unionFS) Open(name string) (fs.File, error) {
+	var errOut error
+	for _, sub := range fsys {
+		f, err := sub.Open(name)
+		if err == nil {
+			// Note: Should technically check for directory
+			// and return a synthetic directory that merges
+			// reads from all the matching directories,
+			// but all the directory reads in internal/godoc
+			// come from fsys.ReadDir, which does that for us.
+			// So we can ignore direct f.ReadDir calls.
+			return f, nil
+		}
+		if errOut == nil {
+			errOut = err
+		}
+	}
+	return nil, errOut
+}
+
+func (fsys unionFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	var all []fs.DirEntry
+	var seen map[string]bool // seen[name] is true if name is listed in all; lazily initialized
+	var errOut error
+	for _, sub := range fsys {
+		list, err := fs.ReadDir(sub, toFS(name))
+		if err != nil {
+			errOut = err
+		}
+		if len(all) == 0 {
+			all = append(all, list...)
+		} else {
+			if seen == nil {
+				// Initialize seen only after we get two different directory listings.
+				seen = make(map[string]bool)
+				for _, d := range all {
+					seen[d.Name()] = true
+				}
+			}
+			for _, d := range list {
+				name := d.Name()
+				if !seen[name] {
+					seen[name] = true
+					all = append(all, d)
+				}
+			}
+		}
+	}
+	if len(all) > 0 {
+		return all, nil
+	}
+	return nil, errOut
+}
diff --git a/cmd/golangorg/project.go b/cmd/golangorg/project.go
index 06f605e..3b6d121 100644
--- a/cmd/golangorg/project.go
+++ b/cmd/golangorg/project.go
@@ -11,12 +11,12 @@
 	"bytes"
 	"fmt"
 	"html/template"
+	"io/fs"
 	"log"
 	"net/http"
 	"sort"
 
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
 	"golang.org/x/website/internal/history"
 )
 
@@ -33,7 +33,7 @@
 
 	const relPath = "doc/contrib.html"
 
-	src, err := vfs.ReadFile(fs, relPath)
+	src, err := fs.ReadFile(fsys, toFS(relPath))
 	if err != nil {
 		log.Printf("reading template %s: %v", relPath, err)
 		pres.ServeError(w, req, relPath, err)
diff --git a/cmd/golangorg/release.go b/cmd/golangorg/release.go
index 198b786..2438178 100644
--- a/cmd/golangorg/release.go
+++ b/cmd/golangorg/release.go
@@ -12,13 +12,13 @@
 	"fmt"
 	"html"
 	"html/template"
+	"io/fs"
 	"log"
 	"net/http"
 	"sort"
 	"strings"
 
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
 	"golang.org/x/website/internal/history"
 )
 
@@ -30,7 +30,7 @@
 func (h releaseHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	const relPath = "doc/devel/release.html"
 
-	src, err := vfs.ReadFile(fs, relPath)
+	src, err := fs.ReadFile(fsys, toFS(relPath))
 	if err != nil {
 		log.Printf("reading template %s: %v", relPath, err)
 		pres.ServeError(w, req, relPath, err)
diff --git a/cmd/golangorg/release_test.go b/cmd/golangorg/release_test.go
index 80e543d..5b2270b 100644
--- a/cmd/golangorg/release_test.go
+++ b/cmd/golangorg/release_test.go
@@ -15,7 +15,6 @@
 
 	"golang.org/x/website"
 	"golang.org/x/website/internal/godoc"
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // Test that the release history page includes expected entries.
@@ -25,11 +24,10 @@
 // It can be relaxed whenever the presentation of the release history
 // page needs to be changed.
 func TestReleaseHistory(t *testing.T) {
-	origFS, origPres := fs, pres
-	defer func() { fs, pres = origFS, origPres }()
-	fs = vfs.NameSpace{}
-	fs.Bind("/", vfs.FromFS(website.Content), "/", vfs.BindReplace)
-	pres = godoc.NewPresentation(godoc.NewCorpus(fs))
+	origFS, origPres := fsys, pres
+	defer func() { fsys, pres = origFS, origPres }()
+	fsys = website.Content
+	pres = godoc.NewPresentation(godoc.NewCorpus(fsys))
 	readTemplates(pres)
 	mux := registerHandlers(pres)
 
diff --git a/internal/godoc/corpus.go b/internal/godoc/corpus.go
index 74a2488..ddfd2e9 100644
--- a/internal/godoc/corpus.go
+++ b/internal/godoc/corpus.go
@@ -2,15 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
 	"errors"
+	"io/fs"
 	"sync"
 	"time"
 
 	"golang.org/x/website/internal/godoc/util"
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // A Corpus holds all the state related to serving and indexing a
@@ -19,7 +22,7 @@
 // Construct a new Corpus with NewCorpus, then modify options,
 // then call its Init method.
 type Corpus struct {
-	fs vfs.FileSystem
+	fs fs.FS
 
 	// Verbose logging.
 	Verbose bool
@@ -58,9 +61,9 @@
 // NewCorpus returns a new Corpus from a filesystem.
 // The returned corpus has all indexing enabled and MaxResults set to 1000.
 // Change or set any options on Corpus before calling the Corpus.Init method.
-func NewCorpus(fs vfs.FileSystem) *Corpus {
+func NewCorpus(fsys fs.FS) *Corpus {
 	c := &Corpus{
-		fs:                    fs,
+		fs:                    fsys,
 		refreshMetadataSignal: make(chan bool, 1),
 	}
 	return c
diff --git a/internal/godoc/dirtrees.go b/internal/godoc/dirtrees.go
index 387d09c..5c0897c 100644
--- a/internal/godoc/dirtrees.go
+++ b/internal/godoc/dirtrees.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // This file contains the code dealing with package directory trees.
 
 package godoc
@@ -10,14 +13,12 @@
 	"go/doc"
 	"go/parser"
 	"go/token"
+	"io/fs"
 	"log"
-	"os"
 	pathpkg "path"
 	"runtime"
 	"sort"
 	"strings"
-
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // Conventional name for directories containing test data.
@@ -35,19 +36,24 @@
 	Dirs     []*Directory // subdirectories
 }
 
-func isGoFile(fi os.FileInfo) bool {
+type dirEntryOrFileInfo interface {
+	Name() string
+	IsDir() bool
+}
+
+func isGoFile(fi dirEntryOrFileInfo) bool {
 	name := fi.Name()
 	return !fi.IsDir() &&
 		len(name) > 0 && name[0] != '.' && // ignore .files
 		pathpkg.Ext(name) == ".go"
 }
 
-func isPkgFile(fi os.FileInfo) bool {
+func isPkgFile(fi dirEntryOrFileInfo) bool {
 	return isGoFile(fi) &&
 		!strings.HasSuffix(fi.Name(), "_test.go") // ignore test files
 }
 
-func isPkgDir(fi os.FileInfo) bool {
+func isPkgDir(fi dirEntryOrFileInfo) bool {
 	name := fi.Name()
 	return fi.IsDir() && len(name) > 0 &&
 		name[0] != '_' && name[0] != '.' // ignore _files and .files
@@ -100,7 +106,7 @@
 	}
 
 	ioGate <- struct{}{}
-	list, err := b.c.fs.ReadDir(path)
+	list, err := fs.ReadDir(b.c.fs, toFS(path))
 	<-ioGate
 	if err != nil {
 		// TODO: propagate more. See golang.org/issue/14252.
@@ -208,11 +214,19 @@
 	}
 }
 
-func isGOROOT(fs vfs.FileSystem) bool {
-	_, err := fs.Lstat("src/math/abs.go")
+func isGOROOT(fsys fs.FS) bool {
+	_, err := fs.Stat(fsys, "src/math/abs.go")
 	return err == nil
 }
 
+// toFS returns the io/fs name for path (no leading slash).
+func toFS(path string) string {
+	if path == "/" {
+		return "."
+	}
+	return pathpkg.Clean(strings.TrimPrefix(path, "/"))
+}
+
 // newDirectory creates a new package directory tree with at most maxDepth
 // levels, anchored at root. The result tree is pruned such that it only
 // contains directories that contain package files or that contain
@@ -225,7 +239,7 @@
 //
 func (c *Corpus) newDirectory(root string, maxDepth int) *Directory {
 	// The root could be a symbolic link so use Stat not Lstat.
-	d, err := c.fs.Stat(root)
+	d, err := fs.Stat(c.fs, toFS(root))
 	// If we fail here, report detailed error messages; otherwise
 	// is is hard to see why a directory tree was not built.
 	switch {
diff --git a/internal/godoc/dirtrees_test.go b/internal/godoc/dirtrees_test.go
index 552fe86..766bc55 100644
--- a/internal/godoc/dirtrees_test.go
+++ b/internal/godoc/dirtrees_test.go
@@ -2,26 +2,20 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
-	"go/build"
-	"path/filepath"
+	"os"
 	"runtime"
 	"sort"
 	"testing"
-
-	"golang.org/x/website/internal/godoc/vfs"
-	"golang.org/x/website/internal/godoc/vfs/gatefs"
 )
 
 func TestNewDirTree(t *testing.T) {
-	fsGate := make(chan bool, 20)
-	rootfs := gatefs.New(vfs.OS(runtime.GOROOT()), fsGate)
-	fs := vfs.NameSpace{}
-	fs.Bind("/", rootfs, "/", vfs.BindReplace)
-
-	c := NewCorpus(fs)
+	c := NewCorpus(os.DirFS(runtime.GOROOT()))
 	// 3 levels deep is enough for testing
 	dir := c.newDirectory("/", 3)
 
@@ -46,15 +40,8 @@
 		b.Skip("not running tests requiring large file scan in short mode")
 	}
 
-	fsGate := make(chan bool, 20)
+	fs := os.DirFS(runtime.GOROOT())
 
-	goroot := runtime.GOROOT()
-	rootfs := gatefs.New(vfs.OS(goroot), fsGate)
-	fs := vfs.NameSpace{}
-	fs.Bind("/", rootfs, "/", vfs.BindReplace)
-	for _, p := range filepath.SplitList(build.Default.GOPATH) {
-		fs.Bind("/src/golang.org", gatefs.New(vfs.OS(p), fsGate), "/src/golang.org", vfs.BindAfter)
-	}
 	b.ResetTimer()
 	b.ReportAllocs()
 	for tries := 0; tries < b.N; tries++ {
@@ -73,7 +60,7 @@
 	}
 
 	for _, item := range tests {
-		fs := vfs.OS(item.path)
+		fs := os.DirFS(item.path)
 		if isGOROOT(fs) != item.isGOROOT {
 			t.Errorf("%s: isGOROOT = %v, want %v", item.path, !item.isGOROOT, item.isGOROOT)
 		}
diff --git a/internal/godoc/format.go b/internal/godoc/format.go
index 3e8c867..e005dcb 100644
--- a/internal/godoc/format.go
+++ b/internal/godoc/format.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // This file implements FormatSelections and FormatText.
 // FormatText is used to HTML-format Go and non-Go source
 // text with line numbers and highlighted sections. It is
diff --git a/internal/godoc/godoc.go b/internal/godoc/godoc.go
index faec584..c23d549 100644
--- a/internal/godoc/godoc.go
+++ b/internal/godoc/godoc.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // Package godoc is a work-in-progress (2013-07-17) package to
 // begin splitting up the godoc binary into multiple pieces.
 //
diff --git a/internal/godoc/godoc_test.go b/internal/godoc/godoc_test.go
index 2719ccc..fd65c7e 100644
--- a/internal/godoc/godoc_test.go
+++ b/internal/godoc/godoc_test.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
diff --git a/internal/godoc/linkify.go b/internal/godoc/linkify.go
index e4add22..3f44ee6 100644
--- a/internal/godoc/linkify.go
+++ b/internal/godoc/linkify.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // This file implements LinkifyText which introduces
 // links for identifiers pointing to their declarations.
 // The approach does not cover all cases because godoc
diff --git a/internal/godoc/markdown.go b/internal/godoc/markdown.go
index fd61aa5..9149bca 100644
--- a/internal/godoc/markdown.go
+++ b/internal/godoc/markdown.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
diff --git a/internal/godoc/meta.go b/internal/godoc/meta.go
index c180254..da5d633 100644
--- a/internal/godoc/meta.go
+++ b/internal/godoc/meta.go
@@ -2,19 +2,21 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"io/fs"
 	"log"
 	"os"
 	pathpkg "path"
 	"strings"
 	"time"
-
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 var (
@@ -67,7 +69,7 @@
 	metadata := make(map[string]*Metadata)
 	var scan func(string) // scan is recursive
 	scan = func(dir string) {
-		fis, err := c.fs.ReadDir(dir)
+		fis, err := fs.ReadDir(c.fs, toFS(dir))
 		if err != nil {
 			if dir == "/doc" && errors.Is(err, os.ErrNotExist) {
 				// Be quiet during tests that don't have a /doc tree.
@@ -86,7 +88,7 @@
 				continue
 			}
 			// Extract metadata from the file.
-			b, err := vfs.ReadFile(c.fs, name)
+			b, err := fs.ReadFile(c.fs, toFS(name))
 			if err != nil {
 				log.Printf("updateMetadata %s: %v", name, err)
 				continue
diff --git a/internal/godoc/page.go b/internal/godoc/page.go
index 279d803..d6cc640 100644
--- a/internal/godoc/page.go
+++ b/internal/godoc/page.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
diff --git a/internal/godoc/parser.go b/internal/godoc/parser.go
index 8712918..f742596 100644
--- a/internal/godoc/parser.go
+++ b/internal/godoc/parser.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // This file contains support functions for parsing .go files
 // accessed via godoc's file system fs.
 
@@ -12,9 +15,8 @@
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"io/fs"
 	pathpkg "path"
-
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 var linePrefix = []byte("//line ")
@@ -47,7 +49,7 @@
 }
 
 func (c *Corpus) parseFile(fset *token.FileSet, filename string, mode parser.Mode) (*ast.File, error) {
-	src, err := vfs.ReadFile(c.fs, filename)
+	src, err := fs.ReadFile(c.fs, toFS(filename))
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/godoc/pres.go b/internal/godoc/pres.go
index cc01204..e4734bf 100644
--- a/internal/godoc/pres.go
+++ b/internal/godoc/pres.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
@@ -9,8 +12,6 @@
 	"regexp"
 	"sync"
 	"text/template"
-
-	"golang.org/x/website/internal/godoc/vfs/httpfs"
 )
 
 // Presentation generates output from a corpus.
@@ -84,7 +85,7 @@
 	p := &Presentation{
 		Corpus:     c,
 		mux:        http.NewServeMux(),
-		fileServer: http.FileServer(httpfs.New(c.fs)),
+		fileServer: http.FileServer(http.FS(c.fs)),
 
 		TabWidth:  4,
 		DeclLinks: true,
diff --git a/internal/godoc/server.go b/internal/godoc/server.go
index 52178ed..3360048 100644
--- a/internal/godoc/server.go
+++ b/internal/godoc/server.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
@@ -15,6 +18,7 @@
 	"go/token"
 	htmlpkg "html"
 	"io"
+	"io/fs"
 	"io/ioutil"
 	"log"
 	"net/http"
@@ -27,7 +31,6 @@
 	"time"
 
 	"golang.org/x/website/internal/godoc/util"
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // handlerServer is a migration from an old godoc http Handler type.
@@ -65,21 +68,24 @@
 	ctxt := build.Default
 	ctxt.IsAbsPath = pathpkg.IsAbs
 	ctxt.IsDir = func(path string) bool {
-		fi, err := h.c.fs.Stat(filepath.ToSlash(path))
+		fi, err := fs.Stat(h.c.fs, toFS(filepath.ToSlash(path)))
 		return err == nil && fi.IsDir()
 	}
 	ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
-		f, err := h.c.fs.ReadDir(filepath.ToSlash(dir))
+		f, err := fs.ReadDir(h.c.fs, toFS(filepath.ToSlash(dir)))
 		filtered := make([]os.FileInfo, 0, len(f))
 		for _, i := range f {
 			if mode&NoFiltering != 0 || i.Name() != "internal" {
-				filtered = append(filtered, i)
+				info, err := i.Info()
+				if err == nil {
+					filtered = append(filtered, info)
+				}
 			}
 		}
 		return filtered, err
 	}
 	ctxt.OpenFile = func(name string) (r io.ReadCloser, err error) {
-		data, err := vfs.ReadFile(h.c.fs, filepath.ToSlash(name))
+		data, err := fs.ReadFile(h.c.fs, toFS(filepath.ToSlash(name)))
 		if err != nil {
 			return nil, err
 		}
@@ -552,7 +558,7 @@
 }
 
 func (p *Presentation) serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath, title string) {
-	src, err := vfs.ReadFile(p.Corpus.fs, abspath)
+	src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
 	if err != nil {
 		log.Printf("ReadFile: %s", err)
 		p.ServeError(w, r, relpath, err)
@@ -636,17 +642,25 @@
 		return
 	}
 
-	list, err := p.Corpus.fs.ReadDir(abspath)
+	list, err := fs.ReadDir(p.Corpus.fs, toFS(abspath))
 	if err != nil {
 		p.ServeError(w, r, relpath, err)
 		return
 	}
 
+	var info []fs.FileInfo
+	for _, d := range list {
+		i, err := d.Info()
+		if err == nil {
+			info = append(info, i)
+		}
+	}
+
 	p.ServePage(w, Page{
 		Title:    "Directory",
 		SrcPath:  relpath,
 		Tabtitle: relpath,
-		Body:     applyTemplate(p.DirlistHTML, "dirlistHTML", list),
+		Body:     applyTemplate(p.DirlistHTML, "dirlistHTML", info),
 		GoogleCN: googleCN(r),
 	})
 }
@@ -654,9 +668,9 @@
 func (p *Presentation) ServeHTMLDoc(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
 	// get HTML body contents
 	isMarkdown := false
-	src, err := vfs.ReadFile(p.Corpus.fs, abspath)
+	src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
 	if err != nil && strings.HasSuffix(abspath, ".html") {
-		if md, errMD := vfs.ReadFile(p.Corpus.fs, strings.TrimSuffix(abspath, ".html")+".md"); errMD == nil {
+		if md, errMD := fs.ReadFile(p.Corpus.fs, toFS(strings.TrimSuffix(abspath, ".html")+".md")); errMD == nil {
 			src = md
 			isMarkdown = true
 			err = nil
@@ -764,19 +778,20 @@
 		return
 	}
 
-	dir, err := p.Corpus.fs.Lstat(abspath)
+	dir, err := fs.Stat(p.Corpus.fs, toFS(abspath))
 	if err != nil {
 		log.Print(err)
 		p.ServeError(w, r, relpath, err)
 		return
 	}
 
+	fsPath := toFS(abspath)
 	if dir != nil && dir.IsDir() {
 		if redirect(w, r) {
 			return
 		}
-		index := pathpkg.Join(abspath, "index.html")
-		if util.IsTextFile(p.Corpus.fs, index) || util.IsTextFile(p.Corpus.fs, pathpkg.Join(abspath, "index.md")) {
+		index := pathpkg.Join(fsPath, "index.html")
+		if util.IsTextFile(p.Corpus.fs, index) || util.IsTextFile(p.Corpus.fs, pathpkg.Join(fsPath, "index.md")) {
 			p.ServeHTMLDoc(w, r, index, index)
 			return
 		}
@@ -784,7 +799,7 @@
 		return
 	}
 
-	if util.IsTextFile(p.Corpus.fs, abspath) {
+	if util.IsTextFile(p.Corpus.fs, fsPath) {
 		if redirectFile(w, r) {
 			return
 		}
diff --git a/internal/godoc/server_test.go b/internal/godoc/server_test.go
index 7a446f9..ea3f8fb 100644
--- a/internal/godoc/server_test.go
+++ b/internal/godoc/server_test.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
@@ -10,9 +13,8 @@
 	"net/url"
 	"strings"
 	"testing"
+	"testing/fstest"
 	"text/template"
-
-	"golang.org/x/website/internal/godoc/vfs/mapfs"
 )
 
 // TestIgnoredGoFiles tests the scenario where a folder has no .go or .c files,
@@ -21,11 +23,12 @@
 	packagePath := "github.com/package"
 	packageComment := "main is documented in an ignored .go file"
 
-	c := NewCorpus(mapfs.New(map[string]string{
-		"src/" + packagePath + "/ignored.go": `// +build ignore
+	c := NewCorpus(fstest.MapFS{
+		"src/" + packagePath + "/ignored.go": {Data: []byte(`// +build ignore
 
 // ` + packageComment + `
-package main`}))
+package main`)},
+	})
 	srv := &handlerServer{
 		p: &Presentation{
 			Corpus: c,
@@ -54,14 +57,15 @@
 
 func TestIssue5247(t *testing.T) {
 	const packagePath = "example.com/p"
-	c := NewCorpus(mapfs.New(map[string]string{
-		"src/" + packagePath + "/p.go": `package p
+	c := NewCorpus(fstest.MapFS{
+		"src/" + packagePath + "/p.go": {Data: []byte(`package p
 
 //line notgen.go:3
 // F doc //line 1 should appear
 // line 2 should appear
 func F()
-//line foo.go:100`})) // No newline at end to check corner cases.
+//line foo.go:100`)}, // No newline at end to check corner cases.
+	})
 
 	srv := &handlerServer{
 		p: &Presentation{Corpus: c},
@@ -85,14 +89,15 @@
 }
 
 func TestRedirectAndMetadata(t *testing.T) {
-	c := NewCorpus(mapfs.New(map[string]string{
-		"doc/y/index.html": "Hello, y.",
-		"doc/x/index.html": `<!--{
+	c := NewCorpus(fstest.MapFS{
+		"doc/y/index.html": {Data: []byte("Hello, y.")},
+		"doc/x/index.html": {Data: []byte(`<!--{
 		"Path": "/doc/x/"
 }-->
 
 Hello, x.
-`}))
+`)},
+	})
 	c.updateMetadata()
 	p := &Presentation{
 		Corpus:    c,
@@ -118,10 +123,10 @@
 
 func TestMarkdown(t *testing.T) {
 	p := &Presentation{
-		Corpus: NewCorpus(mapfs.New(map[string]string{
-			"doc/test.md":  "**bold**",
-			"doc/test2.md": `{{"*template*"}}`,
-		})),
+		Corpus: NewCorpus(fstest.MapFS{
+			"doc/test.md":  {Data: []byte("**bold**")},
+			"doc/test2.md": {Data: []byte(`{{"*template*"}}`)},
+		}),
 		GodocHTML: template.Must(template.New("").Parse(`{{printf "%s" .Body}}`)),
 	}
 
diff --git a/internal/godoc/spec.go b/internal/godoc/spec.go
index 9ec9427..2c2db4b 100644
--- a/internal/godoc/spec.go
+++ b/internal/godoc/spec.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 // This file contains the mechanism to "linkify" html source
diff --git a/internal/godoc/spec_test.go b/internal/godoc/spec_test.go
index c016516..77373f1 100644
--- a/internal/godoc/spec_test.go
+++ b/internal/godoc/spec_test.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (
diff --git a/internal/godoc/tab.go b/internal/godoc/tab.go
index d314ac7..944074e 100644
--- a/internal/godoc/tab.go
+++ b/internal/godoc/tab.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // TODO(bradfitz,adg): move to util
 
 package godoc
diff --git a/internal/godoc/template.go b/internal/godoc/template.go
index 9b99e7e..3e52453 100644
--- a/internal/godoc/template.go
+++ b/internal/godoc/template.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // Template support for writing HTML documents.
 // Documents that include Template: true in their
 // metadata are executed as input to text/template.
@@ -34,11 +37,10 @@
 import (
 	"bytes"
 	"fmt"
+	"io/fs"
 	"log"
 	"regexp"
 	"strings"
-
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // Functions in this file panic on error, but the panic is recovered
@@ -47,7 +49,7 @@
 // contents reads and returns the content of the named file
 // (from the virtual file system, so for example /doc refers to $GOROOT/doc).
 func (c *Corpus) contents(name string) string {
-	file, err := vfs.ReadFile(c.fs, name)
+	file, err := fs.ReadFile(c.fs, toFS(name))
 	if err != nil {
 		log.Panic(err)
 	}
diff --git a/internal/godoc/util/util.go b/internal/godoc/util/util.go
index b15fd5c..2397241 100644
--- a/internal/godoc/util/util.go
+++ b/internal/godoc/util/util.go
@@ -2,16 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // Package util contains utility types and functions for godoc.
 package util // import "golang.org/x/website/internal/godoc/util"
 
 import (
+	"io/fs"
 	pathpkg "path"
 	"sync"
 	"time"
 	"unicode/utf8"
-
-	"golang.org/x/website/internal/godoc/vfs"
 )
 
 // An RWValue wraps a value and permits mutually exclusive
@@ -66,7 +68,7 @@
 // a text file, or if a significant chunk of the specified file looks like
 // correct UTF-8; that is, if it is likely that the file contains human-
 // readable text.
-func IsTextFile(fs vfs.Opener, filename string) bool {
+func IsTextFile(fsys fs.FS, filename string) bool {
 	// if the extension is known, use it for decision making
 	if isText, found := textExt[pathpkg.Ext(filename)]; found {
 		return isText
@@ -74,7 +76,7 @@
 
 	// the extension is not known; read an initial chunk
 	// of the file and check if it looks like text
-	f, err := fs.Open(filename)
+	f, err := fsys.Open(filename)
 	if err != nil {
 		return false
 	}
diff --git a/internal/godoc/versions.go b/internal/godoc/versions.go
index 7342858..e0a16f7 100644
--- a/internal/godoc/versions.go
+++ b/internal/godoc/versions.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 // This file caches information about which standard library types, methods,
 // and functions appeared in what version of Go
 
diff --git a/internal/godoc/versions_test.go b/internal/godoc/versions_test.go
index bfc05f6..1504b61 100644
--- a/internal/godoc/versions_test.go
+++ b/internal/godoc/versions_test.go
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build go1.16
+// +build go1.16
+
 package godoc
 
 import (