diff --git a/cmd/slothfs-gitilesfs/main.go b/cmd/slothfs-gitilesfs/main.go
index 2e9bfa1..30b3feb 100644
--- a/cmd/slothfs-gitilesfs/main.go
+++ b/cmd/slothfs-gitilesfs/main.go
@@ -24,7 +24,7 @@
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/fs"
 	"github.com/google/slothfs/gitiles"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
+	fusefs "github.com/hanwen/go-fuse/fs"
 )
 
 func main() {
@@ -64,12 +64,15 @@
 	}
 
 	root := fs.NewGitilesConfigFSRoot(cache, repoService, &opts)
-	server, _, err := nodefs.MountRoot(mntDir, root, &nodefs.Options{
-		EntryTimeout:    time.Hour,
-		NegativeTimeout: time.Hour,
-		AttrTimeout:     time.Hour,
-		Debug:           *debug,
-	})
+	h := time.Hour
+	fuseOpts := &fusefs.Options{
+		EntryTimeout:    &h,
+		NegativeTimeout: &h,
+		AttrTimeout:     &h,
+	}
+	fuseOpts.Debug = *debug
+
+	server, err := fusefs.Mount(mntDir, root, fuseOpts)
 	if err != nil {
 		log.Fatalf("MountFileSystem: %v", err)
 	}
diff --git a/cmd/slothfs-hostfs/main.go b/cmd/slothfs-hostfs/main.go
index 68a80b6..1fa0436 100644
--- a/cmd/slothfs-hostfs/main.go
+++ b/cmd/slothfs-hostfs/main.go
@@ -24,7 +24,7 @@
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/fs"
 	"github.com/google/slothfs/gitiles"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
+	fusefs "github.com/hanwen/go-fuse/fs"
 )
 
 func main() {
@@ -57,12 +57,14 @@
 		log.Fatalf("NewService: %v", err)
 	}
 
-	server, _, err := nodefs.MountRoot(mntDir, root, &nodefs.Options{
-		EntryTimeout:    time.Hour,
-		NegativeTimeout: time.Hour,
-		AttrTimeout:     time.Hour,
-		Debug:           *debug,
-	})
+	h := time.Hour
+	fuseOpts := &fusefs.Options{
+		EntryTimeout:    &h,
+		NegativeTimeout: &h,
+		AttrTimeout:     &h,
+	}
+	fuseOpts.Debug = *debug
+	server, err := fusefs.Mount(mntDir, root, fuseOpts)
 	if err != nil {
 		log.Fatalf("MountFileSystem: %v", err)
 	}
diff --git a/fs/fixture_test.go b/fs/fixture_test.go
index 92d41f7..0a1cdbc 100644
--- a/fs/fixture_test.go
+++ b/fs/fixture_test.go
@@ -1,4 +1,4 @@
-// Copyright 2016 Google Inc. All rights reserved.
+// Copyright 2019 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -23,8 +23,8 @@
 
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/gitiles"
+	"github.com/hanwen/go-fuse/fs"
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
 )
 
 type testFixture struct {
@@ -34,7 +34,7 @@
 	cache      *cache.Cache
 	testServer *testServer
 	service    *gitiles.Service
-	root       nodefs.Node
+	root       fs.InodeEmbedder
 }
 
 func (f *testFixture) cleanup() {
@@ -52,52 +52,45 @@
 	if err != nil {
 		return nil, err
 	}
-
 	fixture := &testFixture{dir: d}
-
 	fixture.cache, err = cache.NewCache(filepath.Join(d, "/cache"), cache.Options{})
 	if err != nil {
 		return nil, err
 	}
-
 	fixture.testServer, err = newTestServer()
 	if err != nil {
 		return nil, err
 	}
-
 	fixture.service, err = gitiles.NewService(gitiles.Options{
 		Address: fmt.Sprintf("http://%s", fixture.testServer.addr),
 	})
 	if err != nil {
 		return nil, err
 	}
-
 	return fixture, nil
 }
 
