diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..84e64f6
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.jiri
diff --git a/go/src/v.io/mojo/client/client.go b/go/src/v.io/mojo/client/client.go
new file mode 100644
index 0000000..e05fd7b
--- /dev/null
+++ b/go/src/v.io/mojo/client/client.go
@@ -0,0 +1,15 @@
+package v23
+
+import (
+	"mojo/public/go/application"
+	"mojo/public/go/bindings"
+
+	"mojo/public/interfaces/bindings/v23proxy"
+)
+
+func ConnectToRemoteService(ctx application.Context, r application.ServiceRequest, v23Name string) {
+	v23r, v23p := v23proxy.CreateMessagePipeForV23()
+	ctx.ConnectToApplication("mojo:v23proxy").ConnectToService(&v23r)
+	prox := v23proxy.NewV23Proxy(v23p, bindings.GetAsyncWaiter())
+	prox.SetupProxy(v23Name, r.Type(), r.Desc(), r.Name(), r.PassMessagePipe())
+}
diff --git a/go/src/v.io/mojo/proxy/fake_service.go b/go/src/v.io/mojo/proxy/fake_service.go
new file mode 100644
index 0000000..a289776
--- /dev/null
+++ b/go/src/v.io/mojo/proxy/fake_service.go
@@ -0,0 +1,306 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"v.io/v23/context"
+	"v.io/v23/rpc"
+
+	"mojo/public/go/application"
+	"mojo/public/go/bindings"
+	"mojo/public/go/mojovdl"
+	"mojo/public/go/system"
+
+	"v.io/v23/vdl"
+	"v.io/v23/vdlroot/signature"
+
+	"mojo/public/interfaces/bindings/mojom_types"
+	"mojo/public/interfaces/bindings/service_describer"
+)
+
+// As long as fakeService meets the Invoker interface, it is allowed to pass as
+// a universal v23 service.
+// See the function objectToInvoker in v.io/x/ref/runtime/internal/rpc/server.go
+type fakeService struct {
+	appctx application.Context
+	suffix string
+	router *bindings.Router
+	ids    bindings.Counter
+}
+
+// Prepare is used by the Fake Service to prepare the placeholders for the
+// input data.
+func (fs fakeService) Prepare(ctx *context.T, method string, numArgs int) (argptrs []interface{}, tags []*vdl.Value, _ error) {
+	inargs := make([]*vdl.Value, numArgs)
+	inptrs := make([]interface{}, len(inargs))
+	for i := range inargs {
+		inptrs[i] = &inargs[i]
+	}
+	return inptrs, nil, nil
+}
+
+// Wraps the interface request and the name of the requested mojo service.
+type v23ServiceRequest struct {
+	request bindings.InterfaceRequest
+	name    string
+}
+
+func (v *v23ServiceRequest) Name() string {
+	return v.name
+}
+
+func (v *v23ServiceRequest) Type() mojom_types.MojomInterface {
+	panic("not supported")
+}
+
+func (v *v23ServiceRequest) Desc() map[string]mojom_types.UserDefinedType {
+	panic("not supported")
+}
+
+func (v *v23ServiceRequest) PassMessagePipe() system.MessagePipeHandle {
+	return v.request.PassMessagePipe()
+}
+
+// Invoke calls the mojom service based on the suffix and converts the mojom
+// results (a struct) to Vanadium results (a slice of *vdl.Value).
+// Note: The argptrs from Prepare are reused here. The vom bytes should have
+// been decoded into these argptrs, so there are actual values inside now.
+func (fs fakeService) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, _ error) {
+	// fs.suffix consists of the mojo url and the application/interface name.
+	// The last part should be the name; everything else is the url.
+	parts := strings.Split(fs.suffix, "/")
+	mojourl := strings.Join(parts[:len(parts)-1], "/") // e.g., mojo:go_remote_echo_server. May be defined in a BUILD.gn file.
+	mojoname := parts[len(parts)-1]                    // e.g., mojo::examples::RemoteEcho. Defined from the interface + module.
+
+	// Create the generic message pipe. r is a bindings.InterfaceRequest, and
+	// p is a bindings.InterfacePointer.
+	r, p := bindings.CreateMessagePipeForMojoInterface()
+	v := v23ServiceRequest{
+		request: r,
+		name:    mojoname,
+	} // v is an application.ServiceRequest with mojoname
+
+	// Connect to the mojourl.
+	fs.appctx.ConnectToApplication(mojourl).ConnectToService(&v)
+
+	// Then assign a new router the FakeService.
+	// This will never conflict because each FakeService is only invoked once.
+	fs.router = bindings.NewRouter(p.PassMessagePipe(), bindings.GetAsyncWaiter())
+	defer fs.Close_Proxy()
+
+	log.Printf("Fake Service Invoke (Remote Signature)")
+
+	// Vanadium relies on type information, so we will retrieve that first.
+	mojomInterface, desc, err := fs.callRemoteSignature(mojourl, mojoname)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("Fake Service Invoke Signature %v", mojomInterface)
+	log.Printf("Fake Service Invoke (Remote Method)")
+
+	// With the type information, we can make the method call to the remote interface.
+	methodResults, err := fs.callRemoteMethod(method, mojomInterface, desc, argptrs)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("Fake Service Invoke Results %v", methodResults)
+
+	// Convert methodResult to results.
+	results = make([]interface{}, len(methodResults))
+	for i := range methodResults {
+		results[i] = &methodResults[i]
+	}
+	return results, nil
+}
+
+func (fs fakeService) Close_Proxy() {
+	fs.router.Close()
+}
+
+// callRemoteSignature obtains type and header information from the remote
+// mojo service. Remote mojo interfaces all define a signature method.
+func (fs fakeService) callRemoteSignature(mojourl string, mojoname string) (mojomInterface mojom_types.MojomInterface, desc map[string]mojom_types.UserDefinedType, err error) {
+	/*log.Printf("callRemoteSignature: Prepare payload and header")
+
+	// Prepare the input for the mojo call.
+	// This consists of a payload and a header for the RemoteSignature.
+	payload := mojom_types.SignatureInput{}
+	header := bindings.MessageHeader{
+		Type:      0xffffffff,                          // Signature is always type 0xffffffff
+		Flags:     bindings.MessageExpectsResponseFlag, // It always has a response.
+		RequestId: fs.ids.Count(),
+	}
+
+	log.Printf("callRemoteSignature: Encode payload and header")
+
+	var message *bindings.Message
+	if message, err = bindings.EncodeMessage(header, &payload); err != nil {
+		return response, fmt.Errorf("can't encode request: %v", err.Error())
+	}
+
+	log.Printf("callRemoteSignature => callRemoteGeneric")
+
+	outMessage, err := fs.callRemoteGeneric(message)
+	if err != nil {
+		return response, err
+	}
+
+	log.Printf("callRemoteSignature: Decode response")
+
+	if err = outMessage.DecodePayload(&response); err != nil {
+		return
+	}
+
+	return response, nil*/
+
+	// TODO(afandria): The service_describer mojom file defines the constant, but
+	// it is not actually present in the generated code:
+	// https://github.com/domokit/mojo/issues/469
+	// serviceDescriberInterfaceName := "_ServiceDescriber"
+
+	r, p := service_describer.CreateMessagePipeForServiceDescriber()
+	fs.appctx.ConnectToApplication(mojourl).ConnectToService(&r)
+	sDescriber := service_describer.NewServiceDescriberProxy(p, bindings.GetAsyncWaiter())
+	defer sDescriber.Close_Proxy()
+
+	r2, p2 := service_describer.CreateMessagePipeForServiceDescription()
+	err = sDescriber.DescribeService(mojoname, r2)
+	if err != nil {
+		return
+	}
+	sDescription := service_describer.NewServiceDescriptionProxy(p2, bindings.GetAsyncWaiter())
+	defer sDescription.Close_Proxy()
+
+	mojomInterface, err = sDescription.GetTopLevelInterface()
+	if err != nil {
+		return
+	}
+	descPtr, err := sDescription.GetAllTypeDefinitions()
+	if err != nil {
+		return
+	}
+	return mojomInterface, *descPtr, nil
+}
+
+// A helper function that sends a remote message that expects a response.
+func (fs fakeService) callRemoteGeneric(message *bindings.Message) (outMessage *bindings.Message, err error) {
+	log.Printf("callRemoteGeneric: Send message along the router")
+
+	readResult := <-fs.router.AcceptWithResponse(message)
+	if err = readResult.Error; err != nil {
+		return
+	}
+
+	log.Printf("callRemoteGeneric: Audit response message header flag")
+	// The message flag we receive back must be a bindings.MessageIsResponseFlag
+	if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag {
+		err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
+			fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags),
+		}
+		return
+	}
+
+	log.Printf("callRemoteGeneric: Audit response message header type")
+	// While the mojo service we called into will return a header whose
+	// type must match our outgoing one.
+	if got, want := readResult.Message.Header.Type, message.Header.Type; got != want {
+		err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
+			fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
+		}
+		return
+	}
+
+	return readResult.Message, nil
+}
+
+// callRemoteMethod calls the method remotely in a generic way.
+// Produces []*vdl.Value at the end for the invoker to return.
+func (fs fakeService) callRemoteMethod(method string, mi mojom_types.MojomInterface, desc map[string]mojom_types.UserDefinedType, argptrs []interface{}) ([]*vdl.Value, error) {
+	// We need to parse the signature result to get the method relevant info out.
+	found := false
+	var ordinal uint32
+	for ord, mm := range mi.Methods {
+		if *mm.DeclData.ShortName == method {
+			ordinal = ord
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return nil, fmt.Errorf("callRemoteMethod: method %s does not exist", method)
+	}
+
+	mm := mi.Methods[ordinal]
+
+	// A void function must have request id of 0, whereas one with response params
+	// should  have a unique request id.
+	var rqId uint64
+	var flag uint32
+	if mm.ResponseParams != nil {
+		rqId = fs.ids.Count()
+		flag = bindings.MessageExpectsResponseFlag
+	} else {
+		flag = bindings.MessageNoFlag
+	}
+
+	header := bindings.MessageHeader{
+		Type:      ordinal,
+		Flags:     flag,
+		RequestId: rqId,
+	}
+
+	// Now produce the *bindings.Message that we will send to the other side.
+	inType := mojovdl.MojomStructToVDLType(mm.Parameters, desc)
+	message, err := encodeMessageFromVom(header, argptrs, inType)
+	if err != nil {
+		return nil, err
+	}
+
+	// Handle the 0 out-arg case first.
+	if mm.ResponseParams == nil {
+		if err = fs.router.Accept(message); err != nil {
+			return nil, err
+		}
+		return make([]*vdl.Value, 0), nil
+	}
+
+	// Otherwise, make a generic call with the message.
+	outMessage, err := fs.callRemoteGeneric(message)
+	if err != nil {
+		return nil, err
+	}
+
+	// Decode the *vdl.Value from the mojom bytes and mojom type.
+	outType := mojovdl.MojomStructToVDLType(*mm.ResponseParams, desc)
+	outVdlValue, err := mojovdl.DecodeValue(outMessage.Payload, outType)
+	if err != nil {
+		return nil, fmt.Errorf("mojovdl.DecodeValue failed: %v", err)
+	}
+
+	// Then split the *vdl.Value (struct) into []*vdl.Value
+	response := splitVdlValueByMojomType(outVdlValue, outType)
+	return response, nil
+}
+
+// The fake service has no signature.
+func (fs fakeService) Signature(ctx *context.T, call rpc.ServerCall) ([]signature.Interface, error) {
+	log.Printf("Fake Service Signature???")
+	return nil, nil
+}
+
+// The fake service knows nothing about method signatures.
+func (fs fakeService) MethodSignature(ctx *context.T, call rpc.ServerCall, method string) (signature.Method, error) {
+	log.Printf("Fake Service Method Signature???")
+	return signature.Method{}, nil
+}
+
+// The fake service will never need to glob.
+func (fs fakeService) Globber() *rpc.GlobState {
+	log.Printf("Fake Service Globber???")
+	return nil
+}
diff --git a/go/src/v.io/mojo/proxy/misc.go b/go/src/v.io/mojo/proxy/misc.go
new file mode 100644
index 0000000..d156b7f
--- /dev/null
+++ b/go/src/v.io/mojo/proxy/misc.go
@@ -0,0 +1,66 @@
+package main
+
+// Construct the proper *vdl.Value (as a struct) from the mojom type.
+import (
+	"fmt"
+
+	"mojo/public/go/bindings"
+	"mojo/public/go/mojovdl"
+
+	"v.io/v23/vdl"
+)
+
+// TODO(alexfandrianto): Since this function could panic, we should consider
+// handling that if it happens.
+func combineVdlValueByMojomType(values []*vdl.Value, t *vdl.Type) *vdl.Value {
+	outVdlValue := vdl.ZeroValue(t)
+	for i := 0; i < t.NumField(); i++ {
+		outVdlValue.StructField(i).Assign(values[i])
+	}
+	return outVdlValue
+}
+
+// Construct []*vdl.Value from a *vdl.Value (as a struct) via its mojom type.
+// TODO(alexfandrianto): Since this function could panic, we should consider
+// handling that if it happens.
+func splitVdlValueByMojomType(value *vdl.Value, t *vdl.Type) []*vdl.Value {
+	outVdlValues := make([]*vdl.Value, t.NumField())
+	for i := 0; i < t.NumField(); i++ {
+		outVdlValues[i] = value.StructField(i)
+	}
+	return outVdlValues
+}
+
+func encodeMessageFromVom(header bindings.MessageHeader, argptrs []interface{}, t *vdl.Type) (*bindings.Message, error) {
+	// Convert argptrs into their true form: []*vdl.Value
+	inargs := make([]*vdl.Value, len(argptrs))
+	for i := range argptrs {
+		inargs[i] = *argptrs[i].(**vdl.Value)
+	}
+
+	// Construct the proper *vdl.Value (as a struct) from the mojom type.
+	vdlValue := combineVdlValueByMojomType(inargs, t)
+
+	encoder := bindings.NewEncoder()
+	if err := header.Encode(encoder); err != nil {
+		return nil, err
+	}
+	if bytes, handles, err := encoder.Data(); err != nil {
+		return nil, err
+	} else {
+		// Encode here.
+		moreBytes, err := mojovdl.Encode(vdlValue)
+		if err != nil {
+			return nil, fmt.Errorf("mojovdl.Encode failed: %v", err)
+		}
+		// Append the encoded "payload" to the end of the slice.
+		bytes = append(bytes, moreBytes...)
+
+		return &bindings.Message{
+			Header:  header,
+			Bytes:   bytes,
+			Handles: handles,
+			Payload: moreBytes,
+		}, nil
+	}
+}
diff --git a/go/src/v.io/mojo/proxy/proxy.go b/go/src/v.io/mojo/proxy/proxy.go
new file mode 100644
index 0000000..26a9f64
--- /dev/null
+++ b/go/src/v.io/mojo/proxy/proxy.go
@@ -0,0 +1,269 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+
+	"v.io/v23"
+	"v.io/v23/context"
+	"v.io/v23/options"
+	"v.io/v23/security"
+	"v.io/v23/vdl"
+
+	"mojo/public/go/application"
+	"mojo/public/go/bindings"
+	"mojo/public/go/mojovdl"
+	"mojo/public/go/system"
+	"mojo/public/interfaces/bindings/mojom_types"
+	"mojo/public/interfaces/bindings/v23proxy"
+
+	_ "v.io/x/ref/runtime/factories/static"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+func init() {
+	flag.String("child-connection-id", "", "")
+	flag.String("mojo-platform-channel-handle", "", "")
+}
+
+type v23HeaderReceiver struct {
+	delegate    *V23ServerDelegate
+	v23Name     string
+	ifaceSig    mojom_types.MojomInterface
+	desc        map[string]mojom_types.UserDefinedType
+	serviceName string
+	handle      system.MessagePipeHandle
+}
+
+func (r *v23HeaderReceiver) SetupProxy(v23Name string, ifaceSig mojom_types.MojomInterface, desc map[string]mojom_types.UserDefinedType, serviceName string, handle system.MessagePipeHandle) (err error) {
+	log.Printf("[server] In SetupProxy(%s, %v, %v, %s, %v)\n", v23Name, ifaceSig, desc, serviceName, handle)
+	r.v23Name = v23Name
+	r.ifaceSig = ifaceSig
+	r.desc = desc
+	r.serviceName = serviceName
+	r.handle = handle
+
+	go func() {
+		connector := bindings.NewConnector(r.handle, bindings.GetAsyncWaiter())
+
+		// Read generic calls in a loop
+		stub := &genericStub{
+			header:    r,
+			ctx:       r.delegate.ctx,
+			connector: connector,
+		}
+		bindingStub := bindings.NewStub(connector, stub)
+		for {
+			if err := bindingStub.ServeRequest(); err != nil {
+				connectionError, ok := err.(*bindings.ConnectionError)
+				if !ok || !connectionError.Closed() {
+					log.Println(err)
+				}
+				break
+			}
+		}
+		r.delegate.stubs = append(r.delegate.stubs, bindingStub)
+	}()
+	return nil
+}
+
+type byteCopyingPayload []byte
+
+func (bcp byteCopyingPayload) Encode(encoder *bindings.Encoder) error {
+	encoder.WriteRawBytes(bcp)
+	return nil
+}
+
+func (bcp byteCopyingPayload) Decode(decoder *bindings.Decoder) error {
+	panic("not supported")
+}
+
+type genericStub struct {
+	header    *v23HeaderReceiver
+	ctx       *context.T
+	connector *bindings.Connector
+}
+
+func (s *genericStub) Accept(message *bindings.Message) (err error) {
+	/*if int(message.Header.Type) >= len(s.header.ifaceSig.Methods) {
+		return fmt.Errorf("Method had index %d, but interface only has %d methods",
+			message.Header.Type, len(s.header.ifaceSig.Methods))
+	}*/
+	if _, ok := s.header.ifaceSig.Methods[message.Header.Type]; !ok {
+		return fmt.Errorf("Method had index %d, but interface only has %d methods",
+			message.Header.Type, len(s.header.ifaceSig.Methods))
+	}
+
+	methodSig := s.header.ifaceSig.Methods[message.Header.Type]
+	methodName := *methodSig.DeclData.ShortName
+	// Should we perform validation of flags like generated methods?
+	// Does this handle 0-arg methods?
+
+	messageBytes := message.Payload
+
+	response, err := s.Call(s.header.v23Name, methodName, messageBytes, methodSig.Parameters, methodSig.ResponseParams)
+	if err != nil {
+		return err
+	}
+	responseHeader := bindings.MessageHeader{
+		Type:      message.Header.Type,
+		Flags:     bindings.MessageIsResponseFlag,
+		RequestId: message.Header.RequestId,
+	}
+	responseMessage, err := bindings.EncodeMessage(responseHeader, byteCopyingPayload(response))
+	if err != nil {
+		return err
+	}
+	return s.connector.WriteMessage(responseMessage)
+}
+
+func (s *genericStub) Call(name, method string, value []byte, inParamsType mojom_types.MojomStruct, outParamsType *mojom_types.MojomStruct) ([]byte, error) {
+	log.Printf("server: %s.%s: %#v", name, method, inParamsType)
+
+	inVType := mojovdl.MojomStructToVDLType(inParamsType, s.header.desc)
+	var outVType *vdl.Type
+	if outParamsType != nil {
+		outVType = mojovdl.MojomStructToVDLType(*outParamsType, s.header.desc)
+	}
+
+	// Decode the vdl.Value from the mojom bytes and mojom type.
+	inVdlValue, err := mojovdl.DecodeValue(value, inVType)
+	if err != nil {
+		return nil, fmt.Errorf("mojovdl.DecodeValue failed: %v", err)
+	}
+
+	// inVdlValue is a struct, but we need to send []interface.
+	inargs := splitVdlValueByMojomType(inVdlValue, inVType)
+	inargsIfc := make([]interface{}, len(inargs))
+	for i := range inargs {
+		inargsIfc[i] = inargs[i]
+	}
+
+	// We know that the v23proxy (on the other side) will give us back a bunch of
+	// data in []interface{}. so we'll want to decode them into *vdl.Value.
+	log.Printf("%s %v\n", method, outParamsType)
+	outargs := make([]*vdl.Value, len(outParamsType.Fields))
+	outptrs := make([]interface{}, len(outargs))
+	for i := range outargs {
+		outptrs[i] = &outargs[i]
+	}
+
+	// Now, run the call without any authorization.
+	if err := v23.GetClient(s.ctx).Call(s.ctx, name, method, inargsIfc, outptrs, options.SkipServerEndpointAuthorization{}); err != nil {
+		return nil, err
+	}
+
+	// Now convert the []interface{} into a *vdl.Value (struct).
+	outVdlValue := combineVdlValueByMojomType(outargs, outVType)
+
+	// Finally, encode this *vdl.Value (struct) into mojom bytes and send the response.
+	result, err := mojovdl.Encode(outVdlValue)
+	if err != nil {
+		return nil, fmt.Errorf("mojovdl.Encode failed: %v", err)
+	}
+	return result, nil
+}
+
+type V23ServerDelegate struct {
+	ctx      *context.T
+	stubs    []*bindings.Stub
+	shutdown v23.Shutdown
+}
+
+func (delegate *V23ServerDelegate) Initialize(context application.Context) {
+	log.Printf("V23ServerDelegate.Initialize...")
+
+	// Start up v23 whenever a v23proxy is begun.
+	// This is done regardless of whether we are initializing this v23proxy for use
+	// as a client or as a server.
+	ctx, shutdown := v23.Init()
+	delegate.ctx = ctx
+	delegate.shutdown = shutdown
+
+	// TODO(alexfandrianto): Does Mojo stop us from creating too many v23proxy?
+	// Is it 1 per shell? Ideally, each device will only serve 1 of these v23proxy,
+	// but it is not problematic to have extra.
+	/*s := MakeServer(ctx)
+	err := s.ServeDispatcher("", &V23ProxyDispatcher{
+		appctx: context,
+	})*/
+	_, s, err := v23.WithNewDispatchingServer(ctx, "", &V23ProxyDispatcher{
+		appctx: context,
+	})
+	if err != nil {
+		log.Panic("Error serving service: ", err)
+	}
+
+	endpoints := s.Status().Endpoints
+	fmt.Printf("Listening at: /%v\n", endpoints[0])
+}
+
+/*func MakeServer(ctx *context.T) rpc.Server {
+	s, err := v23.NewServer(ctx)
+	if err != nil {
+		log.Panic("Failure creating server: ", err)
+	}
+
+	endpoints, err := s.Listen(v23.GetListenSpec(ctx))
+	if err != nil {
+		log.Panic("Error listening to service: ", err)
+	}
+	fmt.Printf("Listening at: /%v\n", endpoints[0])
+	return s
+}*/
+
+type V23ProxyDispatcher struct {
+	appctx application.Context
+}
+
+func (v23pd *V23ProxyDispatcher) Lookup(ctx *context.T, suffix string) (interface{}, security.Authorizer, error) {
+	log.Printf("Dispatcher: %s", suffix)
+	return fakeService{
+		appctx: v23pd.appctx,
+		suffix: suffix,
+		ids:    bindings.NewCounter(),
+	}, security.AllowEveryone(), nil
+}
+
+func (delegate *V23ServerDelegate) Create(request v23proxy.V23_Request) {
+	headerReceiver := &v23HeaderReceiver{delegate: delegate}
+	v23Stub := v23proxy.NewV23Stub(request, headerReceiver, bindings.GetAsyncWaiter())
+	delegate.stubs = append(delegate.stubs, v23Stub)
+
+	go func() {
+		// Read header message
+		if err := v23Stub.ServeRequest(); err != nil {
+			connectionError, ok := err.(*bindings.ConnectionError)
+			if !ok || !connectionError.Closed() {
+				log.Println(err)
+			}
+			return
+		}
+	}()
+}
+
+func (delegate *V23ServerDelegate) AcceptConnection(connection *application.Connection) {
+	log.Printf("V23ServerDelegate.AcceptConnection...")
+	connection.ProvideServices(&v23proxy.V23_ServiceFactory{delegate})
+}
+
+func (delegate *V23ServerDelegate) Quit() {
+	log.Printf("V23ServerDelegate.Quit...")
+	for _, stub := range delegate.stubs {
+		stub.Close()
+	}
+
+	delegate.shutdown()
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+	application.Run(&V23ServerDelegate{}, system.MojoHandle(handle))
+	return C.MOJO_RESULT_OK
+}
+
+func main() {
+}
diff --git a/go/src/v.io/mojo/transcoder/allocation_size.go b/go/src/v.io/mojo/transcoder/allocation_size.go
new file mode 100644
index 0000000..ff70e88
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/allocation_size.go
@@ -0,0 +1,37 @@
+package mojovdl
+
+import "v.io/v23/vdl"
+
+func neededStructAllocationSize(vt *vdl.Type) uint32 {
+	var totalBits uint32
+	for fi := 0; fi < vt.NumField(); fi++ {
+		field := vt.Field(fi)
+		totalBits += baseTypeSizeBits(field.Type)
+	}
+	return roundBitsTo64Alignment(totalBits)
+}
+
+func baseTypeSizeBits(vt *vdl.Type) uint32 {
+	switch vt.Kind() {
+	case vdl.Bool:
+		return 1
+	case vdl.Byte:
+		return 8
+	case vdl.Uint16, vdl.Int16:
+		return 16
+	case vdl.Uint32, vdl.Int32, vdl.Float32, vdl.Enum:
+		return 32
+	case vdl.Union:
+		return 128 // Header + value / pointer to inner union
+	default: // Either Uint64, Int64, Float64 or pointer.
+		return 64
+	}
+}
+
+// Round up to the nearest 8 byte length.
+func roundBitsTo64Alignment(numBits uint32) uint32 {
+	if numBits%64 == 0 {
+		return numBits / 8
+	}
+	return (numBits + (64 - numBits%64)) / 8
+}
diff --git a/go/src/v.io/mojo/transcoder/allocator.go b/go/src/v.io/mojo/transcoder/allocator.go
new file mode 100644
index 0000000..0f3be60
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/allocator.go
@@ -0,0 +1,75 @@
+package mojovdl
+
+import "encoding/binary"
+
+const HEADER_SIZE uint32 = 8
+
+// TODO(bprosnitz) maybe make an interface to support decode too
+type allocator struct {
+	// Buffer containing encoded data.
+	buf []byte
+
+	// Index of the first unclaimed byte in buf.
+	end uint32
+}
+
+func (a *allocator) makeRoom(size uint32) {
+	totalNeeded := a.end + size
+
+	allocationSize := uint32(1)
+	for allocationSize < totalNeeded {
+		allocationSize *= 2
+	}
+
+	if allocationSize != uint32(len(a.buf)) {
+		oldBuf := a.buf
+		a.buf = make([]byte, allocationSize)
+		copy(a.buf, oldBuf)
+	}
+}
+
+func (a *allocator) allocateBlock(size uint32, numElems uint32) (startIndex, endIndex uint32) {
+	size_with_header := size + HEADER_SIZE
+	size_with_header_rounded := size_with_header
+	if size_with_header%8 != 0 {
+		size_with_header_rounded = size_with_header + (8 - (size_with_header % 8))
+	}
+
+	a.makeRoom(size_with_header_rounded)
+	binary.LittleEndian.PutUint32(a.buf[a.end:a.end+4], size_with_header)
+	binary.LittleEndian.PutUint32(a.buf[a.end+4:a.end+8], numElems)
+
+	prevEnd := a.end
+	start := prevEnd + HEADER_SIZE
+	end := prevEnd + size_with_header
+	a.end = prevEnd + size_with_header_rounded
+	return start, end
+}
+
+func (a *allocator) Allocate(size uint32, numElems uint32) bytesRef {
+	begin, end := a.allocateBlock(size, numElems)
+	ref := bytesRef{
+		allocator:  a,
+		startIndex: begin,
+		endIndex:   end,
+		// zeros
+	}
+	return ref
+}
+
+func (a *allocator) AllocationFromPointer(absoluteIndex uint32) bytesRef {
+	headerPos := absoluteIndex - HEADER_SIZE
+	size := binary.LittleEndian.Uint32(a.buf[headerPos : headerPos+4])
+	return bytesRef{
+		allocator:  a,
+		startIndex: absoluteIndex,
+		endIndex:   absoluteIndex + size,
+	}
+}
+
+func (a *allocator) AllocatedBytes() []byte {
+	if a.buf == nil {
+		return []byte{}
+	}
+	return a.buf[:a.end]
+}
diff --git a/go/src/v.io/mojo/transcoder/decode.go b/go/src/v.io/mojo/transcoder/decode.go
new file mode 100644
index 0000000..b5b7142
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/decode.go
@@ -0,0 +1,370 @@
+package mojovdl
+
+import (
+	"fmt"
+	"reflect"
+
+	"mojo/public/go/bindings"
+
+	"v.io/v23/vdl"
+)
+
+// Decode decodes the mojom-encoded data into valptr, which must be a pointer to
+// the desired value.  The datatype describes the type of the encoded data.
+// Returns an error if the data cannot be decoded into valptr, based on the VDL
+// value conversion rules.
+func Decode(data []byte, datatype *vdl.Type, valptr interface{}) error {
+	target, err := vdl.ReflectTarget(reflect.ValueOf(valptr))
+	if err != nil {
+		return err
+	}
+	d := &decoder{dec: bindings.NewDecoder(data, nil)}
+	return d.decodeValue(datatype, target, true, false)
+}
+
+// DecodeValue is like Decode, but decodes mojom-encoded data into a vdl.Value.
+func DecodeValue(data []byte, datatype *vdl.Type) (*vdl.Value, error) {
+	v := new(vdl.Value)
+	if err := Decode(data, datatype, &v); err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+type decoder struct {
+	dec       *bindings.Decoder
+	typeStack []*vdl.Type
+}
+
+func (d *decoder) decodeValue(vt *vdl.Type, target vdl.Target, isTopType, isNullable bool) error {
+	switch vt.Kind() {
+	case vdl.Bool:
+		value, err := d.dec.ReadBool()
+		if err != nil {
+			return err
+		}
+		return target.FromBool(value, vt)
+	case vdl.Int16:
+		value, err := d.dec.ReadInt16()
+		if err != nil {
+			return err
+		}
+		return target.FromInt(int64(value), vt)
+	case vdl.Int32:
+		value, err := d.dec.ReadInt32()
+		if err != nil {
+			return err
+		}
+		return target.FromInt(int64(value), vt)
+	case vdl.Int64:
+		value, err := d.dec.ReadInt64()
+		if err != nil {
+			return err
+		}
+		return target.FromInt(value, vt)
+	case vdl.Byte:
+		value, err := d.dec.ReadUint8()
+		if err != nil {
+			return err
+		}
+		return target.FromUint(uint64(value), vt)
+	case vdl.Uint16:
+		value, err := d.dec.ReadUint16()
+		if err != nil {
+			return err
+		}
+		return target.FromUint(uint64(value), vt)
+	case vdl.Uint32:
+		value, err := d.dec.ReadUint32()
+		if err != nil {
+			return err
+		}
+		return target.FromUint(uint64(value), vt)
+	case vdl.Uint64:
+		value, err := d.dec.ReadUint64()
+		if err != nil {
+			return err
+		}
+		return target.FromUint(value, vt)
+	case vdl.Float32:
+		value, err := d.dec.ReadFloat32()
+		if err != nil {
+			return err
+		}
+		return target.FromFloat(float64(value), vt)
+	case vdl.Float64:
+		value, err := d.dec.ReadFloat64()
+		if err != nil {
+			return err
+		}
+		return target.FromFloat(value, vt)
+	case vdl.String:
+		switch ptr, err := d.dec.ReadPointer(); {
+		case err != nil:
+			return err
+		case ptr == 0:
+			return fmt.Errorf("invalid null string pointer")
+		default:
+			value, err := d.dec.ReadString()
+			if err != nil {
+				return err
+			}
+			return target.FromString(value, vt)
+		}
+		return nil
+	case vdl.Enum:
+		index, err := d.dec.ReadInt32()
+		if err != nil {
+			return err
+		}
+		if int(index) >= vt.NumEnumLabel() || index < 0 {
+			return fmt.Errorf("enum label out of range")
+		}
+		target.FromEnumLabel(vt.EnumLabel(int(index)), vt)
+		return nil
+	case vdl.Complex64:
+		panic("unimplemented")
+	case vdl.Complex128:
+		panic("unimplemented")
+	case vdl.Array, vdl.List:
+		switch ptr, err := d.dec.ReadPointer(); {
+		case err != nil:
+			return err
+		case ptr == 0 && isNullable:
+			return target.FromNil(vdl.OptionalType(vt))
+		case ptr == 0 && !isNullable:
+			return fmt.Errorf("invalid null struct pointer")
+		}
+
+		if vt.IsBytes() {
+			str, err := d.dec.ReadString()
+			if err != nil {
+				return err
+			}
+			return target.FromBytes([]byte(str), vt)
+		} else {
+			elemBitSize := baseTypeSizeBits(vt.Elem())
+			numElems, err := d.dec.StartArray(elemBitSize)
+			if err != nil {
+				return err
+			}
+			listTarget, err := target.StartList(vt, int(numElems))
+			if err != nil {
+				return err
+			}
+			for i := 0; i < int(numElems); i++ {
+				elemTarget, err := listTarget.StartElem(i)
+				if err != nil {
+					return err
+				}
+				if err := d.decodeValue(vt.Elem(), elemTarget, false, false); err != nil {
+					return err
+				}
+				if err := listTarget.FinishElem(elemTarget); err != nil {
+					return err
+				}
+			}
+			if err := target.FinishList(listTarget); err != nil {
+				return err
+			}
+		}
+		return d.dec.Finish()
+	case vdl.Set:
+		panic("unimplemented")
+		/*switch ptr, err := d.dec.ReadPointer(); {
+		case err != nil:
+			return err
+		case ptr == 0 && isNullable:
+			return target.FromNil(vdl.OptionalType(vt))
+		case ptr == 0 && !isNullable:
+			return fmt.Errorf("invalid null struct pointer")
+		}
+		keyBitSize := baseTypeSizeBits(vt.Key())
+		numKeys, err := d.dec.StartArray(keyBitSize)
+		if err != nil {
+			return err
+		}
+		setTarget, err := target.StartSet(vt, int(numKeys))
+		if err != nil {
+			return err
+		}
+		for i := 0; i < int(numKeys); i++ {
+			keyTarget, err := setTarget.StartKey()
+			if err != nil {
+				return err
+			}
+			if err := d.decodeValue(mt.Key, keyTarget, false, false); err != nil {
+				return err
+			}
+			if err := setTarget.FinishKey(keyTarget); err != nil {
+				return err
+			}
+		}
+		if err := target.FinishSet(setTarget); err != nil {
+			return err
+		}
+		return d.dec.Finish()*/
+	case vdl.Map:
+		switch ptr, err := d.dec.ReadPointer(); {
+		case err != nil:
+			return err
+		case ptr == 0 && isNullable:
+			return target.FromNil(vdl.OptionalType(vt))
+		case ptr == 0 && !isNullable:
+			return fmt.Errorf("invalid null struct pointer")
+		}
+		if err := d.dec.StartMap(); err != nil {
+			return err
+		}
+		var keys, values []*vdl.Value
+		keysTarget, err := vdl.ReflectTarget(reflect.ValueOf(&keys))
+		if err != nil {
+			return err
+		}
+		keysListType := vdl.ListType(vt.Key())
+		if err := d.decodeValue(keysListType, keysTarget, false, false); err != nil {
+			return err
+		}
+		valuesTarget, err := vdl.ReflectTarget(reflect.ValueOf(&values))
+		if err != nil {
+			return err
+		}
+		valuesListType := vdl.ListType(vt.Elem())
+		if err := d.decodeValue(valuesListType, valuesTarget, false, false); err != nil {
+			return err
+		}
+
+		if len(keys) != len(values) {
+			return fmt.Errorf("values don't match keys")
+		}
+		mapTarget, err := target.StartMap(vt, len(keys))
+		if err != nil {
+			return err
+		}
+		for i, key := range keys {
+			value := values[i]
+
+			keyTarget, err := mapTarget.StartKey()
+			if err != nil {
+				return err
+			}
+			if err := vdl.FromValue(keyTarget, key); err != nil {
+				return err
+			}
+			fieldTarget, err := mapTarget.FinishKeyStartField(keyTarget)
+			if err != nil {
+				return err
+			}
+			if err := vdl.FromValue(fieldTarget, value); err != nil {
+				return err
+			}
+			if err := mapTarget.FinishField(keyTarget, fieldTarget); err != nil {
+				return err
+			}
+		}
+		if err := target.FinishMap(mapTarget); err != nil {
+			return err
+		}
+
+		return d.dec.Finish()
+	case vdl.Struct:
+		// TODO(toddw): See the comment in encoder.mojomStructSize; we rely on the
+		// fields to be presented in the canonical mojom field ordering.
+		if !isTopType {
+			switch ptr, err := d.dec.ReadPointer(); {
+			case err != nil:
+				return err
+			case ptr == 0 && isNullable:
+				return target.FromNil(vdl.OptionalType(vt))
+			case ptr == 0 && !isNullable:
+				return fmt.Errorf("invalid null struct pointer")
+			}
+		}
+		_, err := d.dec.StartStruct()
+		if err != nil {
+			return err
+		}
+		targetFields, err := target.StartFields(vt)
+		if err != nil {
+			return err
+		}
+		for i := 0; i < vt.NumField(); i++ {
+			mfield := vt.Field(i)
+			switch vkey, vfield, err := targetFields.StartField(mfield.Name); {
+			// TODO(toddw): Handle err == vdl.ErrFieldNoExist case?
+			case err != nil:
+				return err
+			default:
+				if err := d.decodeValue(mfield.Type, vfield, false, false); err != nil {
+					return err
+				}
+				if err := targetFields.FinishField(vkey, vfield); err != nil {
+					return err
+				}
+			}
+		}
+		// TODO(toddw): Fill in fields that weren't decoded with their zero value.
+		if err := target.FinishFields(targetFields); err != nil {
+			return err
+		}
+		return d.dec.Finish()
+	case vdl.Union:
+		size, tag, err := d.dec.ReadUnionHeader()
+		if err != nil {
+			return err
+		}
+		if size == 0 {
+			d.dec.SkipUnionValue()
+			return target.FromNil(vdl.OptionalType(vt))
+		}
+		if int(tag) >= vt.NumField() {
+			return fmt.Errorf("union tag out of bounds")
+		}
+		fld := vt.Field(int(tag))
+		targetFields, err := target.StartFields(vt)
+		if err != nil {
+			return err
+		}
+		vKey, vField, err := targetFields.StartField(fld.Name)
+		if err != nil {
+			return err
+		}
+		if fld.Type.Kind() == vdl.Union {
+			switch ptr, err := d.dec.ReadPointer(); {
+			case err != nil:
+				return err
+			case ptr == 0 && isNullable:
+				return target.FromNil(vdl.OptionalType(fld.Type))
+			case ptr == 0 && !isNullable:
+				return fmt.Errorf("invalid null union pointer")
+			}
+			if err := d.dec.StartNestedUnion(); err != nil {
+				return err
+			}
+		}
+		if err := d.decodeValue(fld.Type, vField, false, false); err != nil {
+			return err
+		}
+		if fld.Type.Kind() == vdl.Union {
+			if err := d.dec.Finish(); err != nil {
+				return err
+			}
+		}
+		if err := targetFields.FinishField(vKey, vField); err != nil {
+			return err
+		}
+		if err := target.FinishFields(targetFields); err != nil {
+			return err
+		}
+		d.dec.FinishReadingUnionValue()
+		return nil
+	case vdl.Optional:
+		return d.decodeValue(vt.Elem(), target, false, true)
+	case vdl.Any:
+		panic("unimplemented")
+	//case vdl.TypeObject:
+	//	panic("unimplemented")
+	default:
+		panic(fmt.Errorf("decodeValue unhandled vdl type: %v", vt))
+	}
+}
diff --git a/go/src/v.io/mojo/transcoder/encode.go b/go/src/v.io/mojo/transcoder/encode.go
new file mode 100644
index 0000000..b778e0e
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/encode.go
@@ -0,0 +1,94 @@
+package mojovdl
+
+import (
+	"reflect"
+
+	"v.io/v23/vdl"
+)
+
+func Encode(value interface{}) ([]byte, error) {
+	enc := &encoder{
+		allocator: &allocator{},
+	}
+	err := vdl.FromReflect(enc, reflect.ValueOf(value))
+	return enc.Bytes(), err
+}
+
+type encoder struct {
+	allocator *allocator
+}
+
+func (e *encoder) Bytes() []byte {
+	return e.allocator.AllocatedBytes()
+}
+
+func (e *encoder) FromBool(src bool, tt *vdl.Type) error {
+	panic("cannot encode top level bool")
+}
+func (e *encoder) FromUint(src uint64, tt *vdl.Type) error {
+	panic("cannot encode top level uint")
+}
+func (e *encoder) FromInt(src int64, tt *vdl.Type) error {
+	panic("cannot encode top level int")
+}
+func (e *encoder) FromFloat(src float64, tt *vdl.Type) error {
+	panic("cannot encode top level float")
+}
+func (e *encoder) FromComplex(src complex128, tt *vdl.Type) error {
+	panic("cannot encode top level complex")
+}
+func (e *encoder) FromBytes(src []byte, tt *vdl.Type) error {
+	panic("cannot encode top level bytes")
+}
+func (e *encoder) FromString(src string, tt *vdl.Type) error {
+	panic("cannot encode top level string")
+}
+func (e *encoder) FromEnumLabel(src string, tt *vdl.Type) error {
+	panic("cannot encode top level enum")
+}
+func (e *encoder) FromTypeObject(src *vdl.Type) error {
+	panic("cannot encode top level type object")
+}
+func (e *encoder) FromNil(tt *vdl.Type) error {
+	panic("cannot encode top level nil")
+}
+
+func (e *encoder) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
+	panic("UNIMPLEMENTED")
+	return nil, nil
+}
+func (e *encoder) FinishList(x vdl.ListTarget) error {
+	return nil
+}
+func (e *encoder) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {
+	panic("UNIMPLEMENTED")
+}
+func (e *encoder) FinishSet(x vdl.SetTarget) error {
+	panic("UNIMPLEMENTED")
+
+}
+func (e *encoder) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
+	panic("UNIMPLEMENTED")
+
+}
+func (e *encoder) FinishMap(x vdl.MapTarget) error {
+	panic("UNIMPLEMENTED")
+
+}
+func (e *encoder) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+	if tt.Kind() == vdl.Union {
+		panic("not yet supported")
+	}
+	if tt.Kind() == vdl.Optional {
+		tt = tt.Elem()
+	}
+	block := e.allocator.Allocate(neededStructAllocationSize(tt), 0)
+	return fieldsTarget{
+			vdlType: tt,
+			block:   block,
+		},
+		nil
+}
+func (e *encoder) FinishFields(x vdl.FieldsTarget) error {
+	return nil
+}
diff --git a/go/src/v.io/mojo/transcoder/ref.go b/go/src/v.io/mojo/transcoder/ref.go
new file mode 100644
index 0000000..9d53c75
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/ref.go
@@ -0,0 +1,35 @@
+package mojovdl
+
+type bytesRef struct {
+	allocator            *allocator
+	startIndex, endIndex uint32
+}
+
+func (b bytesRef) Slice(low, high uint32) bytesRef {
+	return bytesRef{
+		allocator:  b.allocator,
+		startIndex: b.startIndex + low,
+		endIndex:   b.startIndex + high,
+	}
+}
+
+// SignedSlice allows going backwards in the slice (temporary hack to include header in slice for unions)
+func (b bytesRef) SignedSlice(low, high int) bytesRef {
+	return bytesRef{
+		allocator:  b.allocator,
+		startIndex: uint32(int(b.startIndex) + low),
+		endIndex:   uint32(int(b.startIndex) + high),
+	}
+}
+
+func (b bytesRef) Bytes() []byte {
+	return b.allocator.buf[b.startIndex:b.endIndex]
+}
+
+func (b bytesRef) AsPointer(fromRefPos bytesRef) uint32 {
+	offset := b.startIndex - fromRefPos.startIndex
+	if offset <= 0 {
+		panic("invalid non-positive offset for pointer")
+	}
+	return offset - HEADER_SIZE
+}
diff --git a/go/src/v.io/mojo/transcoder/struct_offset.go b/go/src/v.io/mojo/transcoder/struct_offset.go
new file mode 100644
index 0000000..317a45b
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/struct_offset.go
@@ -0,0 +1,204 @@
+package mojovdl
+
+import (
+	"fmt"
+
+	"v.io/v23/vdl"
+)
+
+func offsetInStruct(index int, structVdlType *vdl.Type) (byteOffset uint32, bitOffset uint8) {
+	if index >= structVdlType.NumField() {
+		panic(fmt.Sprintf("index %v out of bounds for type %v", index, structVdlType))
+	}
+
+	offsetComputation := &structOffsetComputation{}
+	for i := 0; i < index; i++ {
+		bits := baseTypeSizeBits(structVdlType.Field(i).Type)
+		switch bits {
+		case 1:
+			offsetComputation.next1()
+		case 8:
+			offsetComputation.next8()
+		case 16:
+			offsetComputation.next16()
+		case 32:
+			offsetComputation.next32()
+		case 64:
+			offsetComputation.next64()
+		case 128:
+			offsetComputation.next64()
+			offsetComputation.next64()
+		default:
+			panic("unknown bit size")
+		}
+	}
+
+	switch baseTypeSizeBits(structVdlType.Field(index).Type) {
+	case 1:
+		return offsetComputation.index1, offsetComputation.bitOffset1
+	case 8:
+		return offsetComputation.index8, 0
+	case 16:
+		return offsetComputation.index16, 0
+	case 32:
+		return offsetComputation.index32, 0
+	case 64, 128:
+		return offsetComputation.index64, 0
+
+	default:
+		panic("unknown bit size")
+	}
+}
+
+type structOffsetComputation struct {
+	index8, index16, index32, index64 uint32
+	index1                            uint32
+	bitOffset1                        uint8
+}
+
+func (sa *structOffsetComputation) next1() {
+	newBitOffset1 := (sa.bitOffset1 + 1) % 8
+	var nextIndex uint32
+	if sa.index1 != sa.index8 {
+		nextIndex = sa.index8
+	} else {
+		nextIndex = sa.index1 + 1
+	}
+	if sa.bitOffset1 == 0 {
+		// bit offset == 0 means fetch a new byte
+		if sa.index8 == sa.index1 {
+			sa.index8 = nextIndex
+		}
+		if sa.index16 == sa.index1 {
+			if nextIndex&0x1 == 0 {
+				sa.index16 = nextIndex
+			} else {
+				sa.index16 = nextIndex + 1
+			}
+		}
+		if sa.index32 == sa.index1 {
+			if nextIndex&0x3 == 0 {
+				sa.index32 = nextIndex
+			} else {
+				sa.index32 = nextIndex + (4 - (nextIndex & 0x3))
+			}
+		}
+		if sa.index64 == sa.index1 {
+			if nextIndex&0x7 == 0 {
+				sa.index64 = nextIndex
+			} else {
+				sa.index64 = nextIndex + (8 - (nextIndex & 0x7))
+			}
+		}
+	}
+
+	if sa.bitOffset1 == 7 {
+		sa.index1 = nextIndex
+	}
+	sa.bitOffset1 = newBitOffset1
+}
+func (sa *structOffsetComputation) next8() {
+	var newIndex8 uint32
+	if sa.index8 != sa.index16 {
+		newIndex8 = sa.index16
+	} else {
+		newIndex8 = sa.index8 + 1
+	}
+
+	if sa.index1 == sa.index8 && sa.bitOffset1 == 0 {
+		sa.index1 = newIndex8
+	}
+	if sa.index16 == sa.index8 {
+		if newIndex8&0x1 == 0 {
+			sa.index16 = newIndex8
+		} else {
+			sa.index16 = newIndex8 + 1
+		}
+	}
+	if sa.index32 == sa.index8 {
+		if newIndex8&0x3 == 0 {
+			sa.index32 = newIndex8
+		} else {
+			sa.index32 = newIndex8 + (4 - (newIndex8 & 0x3))
+		}
+	}
+	if sa.index64 == sa.index8 {
+		if newIndex8&0x7 == 0 {
+			sa.index64 = newIndex8
+		} else {
+			sa.index64 = newIndex8 + (8 - (newIndex8 & 0x7))
+		}
+	}
+	sa.index8 = newIndex8
+}
+func (sa *structOffsetComputation) next16() {
+	var newIndex16 uint32
+	if sa.index16 != sa.index32 {
+		newIndex16 = sa.index32
+	} else {
+		newIndex16 = sa.index16 + 2
+	}
+	if sa.index1 == sa.index16 && sa.bitOffset1 == 0 {
+		sa.index1 = newIndex16
+	}
+	if sa.index8 == sa.index16 {
+		sa.index8 = newIndex16
+	}
+	if sa.index32 == sa.index16 {
+		if newIndex16&0x3 == 0 {
+			sa.index32 = newIndex16
+		} else {
+			sa.index32 = newIndex16 + (4 - (newIndex16 & 0x3))
+		}
+	}
+	if sa.index64 == sa.index16 {
+		if newIndex16&0x7 == 0 {
+			sa.index64 = newIndex16
+		} else {
+			sa.index64 = newIndex16 + (8 - (newIndex16 & 0x7))
+		}
+	}
+	sa.index16 = newIndex16
+}
+func (sa *structOffsetComputation) next32() {
+	var newIndex32 uint32
+	if sa.index32 != sa.index64 {
+		newIndex32 = sa.index64
+	} else {
+		newIndex32 = sa.index32 + 4
+	}
+	if sa.index1 == sa.index32 && sa.bitOffset1 == 0 {
+		sa.index1 = newIndex32
+	}
+	if sa.index8 == sa.index32 {
+		sa.index8 = newIndex32
+	}
+	if sa.index16 == sa.index32 {
+		sa.index16 = newIndex32
+	}
+	if sa.index64 == sa.index32 {
+		if newIndex32&0x7 == 0 {
+			sa.index64 = newIndex32
+		} else {
+			sa.index64 = newIndex32 + (8 - (newIndex32 & 0x7))
+		}
+	}
+	sa.index32 = newIndex32
+}
+func (sa *structOffsetComputation) next64() {
+	newIndex64 := sa.index64 + 8
+
+	if sa.index1 == sa.index64 && sa.bitOffset1 == 0 {
+		sa.index1 = newIndex64
+	}
+	if sa.index8 == sa.index64 {
+		sa.index8 = newIndex64
+	}
+	if sa.index16 == sa.index64 {
+		sa.index16 = newIndex64
+	}
+	if sa.index32 == sa.index64 {
+		sa.index32 = newIndex64
+	}
+	sa.index64 = newIndex64
+}
diff --git a/go/src/v.io/mojo/transcoder/target.go b/go/src/v.io/mojo/transcoder/target.go
new file mode 100644
index 0000000..cfb26f5
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/target.go
@@ -0,0 +1,213 @@
+package mojovdl
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+
+	"v.io/v23/vdl"
+)
+
+type target struct {
+	currentBitOffset uint8
+	current          bytesRef
+}
+
+func (t target) allocator() *allocator {
+	return t.current.allocator
+}
+
+func (t target) FromBool(src bool, tt *vdl.Type) error {
+	if src {
+		t.current.Bytes()[0] |= 1 << t.currentBitOffset
+	}
+	// shouldn't have to do anything for false
+	return nil
+}
+func (t target) FromUint(src uint64, tt *vdl.Type) error {
+	switch tt.Kind() {
+	case vdl.Byte:
+		t.current.Bytes()[0] = byte(src)
+	case vdl.Uint16:
+		binary.LittleEndian.PutUint16(t.current.Bytes(), uint16(src))
+	case vdl.Uint32:
+		binary.LittleEndian.PutUint32(t.current.Bytes(), uint32(src))
+	case vdl.Uint64:
+		binary.LittleEndian.PutUint64(t.current.Bytes(), src)
+	default:
+		return fmt.Errorf("invalid FromUint(%v, %v)", src, tt)
+	}
+	return nil
+}
+func (t target) FromInt(src int64, tt *vdl.Type) error {
+	switch tt.Kind() {
+	case vdl.Int16:
+		binary.LittleEndian.PutUint16(t.current.Bytes(), uint16(src))
+	case vdl.Int32:
+		binary.LittleEndian.PutUint32(t.current.Bytes(), uint32(src))
+	case vdl.Int64:
+		binary.LittleEndian.PutUint64(t.current.Bytes(), uint64(src))
+	default:
+		return fmt.Errorf("invalid FromInt(%v, %v)", src, tt)
+	}
+	return nil
+}
+func (t target) FromFloat(src float64, tt *vdl.Type) error {
+	switch tt.Kind() {
+	case vdl.Float32:
+		binary.LittleEndian.PutUint32(t.current.Bytes(), math.Float32bits(float32(src)))
+	case vdl.Float64:
+		binary.LittleEndian.PutUint64(t.current.Bytes(), math.Float64bits(src))
+	default:
+		return fmt.Errorf("invalid FromFloat(%v, %v)", src, tt)
+	}
+	return nil
+}
+func (t target) FromComplex(src complex128, tt *vdl.Type) error {
+	panic("UNIMPLEMENTED")
+}
+func (t target) writeBytes(src []byte) {
+	block := t.allocator().Allocate(uint32(len(src)), uint32(len(src)))
+	t.writePointer(block)
+	copy(block.Bytes(), src)
+}
+func (t target) FromBytes(src []byte, tt *vdl.Type) error {
+	t.writeBytes(src)
+	return nil
+}
+func (t target) FromString(src string, tt *vdl.Type) error {
+	t.writeBytes([]byte(src))
+	return nil
+}
+func (t target) FromEnumLabel(src string, tt *vdl.Type) error {
+	// enums in mojo are treated as an int32 on the wire (but have gaps in their values).
+	// This implementation assumes that we will use generated VDL values and not have gaps.
+	index := tt.EnumIndex(src)
+	binary.LittleEndian.PutUint32(t.current.Bytes(), uint32(index))
+	return nil
+}
+func (t target) FromTypeObject(src *vdl.Type) error {
+	panic("UNIMPLEMENTED")
+
+}
+func (t target) FromNil(tt *vdl.Type) error {
+	switch tt.Kind() {
+	case vdl.Optional:
+		elemType := tt.Elem()
+		switch elemType.Kind() {
+		case vdl.Union, vdl.Struct: // Array? String? Bytes? List? Set?
+			// Note: for union, this zeros 16 bytes, but for others it does just 8.
+			zeroBytes(t.current.Bytes())
+		default:
+			panic(fmt.Sprintf("Vdl type %v cannot be optional", tt))
+		}
+	case vdl.Any:
+		panic("Any rep not yet determined")
+	default:
+		panic("Type cannot be nil")
+	}
+	return nil
+}
+func zeroBytes(dat []byte) {
+	copy(dat, make([]byte, len(dat)))
+}
+
+func (t target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
+	if tt.Kind() == vdl.Optional {
+		tt = tt.Elem()
+	}
+	bitsNeeded := baseTypeSizeBits(tt.Elem()) * uint32(len)
+	block := t.allocator().Allocate((bitsNeeded+7)/8, uint32(len))
+	t.writePointer(block)
+	if tt.Elem().Kind() == vdl.Bool {
+		return &bitListTarget{
+			block: block,
+		}, nil
+	} else {
+		return &listTarget{
+			incrementSize: baseTypeSizeBits(tt.Elem()) / 8,
+			block:         block,
+		}, nil
+	}
+}
+func (t target) FinishList(x vdl.ListTarget) error {
+	return nil
+}
+
+// TODO(bprosnitz) This uses list, should we use map instead?
+func (t target) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {
+	if tt.Kind() == vdl.Optional {
+		tt = tt.Elem()
+	}
+	bitsNeeded := baseTypeSizeBits(tt.Key()) * uint32(len)
+	block := t.allocator().Allocate((bitsNeeded+7)/8, uint32(len))
+	t.writePointer(block)
+	if tt.Key().Kind() == vdl.Bool {
+		return &bitListTarget{
+			block: block,
+		}, nil
+	} else {
+		return &listTarget{
+			incrementSize: baseTypeSizeBits(tt.Key()) / 8,
+			block:         block,
+		}, nil
+	}
+}
+func (t target) FinishSet(x vdl.SetTarget) error {
+	return nil
+}
+func (t target) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
+	if tt.Kind() == vdl.Optional {
+		tt = tt.Elem()
+	}
+	pointerBlock := t.allocator().Allocate(16, 0)
+	t.writePointer(pointerBlock)
+
+	st := target{
+		current: pointerBlock.Slice(0, 8),
+	}
+	setTarget, err := st.StartSet(vdl.SetType(tt.Key()), len)
+	if err != nil {
+		return nil, err
+	}
+	lt := target{
+		current: pointerBlock.Slice(8, 16),
+	}
+	listTarget, err := lt.StartList(vdl.ListType(tt.Elem()), len)
+	if err != nil {
+		return nil, err
+	}
+	return &mapTarget{
+		setTarget:  setTarget,
+		listTarget: listTarget,
+	}, nil
+}
+func (t target) FinishMap(x vdl.MapTarget) error {
+	return nil
+}
+func (t target) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+	if tt.Kind() == vdl.Optional {
+		tt = tt.Elem()
+	}
+	if tt.Kind() == vdl.Union {
+		return unionFieldsTarget{
+			vdlType: tt,
+			block:   t.current,
+		}, nil
+	}
+	block := t.allocator().Allocate(neededStructAllocationSize(tt), 0)
+	t.writePointer(block)
+	return fieldsTarget{
+			vdlType: tt,
+			block:   block,
+		},
+		nil
+}
+func (t target) FinishFields(x vdl.FieldsTarget) error {
+	return nil
+}
+
+func (t target) writePointer(alloc bytesRef) {
+	offset := alloc.AsPointer(t.current)
+	binary.LittleEndian.PutUint64(t.current.Bytes(), uint64(offset))
+}
diff --git a/go/src/v.io/mojo/transcoder/type.go b/go/src/v.io/mojo/transcoder/type.go
new file mode 100644
index 0000000..3fc7c35
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/type.go
@@ -0,0 +1,265 @@
+package mojovdl
+
+import (
+	"fmt"
+
+	"mojo/public/interfaces/bindings/mojom_types"
+
+	"v.io/v23/vdl"
+)
+
+/*// Given a descriptor mapping, produce 2 maps.
+// The former maps from mojom identifiers to VDL Type.
+// The latter maps from VDL Type string (hash cons) to the mojom identifier.
+// These maps are used to interconvert more easily.
+func AnalyzeMojomDescriptors(mp map[string]mojom_types.UserDefinedType) map[string]*vdl.Type {
+	m2V := make(map[string]*vdl.Type)
+	for s, udt := range mp {
+		m2V[s] = mojomToVDLTypeUDT(udt, mp)
+	}
+	return m2V
+}*/
+
+// Convert the known type reference to a vdl type.
+// Panics if the type reference was not known.
+/*func TypeReferenceToVDLType(tr mojom_types.TypeReference, mp map[string]mojom_types.UserDefinedType) *vdl.Type {
+	if udt, ok := mp[tr.TypeKey]; ok {
+		return mojomToVDLTypeUDT(udt, mp)
+	}
+	panic("Type Key %s was not present in the mapping", tr.typeKey)
+}*/
+
+func mojomToVDLTypeUDT(udt mojom_types.UserDefinedType, mp map[string]mojom_types.UserDefinedType) (vt *vdl.Type) {
+	u := interface{}(udt)
+	switch u := u.(type) { // To do the type switch, udt has to be converted to interface{}.
+	case *mojom_types.UserDefinedTypeEnumType: // enum
+		me := u.Value
+
+		// TODO: Assumes that the maximum enum index is len(me.Values) - 1.
+		labels := make([]string, len(me.Values))
+		for _, ev := range me.Values { // per EnumValue...
+			// EnumValue contains a ConstantOccurrence
+			// ConstantOccurrence contains a ConstantValue
+			// ConstantValue is a union that contains an EnumConstantValue
+			ecv := ev.Value.Value.(*mojom_types.ConstantValueEnumValue).Value
+
+			// EnumConstantValue contains the EnumValueName and IntValue
+			labels[int(ecv.IntValue)] = *ecv.EnumValueName
+		}
+
+		vt = vdl.NamedType(*me.DeclData.ShortName, vdl.EnumType(labels...))
+	case *mojom_types.UserDefinedTypeStructType: // struct
+		ms := u.Value
+
+		vt = MojomStructToVDLType(ms, mp)
+	case *mojom_types.UserDefinedTypeUnionType: // union
+		mu := u.Value
+
+		vfields := make([]vdl.Field, len(mu.Fields))
+		for ix, mfield := range mu.Fields {
+			vfields[ix] = vdl.Field{
+				Name: *mfield.DeclData.ShortName,
+				Type: MojomToVDLType(mfield.Type, mp),
+			}
+		}
+		vt = vdl.NamedType(*mu.DeclData.ShortName, vdl.UnionType(vfields...))
+	case *mojom_types.UserDefinedTypeInterfaceType: // interface
+		panic("interfaces don't exist in vdl")
+	default: // unknown
+		panic(fmt.Errorf("user defined type %#v with unknown tag %d", udt, udt.Tag()))
+	}
+	return vt
+}
+
+func MojomStructToVDLType(ms mojom_types.MojomStruct, mp map[string]mojom_types.UserDefinedType) (vt *vdl.Type) {
+	vfields := make([]vdl.Field, len(ms.Fields))
+	for ix, mfield := range ms.Fields {
+		vfields[ix] = vdl.Field{
+			Name: *mfield.DeclData.ShortName,
+			Type: MojomToVDLType(mfield.FieldType, mp),
+		}
+	}
+	vt = vdl.NamedType(*ms.DeclData.ShortName, vdl.StructType(vfields...))
+	return vt
+}
+
+// Given a mojom Type and the descriptor mapping, produce the corresponding vdltype.
+func MojomToVDLType(mojomtype mojom_types.Type, mp map[string]mojom_types.UserDefinedType) (vt *vdl.Type) {
+	// TODO(alexfandrianto): Cyclic types?
+	mt := interface{}(mojomtype)
+	switch mt := interface{}(mt).(type) { // To do the type switch, mt has to be converted to interface{}.
+	case *mojom_types.TypeSimpleType: // TypeSimpleType
+		switch mt.Value {
+		case mojom_types.SimpleType_Bool:
+			vt = vdl.BoolType
+		case mojom_types.SimpleType_Double:
+			vt = vdl.BoolType
+		case mojom_types.SimpleType_Float:
+			vt = vdl.BoolType
+		case mojom_types.SimpleType_InT8:
+			panic("int8 doesn't exist in vdl")
+		case mojom_types.SimpleType_InT16:
+			vt = vdl.Int16Type
+		case mojom_types.SimpleType_InT32:
+			vt = vdl.Int32Type
+		case mojom_types.SimpleType_InT64:
+			vt = vdl.Int64Type
+		case mojom_types.SimpleType_UinT8:
+			vt = vdl.ByteType
+		case mojom_types.SimpleType_UinT16:
+			vt = vdl.Uint16Type
+		case mojom_types.SimpleType_UinT32:
+			vt = vdl.Uint32Type
+		case mojom_types.SimpleType_UinT64:
+			vt = vdl.Uint64Type
+		}
+	case *mojom_types.TypeStringType: // TypeStringType
+		st := mt.Value
+		if st.Nullable {
+			panic("nullable strings don't exist in vdl")
+		}
+		vt = vdl.StringType
+	case *mojom_types.TypeArrayType: // TypeArrayType
+		at := mt.Value
+		if at.Nullable {
+			panic("nullable arrays don't exist in vdl")
+		}
+		if at.FixedLength > 0 {
+			vt = vdl.ArrayType(int(at.FixedLength), MojomToVDLType(at.ElementType, mp))
+		} else {
+			vt = vdl.ListType(MojomToVDLType(at.ElementType, mp))
+		}
+	case *mojom_types.TypeMapType: // TypeMapType
+		// Note that mojom doesn't have sets.
+		m := mt.Value
+		if m.Nullable {
+			panic("nullable maps don't exist in vdl")
+		}
+		vt = vdl.MapType(MojomToVDLType(m.KeyType, mp), MojomToVDLType(m.ValueType, mp))
+	case *mojom_types.TypeHandleType: // TypeHandleType
+		panic("handles don't exist in vdl")
+	case *mojom_types.TypeTypeReference: // TypeTypeReference
+		tr := mt.Value
+		if tr.IsInterfaceRequest {
+			panic("interface requests don't exist in vdl")
+		}
+		udt := mp[*tr.TypeKey]
+		if udt.Tag() != 1 && tr.Nullable {
+			panic("nullable non-struct type reference cannot be represented in vdl")
+		}
+		vt = mojomToVDLTypeUDT(udt, mp)
+	default:
+		panic(fmt.Errorf("%#v has unknown tag %d", mojomtype, mojomtype.Tag()))
+	}
+
+	return vt
+}
+
+/*func V2M(vt *vdl.Type, v2M map[string]string) mojom_types.Type {
+	if m, ok := v2M[vt.String()]; ok {
+		return mojom_types.TypeTypeReference{
+			Value: mojom_types.TypeReference{
+				Nullable:   nullable,
+				Identifier: m,
+				TypeKey:    m,
+			},
+		}
+	}
+	panic("vdl type %#v was not present in the mapping", vt)
+}
+
+// From the vdltype and the reverse mapping of the descriptor (hashcons vdltype string => typekey),
+// produce the corresponding mojom Type.
+func VDLToMojomType(vt *vdl.Type, v2M map[string]string) mojom_types.Type {
+	return vdlToMojomTypeImpl(vt, v2M, false)
+}
+
+func vdlToMojomTypeImpl(vt *vdl.Type, v2M map[string]string, bool nullable) mojom_types.Type {
+	if m, ok := v2M[vt.String()]; ok {
+		return mojom_types.TypeTypeReference{
+			Value: mojom_types.TypeReference{
+				Nullable:   nullable,
+				Identifier: m,
+				TypeKey:    m,
+			},
+		}
+	}
+
+	fmt.Println("Missed the vdl to mojom map")
+	// In the unlikely case where v2M was insufficient, we have the remaining logic.
+
+	switch vt.Kind() {
+	case vdl.Bool:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_Bool}
+	case vdl.Byte:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_UinT8}
+	case vdl.Uint16:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_UinT16}
+	case vdl.Uint32:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_UinT32}
+	case vdl.Uint64:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_UinT64}
+	case vdl.Int16:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_InT16}
+	case vdl.Int32:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_InT32}
+	case vdl.Int64:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_InT64}
+	case vdl.Float32:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_Float}
+	case vdl.Float64:
+		return mojom_types.TypeSimpleType{Value: mojom_types.SimpleType_Double}
+	case vdl.Complex64:
+		panic("complex float doesn't exist in mojom")
+	case vdl.Complex128:
+		panic("complex double doesn't exist in mojom")
+	case vdl.String:
+		return mojom_types.TypeStringType{Value: mojom_types.StringType{}}
+	case vdl.Array:
+		elemType := VDLToMojomType(vt.Elem(), v2M)
+		return mojom_types.TypeArrayType{
+			Value: mojom_types.ArrayType{
+				FixedLength: int64(vt.Len()),
+				ElementType: elemType,
+			},
+		}
+	case vdl.List:
+		elemType := VDLToMojomType(vt.Elem(), v2M)
+		return mojom_types.TypeArrayType{
+			Value: mojom_types.ArrayType{
+				FixedLength: -1,
+				ElementType: elemType,
+			},
+		}
+	case vdl.Set:
+		panic("set doesn't exist in mojom")
+	case vdl.Map:
+		keyType := VDLToMojomType(vt.Key(), v2M)
+		elemType := VDLToMojomType(vt.Elem(), v2M)
+		return mojom_types.TypeMapType{
+			Value: mojom_types.MapType{
+				KeyType:   &keyType,
+				ValueType: &elemType,
+			},
+		}
+	case vdl.Struct, vdl.Union, vdl.Enum:
+		mt := mojom_types.TypeTypeReference{
+			Value: mojom_types.TypeReference{
+				Nullable:   nullable,
+				Identifier: v2M[vt.String()],
+				TypeKey:    v2M[vt.String()],
+			},
+		}
+		return mt
+	case vdl.TypeObject:
+		panic("typeobject doesn't exist in mojom")
+	case vdl.Any:
+		panic("any doesn't exist in mojom")
+	case vdl.Optional:
+		// TODO(alexfandrianto): Unfortunately, without changing vdl, we can only
+		// manage optional (named) structs. This doesn't Nullify anything else.
+		return vdlToMojomTypeImpl(vt.Elem(), v2M, true)
+	}
+	panic(fmt.Errorf("%v can't be converted to MojomType", vt))
+}
+*/
diff --git a/go/src/v.io/mojo/transcoder/typed_targets.go b/go/src/v.io/mojo/transcoder/typed_targets.go
new file mode 100644
index 0000000..d09160e
--- /dev/null
+++ b/go/src/v.io/mojo/transcoder/typed_targets.go
@@ -0,0 +1,123 @@
+package mojovdl
+
+import (
+	"encoding/binary"
+
+	"v.io/v23/vdl"
+)
+
+// for struct
+type fieldsTarget struct {
+	vdlType *vdl.Type
+	block   bytesRef
+}
+
+func (fe fieldsTarget) StartField(name string) (key, field vdl.Target, _ error) {
+	fieldType, fieldIndex := fe.vdlType.FieldByName(name)
+	byteOffset, bitOffset := offsetInStruct(fieldIndex, fe.vdlType)
+	numBits := baseTypeSizeBits(fieldType.Type)
+	refSize := (numBits + 7) / 8
+	newRef := fe.block.Slice(byteOffset, byteOffset+refSize)
+	return nil, target{
+		currentBitOffset: bitOffset,
+		current:          newRef,
+	}, nil
+}
+func (fieldsTarget) FinishField(key, field vdl.Target) error {
+	return nil
+}
+
+type unionFieldsTarget struct {
+	vdlType *vdl.Type
+	block   bytesRef
+}
+
+func (ufe unionFieldsTarget) StartField(name string) (key, field vdl.Target, _ error) {
+	fld, index := ufe.vdlType.FieldByName(name)
+	binary.LittleEndian.PutUint32(ufe.block.Bytes(), 16)
+	binary.LittleEndian.PutUint32(ufe.block.Bytes()[4:], uint32(index))
+
+	valueSlice := ufe.block.Slice(8, 16)
+	if fld.Type.Kind() == vdl.Union {
+		// nested union, create a pointer to the body
+		nestedUnionBlock := ufe.block.allocator.Allocate(8, 0)
+		offset := nestedUnionBlock.AsPointer(valueSlice)
+		binary.LittleEndian.PutUint64(valueSlice.Bytes(), uint64(offset))
+		return nil, target{
+			currentBitOffset: 0,
+			current:          nestedUnionBlock.SignedSlice(-8, 8),
+		}, nil
+	}
+	return nil, target{
+		currentBitOffset: 0,
+		current:          valueSlice,
+	}, nil
+}
+func (unionFieldsTarget) FinishField(key, field vdl.Target) error {
+	return nil
+}
+
+// doubles as set target
+type listTarget struct {
+	incrementSize uint32
+	block         bytesRef
+	nextPosition  uint32
+}
+
+func (lt *listTarget) StartElem(index int) (elem vdl.Target, _ error) {
+	// TODO(bprosnitz) Index is ignored -- we should probably remove this from Target.
+	sliceBlock := lt.block.Slice(lt.nextPosition, lt.nextPosition+lt.incrementSize)
+	lt.nextPosition += lt.incrementSize
+	return target{
+		current: sliceBlock,
+	}, nil
+}
+func (lt *listTarget) StartKey() (key vdl.Target, _ error) {
+	return lt.StartElem(0)
+}
+func (listTarget) FinishElem(elem vdl.Target) error {
+	return nil
+}
+func (listTarget) FinishKey(key vdl.Target) error {
+	return nil
+}
+
+type bitListTarget struct {
+	block           bytesRef
+	nextBitPosition uint32
+}
+
+func (blt *bitListTarget) StartElem(index int) (elem vdl.Target, _ error) {
+	bitPos := blt.nextBitPosition
+	blt.nextBitPosition++
+	byteIndex := bitPos / 8
+	sliceBlock := blt.block.Slice(byteIndex, byteIndex+1)
+	return target{
+		currentBitOffset: uint8(bitPos % 8),
+		current:          sliceBlock,
+	}, nil
+}
+func (blt *bitListTarget) StartKey() (key vdl.Target, _ error) {
+	return blt.StartElem(0)
+}
+func (bitListTarget) FinishElem(elem vdl.Target) error {
+	return nil
+}
+func (bitListTarget) FinishKey(key vdl.Target) error {
+	return nil
+}
+
+type mapTarget struct {
+	listTarget vdl.ListTarget
+	setTarget  vdl.SetTarget
+}
+
+func (mt *mapTarget) StartKey() (key vdl.Target, _ error) {
+	return mt.setTarget.StartKey()
+}
+func (mt *mapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
+	return mt.listTarget.StartElem(0)
+}
+func (mapTarget) FinishField(key, field vdl.Target) error {
+	return nil
+}