diff --git a/vtrace/format.go b/vtrace/format.go
index 8de9bdc..a6bc9c4 100644
--- a/vtrace/format.go
+++ b/vtrace/format.go
@@ -15,11 +15,11 @@
 
 const indentStep = "    "
 
-type children []*node
+type children []*Node
 
 // children implements sort.Interface
 func (c children) Len() int           { return len(c) }
-func (c children) Less(i, j int) bool { return c[i].span.Start.Before(c[j].span.Start) }
+func (c children) Less(i, j int) bool { return c[i].Span.Start.Before(c[j].Span.Start) }
 func (c children) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
 
 type annotations []Annotation
@@ -29,18 +29,18 @@
 func (a annotations) Less(i, j int) bool { return a[i].When.Before(a[j].When) }
 func (a annotations) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 
-type node struct {
-	span     *SpanRecord
-	children children
+type Node struct {
+	Span *SpanRecord
+	Children []*Node
 }
 
 // TODO(mattr): It is useful in general to make a tree of spans
 // for analysis as well as formatting.  This interface should
 // be cleaned up and exported.
-func buildTree(trace *TraceRecord) *node {
-	var root *node
+func BuildTree(trace *TraceRecord) *Node {
+	var root *Node
 	var earliestTime time.Time
-	nodes := make(map[uniqueid.Id]*node, len(trace.Spans))
+	nodes := make(map[uniqueid.Id]*Node, len(trace.Spans))
 
 	for i := range trace.Spans {
 		span := &trace.Spans[i]
@@ -50,38 +50,38 @@
 
 		n := nodes[span.Id]
 		if n == nil {
-			n = &node{}
+			n = &Node{}
 			nodes[span.Id] = n
 		}
 
-		n.span = span
+		n.Span = span
 
 		if span.Parent == trace.Id {
 			root = n
 		} else {
 			p := nodes[span.Parent]
 			if p == nil {
-				p = &node{}
+				p = &Node{}
 				nodes[span.Parent] = p
 			}
-			p.children = append(p.children, n)
+			p.Children = append(p.Children, n)
 		}
 	}
 
 	// Sort the children of each node in start-time order, and the
 	// annotation in time-order.
 	for _, node := range nodes {
-		sort.Sort(node.children)
-		if node.span != nil {
-			sort.Sort(annotations(node.span.Annotations))
+		sort.Sort(children(node.Children))
+		if node.Span != nil {
+			sort.Sort(annotations(node.Span.Annotations))
 		}
 	}
 
 	// If we didn't find the root span of the trace
 	// create a stand-in.
 	if root == nil {
-		root = &node{
-			span: &SpanRecord{
+		root = &Node{
+			Span: &SpanRecord{
 				Name:  "Missing Root Span",
 				Start: earliestTime,
 			},
@@ -92,10 +92,10 @@
 	// in the tree.  We invent fake "missing" spans to represent
 	// (perhaps several) layers of missing spans.  Then we add these as
 	// children of the root.
-	var missing []*node
+	var missing []*Node
 	for _, n := range nodes {
-		if n.span == nil {
-			n.span = &SpanRecord{
+		if n.Span == nil {
+			n.Span = &SpanRecord{
 				Name: "Missing Data",
 			}
 			missing = append(missing, n)
@@ -103,7 +103,7 @@
 	}
 
 	if len(missing) > 0 {
-		root.children = append(root.children, missing...)
+		root.Children = append(root.Children, missing...)
 	}
 
 	return root
@@ -116,20 +116,20 @@
 	return when.Sub(start).String()
 }
 
-func formatNode(w io.Writer, n *node, traceStart time.Time, indent string) {
+func formatNode(w io.Writer, n *Node, traceStart time.Time, indent string) {
 	fmt.Fprintf(w, "%sSpan - %s [id: %x parent %x] (%s, %s: %s)\n",
 		indent,
-		n.span.Name,
-		n.span.Id[12:],
-		n.span.Parent[12:],
-		formatDelta(n.span.Start, traceStart),
-		formatDelta(n.span.End, traceStart),
-		formatDelta(n.span.End, n.span.Start))
+		n.Span.Name,
+		n.Span.Id[12:],
+		n.Span.Parent[12:],
+		formatDelta(n.Span.Start, traceStart),
+		formatDelta(n.Span.End, traceStart),
+		formatDelta(n.Span.End, n.Span.Start))
 	indent += indentStep
-	for _, a := range n.span.Annotations {
+	for _, a := range n.Span.Annotations {
 		fmt.Fprintf(w, "%s@%s %s\n", indent, formatDelta(a.When, traceStart), a.Message)
 	}
-	for _, c := range n.children {
+	for _, c := range n.Children {
 		formatNode(w, c, traceStart, indent)
 	}
 }
@@ -148,13 +148,13 @@
 // given writer.  Times will be formatted according to the given
 // location, if loc is nil local times will be used.
 func FormatTrace(w io.Writer, record *TraceRecord, loc *time.Location) {
-	if root := buildTree(record); root != nil {
+	if root := BuildTree(record); root != nil {
 		fmt.Fprintf(w, "Trace - %s (%s, %s)\n",
 			record.Id,
-			formatTime(root.span.Start, loc),
-			formatTime(root.span.End, loc))
-		for _, c := range root.children {
-			formatNode(w, c, root.span.Start, indentStep)
+			formatTime(root.Span.Start, loc),
+			formatTime(root.Span.End, loc))
+		for _, c := range root.Children {
+			formatNode(w, c, root.Span.Start, indentStep)
 		}
 	}
 }