-func (f *testFixture) mount(root nodefs.Node) error {
+func (f *testFixture) mount(root fs.InodeEmbedder) error {
 	f.mntDir = filepath.Join(f.dir, "mnt")
 	if err := os.Mkdir(f.mntDir, 0755); err != nil {
 		return err
 	}
-
-	fuseOpts := &nodefs.Options{
-		EntryTimeout:    time.Hour,
-		NegativeTimeout: time.Hour,
-		AttrTimeout:     time.Hour,
+	t := time.Hour
+	fuseOpts := &fs.Options{
+		EntryTimeout:    &t,
+		NegativeTimeout: &t,
+		AttrTimeout:     &t,
 	}
-
+	fuseOpts.Debug = true
 	var err error
-	f.server, _, err = nodefs.MountRoot(f.mntDir, root, fuseOpts)
+	f.server, err = fs.Mount(f.mntDir, root, fuseOpts)
 	if err != nil {
 		return err
 	}
-
 	if fuseDebug {
 		f.server.SetDebug(true)
 	}
 	go f.server.Serve()
-
 	f.root = root
 	return nil
 }
diff --git a/fs/gitilesconfigfs.go b/fs/gitilesconfigfs.go
index 19ae65a..dad2b6a 100644
--- a/fs/gitilesconfigfs.go
+++ b/fs/gitilesconfigfs.go
@@ -15,31 +15,28 @@
 package fs
 
 import (
+	"context"
 	"encoding/hex"
 	"fmt"
 	"log"
+	"syscall"
 
 	"gopkg.in/src-d/go-git.v4/plumbing"
 
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/gitiles"
+	"github.com/hanwen/go-fuse/fs"
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
 )
 
 type gitilesConfigFSRoot struct {
-	nodefs.Node
+	fs.Inode
 
-	fsConn  *nodefs.FileSystemConnector
 	cache   *cache.Cache
 	service *gitiles.RepoService
 	options GitilesOptions
 }
 
-func (r *gitilesConfigFSRoot) OnMount(fsConn *nodefs.FileSystemConnector) {
-	r.fsConn = fsConn
-}
-
 func parseID(s string) (*plumbing.Hash, error) {
 	b, err := hex.DecodeString(s)
 	if err != nil || len(b) != 20 {
@@ -51,14 +48,16 @@
 	return &h, nil
 }
 
-func (r *gitilesConfigFSRoot) Lookup(out *fuse.Attr, name string, context *fuse.Context) (*nodefs.Inode, fuse.Status) {
+var _ = (fs.NodeLookuper)((*gitilesConfigFSRoot)(nil))
+
+func (r *gitilesConfigFSRoot) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
 	id, err := parseID(name)
 	if err != nil {
-		return nil, fuse.ENOENT
+		return nil, syscall.ENOENT
 	}
 
-	if ch := r.Inode().GetChild(name); ch != nil {
-		return ch, fuse.OK
+	if ch := r.GetChild(name); ch != nil {
+		return ch, 0
 	}
 
 	tree, err := r.cache.Tree.Get(id)
@@ -66,7 +65,7 @@
 		tree, err = r.service.GetTree(id.String(), "/", true)
 		if err != nil {
 			log.Printf("GetTree(%s): %v", id, err)
-			return nil, fuse.EIO
+			return nil, syscall.EIO
 		}
 
 		if err := r.cache.Tree.Add(id, tree); err != nil {
@@ -79,17 +78,18 @@
 		GitilesOptions: r.options,
 	}
 	newRoot := NewGitilesRoot(r.cache, tree, r.service, gro)
-	ch := r.Inode().NewChild(id.String(), true, newRoot)
-	out.Mode = fuse.S_IFDIR | 0755
+	ch := r.NewPersistentInode(
+		ctx,
+		newRoot,
+		fs.StableAttr{Mode: syscall.S_IFDIR})
 
-	newRoot.OnMount(r.fsConn)
-	return ch, fuse.OK
+	return ch, 0
 }
 
 // NewGitilesConfigFSRoot returns a root node for a filesystem that lazily
 // instantiates a repository if you access any subdirectory named by a
 // 40-byte hex SHA1.
-func NewGitilesConfigFSRoot(c *cache.Cache, service *gitiles.RepoService, options *GitilesOptions) nodefs.Node {
+func NewGitilesConfigFSRoot(c *cache.Cache, service *gitiles.RepoService, options *GitilesOptions) fs.InodeEmbedder {
 	// TODO(hanwen): nodefs.Node has an OnForget(), but it will
 	// never trigger for directories that have children. That
 	// means that we effectively never drop old trees. We can fix
@@ -97,7 +97,6 @@
 	// a periodic removal of all subtrees trees. Since the FS is
 	// read-only that should cause no ill effects.
 	return &gitilesConfigFSRoot{
-		Node:    nodefs.NewDefaultNode(),
 		cache:   c,
 		service: service,
 		options: *options,
diff --git a/fs/gitilesfs.go b/fs/gitilesfs.go
index dd96b08..394e4ee 100644
--- a/fs/gitilesfs.go
+++ b/fs/gitilesfs.go
@@ -15,6 +15,7 @@
 package fs
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -22,6 +23,7 @@
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"syscall"
@@ -32,14 +34,14 @@
 
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/gitiles"
+	"github.com/hanwen/go-fuse/fs"
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
 )
 
 // gitilesRoot is the root for a FUSE filesystem backed by a Gitiles
 // service.
 type gitilesRoot struct {
-	nodefs.Node
+	fs.Inode
 
 	nodeCache *nodeCache
 
@@ -59,37 +61,9 @@
 	fetching     map[plumbing.Hash]bool
 }
 
-type linkNode struct {
-	nodefs.Node
-	linkTarget []byte
-}
-
-func (n *linkNode) Deletable() bool { return false }
-
-func newLinkNode(target string) *linkNode {
-	return &linkNode{
-		Node:       nodefs.NewDefaultNode(),
-		linkTarget: []byte(target),
-	}
-}
-
-func (n *linkNode) GetAttr(out *fuse.Attr, file nodefs.File, context *fuse.Context) (code fuse.Status) {
-	out.Size = uint64(len(n.linkTarget))
-	out.Mode = fuse.S_IFLNK
-
-	t := time.Unix(1, 0)
-	out.SetTimes(nil, &t, nil)
-
-	return fuse.OK
-}
-
-func (n *linkNode) Readlink(c *fuse.Context) ([]byte, fuse.Status) {
-	return n.linkTarget, fuse.OK
-}
-
 // gitilesNode represents a read-only blob in the FUSE filesystem.
 type gitilesNode struct {
-	nodefs.Node
+	fs.Inode
 
 	root *gitilesRoot
 
@@ -110,24 +84,15 @@
 	readCount uint32
 }
 
-func (n *gitilesNode) Deletable() bool {
-	return false
+var _ = (fs.NodeReadlinker)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Readlink(ctx context.Context) ([]byte, syscall.Errno) {
+	return n.linkTarget, 0
 }
 
-func (n *gitilesNode) Utimens(file nodefs.File, atime *time.Time, mtime *time.Time, context *fuse.Context) (code fuse.Status) {
-	if mtime != nil {
-		n.mtimeMu.Lock()
-		n.mtime = *mtime
-		n.mtimeMu.Unlock()
-	}
-	return fuse.OK
-}
+var _ = (fs.NodeGetattrer)((*gitilesNode)(nil))
 
-func (n *gitilesNode) Readlink(c *fuse.Context) ([]byte, fuse.Status) {
-	return n.linkTarget, fuse.OK
-}
-
-func (n *gitilesNode) GetAttr(out *fuse.Attr, file nodefs.File, context *fuse.Context) (code fuse.Status) {
+func (n *gitilesNode) Getattr(ctx context.Context, h fs.FileHandle, out *fuse.AttrOut) (code syscall.Errno) {
 	out.Size = uint64(n.size)
 	out.Mode = n.mode
 
@@ -136,57 +101,86 @@
 	n.mtimeMu.Unlock()
 
 	out.SetTimes(nil, &t, nil)
-	return fuse.OK
+	return 0
+}
+
+var _ = (fs.NodeSetattrer)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Setattr(ctx context.Context, h fs.FileHandle, in *fuse.SetAttrIn, out *fuse.AttrOut) (code syscall.Errno) {
+	if 0 != in.Valid&(fuse.FATTR_MODE|
+		fuse.FATTR_UID|
+		fuse.FATTR_GID|
+		fuse.FATTR_SIZE|
+		fuse.FATTR_LOCKOWNER|
+		fuse.FATTR_CTIME) {
+		return syscall.ENOTSUP
+	}
+	if mt, ok := in.GetMTime(); ok {
+		n.mtimeMu.Lock()
+		n.mtime = mt
+		n.mtimeMu.Unlock()
+
+		return n.Getattr(ctx, h, out)
+	}
+	return 0
 }
 
 const xattrName = "user.gitsha1"
 
-func (n *gitilesNode) GetXAttr(attribute string, context *fuse.Context) (data []byte, code fuse.Status) {
+var _ = (fs.NodeGetxattrer)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Getxattr(ctx context.Context, attribute string, dest []byte) (uint32, syscall.Errno) {
 	if attribute != xattrName {
-		return nil, fuse.ENODATA
+		return 0, syscall.ENODATA
 	}
-	return []byte(n.id.String()), fuse.OK
+	sz := copy(dest, n.id.String())
+	return uint32(sz), 0
 }
 
-func (n *gitilesNode) ListXAttr(context *fuse.Context) (attrs []string, code fuse.Status) {
-	return []string{xattrName}, fuse.OK
+var _ = (fs.NodeListxattrer)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Listxattr(ctx context.Context, dest []byte) (uint32, syscall.Errno) {
+	sz := copy(dest, xattrName)
+	dest[sz] = 0
+	return uint32(sz + 1), 0
 }
 
-func (n *gitilesNode) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) {
+var _ = (fs.NodeOpener)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Open(ctx context.Context, flags uint32) (h fs.FileHandle, fuseFlags uint32, code syscall.Errno) {
 	if n.root.handleLessIO {
 		// We say ENOSYS so FUSE on Linux uses handle-less I/O.
-		return nil, fuse.ENOSYS
+		return nil, 0, syscall.ENOSYS
 	}
 
 	f, err := n.root.openFile(n.id, n.clone)
 	if err != nil {
-		return nil, fuse.ToStatus(err)
+		return nil, 0, fs.ToErrno(err)
 	}
 
-	return &nodefs.WithFlags{
-		File:      nodefs.NewLoopbackFile(f),
-		FuseFlags: fuse.FOPEN_KEEP_CACHE,
-	}, fuse.OK
+	return fs.NewLoopbackFile(int(f.Fd())), fuse.FOPEN_KEEP_CACHE, 0
 }
 
-func (n *gitilesNode) Read(file nodefs.File, dest []byte, off int64, context *fuse.Context) (fuse.ReadResult, fuse.Status) {
+var _ = (fs.NodeReader)((*gitilesNode)(nil))
+
+func (n *gitilesNode) Read(ctx context.Context, file fs.FileHandle, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
 	if off == 0 {
 		atomic.AddUint32(&n.readCount, 1)
 	}
 
 	if n.root.handleLessIO {
-		return n.handleLessRead(file, dest, off, context)
+		return n.handleLessRead(file, dest, off)
 	}
 
-	return file.Read(dest, off)
+	return file.(fs.FileReader).Read(ctx, dest, off)
 }
 
-func (n *gitilesNode) handleLessRead(file nodefs.File, dest []byte, off int64, context *fuse.Context) (fuse.ReadResult, fuse.Status) {
+func (n *gitilesNode) handleLessRead(file fs.FileHandle, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
 	// TODO(hanwen): for large files this is not efficient. Should
 	// have a cache of open file handles.
 	f, err := n.root.openFile(n.id, n.clone)
 	if err != nil {
-		return nil, fuse.ToStatus(err)
+		return nil, fs.ToErrno(err)
 	}
 
 	m, err := f.ReadAt(dest, off)
@@ -194,7 +188,7 @@
 		err = nil
 	}
 	f.Close()
-	return fuse.ReadResultData(dest[:m]), fuse.ToStatus(err)
+	return fuse.ReadResultData(dest[:m]), fs.ToErrno(err)
 }
 
 // openFile returns a file handle for the given blob. If `clone` is
@@ -290,37 +284,36 @@
 
 // dataNode makes arbitrary data available as a file.
 type dataNode struct {
-	nodefs.Node
+	fs.Inode
 	data []byte
 }
 
-func (n *dataNode) GetAttr(out *fuse.Attr, file nodefs.File, context *fuse.Context) (code fuse.Status) {
+var _ = (fs.NodeGetattrer)((*dataNode)(nil))
+
+func (n *dataNode) Getattr(ctx context.Context, file fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
 	out.Size = uint64(len(n.data))
 	out.Mode = fuse.S_IFREG | 0644
 	t := time.Unix(1, 0)
 	out.SetTimes(nil, &t, nil)
 
-	return fuse.OK
+	return 0
 }
 
-func (n *dataNode) Open(flags uint32, content *fuse.Context) (nodefs.File, fuse.Status) {
-	return nodefs.NewDataFile(n.data), fuse.OK
+var _ = (fs.NodeOpener)((*gitilesNode)(nil))
+
+func (n *dataNode) Open(ctx context.Context, flags uint32) (fs.FileHandle, syscall.Errno) {
+	return fs.MemRegularFile{Data: n.data}, 0
 }
 
-func (n *dataNode) GetXAttr(attribute string, context *fuse.Context) (data []byte, code fuse.Status) {
-	return nil, fuse.ENODATA
-}
+var _ = (fs.NodeGetxattrer)((*gitilesNode)(nil))
 
-func (n *dataNode) Deletable() bool { return false }
-
-func newDataNode(c []byte) nodefs.Node {
-	return &dataNode{nodefs.NewDefaultNode(), c}
+func (n *dataNode) GetXAttr(ctx context.Context, attribute string) (data []byte, code syscall.Errno) {
+	return nil, syscall.ENODATA
 }
 
 // NewGitilesRoot returns the root node for a file system.
-func NewGitilesRoot(c *cache.Cache, tree *gitiles.Tree, service *gitiles.RepoService, options GitilesRevisionOptions) nodefs.Node {
+func NewGitilesRoot(c *cache.Cache, tree *gitiles.Tree, service *gitiles.RepoService, options GitilesRevisionOptions) *gitilesRoot {
 	r := &gitilesRoot{
-		Node:         newDirNode(),
 		service:      service,
 		nodeCache:    newNodeCache(),
 		cache:        c,
@@ -335,63 +328,39 @@
 	return r
 }
 
-func (r *gitilesRoot) Deletable() bool { return false }
+var _ = (fs.NodeGetxattrer)((*gitilesRoot)(nil))
 
-func (r *gitilesRoot) GetXAttr(attribute string, context *fuse.Context) (data []byte, code fuse.Status) {
-	return nil, fuse.ENODATA
+func (r *gitilesRoot) Getxattr(ctx context.Context, attribute string, data []byte) (sz uint32, code syscall.Errno) {
+	return 0, syscall.ENODATA
 }
 
-func (r *gitilesRoot) OnMount(fsConn *nodefs.FileSystemConnector) {
-	if err := r.onMount(fsConn); err != nil {
-		log.Printf("onMount: %v", err)
-		for k := range r.Inode().Children() {
-			r.Inode().RmChild(k)
+func (r *gitilesRoot) pathTo(dir string) *fs.Inode {
+	p := &r.Inode
+	for _, c := range strings.Split(dir, "/") {
+		if len(c) == 0 {
+			continue
 		}
-		r.Inode().NewChild("ERROR", false, newDataNode([]byte(err.Error())))
+		ch := p.GetChild(c)
+		if ch == nil {
+			ch = p.NewPersistentInode(context.Background(),
+				&fs.Inode{},
+				fs.StableAttr{Mode: syscall.S_IFDIR})
+			p.AddChild(c, ch, true)
+		}
+		p = ch
 	}
+	return p
 }
 
-type dirNode struct {
-	nodefs.Node
-}
+var _ = (fs.NodeOnAdder)((*gitilesRoot)(nil))
 
-// Implement Utimens so we don't create spurious "not implemented"
-// messages when directory targets for symlinks are touched.
-func (n *dirNode) Utimens(file nodefs.File, atime *time.Time, mtime *time.Time, context *fuse.Context) (code fuse.Status) {
-	return fuse.OK
-}
-
-func (n *dirNode) GetAttr(out *fuse.Attr, file nodefs.File, context *fuse.Context) (code fuse.Status) {
-	out.Mode = fuse.S_IFDIR | 0755
-	t := time.Unix(1, 0)
-	out.SetTimes(nil, &t, nil)
-	return fuse.OK
-}
-
-func (n *dirNode) Deletable() bool {
-	return false
-}
-
-func newDirNode() nodefs.Node {
-	return &dirNode{nodefs.NewDefaultNode()}
-}
-
-func (r *gitilesRoot) pathTo(fsConn *nodefs.FileSystemConnector, dir string) *nodefs.Inode {
-	parent, left := fsConn.Node(r.Inode(), dir)
-	for _, l := range left {
-		ch := parent.NewChild(l, true, newDirNode())
-		parent = ch
-	}
-	return parent
-}
-
-func (r *gitilesRoot) onMount(fsConn *nodefs.FileSystemConnector) error {
+func (r *gitilesRoot) OnAdd(ctx context.Context) {
 	for _, e := range r.tree.Entries {
 		if e.Type == "commit" {
 			// TODO(hanwen): support submodules.  For now,
 			// we pretend we are plain git, which also
 			// leaves an empty directory in the place of a submodule.
-			r.pathTo(fsConn, e.Name)
+			r.pathTo(e.Name)
 			continue
 		}
 		if e.Type != "blob" {
@@ -401,10 +370,10 @@
 		p := e.Name
 		dir, base := filepath.Split(p)
 
-		parent := r.pathTo(fsConn, dir)
+		parent := r.pathTo(dir)
 		id, err := parseID(e.ID)
 		if err != nil {
-			return err
+			return
 		}
 
 		// Determine if file should trigger a clone.
@@ -422,7 +391,6 @@
 		n := r.nodeCache.get(id, xbit)
 		if n == nil {
 			n = &gitilesNode{
-				Node:  nodefs.NewDefaultNode(),
 				id:    *id,
 				mode:  uint32(e.Mode),
 				clone: clone,
@@ -436,35 +404,45 @@
 				n.size = int64(*e.Size)
 			}
 
+			mode := uint32(syscall.S_IFREG)
 			if e.Target != nil {
 				n.linkTarget = []byte(*e.Target)
 				n.size = int64(len(n.linkTarget))
+				mode = syscall.S_IFLNK
 			}
 
 			r.shaMap[*id] = p
-			parent.NewChild(base, false, n)
+
+			ch := parent.NewPersistentInode(ctx, n, fs.StableAttr{Mode: mode})
+			parent.AddChild(base, ch, true)
 			r.nodeCache.add(n)
 		} else {
-			parent.AddChild(base, n.Inode())
+			parent.AddChild(base, n.EmbeddedInode(), true)
 		}
 
 	}
 
-	slothfsNode := r.Inode().NewChild(".slothfs", true, newDirNode())
-	slothfsNode.NewChild("treeID", false, newDataNode([]byte(r.tree.ID)))
+	slothfsNode := r.NewPersistentInode(ctx, &fs.Inode{}, fs.StableAttr{Mode: syscall.S_IFDIR})
+	r.AddChild(".slothfs", slothfsNode, true)
+	idFile := r.NewPersistentInode(ctx, &fs.MemRegularFile{
+		Data: []byte(r.tree.ID)}, fs.StableAttr{Mode: syscall.S_IFREG})
+
+	slothfsNode.AddChild("treeID", idFile, false)
 
 	treeContent, err := json.MarshalIndent(r.tree, "", " ")
 	if err != nil {
 		log.Panicf("json.Marshal: %v", err)
 	}
+	jsonFile := r.NewPersistentInode(ctx, &fs.MemRegularFile{
+		Data: treeContent}, fs.StableAttr{Mode: syscall.S_IFREG})
 
-	slothfsNode.NewChild("tree.json", false, newDataNode([]byte(treeContent)))
+	slothfsNode.AddChild("tree.json", jsonFile, false)
 
 	// We don't need the tree data anymore.
 	r.tree = nil
 
-	if fsConn.Server().KernelSettings().Flags&fuse.CAP_NO_OPEN_SUPPORT != 0 {
-		r.handleLessIO = true
-	}
-	return nil
+	// XXX
+	//	if fsConn.Server().KernelSettings().Flags&fuse.CAP_NO_OPEN_SUPPORT != 0 {
+	//		r.handleLessIO = true
+	//	}
 }
diff --git a/fs/gitilesfs_test.go b/fs/gitilesfs_test.go
index f444292..ddac371 100644
--- a/fs/gitilesfs_test.go
+++ b/fs/gitilesfs_test.go
@@ -296,12 +296,12 @@
 		t.Fatal("mount", err)
 	}
 
-	ch1 := fs.Inode().GetChild("AUTHORS")
+	ch1 := fs.GetChild("AUTHORS")
 	if ch1 == nil {
 		t.Fatalf("node for AUTHORS not found")
 	}
 
-	ch2 := fs.Inode().GetChild("AUTHORS2")
+	ch2 := fs.GetChild("AUTHORS2")
 	if ch2 == nil {
 		t.Fatalf("node for AUTHORS2 not found")
 	}
@@ -309,7 +309,7 @@
 	if ch1 != ch2 {
 		t.Error("equal blobs did not share inodes.")
 	}
-	ch3 := fs.Inode().GetChild("AUTHORSx")
+	ch3 := fs.GetChild("AUTHORSx")
 	if ch1 == ch3 {
 		t.Error("blob with different modes shared inode.")
 	}
@@ -430,7 +430,7 @@
 	}
 
 	// TODO(hanwen): is this race-detector sane?
-	ch := fs.Inode().GetChild("testcase")
+	ch := fs.GetChild("testcase")
 	if ch == nil {
 		t.Fatalf("node for testcase/ not found")
 	}
@@ -439,9 +439,9 @@
 		t.Fatalf("node for addprefix.mk not found")
 	}
 
-	giNode, ok := ch.Node().(*gitilesNode)
+	giNode, ok := ch.Operations().(*gitilesNode)
 	if !ok {
-		t.Fatalf("got node type %T, want *gitilesNode", ch.Node())
+		t.Fatalf("got node type %T, want *gitilesNode", ch.Operations())
 	}
 
 	if giNode.clone {
@@ -477,14 +477,14 @@
 		}
 	}
 
-	ch := fs.Inode().GetChild("AUTHORS")
+	ch := fs.GetChild("AUTHORS")
 	if ch == nil {
 		t.Fatalf("node for AUTHORS not found")
 	}
 
-	giNode, ok := ch.Node().(*gitilesNode)
+	giNode, ok := ch.Operations().(*gitilesNode)
 	if !ok {
-		t.Fatalf("got node type %T, want *gitilesNode", ch.Node())
+		t.Fatalf("got node type %T, want *gitilesNode", ch.Operations())
 	}
 
 	if c := atomic.LoadUint32(&giNode.readCount); c != 1 {
diff --git a/fs/gitileshostfs.go b/fs/gitileshostfs.go
index 7c83e6d..b283831 100644
--- a/fs/gitileshostfs.go
+++ b/fs/gitileshostfs.go
@@ -15,18 +15,20 @@
 package fs
 
 import (
+	"context"
 	"fmt"
 	"path/filepath"
 	"sort"
 	"strings"
+	"syscall"
 
 	"github.com/google/slothfs/cache"
 	"github.com/google/slothfs/gitiles"
-	"github.com/hanwen/go-fuse/fuse/nodefs"
+	"github.com/hanwen/go-fuse/fs"
 )
 
 type hostFS struct {
-	nodefs.Node
+	fs.Inode
 
 	cache        *cache.Cache
 	service      *gitiles.Service
@@ -60,7 +62,6 @@
 	}
 
 	return &hostFS{
-		Node:         nodefs.NewDefaultNode(),
 		projects:     projMap,
 		cloneOptions: cloneOptions,
 		service:      service,
@@ -68,34 +69,38 @@
 	}, nil
 }
 
-func (h *hostFS) OnMount(fsConn *nodefs.FileSystemConnector) {
+var _ = (fs.NodeOnAdder)((*hostFS)(nil))
+
+func (h *hostFS) OnAdd(ctx context.Context) {
 	var keys []string
 	for k := range parents(h.projects) {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
-	nodes := map[string]*nodefs.Inode{
-		"": h.Inode(),
+	nodes := map[string]*fs.Inode{
+		"": h.EmbeddedInode(),
 	}
 
 	for _, k := range keys {
 		if k == "." {
 			continue
 		}
+		// XXX should loop ?
 		d, nm := filepath.Split(k)
 		d = strings.TrimSuffix(d, "/")
 		parent := nodes[d]
 
-		var node nodefs.Node
+		var node fs.InodeEmbedder
 		if p := h.projects[k]; p != nil {
 			node = h.newProjectNode(parent, p)
 			delete(h.projects, k)
-			node.OnMount(fsConn)
 		} else {
-			node = newDirNode()
+			node = &fs.Inode{}
 		}
-		ch := parent.NewChild(nm, true, node)
+
+		ch := parent.NewPersistentInode(ctx, node, fs.StableAttr{Mode: syscall.S_IFDIR})
+		parent.AddChild(nm, ch, true)
 		nodes[k] = ch
 	}
 
@@ -105,13 +110,13 @@
 
 		parent := nodes[d]
 		node := h.newProjectNode(parent, p)
-		node.OnMount(fsConn)
 
-		parent.NewChild(nm, true, node)
+		ch := parent.NewPersistentInode(ctx, node, fs.StableAttr{Mode: syscall.S_IFDIR})
+		parent.AddChild(nm, ch, true)
 	}
 }
 
-func (h *hostFS) newProjectNode(parent *nodefs.Inode, proj *gitiles.Project) nodefs.Node {
+func (h *hostFS) newProjectNode(parent *fs.Inode, proj *gitiles.Project) fs.InodeEmbedder {
 	repoService := h.service.NewRepoService(proj.Name)
 	opts := GitilesOptions{
 		CloneURL:    proj.CloneURL,