diff --git a/syncbase/watch_stream.go b/syncbase/watch_stream.go
index 15cb28b..ff23b8f 100644
--- a/syncbase/watch_stream.go
+++ b/syncbase/watch_stream.go
@@ -6,14 +6,12 @@
 
 import (
 	"fmt"
-	"reflect"
 	"sync"
 
 	"v.io/v23/context"
 	wire "v.io/v23/services/syncbase"
 	"v.io/v23/services/watch"
 	"v.io/v23/syncbase/util"
-	"v.io/v23/vdl"
 	"v.io/v23/verror"
 )
 
@@ -106,12 +104,8 @@
 	}
 	// Parse the store change.
 	var storeChange wire.StoreChange
-	rtarget, err := vdl.ReflectTarget(reflect.ValueOf(&storeChange))
-	if err != nil {
-		panic(err)
-	}
-	if err := c.Value.FillVDLTarget(rtarget, c.Value.Type); err != nil {
-		panic(err)
+	if err := c.Value.ToValue(&storeChange); err != nil {
+		panic(fmt.Errorf("ToValue failed: %v, RawBytes: %#v", err, c.Value))
 	}
 	// Parse the state.
 	var changeType ChangeType
diff --git a/vdl/target.go b/vdl/target.go
index cc9af88..f2e300c 100644
--- a/vdl/target.go
+++ b/vdl/target.go
@@ -132,7 +132,7 @@
 // ReflectTarget(reflect.ValueOf(dst)).FromReflect(reflect.ValueOf(src)).
 func Convert(dst, src interface{}) error {
 	// TODO(bprosnitz) Flip useOldConvert=false to enable the new convert.
-	const useOldConvert = true
+	const useOldConvert = false
 	if useOldConvert {
 		target, err := ReflectTarget(reflect.ValueOf(dst))
 		if err != nil {
@@ -155,7 +155,7 @@
 
 // ValueFromReflect returns the value corresponding to rv.
 func ValueFromReflect(rv reflect.Value) (*Value, error) {
-	const useOldConvert = true
+	const useOldConvert = false
 	if useOldConvert {
 		var result *Value
 		target, err := ReflectTarget(reflect.ValueOf(&result))
diff --git a/vom/.api b/vom/.api
index a98f599..4376a6d 100644
--- a/vom/.api
+++ b/vom/.api
@@ -55,19 +55,16 @@
 pkg vom, func NewVersionedEncoder(Version, io.Writer) *Encoder
 pkg vom, func NewVersionedEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *Encoder
 pkg vom, func NewVersionedTypeEncoder(Version, io.Writer) *TypeEncoder
-pkg vom, func NewVersionedXEncoder(Version, io.Writer) *XEncoder
-pkg vom, func NewVersionedXEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *XEncoder
-pkg vom, func NewXDecoder(io.Reader) *XDecoder
-pkg vom, func NewXDecoderWithTypeDecoder(io.Reader, *TypeDecoder) *XDecoder
-pkg vom, func NewXEncoder(io.Writer) *XEncoder
-pkg vom, func NewXEncoderWithTypeEncoder(io.Writer, *TypeEncoder) *XEncoder
+pkg vom, func NewVersionedZEncoder(Version, io.Writer) *ZEncoder
+pkg vom, func NewVersionedZEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *ZEncoder
+pkg vom, func NewZDecoder(io.Reader) *ZDecoder
+pkg vom, func NewZDecoderWithTypeDecoder(io.Reader, *TypeDecoder) *ZDecoder
+pkg vom, func NewZEncoder(io.Writer) *ZEncoder
+pkg vom, func NewZEncoderWithTypeEncoder(io.Writer, *TypeEncoder) *ZEncoder
 pkg vom, func RawBytesFromValue(interface{}) (*RawBytes, error)
 pkg vom, func RawBytesOf(interface{}) *RawBytes
 pkg vom, func VDLReadPrimitive(vdl.Decoder, *Primitive) error
 pkg vom, func VersionedEncode(Version, interface{}) ([]byte, error)
-pkg vom, func VersionedXEncode(Version, interface{}) ([]byte, error)
-pkg vom, func XDecode([]byte, interface{}) error
-pkg vom, func XEncode(interface{}) ([]byte, error)
 pkg vom, func XRawBytesFromValue(interface{}) (*RawBytes, error)
 pkg vom, method (*ControlKind) FillVDLTarget(vdl.Target, *vdl.Type) error
 pkg vom, method (*ControlKind) MakeVDLTarget() vdl.Target
@@ -75,6 +72,7 @@
 pkg vom, method (*ControlKind) VDLRead(vdl.Decoder) error
 pkg vom, method (*ControlKindTarget) FromEnumLabel(string, *vdl.Type) error
 pkg vom, method (*Decoder) Decode(interface{}) error
+pkg vom, method (*Decoder) Decoder() vdl.Decoder
 pkg vom, method (*Decoder) Ignore() error
 pkg vom, method (*DumpAtom) FillVDLTarget(vdl.Target, *vdl.Type) error
 pkg vom, method (*DumpAtom) MakeVDLTarget() vdl.Target
@@ -94,6 +92,7 @@
 pkg vom, method (*Dumper) Status()
 pkg vom, method (*Dumper) Write([]byte) (int, error)
 pkg vom, method (*Encoder) Encode(interface{}) error
+pkg vom, method (*Encoder) Encoder() vdl.Encoder
 pkg vom, method (*PrimitiveTarget) FinishField(vdl.Target, vdl.Target) error
 pkg vom, method (*PrimitiveTarget) FinishFields(vdl.FieldsTarget) error
 pkg vom, method (*PrimitiveTarget) StartField(string) (vdl.Target, vdl.Target, error)
@@ -122,11 +121,9 @@
 pkg vom, method (*VersionTarget) FromFloat(float64, *vdl.Type) error
 pkg vom, method (*VersionTarget) FromInt(int64, *vdl.Type) error
 pkg vom, method (*VersionTarget) FromUint(uint64, *vdl.Type) error
-pkg vom, method (*XDecoder) Decode(interface{}) error
-pkg vom, method (*XDecoder) Decoder() vdl.Decoder
-pkg vom, method (*XDecoder) Ignore() error
-pkg vom, method (*XEncoder) Encode(interface{}) error
-pkg vom, method (*XEncoder) Encoder() vdl.Encoder
+pkg vom, method (*ZDecoder) Decode(interface{}) error
+pkg vom, method (*ZDecoder) Ignore() error
+pkg vom, method (*ZEncoder) Encode(interface{}) error
 pkg vom, method (ControlKind) String() string
 pkg vom, method (ControlKind) VDLIsZero() bool
 pkg vom, method (ControlKind) VDLWrite(vdl.Encoder) error
@@ -265,7 +262,7 @@
 pkg vom, type VersionTarget struct
 pkg vom, type VersionTarget struct, Value *Version
 pkg vom, type VersionTarget struct, embedded vdl.TargetBase
-pkg vom, type XDecoder struct
-pkg vom, type XEncoder struct
+pkg vom, type ZDecoder struct
+pkg vom, type ZEncoder struct
 pkg vom, var ControlKindAll [...]ControlKind
 pkg vom, var DumpKindAll [...]DumpKind
diff --git a/vom/binary_util.go b/vom/binary_util.go
index 22bd8b4..196cc8f 100644
--- a/vom/binary_util.go
+++ b/vom/binary_util.go
@@ -13,7 +13,7 @@
 )
 
 // TODO(toddw) Reduce the number of functions and optimize.
-const pkgPath = "v.io/v23/vom3"
+const pkgPath = "v.io/v23/vom"
 
 var (
 	errInvalid                = verror.Register(pkgPath+".errInvalid", verror.NoRetry, "{1:}{2:} vom: invalid encoding{:_}")
diff --git a/vom/convert_test.go b/vom/convert_test.go
index 961901b..06ffb52 100644
--- a/vom/convert_test.go
+++ b/vom/convert_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build newvdltests
-
 package vom_test
 
 import (
@@ -105,12 +103,12 @@
 
 func testConvertCoder(target, source interface{}) error {
 	var buf bytes.Buffer
-	enc := vom.NewXEncoder(&buf)
+	enc := vom.NewEncoder(&buf)
 	if err := enc.Encode(source); err != nil {
 		return fmt.Errorf("Encode failed: %v", err)
 	}
 	data := buf.Bytes()
-	dec := vom.NewXDecoder(&buf)
+	dec := vom.NewDecoder(&buf)
 	if err := dec.Decode(target); err != nil {
 		return fmt.Errorf("Decode failed: %v\nDATA %x", err, data)
 	}
@@ -118,11 +116,11 @@
 }
 
 func testConvertSingleShot(target, source interface{}) error {
-	data, err := vom.XEncode(source)
+	data, err := vom.Encode(source)
 	if err != nil {
 		return fmt.Errorf("(single-shot) Encode failed: %v", err)
 	}
-	if err := vom.XDecode(data, target); err != nil {
+	if err := vom.Decode(data, target); err != nil {
 		return fmt.Errorf("(single-shot) Decode failed: %v\nDATA %x", err, data)
 	}
 	return nil
@@ -130,12 +128,12 @@
 
 func testConvertWithTypeCoder(target, source interface{}, encT *vom.TypeEncoder, decT *vom.TypeDecoder) error {
 	var buf bytes.Buffer
-	enc := vom.NewXEncoderWithTypeEncoder(&buf, encT)
+	enc := vom.NewEncoderWithTypeEncoder(&buf, encT)
 	if err := enc.Encode(source); err != nil {
 		return fmt.Errorf("(with TypeEncoder) Encode failed: %v", err)
 	}
 	data := buf.Bytes()
-	dec := vom.NewXDecoderWithTypeDecoder(&buf, decT)
+	dec := vom.NewDecoderWithTypeDecoder(&buf, decT)
 	if err := dec.Decode(target); err != nil {
 		return fmt.Errorf("(with TypeDecoder) Decode failed: %v\nDATA %x", err, data)
 	}
diff --git a/vom/decoder.go b/vom/decoder.go
index 161860e..d841305 100644
--- a/vom/decoder.go
+++ b/vom/decoder.go
@@ -25,9 +25,9 @@
 	errInvalidAnyIndex          = verror.Register(pkgPath+".errInvalidAnyIndex", verror.NoRetry, "{1:}{2:} vom: value referenced invalid index into anyLen table {:_}")
 )
 
-// Decoder manages the receipt and unmarshalling of typed values from the other
+// ZDecoder manages the receipt and unmarshalling of typed values from the other
 // side of a connection.
-type Decoder struct {
+type ZDecoder struct {
 	typeDec *TypeDecoder
 
 	hasSeparateTypeDec bool // TODO(bprosnitz) This should probably be removed.
@@ -48,26 +48,26 @@
 	return io.TeeReader(r, NewDumper(NewDumpWriter(os.Stdout)))
 }
 
-// NewDecoder returns a new Decoder that reads from the given reader. The
-// Decoder understands all formats generated by the Encoder.
-func NewDecoder(r io.Reader) *Decoder {
+// NewZDecoder returns a new ZDecoder that reads from the given reader. The
+// ZDecoder understands all formats generated by the Encoder.
+func NewZDecoder(r io.Reader) *ZDecoder {
 	// When the TypeDecoder isn't shared, we always decode type messages in
 	// Decoder.decodeValueType() and feed them to the TypeDecoder. That is,
 	// the TypeDecoder will never read messages from the buffer. So we pass
 	// a nil buffer to newTypeDecoder.
 	buf := newDecbuf(r)
 	typeDec := newTypeDecoderInternal(buf)
-	return &Decoder{
+	return &ZDecoder{
 		buf:                buf,
 		typeDec:            typeDec,
 		hasSeparateTypeDec: false,
 	}
 }
 
-// NewDecoderWithTypeDecoder returns a new Decoder that reads from the given
+// NewZDecoderWithTypeDecoder returns a new Decoder that reads from the given
 // reader. Types will be decoded separately through the given typeDec.
-func NewDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *Decoder {
-	return &Decoder{
+func NewZDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *ZDecoder {
+	return &ZDecoder{
 		buf:                newDecbuf(r),
 		typeDec:            typeDec,
 		hasSeparateTypeDec: true,
@@ -89,7 +89,7 @@
 // subsequently passed to an Encoder for transcoding.
 //
 // Decode(nil) always returns an error.  Use Ignore() to ignore the next value.
-func (d *Decoder) Decode(v interface{}) error {
+func (d *ZDecoder) Decode(v interface{}) error {
 	if v == nil {
 		return verror.New(errDecodeNil, nil)
 	}
@@ -100,7 +100,7 @@
 	return d.decodeToTarget(target)
 }
 
-func (d *Decoder) decodeTypeDefs() error {
+func (d *ZDecoder) decodeTypeDefs() error {
 	if !d.hasSeparateTypeDec {
 		for {
 			typeNext, err := d.typeIsNext()
@@ -118,7 +118,7 @@
 	return nil
 }
 
-func (d *Decoder) decodeToTarget(target vdl.Target) error {
+func (d *ZDecoder) decodeToTarget(target vdl.Target) error {
 	if err := d.decodeTypeDefs(); err != nil {
 		return err
 	}
@@ -149,7 +149,7 @@
 }
 
 // Ignore ignores the next value from the reader.
-func (d *Decoder) Ignore() error {
+func (d *ZDecoder) Ignore() error {
 	if err := d.decodeTypeDefs(); err != nil {
 		return err
 	}
@@ -174,7 +174,7 @@
 
 // decodeWireType decodes the next type definition message and returns its
 // type id.
-func (d *Decoder) decodeWireType(wt *wireType) (TypeId, error) {
+func (d *ZDecoder) decodeWireType(wt *wireType) (TypeId, error) {
 	tid, err := d.nextMessage()
 	if err != nil {
 		return 0, err
@@ -191,7 +191,7 @@
 }
 
 // peekValueByteLen returns the byte length of the next value.
-func (d *Decoder) peekValueByteLen(tt *vdl.Type) (int, error) {
+func (d *ZDecoder) peekValueByteLen(tt *vdl.Type) (int, error) {
 	if hasChunkLen(tt) {
 		// Use the explicit message length.
 		return d.buf.lim, nil
@@ -223,7 +223,7 @@
 	}
 }
 
-func (d *Decoder) decodeRaw(tt *vdl.Type, valLen int, raw *RawBytes) error {
+func (d *ZDecoder) decodeRaw(tt *vdl.Type, valLen int, raw *RawBytes) error {
 	raw.Version = d.buf.version
 	raw.Type = tt
 	raw.Data = make([]byte, valLen)
@@ -250,7 +250,7 @@
 	HackGetRv() reflect.Value
 }
 
-func (d *Decoder) tryDecodeRaw(tt *vdl.Type, valLen int, rv reflect.Value) (isRawBytes bool, _ error) {
+func (d *ZDecoder) tryDecodeRaw(tt *vdl.Type, valLen int, rv reflect.Value) (isRawBytes bool, _ error) {
 	// Dereference pointers down to at most one remaining *.
 	for rv.IsValid() && rv.Kind() == reflect.Ptr && rv.Elem().IsValid() && rv.Elem().Kind() == reflect.Ptr {
 		rv = rv.Elem()
@@ -274,7 +274,7 @@
 }
 
 // decodeValue decodes the rest of the message assuming type tt.
-func (d *Decoder) decodeValue(tt *vdl.Type, target vdl.Target) error {
+func (d *ZDecoder) decodeValue(tt *vdl.Type, target vdl.Target) error {
 	ttFrom := tt
 	if tt.Kind() == vdl.Optional {
 		// If the type is optional, we expect to see either WireCtrlNil or the actual
@@ -548,7 +548,7 @@
 	}
 }
 
-func (d *Decoder) readAnyHeader() (*vdl.Type, int, error) {
+func (d *ZDecoder) readAnyHeader() (*vdl.Type, int, error) {
 	// Read either WireCtrlNil or the index of the referenced type id.
 	typeIndex, ctrl, err := binaryDecodeUintWithControl(d.buf)
 	switch {
@@ -587,7 +587,7 @@
 
 // ignoreValue ignores the rest of the value of type t. This is used to ignore
 // unknown struct fields.
-func (d *Decoder) ignoreValue(tt *vdl.Type) error {
+func (d *ZDecoder) ignoreValue(tt *vdl.Type) error {
 	// TODO(toddw): How about ignoring optional values?
 	if tt.IsBytes() {
 		len, err := binaryDecodeLenOrArrayLen(d.buf, tt)
@@ -686,7 +686,7 @@
 	}
 }
 
-func (d *Decoder) nextMessage() (TypeId, error) {
+func (d *ZDecoder) nextMessage() (TypeId, error) {
 	if leftover := d.buf.RemoveLimit(); leftover > 0 {
 		return 0, verror.New(errLeftOverBytes, nil, leftover)
 	}
@@ -787,7 +787,7 @@
 	return tid, nil
 }
 
-func (d *Decoder) typeIsNext() (bool, error) {
+func (d *ZDecoder) typeIsNext() (bool, error) {
 	if d.buf.version == 0 {
 		version, err := d.buf.ReadByte()
 		if err != nil {
@@ -805,7 +805,7 @@
 	return mid < 0 || cr == WireCtrlTypeIncomplete, nil
 }
 
-func (d *Decoder) endMessage() error {
+func (d *ZDecoder) endMessage() error {
 	if leftover := d.buf.RemoveLimit(); leftover > 0 {
 		return verror.New(errLeftOverBytes, nil, leftover)
 	}
@@ -818,7 +818,7 @@
 	return nil
 }
 
-func (d *Decoder) reset() error {
+func (d *ZDecoder) reset() error {
 	return nil
 }
 
diff --git a/vom/encoder.go b/vom/encoder.go
index 16e1419..fa3afcf 100644
--- a/vom/encoder.go
+++ b/vom/encoder.go
@@ -53,9 +53,9 @@
 	_ vdl.FieldsTarget = (*encoder)(nil)
 )
 
-// Encoder manages the transmission and marshaling of typed values to the other
+// ZEncoder manages the transmission and marshaling of typed values to the other
 // side of a connection.
-type Encoder struct {
+type ZEncoder struct {
 	// The underlying implementation is hidden to avoid exposing the Target
 	// interface methods.
 	enc encoder
@@ -90,34 +90,34 @@
 	anyStartRef *anyStartRef // only non-nil for any
 }
 
-// NewEncoder returns a new Encoder that writes to the given writer in the
+// NewZEncoder returns a new Encoder that writes to the given writer in the
 // binary format. The binary format is compact and fast.
-func NewEncoder(w io.Writer) *Encoder {
-	return NewVersionedEncoder(DefaultVersion, w)
+func NewZEncoder(w io.Writer) *ZEncoder {
+	return NewVersionedZEncoder(DefaultVersion, w)
 }
 
-// NewVersionedEncoder returns a new Encoder that writes to the given writer with
+// NewVersionedZEncoder returns a new Encoder that writes to the given writer with
 // the specified VOM version.
-func NewVersionedEncoder(version Version, w io.Writer) *Encoder {
-	typeEnc := newTypeEncoderInternal(version, newXEncoderForTypes(version, w))
-	return NewVersionedEncoderWithTypeEncoder(version, w, typeEnc)
+func NewVersionedZEncoder(version Version, w io.Writer) *ZEncoder {
+	typeEnc := newTypeEncoderInternal(version, newEncoderForTypes(version, w))
+	return NewVersionedZEncoderWithTypeEncoder(version, w, typeEnc)
 }
 
-// NewEncoderWithTypeEncoder returns a new Encoder that writes to the given
+// NewZEncoderWithTypeEncoder returns a new ZEncoder that writes to the given
 // writer in the binary format. Types will be encoded separately through the
 // given typeEncoder.
-func NewEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *Encoder {
-	return NewVersionedEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
+func NewZEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *ZEncoder {
+	return NewVersionedZEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
 }
 
-// NewVersionedEncoderWithTypeEncoder returns a new Encoder that writes to the given
+// NewVersionedZEncoderWithTypeEncoder returns a new ZEncoder that writes to the given
 // writer in the binary format. Types will be encoded separately through the
 // given typeEncoder.
-func NewVersionedEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *Encoder {
+func NewVersionedZEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *ZEncoder {
 	if !isAllowedVersion(version) {
 		panic(fmt.Sprintf("unsupported VOM version: %x", version))
 	}
-	return &Encoder{encoder{
+	return &ZEncoder{encoder{
 		writer:          w,
 		buf:             newEncbuf(),
 		typeStack:       make([]typeStackEntry, 0, 10),
@@ -140,7 +140,7 @@
 //
 // Encode(nil) is a special case that encodes the zero value of the any type.
 // See the discussion of zero values in the Value documentation.
-func (e *Encoder) Encode(v interface{}) error {
+func (e *ZEncoder) Encode(v interface{}) error {
 	if e.enc.version == Version80 {
 		return verror.New(errDeprecatedVersionUsed, nil)
 	}
diff --git a/vom/new_raw_bytes_test.go b/vom/new_raw_bytes_test.go
index 8c17d6e..3631218 100644
--- a/vom/new_raw_bytes_test.go
+++ b/vom/new_raw_bytes_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build newvdltests
-
 package vom_test
 
 import (
@@ -23,7 +21,7 @@
 		// Interleaved
 		rb := vom.RawBytes{}
 		interleavedReader := bytes.NewReader(test.Bytes())
-		if err := vom.NewXDecoder(interleavedReader).Decode(&rb); err != nil {
+		if err := vom.NewDecoder(interleavedReader).Decode(&rb); err != nil {
 			t.Errorf("%s: decode failed: %v", test.Name(), err)
 			continue
 		}
@@ -33,7 +31,7 @@
 		}
 
 		var out bytes.Buffer
-		enc := vom.NewVersionedXEncoder(test.Version, &out)
+		enc := vom.NewVersionedEncoder(test.Version, &out)
 		if err := enc.Encode(&rb); err != nil {
 			t.Errorf("%s: encode failed: %v\nRawBytes: %v", test.Name(), err, rb)
 			continue
@@ -49,7 +47,7 @@
 		typeDec.Start()
 		defer typeDec.Stop()
 		valueReader := bytes.NewReader(test.ValueBytes())
-		if err := vom.NewXDecoderWithTypeDecoder(valueReader, typeDec).Decode(&rb); err != nil {
+		if err := vom.NewDecoderWithTypeDecoder(valueReader, typeDec).Decode(&rb); err != nil {
 			t.Errorf("%s: decode failed: %v", test.Name(), err)
 			continue
 		}
@@ -65,7 +63,7 @@
 		out.Reset()
 		var typeOut bytes.Buffer
 		typeEnc := vom.NewVersionedTypeEncoder(test.Version, &typeOut)
-		enc = vom.NewVersionedXEncoderWithTypeEncoder(test.Version, &out, typeEnc)
+		enc = vom.NewVersionedEncoderWithTypeEncoder(test.Version, &out, typeEnc)
 		if err := enc.Encode(&rb); err != nil {
 			t.Errorf("%s: encode failed: %v\nRawBytes: %v", test.Name(), err, rb)
 			continue
@@ -123,7 +121,7 @@
 func TestXRawBytesWriter(t *testing.T) {
 	for _, test := range vomtest.AllPass() {
 		var buf bytes.Buffer
-		enc := vom.NewXEncoder(&buf)
+		enc := vom.NewEncoder(&buf)
 		rb, err := vom.XRawBytesFromValue(test.Value.Interface())
 		if err != nil {
 			t.Errorf("%s: XRawBytesFromValue failed: %v", test.Name(), err)
diff --git a/vom/new_transcode_test.go b/vom/new_transcode_test.go
index 2be0494..9c00e7d 100644
--- a/vom/new_transcode_test.go
+++ b/vom/new_transcode_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build newvdltests
-
 package vom_test
 
 import (
@@ -18,8 +16,8 @@
 func TestTranscodeXDecoderToXEncoder(t *testing.T) {
 	for _, test := range vomtest.AllPass() {
 		var buf bytes.Buffer
-		enc := vom.NewVersionedXEncoder(test.Version, &buf)
-		dec := vom.NewXDecoder(bytes.NewReader(test.Bytes()))
+		enc := vom.NewVersionedEncoder(test.Version, &buf)
+		dec := vom.NewDecoder(bytes.NewReader(test.Bytes()))
 		if err := vdl.Transcode(enc.Encoder(), dec.Decoder()); err != nil {
 			t.Errorf("%s: Transcode failed: %v", test.Name(), err)
 			continue
@@ -34,7 +32,7 @@
 func TestTranscodeVDLValueToXEncoder(t *testing.T) {
 	for _, test := range vomtest.AllPass() {
 		var buf bytes.Buffer
-		enc := vom.NewXEncoder(&buf)
+		enc := vom.NewEncoder(&buf)
 		if err := vdl.Write(enc.Encoder(), test.Value.Interface()); err != nil {
 			t.Errorf("%s: vdl.Write failed: %v", test.Name(), err)
 			continue
diff --git a/vom/raw_bytes.go b/vom/raw_bytes.go
index 913f928..233eb57 100644
--- a/vom/raw_bytes.go
+++ b/vom/raw_bytes.go
@@ -52,12 +52,12 @@
 // TODO(toddw): Remove this function after we've switched to XEncoder and
 // XDecoder, and thus it's no longer needed.
 func XRawBytesFromValue(value interface{}) (*RawBytes, error) {
-	data, err := VersionedXEncode(DefaultVersion, value)
+	data, err := VersionedEncode(DefaultVersion, value)
 	if err != nil {
 		return nil, err
 	}
 	rb := new(RawBytes)
-	if err := XDecode(data, rb); err != nil {
+	if err := Decode(data, rb); err != nil {
 		return nil, err
 	}
 	return rb, nil
@@ -114,11 +114,11 @@
 		return vdl.FromValue(target, vdl.ZeroValue(vdl.AnyType))
 	}
 	var buf bytes.Buffer
-	enc := NewVersionedEncoder(rb.Version, &buf)
+	enc := NewVersionedZEncoder(rb.Version, &buf)
 	if err := enc.enc.encodeRaw(rb); err != nil {
 		return err
 	}
-	dec := NewDecoder(bytes.NewReader(buf.Bytes()))
+	dec := NewZDecoder(bytes.NewReader(buf.Bytes()))
 	return dec.decodeToTarget(target)
 }
 
@@ -133,7 +133,7 @@
 }
 
 func (rb *RawBytes) Decoder() vdl.Decoder {
-	dec := NewDecoder(bytes.NewReader(rb.Data))
+	dec := NewZDecoder(bytes.NewReader(rb.Data))
 	dec.buf.version = rb.Version
 	dec.refTypes.tids = make([]TypeId, len(rb.RefTypes))
 	for i, refType := range rb.RefTypes {
@@ -235,7 +235,7 @@
 	}
 
 	r.buf = bytes.NewBuffer(nil)
-	e := NewEncoder(r.buf)
+	e := NewZEncoder(r.buf)
 	r.enc = &e.enc
 	if _, err := r.enc.writer.Write([]byte{byte(r.enc.version)}); err != nil {
 		return err
diff --git a/vom/raw_bytes_test.go b/vom/raw_bytes_test.go
index a8e937f..0bd4016 100644
--- a/vom/raw_bytes_test.go
+++ b/vom/raw_bytes_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build !newvdltests
-
 package vom
 
 import (
@@ -462,10 +460,10 @@
 	for _, test := range rawBytesTestCases {
 		var rb *RawBytes
 		if err := vdl.Convert(&rb, test.goValue); err != nil {
-			t.Errorf("vdl.Convert %#v to RawBytes: %v", test.goValue, err)
+			t.Errorf("%s: Convert failed: %v", test.name, err)
 		}
-		if !reflect.DeepEqual(rb, &test.rawBytes) {
-			t.Errorf("vdl.Convert to RawBytes %s: got %v, want %v", test.name, rb, test.rawBytes)
+		if got, want := rb, &test.rawBytes; !reflect.DeepEqual(got, want) {
+			t.Errorf("%s\nGOT  %v\nWANT %v", test.name, got, want)
 		}
 	}
 }
@@ -477,12 +475,13 @@
 func TestConvertRawBytesWrapped(t *testing.T) {
 	for _, test := range rawBytesTestCases {
 		var any structAny
-		if err := vdl.Convert(&any, structAnyInterface{test.goValue}); err != nil {
-			t.Errorf("vdl.Convert %#v to RawBytes: %v", structAnyInterface{test.goValue}, err)
+		src := structAnyInterface{test.goValue}
+		if err := vdl.Convert(&any, src); err != nil {
+			t.Errorf("%s: Convert failed: %v", test.name, err)
 		}
 		got, want := any, structAny{&test.rawBytes}
 		if !reflect.DeepEqual(got, want) {
-			t.Errorf("vdl.Convert to RawBytes %s: got %v, want %v", test.name, got, want)
+			t.Errorf("%s\nGOT  %v\nWANT %v", test.name, got, want)
 		}
 	}
 }
@@ -647,7 +646,7 @@
 		}
 
 		var buf bytes.Buffer
-		enc := NewXEncoder(&buf)
+		enc := NewEncoder(&buf)
 		if err := RawBytesOf(test.Value).VDLWrite(enc.Encoder()); err != nil {
 			t.Errorf("%s: error in transcode: %v", test.Name, err)
 			continue
diff --git a/vom/single_shot.go b/vom/single_shot.go
index 14fb247..5838351 100644
--- a/vom/single_shot.go
+++ b/vom/single_shot.go
@@ -21,10 +21,6 @@
 	return VersionedEncode(DefaultVersion, v)
 }
 
-func XEncode(v interface{}) ([]byte, error) {
-	return VersionedXEncode(DefaultVersion, v)
-}
-
 // VersionedEncode performs single-shot encoding to a specific version of VOM
 func VersionedEncode(version Version, v interface{}) ([]byte, error) {
 	var buf bytes.Buffer
@@ -34,14 +30,6 @@
 	return buf.Bytes(), nil
 }
 
-func VersionedXEncode(version Version, v interface{}) ([]byte, error) {
-	var buf bytes.Buffer
-	if err := NewVersionedXEncoder(version, &buf).Encode(v); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
 // Decode reads the value from the given data, and stores it in value v.  The
 // semantics of value decoding are described by Decoder.Decode.
 //
@@ -75,49 +63,8 @@
 	}
 	// Decode the value message.
 	decoder := &Decoder{
-		buf:     buf,
-		typeDec: typeDec,
-	}
-	if err := decoder.Decode(v); err != nil {
-		return err
-	}
-	// Populate the typeDecoder cache for future re-use.
-	if cacheMiss {
-		singleShotTypeDecoderCache.insert(key, typeDec)
-	}
-	return nil
-}
-
-func XDecode(data []byte, v interface{}) error {
-	// The implementation below corresponds (logically) to the following:
-	//   return NewDecoder(bytes.NewReader(data)).Decode(valptr)
-	//
-	// However decoding type messages is expensive, so we cache typeDecoders to
-	// skip the decoding in the common case.
-	key, err := computeTypeDecoderCacheKey(data)
-	if err != nil {
-		return err
-	}
-	var buf *decbuf
-	typeDec := singleShotTypeDecoderCache.lookup(key)
-	cacheMiss := false
-	if typeDec == nil {
-		// Cache miss; start decoding at the beginning of all type messages with a
-		// new TypeDecoder.
-		cacheMiss = true
-		buf = newDecbufFromBytes(data)
-		typeDec = newTypeDecoderInternal(buf)
-	} else {
-		version := Version(data[0])
-		data = data[len(key):] // skip the already-read types
-		buf = newDecbufFromBytes(data)
-		buf.version = version
-		typeDec = newDerivedTypeDecoderInternal(buf, typeDec)
-	}
-	// Decode the value message.
-	decoder := &XDecoder{
 		xDecoder{
-			old: &Decoder{
+			old: &ZDecoder{
 				buf:     buf,
 				typeDec: typeDec,
 			},
diff --git a/vom/transcode_test.go b/vom/transcode_test.go
index db81063..a91bafb 100644
--- a/vom/transcode_test.go
+++ b/vom/transcode_test.go
@@ -38,8 +38,8 @@
 
 		inBytes := hex2Bin(t, test.Hex)
 		var buf bytes.Buffer
-		enc := NewXEncoder(&buf)
-		dec := NewXDecoder(bytes.NewReader(inBytes))
+		enc := NewEncoder(&buf)
+		dec := NewDecoder(bytes.NewReader(inBytes))
 		if err := vdl.Transcode(enc.Encoder(), dec.Decoder()); err != nil {
 			t.Errorf("%s: error in transcode: %v", test.Name, err)
 			continue
@@ -59,7 +59,7 @@
 		}
 
 		var buf bytes.Buffer
-		enc := NewXEncoder(&buf)
+		enc := NewEncoder(&buf)
 		if err := test.Value.VDLWrite(enc.Encoder()); err != nil {
 			t.Errorf("%s: error in transcode: %v", test.Name, err)
 			continue
diff --git a/vom/type_decoder.go b/vom/type_decoder.go
index 44e868c..2d1968a 100644
--- a/vom/type_decoder.go
+++ b/vom/type_decoder.go
@@ -52,7 +52,7 @@
 	td := &TypeDecoder{
 		idToType: make(map[TypeId]*vdl.Type),
 		idToWire: make(map[TypeId]wireType),
-		dec:      &xDecoder{old: &Decoder{buf: buf}},
+		dec:      &xDecoder{old: &ZDecoder{buf: buf}},
 	}
 	td.buildCond = sync.NewCond(&td.buildMu)
 	return td
@@ -62,7 +62,7 @@
 	td := &TypeDecoder{
 		idToType: orig.idToType,
 		idToWire: orig.idToWire,
-		dec:      &xDecoder{old: &Decoder{buf: buf}},
+		dec:      &xDecoder{old: &ZDecoder{buf: buf}},
 	}
 	td.buildCond = sync.NewCond(&td.buildMu)
 	return td
diff --git a/vom/type_encoder.go b/vom/type_encoder.go
index 432334c..f1cc801 100644
--- a/vom/type_encoder.go
+++ b/vom/type_encoder.go
@@ -42,7 +42,7 @@
 	return &TypeEncoder{
 		typeToId:        make(map[*vdl.Type]TypeId),
 		nextId:          WireIdFirstUserType,
-		enc:             newXEncoderForTypes(version, w),
+		enc:             newEncoderForTypes(version, w),
 		sentVersionByte: false,
 	}
 }
diff --git a/vom/xdecoder.go b/vom/xdecoder.go
index e44851e..494c7cf 100644
--- a/vom/xdecoder.go
+++ b/vom/xdecoder.go
@@ -35,12 +35,12 @@
 
 // Decoder manages the receipt and unmarshalling of typed values from the other
 // side of a connection.
-type XDecoder struct {
+type Decoder struct {
 	dec xDecoder
 }
 
 type xDecoder struct {
-	old                  *Decoder
+	old                  *ZDecoder
 	stack                []decoderStackEntry
 	ignoreNextStartValue bool
 }
@@ -56,36 +56,36 @@
 
 // NewDecoder returns a new Decoder that reads from the given reader.  The
 // Decoder understands all formats generated by the Encoder.
-func NewXDecoder(r io.Reader) *XDecoder {
-	return &XDecoder{xDecoder{
-		old: NewDecoder(r),
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{xDecoder{
+		old: NewZDecoder(r),
 	}}
 }
 
 // NewDecoderWithTypeDecoder returns a new Decoder that reads from the given
 // reader.  Types are decoded separately through the typeDec.
-func NewXDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *XDecoder {
-	return &XDecoder{xDecoder{
-		old: NewDecoderWithTypeDecoder(r, typeDec),
+func NewDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *Decoder {
+	return &Decoder{xDecoder{
+		old: NewZDecoderWithTypeDecoder(r, typeDec),
 	}}
 }
 
 // Decoder returns d as a vdl.Decoder.
-func (d *XDecoder) Decoder() vdl.Decoder {
+func (d *Decoder) Decoder() vdl.Decoder {
 	return &d.dec
 }
 
 // Decode reads the next value and stores it in value v.  The type of v need not
 // exactly match the type of the originally encoded value; decoding succeeds as
 // long as the values are convertible.
-func (d *XDecoder) Decode(v interface{}) error {
+func (d *Decoder) Decode(v interface{}) error {
 	return vdl.Read(&d.dec, v)
 }
 
 // Ignore ignores the next value from d.
 //
 // TODO(toddw): Rename to SkipValue.
-func (d *XDecoder) Ignore() error {
+func (d *Decoder) Ignore() error {
 	return d.dec.old.Ignore()
 }
 
@@ -98,8 +98,8 @@
 }
 
 func (d *xDecoder) decodeWireType(wt *wireType) (TypeId, error) {
-	// TODO(toddw): Flip useOldDecoder=false to enable XDecoder.
-	const useOldDecoder = true
+	// TODO(toddw): Flip useOldDecoder=false to enable Decoder.
+	const useOldDecoder = false
 	if useOldDecoder {
 		return d.old.decodeWireType(wt)
 	}
diff --git a/vom/xdecoder_test.go b/vom/xdecoder_test.go
index 7d3db6b..90fd789 100644
--- a/vom/xdecoder_test.go
+++ b/vom/xdecoder_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build newvdltests
-
 package vom_test
 
 import (
@@ -80,7 +78,7 @@
 			name := fmt.Sprintf("%s (%s) %s", pre, mode, test.Name())
 			rvGot := rvNew()
 			reader := mode.TestReader(bytes.NewReader(test.Bytes()))
-			dec := vom.NewXDecoder(reader)
+			dec := vom.NewDecoder(reader)
 			if err := dec.Decode(rvGot.Interface()); err != nil {
 				t.Errorf("%s: Decode failed: %v", name, err)
 				return
@@ -101,7 +99,7 @@
 			decT := vom.NewTypeDecoder(readerT)
 			decT.Start()
 			reader := mode.TestReader(bytes.NewReader(test.ValueBytes()))
-			dec := vom.NewXDecoderWithTypeDecoder(reader, decT)
+			dec := vom.NewDecoderWithTypeDecoder(reader, decT)
 			err := dec.Decode(rvGot.Interface())
 			decT.Stop()
 			if err != nil {
@@ -124,7 +122,7 @@
 	for i := 0; i < 2; i++ {
 		name := fmt.Sprintf("%s (single-shot %d) %s", pre, i, test.Name())
 		rvGot := rvNew()
-		if err := vom.XDecode(test.Bytes(), rvGot.Interface()); err != nil {
+		if err := vom.Decode(test.Bytes(), rvGot.Interface()); err != nil {
 			t.Errorf("%s: Decode failed: %v", name, err)
 			return
 		}
diff --git a/vom/xencoder.go b/vom/xencoder.go
index 1817e93..3c05d8f 100644
--- a/vom/xencoder.go
+++ b/vom/xencoder.go
@@ -19,37 +19,37 @@
 
 // Encoder manages the transmission and marshaling of typed values to the other
 // side of a connection.
-type XEncoder struct {
+type Encoder struct {
 	enc xEncoder
 }
 
 // NewEncoder returns a new Encoder that writes to the given writer in the VOM
 // binary format.  The binary format is compact and fast.
-func NewXEncoder(w io.Writer) *XEncoder {
-	return NewVersionedXEncoder(DefaultVersion, w)
+func NewEncoder(w io.Writer) *Encoder {
+	return NewVersionedEncoder(DefaultVersion, w)
 }
 
 // NewVersionedEncoder returns a new Encoder that writes to the given writer with
 // the specified version.
-func NewVersionedXEncoder(version Version, w io.Writer) *XEncoder {
-	typeEnc := newTypeEncoderInternal(version, newXEncoderForTypes(version, w))
-	return NewVersionedXEncoderWithTypeEncoder(version, w, typeEnc)
+func NewVersionedEncoder(version Version, w io.Writer) *Encoder {
+	typeEnc := newTypeEncoderInternal(version, newEncoderForTypes(version, w))
+	return NewVersionedEncoderWithTypeEncoder(version, w, typeEnc)
 }
 
 // NewEncoderWithTypeEncoder returns a new Encoder that writes to the given
 // writer, where types are encoded separately through the typeEnc.
-func NewXEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *XEncoder {
-	return NewVersionedXEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
+func NewEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *Encoder {
+	return NewVersionedEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
 }
 
 // NewVersionedEncoderWithTypeEncoder returns a new Encoder that writes to the
 // given writer with the specified version, where types are encoded separately
 // through the typeEnc.
-func NewVersionedXEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *XEncoder {
+func NewVersionedEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *Encoder {
 	if !isAllowedVersion(version) {
 		panic(fmt.Sprintf("unsupported VOM version: %x", version))
 	}
-	return &XEncoder{xEncoder{
+	return &Encoder{xEncoder{
 		writer:          w,
 		buf:             newEncbuf(),
 		typeEnc:         typeEnc,
@@ -58,10 +58,10 @@
 	}}
 }
 
-// TODO(toddw): Flip useOldEncoderForTypes=false to enable XEncoder for types.
-const useOldEncoderForTypes = true
+// TODO(toddw): Flip useOldEncoderForTypes=false to enable Encoder for types.
+const useOldEncoderForTypes = false
 
-func newXEncoderForTypes(version Version, w io.Writer) *xEncoder {
+func newEncoderForTypes(version Version, w io.Writer) *xEncoder {
 	if !isAllowedVersion(version) {
 		panic(fmt.Sprintf("unsupported VOM version: %x", version))
 	}
@@ -106,13 +106,13 @@
 }
 
 // Encoder returns e as a vdl.Encoder.
-func (e *XEncoder) Encoder() vdl.Encoder {
+func (e *Encoder) Encoder() vdl.Encoder {
 	return &e.enc
 }
 
 // Encode transmits the value v.  Values of type T are encodable as long as the
 // T is a valid vdl type.
-func (e *XEncoder) Encode(v interface{}) error {
+func (e *Encoder) Encode(v interface{}) error {
 	return vdl.Write(&e.enc, v)
 }
 
diff --git a/vom/xencoder_test.go b/vom/xencoder_test.go
index 79940a5..2b9d013 100644
--- a/vom/xencoder_test.go
+++ b/vom/xencoder_test.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build newvdltests
-
 package vom_test
 
 import (
@@ -33,7 +31,7 @@
 	{
 		var buf bytes.Buffer
 		name := fmt.Sprintf("%s %s", pre, test.Name())
-		enc := vom.NewVersionedXEncoder(test.Version, &buf)
+		enc := vom.NewVersionedEncoder(test.Version, &buf)
 		if err := enc.Encode(value); err != nil {
 			t.Errorf("%s: Encode failed: %v", name, err)
 			return
@@ -48,7 +46,7 @@
 		var buf, bufT bytes.Buffer
 		name := fmt.Sprintf("%s (with TypeEncoder) %s", pre, test.Name())
 		encT := vom.NewVersionedTypeEncoder(test.Version, &bufT)
-		enc := vom.NewVersionedXEncoderWithTypeEncoder(test.Version, &buf, encT)
+		enc := vom.NewVersionedEncoderWithTypeEncoder(test.Version, &buf, encT)
 		if err := enc.Encode(value); err != nil {
 			t.Errorf("%s: Encode failed: %v", name, err)
 			return
@@ -65,7 +63,7 @@
 	// Test single-shot vom.XEncode.
 	{
 		name := fmt.Sprintf("%s (single-shot) %s", pre, test.Name())
-		buf, err := vom.VersionedXEncode(test.Version, value)
+		buf, err := vom.VersionedEncode(test.Version, value)
 		if err != nil {
 			t.Errorf("%s: Encode failed: %v", name, err)
 			return