diff --git a/cue/build.go b/cue/build.go
index 4ac5214..8487a2b 100644
--- a/cue/build.go
+++ b/cue/build.go
@@ -39,13 +39,22 @@
 	internal.GetRuntime = func(instance interface{}) interface{} {
 		return &Runtime{idx: instance.(*Instance).index}
 	}
+
+	internal.CheckAndForkRuntime = func(runtime, value interface{}) interface{} {
+		r := runtime.(*Runtime)
+		idx := value.(Value).ctx().index
+		if idx != r.idx {
+			panic("value not from same runtime")
+		}
+		return &Runtime{idx: newIndex(idx)}
+	}
 }
 
 func dummyLoad(token.Pos, string) *build.Instance { return nil }
 
 func (r *Runtime) index() *index {
 	if r.idx == nil {
-		r.idx = newIndex()
+		r.idx = newIndex(sharedIndex)
 	}
 	return r.idx
 }
@@ -197,12 +206,19 @@
 
 	offset label
 	parent *index
-	freeze bool
 
 	mutex     sync.Mutex
 	typeCache sync.Map // map[reflect.Type]evaluated
 }
 
+// work around golang-ci linter bug: fields are used.
+func init() {
+	var i index
+	i.mutex.Lock()
+	i.mutex.Unlock()
+	i.typeCache.Load(1)
+}
+
 const sharedOffset = 0x40000000
 
 // sharedIndex is used for indexing builtins and any other labels common to
@@ -225,8 +241,7 @@
 }
 
 // newIndex creates a new index.
-func newIndex() *index {
-	parent := sharedIndex
+func newIndex(parent *index) *index {
 	i := &index{
 		labelMap:      map[string]label{},
 		loaded:        map[*build.Instance]*Instance{},
@@ -235,7 +250,6 @@
 		offset:        label(len(parent.labels)) + parent.offset,
 		parent:        parent,
 	}
-	parent.freeze = true
 	return i
 }
 
@@ -267,9 +281,6 @@
 func (idx *index) label(s string, isIdent bool) label {
 	f, ok := idx.findLabel(s)
 	if !ok {
-		if idx.freeze {
-			panic("adding label to frozen index")
-		}
 		f = label(len(idx.labelMap)) + idx.offset
 		idx.labelMap[s] = f
 		idx.labels = append(idx.labels, s)
diff --git a/cue/builtin.go b/cue/builtin.go
index af15465..dc73586 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -257,7 +257,7 @@
 	if e, ok := call.ret.(value); ok {
 		return e
 	}
-	return convert(ctx, x, call.ret)
+	return convert(ctx, x, false, call.ret)
 }
 
 // callCtxt is passed to builtin implementations.
diff --git a/cue/go.go b/cue/go.go
index 7012edf..b61026d 100644
--- a/cue/go.go
+++ b/cue/go.go
@@ -36,8 +36,8 @@
 // optimized.
 
 func init() {
-	internal.FromGoValue = func(runtime, x interface{}) interface{} {
-		return convertValue(runtime.(*Runtime), x)
+	internal.FromGoValue = func(runtime, x interface{}, allowDefault bool) interface{} {
+		return convertValue(runtime.(*Runtime), x, allowDefault)
 	}
 
 	internal.FromGoType = func(runtime, x interface{}) interface{} {
@@ -45,9 +45,9 @@
 	}
 }
 
-func convertValue(r *Runtime, x interface{}) Value {
+func convertValue(r *Runtime, x interface{}, allowDefault bool) Value {
 	ctx := r.index().newContext()
-	v := convert(ctx, baseValue{}, x)
+	v := convert(ctx, baseValue{}, allowDefault, x)
 	return newValueRoot(ctx, v)
 }
 
@@ -187,17 +187,20 @@
 	}
 }
 
-func convert(ctx *context, src source, x interface{}) evaluated {
-	v := convertRec(ctx, src, x)
+func convert(ctx *context, src source, allowDefault bool, x interface{}) evaluated {
+	v := convertRec(ctx, src, allowDefault, x)
 	if v == nil {
 		return ctx.mkErr(baseValue{}, "unsupported Go type (%v)", v)
 	}
 	return v
 }
 
-func convertRec(ctx *context, src source, x interface{}) evaluated {
+func convertRec(ctx *context, src source, allowDefault bool, x interface{}) evaluated {
 	switch v := x.(type) {
 	case nil:
+		if !allowDefault {
+			return &nullLit{src.base()}
+		}
 		// Interpret a nil pointer as an undefined value that is only
 		// null by default, but may still be set: *null | _.
 		return makeNullable(&top{src.base()}, false).(evaluated)
@@ -291,16 +294,16 @@
 		return toUint(ctx, src, uint64(v))
 	case float64:
 		r := newNum(src, floatKind)
-		r.v.SetString(fmt.Sprintf("%g", v))
+		_, _, _ = r.v.SetString(fmt.Sprintf("%g", v))
 		return r
 	case float32:
 		r := newNum(src, floatKind)
-		r.v.SetString(fmt.Sprintf("%g", v))
+		_, _, _ = r.v.SetString(fmt.Sprintf("%g", v))
 		return r
 
 	case reflect.Value:
 		if v.CanInterface() {
-			return convertRec(ctx, src, v.Interface())
+			return convertRec(ctx, src, allowDefault, v.Interface())
 		}
 
 	default:
@@ -321,16 +324,19 @@
 			return toUint(ctx, src, value.Uint())
 
 		case reflect.Float32, reflect.Float64:
-			return convertRec(ctx, src, value.Float())
+			return convertRec(ctx, src, allowDefault, value.Float())
 
 		case reflect.Ptr:
 			if value.IsNil() {
+				if !allowDefault {
+					return &nullLit{src.base()}
+				}
 				// Interpret a nil pointer as an undefined value that is only
 				// null by default, but may still be set: *null | _.
 				elem := goTypeToValue(ctx, false, reflect.TypeOf(v).Elem())
 				return makeNullable(elem, false).(evaluated)
 			}
-			return convertRec(ctx, src, value.Elem().Interface())
+			return convertRec(ctx, src, allowDefault, value.Elem().Interface())
 
 		case reflect.Struct:
 			obj := newStruct(src)
@@ -344,7 +350,7 @@
 				if isOmitEmpty(&t) && isZero(val) {
 					continue
 				}
-				sub := convertRec(ctx, src, val.Interface())
+				sub := convertRec(ctx, src, allowDefault, val.Interface())
 				if sub == nil {
 					// mimic behavior of encoding/json: skip fields of unsupported types
 					continue
@@ -383,7 +389,7 @@
 					sorted = append(sorted, s)
 
 					val := value.MapIndex(k).Interface()
-					sub := convertRec(ctx, src, val)
+					sub := convertRec(ctx, src, allowDefault, val)
 					// mimic behavior of encoding/json: report error of
 					// unsupported type.
 					if sub == nil {
@@ -419,7 +425,7 @@
 			arcs := []arc{}
 			for i := 0; i < value.Len(); i++ {
 				val := value.Index(i).Interface()
-				x := convertRec(ctx, src, val)
+				x := convertRec(ctx, src, allowDefault, val)
 				if x == nil {
 					return ctx.mkErr(baseValue{}, "unsupported Go type (%v)", val)
 				}
diff --git a/cue/go_test.go b/cue/go_test.go
index cedfbe8..fe8133b 100644
--- a/cue/go_test.go
+++ b/cue/go_test.go
@@ -130,7 +130,7 @@
 	for _, tc := range testCases {
 		ctx := inst.newContext()
 		t.Run("", func(t *testing.T) {
-			v := convert(ctx, newNode(b), tc.goVal)
+			v := convert(ctx, newNode(b), true, tc.goVal)
 			got := debugStr(ctx, v)
 			if got != tc.want {
 				t.Errorf("got %q; want %q", got, tc.want)
diff --git a/cue/instance.go b/cue/instance.go
index 1083cd0..2b1d551 100644
--- a/cue/instance.go
+++ b/cue/instance.go
@@ -279,7 +279,7 @@
 	for i := len(path) - 1; i >= 0; i-- {
 		x = map[string]interface{}{path[i]: x}
 	}
-	value := convert(ctx, root, x)
+	value := convert(ctx, root, true, x)
 	eval := binOp(ctx, baseValue{}, opUnify, root, value)
 	// TODO: validate recursively?
 	err := inst.Err
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index eaf637f..34798b2 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -43,7 +43,7 @@
 	inst, err := r.Parse("test", body)
 
 	if err != nil {
-		x := newIndex().newInstance(nil)
+		x := newIndex(sharedIndex).newInstance(nil)
 		ctx := x.newContext()
 		return ctx, x, err
 	}
diff --git a/cuego/cuego.go b/cuego/cuego.go
index 6f8e35c..63647d9 100644
--- a/cuego/cuego.go
+++ b/cuego/cuego.go
@@ -75,7 +75,7 @@
 // function.
 func (c *Context) Validate(x interface{}) error {
 	a := c.load(x)
-	v, err := fromGoValue(x)
+	v, err := fromGoValue(x, false)
 	if err != nil {
 		return err
 	}
@@ -99,7 +99,7 @@
 // successful update.
 func (c *Context) Complete(x interface{}) error {
 	a := c.load(x)
-	v, err := fromGoValue(x)
+	v, err := fromGoValue(x, true)
 	if err != nil {
 		return err
 	}
@@ -171,12 +171,12 @@
 }
 
 // fromGoValue converts a Go value to CUE
-func fromGoValue(x interface{}) (v cue.Value, err error) {
+func fromGoValue(x interface{}, allowDefault bool) (v cue.Value, err error) {
 	// TODO: remove the need to have a lock here. We could use a new index (new
 	// Instance) here as any previously unrecognized field can never match an
 	// existing one and can only be merged.
 	mutex.Lock()
-	v = internal.FromGoValue(runtime, x).(cue.Value)
+	v = internal.FromGoValue(runtime, x, allowDefault).(cue.Value)
 	mutex.Unlock()
 	if err := v.Err(); err != nil {
 		return v, err
diff --git a/encoding/gocode/doc.go b/encoding/gocode/doc.go
new file mode 100644
index 0000000..7bf0af6
--- /dev/null
+++ b/encoding/gocode/doc.go
@@ -0,0 +1,20 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package gocode defines functions for extracting CUE definitions from Go code
+// and generating Go code from CUE values.
+//
+// This package is used for offline processing. For converting Go values to and
+// from CUE at runtime, use the gocodec package.
+package gocode
diff --git a/encoding/gocode/gen_test.go b/encoding/gocode/gen_test.go
new file mode 100644
index 0000000..6f01c2b
--- /dev/null
+++ b/encoding/gocode/gen_test.go
@@ -0,0 +1,89 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !gen
+
+package gocode
+
+import (
+	"strings"
+	"testing"
+
+	"cuelang.org/go/encoding/gocode/testdata/pkg1"
+	"cuelang.org/go/encoding/gocode/testdata/pkg2"
+)
+
+func TestPackages(t *testing.T) {
+	testCases := []struct {
+		name string
+		got  error
+		want string
+	}{{
+		name: "failing int",
+		got: func() error {
+			v := pkg2.PickMe(4)
+			return v.Validate()
+		}(),
+		want: "invalid value 4 (out of bound >5):\n    pkg2/instance.cue:x:x",
+	}, {
+		name: "failing field with validator",
+		got: func() error {
+			v := &pkg1.OtherStruct{A: "car"}
+			return v.Validate()
+		}(),
+		want: "A: invalid value \"car\" (does not satisfy strings.ContainsAny(\"X\")):\n    pkg1/instance.cue:x:x",
+	}, {
+		name: "failing field of type int",
+		got: func() error {
+			v := &pkg1.MyStruct{A: 11, B: "dog"}
+			return v.Validate()
+		}(),
+		want: "A: invalid value 11 (out of bound <=10):\n    pkg1/instance.cue:x:x",
+	}, {
+		name: "failing nested struct ",
+		got: func() error {
+			v := &pkg1.MyStruct{A: 5, B: "dog", O: &pkg1.OtherStruct{A: "car"}}
+			return v.Validate()
+		}(),
+		want: "O.A: invalid value \"car\" (does not satisfy strings.ContainsAny(\"X\")):\n    pkg1/instance.cue:x:x",
+	}, {
+		name: "fail nested struct of different package",
+		got: func() error {
+			v := &pkg1.MyStruct{A: 5, B: "dog", O: &pkg1.OtherStruct{A: "X", P: 4}}
+			return v.Validate()
+		}(),
+		want: "O.P: invalid value 4 (out of bound >5):\n    pkg2/instance.cue:x:x",
+	}, {
+		name: "all good",
+		got: func() error {
+			v := &pkg1.MyStruct{
+				A: 5,
+				B: "dog",
+				I: &pkg2.ImportMe{A: 1000, B: "a"},
+			}
+			return v.Validate()
+		}(),
+		want: "nil",
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := strings.TrimSpace(errStr(tc.got))
+			want := tc.want
+			if got != want {
+				t.Errorf("got:\n%q\nwant:\n%q", got, want)
+			}
+
+		})
+	}
+}
diff --git a/encoding/gocode/generator.go b/encoding/gocode/generator.go
new file mode 100644
index 0000000..494edf1
--- /dev/null
+++ b/encoding/gocode/generator.go
@@ -0,0 +1,277 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gocode
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/types"
+	"text/template"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/internal"
+	"golang.org/x/tools/go/packages"
+)
+
+// Config defines options for generation Go code.
+type Config struct {
+	// Prefix is used as a prefix to all generated variables. It defaults to
+	// cuegen.
+	Prefix string
+
+	// ValidateName defines the default name for validation methods or prefix
+	// for validation functions. The default is "Validate". Set to "-" to
+	// disable generating validators.
+	ValidateName string
+
+	// CompleteName defines the default name for complete methods or prefix
+	// for complete functions. The default is "-" (disabled).
+	CompleteName string
+
+	// The cue.Runtime variable name to use for initializing Codecs.
+	// A new Runtime is created by default.
+	RuntimeVar string
+}
+
+const defaultPrefix = "cuegen"
+
+// Generate generates Go code for the given instance in the directory of the
+// given package.
+//
+// Generate converts top-level declarations to corresponding Go code. By default,
+// it will only generate validation functions of methods for exported top-level
+// declarations. The behavior can be altered with the @go attribute.
+//
+// The go attribute has the following form @go(<name>{,<option>}), where option
+// is either a key-value pair or a flag. The name maps the CUE name to an
+// alternative Go name. The special value '-' is used to indicate the field
+// should be ignored for any Go generation.
+//
+// The following options are supported:
+//
+//     type=<gotype>    The Go type as which this value should be interpreted.
+//                      This defaults to the type with the (possibly overridden)
+//                      name of the field.
+//     validate=<name>  Alternative name for the validation function or method
+//                      Setting this to the empty string disables generation.
+//     complete=<name>  Alternative name for the validation function or method.
+//                      Setting this to the empty string disables generation.
+//     func             Generate as a function instead of a method.
+//
+//
+// Selection and Naming
+//
+// Generate will not generate any code for fields that have no go attribute
+// and that are not exported or for which there is no namesake Go type.
+// If the go attribute has the special value '-' as its name it wil be dropped
+// as well. In all other cases Generate will generate Go code, even if the
+// resulting code will not compile. For instance, Generate will generate Go
+// code even if the user defines a Go type in the attribute that does not
+// exist.
+//
+// If a field selected for generation and the go name matches that the name of
+// the Go type, the corresponding validate and complete code are generated as
+// methods by default. If not, it will be generated as a function. The default
+// function name is the default operation name with the Go name as a suffix.
+//
+//
+// Caveats
+// Currently not supported:
+//   - option to generate Go structs (or automatically generate if undefined)
+//   - for type option to refer to types outside the package.
+//
+func Generate(pkgPath string, inst *cue.Instance, c *Config) (b []byte, err error) {
+	// TODO: if inst is nil, the instance is loaded from CUE files in the same
+	// package directory with the same package name.
+	if err = inst.Value().Validate(); err != nil {
+		return nil, err
+	}
+	if c == nil {
+		c = &Config{}
+	}
+	g := &generator{
+		Config: *c,
+
+		typeMap: map[string]types.Type{},
+	}
+
+	pkgName := inst.Name
+
+	if pkgPath != "" {
+		loadCfg := &packages.Config{
+			Mode: packages.LoadAllSyntax,
+		}
+		pkgs, err := packages.Load(loadCfg, pkgPath)
+		if err != nil {
+			return nil, fmt.Errorf("generating failed: %v", err)
+		}
+
+		if len(pkgs) != 1 {
+			return nil, fmt.Errorf(
+				"generate only allowed for one package at a time, found %d",
+				len(pkgs))
+		}
+
+		g.pkg = pkgs[0]
+		if len(g.pkg.Errors) > 0 {
+			for _, err := range g.pkg.Errors {
+				g.addErr(err)
+			}
+			return nil, g.err
+		}
+
+		pkgName = g.pkg.Name
+
+		for _, obj := range g.pkg.TypesInfo.Defs {
+			if obj == nil || obj.Pkg() != g.pkg.Types {
+				continue
+			}
+			g.typeMap[obj.Name()] = obj.Type()
+		}
+	}
+
+	// TODO: add package doc if there is no existing Go package or if it doesn't
+	// have package documentation already.
+	g.exec(headerCode, map[string]string{
+		"pkgName": pkgName,
+	})
+
+	iter, err := inst.Value().Fields()
+	g.addErr(err)
+
+	for iter.Next() {
+		g.decl(iter.Label(), iter.Value())
+	}
+
+	r := internal.GetRuntime(inst).(*cue.Runtime)
+	b, err = r.Marshal(inst)
+	g.addErr(err)
+
+	g.exec(loadCode, map[string]string{
+		"runtime": g.RuntimeVar,
+		"prefix":  strValue(g.Prefix, defaultPrefix),
+		"data":    string(b),
+	})
+
+	if g.err != nil {
+		return nil, g.err
+	}
+
+	b, err = format.Source(g.w.Bytes())
+	if err != nil {
+		// Return bytes as well to allow analysis of the failed Go code.
+		return g.w.Bytes(), err
+	}
+
+	return b, err
+}
+
+type generator struct {
+	Config
+	pkg     *packages.Package
+	typeMap map[string]types.Type
+
+	w   bytes.Buffer
+	err errors.Error
+}
+
+func (g *generator) addErr(err error) {
+	if err != nil {
+		g.err = errors.Append(g.err, errors.Promote(err, "generate failed"))
+	}
+}
+
+func (g *generator) exec(t *template.Template, data interface{}) {
+	g.addErr(t.Execute(&g.w, data))
+}
+
+func (g *generator) decl(name string, v cue.Value) {
+	attr := v.Attribute("go")
+
+	if !ast.IsExported(name) && attr.Err() != nil {
+		return
+	}
+
+	goName := name
+	switch s, _ := attr.String(0); s {
+	case "":
+	case "-":
+		return
+	default:
+		goName = s
+	}
+
+	goTypeName := goName
+	goType := ""
+	if str, ok, _ := attr.Lookup(1, "type"); ok {
+		goType = str
+		goTypeName = str
+	}
+
+	isFunc, _ := attr.Flag(1, "func")
+	if goTypeName != goName {
+		isFunc = true
+	}
+
+	zero := "nil"
+
+	typ := g.typeMap[goTypeName]
+	if goType == "" {
+		goType = goTypeName
+		if typ != nil {
+			switch typ.Underlying().(type) {
+			case *types.Struct, *types.Array:
+				goType = "*" + goTypeName
+				zero = fmt.Sprintf("&%s{}", goTypeName)
+			case *types.Pointer:
+				zero = fmt.Sprintf("%s(nil)", goTypeName)
+				isFunc = true
+			}
+		}
+	}
+
+	g.exec(stubCode, map[string]interface{}{
+		"prefix":  strValue(g.Prefix, defaultPrefix),
+		"cueName": name,   // the field name of the CUE type
+		"goType":  goType, // the receiver or argument type
+		"zero":    zero,   // the zero value of the underlying type
+
+		// @go attribute options
+		"func":     isFunc,
+		"validate": lookupName(attr, "validate", strValue(g.ValidateName, "Validate")),
+		"complete": lookupName(attr, "complete", g.CompleteName),
+	})
+}
+
+func lookupName(attr cue.Attribute, option, config string) string {
+	name, ok, _ := attr.Lookup(1, option)
+	if !ok {
+		name = config
+	}
+	if name == "-" {
+		return ""
+	}
+	return name
+}
+
+func strValue(have, fallback string) string {
+	if have == "" {
+		return fallback
+	}
+	return have
+}
diff --git a/encoding/gocode/generator_test.go b/encoding/gocode/generator_test.go
new file mode 100644
index 0000000..70e0aa8
--- /dev/null
+++ b/encoding/gocode/generator_test.go
@@ -0,0 +1,84 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gocode
+
+import (
+	"bytes"
+	"flag"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"testing"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/load"
+)
+
+var update = flag.Bool("update", false, "update test files")
+
+func TestGenerate(t *testing.T) {
+	dirs, err := ioutil.ReadDir("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, d := range dirs {
+		if !d.IsDir() {
+			continue
+		}
+		t.Run(d.Name(), func(t *testing.T) {
+			dir := filepath.Join(cwd, "testdata")
+			pkg := "." + string(filepath.Separator) + d.Name()
+			inst := cue.Build(load.Instances([]string{pkg}, &load.Config{
+				Dir:        dir,
+				ModuleRoot: dir,
+				Module:     "cuelang.org/go/encoding/gocode/testdata",
+			}))[0]
+			if err := inst.Err; err != nil {
+				t.Fatal(err)
+			}
+
+			goPkg := "./testdata/" + d.Name()
+			b, err := Generate(goPkg, inst, nil)
+			if err != nil {
+				t.Fatal(errStr(err))
+			}
+			// t.Log(string(b))
+
+			goFile := filepath.Join("testdata", d.Name(), "cue_gen.go")
+			if *update {
+				_ = ioutil.WriteFile(goFile, b, 0644)
+				return
+			}
+		})
+	}
+}
+
+func errStr(err error) string {
+	if err == nil {
+		return "nil"
+	}
+	buf := &bytes.Buffer{}
+	errors.Print(buf, err, nil)
+	r := regexp.MustCompile(`.cue:\d+:\d+`)
+	return r.ReplaceAllString(buf.String(), ".cue:x:x")
+}
diff --git a/encoding/gocode/gocodec/codec.go b/encoding/gocode/gocodec/codec.go
new file mode 100644
index 0000000..0037d2a
--- /dev/null
+++ b/encoding/gocode/gocodec/codec.go
@@ -0,0 +1,157 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package codec converts Go to and from CUE and validates Go values based on
+// CUE constraints.
+//
+// CUE constraints can be used to validate Go types as well as fill out
+// missing struct fields that are implied from the constraints and the values
+// already defined by the struct value.
+package gocodec
+
+import (
+	"sync"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/internal"
+)
+
+// Config has no options yet, but is defined for future extensibility.
+type Config struct {
+}
+
+// A Codec decodes and encodes CUE from and to Go values and validates and
+// completes Go values based on CUE templates.
+type Codec struct {
+	runtime *cue.Runtime
+	mutex   sync.RWMutex
+}
+
+// New creates a new Codec for the given instance.
+//
+// It is safe to use the methods of Codec concurrently as long as the given
+// Runtime is not used elsewhere while using Codec. However, only the concurrent
+// use of Decode, Validate, and Complete is efficient.
+func New(r *cue.Runtime, c *Config) *Codec {
+	return &Codec{runtime: r}
+}
+
+// ExtractType extracts a CUE value from a Go type.
+//
+// The type represented by x is converted as the underlying type. Specific
+// values, such as map or slice elements or field values of structs are ignored.
+// If x is of type reflect.Type, the type represented by x is extracted.
+//
+// Fields of structs can be annoted using additional constrains using the 'cue'
+// field tag. The value of the tag is a CUE expression, which may contain
+// references to the JSON name of other fields in a struct.
+//
+//     type Sum struct {
+//         A int `cue:"c-b" json:"a,omitempty"`
+//         B int `cue:"c-a" json:"b,omitempty"`
+//         C int `cue:"a+b" json:"c,omitempty"`
+//     }
+//
+func (c *Codec) ExtractType(x interface{}) (cue.Value, error) {
+	// ExtractType cannot introduce new fields on repeated calls. We could
+	// consider optimizing the lock usage based on this property.
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	return fromGoType(c.runtime, x)
+}
+
+// TODO: allow extracting constraints and type info separately?
+
+// Decode converts x to a CUE value.
+//
+// If x is of type reflect.Value it will convert the value represented by x.
+func (c *Codec) Decode(x interface{}) (cue.Value, error) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// Depending on the type, can introduce new labels on repeated calls.
+	return fromGoValue(c.runtime, x, false)
+}
+
+// Encode converts v to a Go value.
+func (c *Codec) Encode(v cue.Value, x interface{}) error {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	return v.Decode(x)
+}
+
+// Validate checks whether x satisfies the constraints defined by v.
+//
+// The given value must be created using the same Runtime with which c was
+// initialized.
+func (c *Codec) Validate(v cue.Value, x interface{}) error {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	r := checkAndForkRuntime(c.runtime, v)
+	w, err := fromGoValue(r, x, false)
+	if err != nil {
+		return err
+	}
+	return w.Unify(v).Err()
+}
+
+// Complete sets previously undefined values in x that can be uniquely
+// determined form the constraints defined by v if validation passes, or returns
+// an error, without modifying anything, otherwise.
+//
+// Only undefined values are modified. A value is considered undefined if it is
+// pointer type and is nil or if it is a field with a zero value that has a json
+// tag with the omitempty flag.
+//
+// The given value must be created using the same Runtime with which c was
+// initialized.
+//
+// Complete does a JSON round trip. This means that data not preserved in such a
+// round trip, such as the location name of a time.Time, is lost after a
+// successful update.
+func (c *Codec) Complete(v cue.Value, x interface{}) error {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	r := checkAndForkRuntime(c.runtime, v)
+	w, err := fromGoValue(r, x, true)
+	if err != nil {
+		return err
+	}
+
+	return w.Unify(v).Decode(x)
+}
+
+func fromGoValue(r *cue.Runtime, x interface{}, allowDefault bool) (cue.Value, error) {
+	v := internal.FromGoValue(r, x, allowDefault).(cue.Value)
+	if err := v.Err(); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+func fromGoType(r *cue.Runtime, x interface{}) (cue.Value, error) {
+	v := internal.FromGoType(r, x).(cue.Value)
+	if err := v.Err(); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+func checkAndForkRuntime(r *cue.Runtime, v cue.Value) *cue.Runtime {
+	return internal.CheckAndForkRuntime(r, v).(*cue.Runtime)
+}
diff --git a/encoding/gocode/gocodec/codec_test.go b/encoding/gocode/gocodec/codec_test.go
new file mode 100644
index 0000000..cb38865
--- /dev/null
+++ b/encoding/gocode/gocodec/codec_test.go
@@ -0,0 +1,286 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gocodec
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"cuelang.org/go/cue"
+	"github.com/google/go-cmp/cmp"
+)
+
+type Sum struct {
+	A int `cue:"C-B" json:",omitempty"`
+	B int `cue:"C-A" json:",omitempty"`
+	C int `cue:"A+B & >=5" json:",omitempty"`
+}
+
+func checkErr(t *testing.T, got error, want string) {
+	t.Helper()
+	if (got == nil) != (want == "") {
+		t.Errorf("error: got %v; want %v", got, want)
+	}
+}
+func TestValidate(t *testing.T) {
+	fail := "some error"
+	testCases := []struct {
+		name        string
+		value       interface{}
+		constraints string
+		err         string
+	}{{
+		name:        "*Sum: nil disallowed by constraint",
+		value:       (*Sum)(nil),
+		constraints: "!=null",
+		err:         fail,
+	}, {
+		name:  "Sum",
+		value: Sum{A: 1, B: 4, C: 5},
+	}, {
+		name:  "*Sum",
+		value: &Sum{A: 1, B: 4, C: 5},
+	}, {
+		name:  "*Sum: incorrect sum",
+		value: &Sum{A: 1, B: 4, C: 6},
+		err:   fail,
+	}, {
+		name:  "*Sum: field C is too low",
+		value: &Sum{A: 1, B: 3, C: 4},
+		err:   fail,
+	}, {
+		name:  "*Sum: nil value",
+		value: (*Sum)(nil),
+	}, {
+		// Not a typical constraint, but it is possible.
+		name:        "string list",
+		value:       []string{"a", "b", "c"},
+		constraints: `[_, "b", ...]`,
+	}, {
+		// Not a typical constraint, but it is possible.
+		name:        "string list incompatible lengths",
+		value:       []string{"a", "b", "c"},
+		constraints: `4*[string]`,
+		err:         fail,
+	}}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			r := &cue.Runtime{}
+			codec := New(r, nil)
+
+			v, err := codec.ExtractType(tc.value)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if tc.constraints != "" {
+				inst, err := r.Compile(tc.name, tc.constraints)
+				if err != nil {
+					t.Fatal(err)
+				}
+				v = v.Unify(inst.Value())
+				fmt.Println("XXX", v)
+				fmt.Println("XXX", inst.Value())
+				fmt.Println("UUU", v)
+			}
+
+			err = codec.Validate(v, tc.value)
+			checkErr(t, err, tc.err)
+		})
+	}
+}
+
+func TestComplete(t *testing.T) {
+	type updated struct {
+		A []*int `cue:"[...int|*1]"` // arbitrary length slice with values 1
+		B []int  `cue:"3*[int|*1]"`  // slice of length 3, defaults to [1,1,1]
+
+		// TODO: better errors if the user forgets to quote.
+		M map[string]int `cue:",opt"`
+	}
+	type sump struct {
+		A *int `cue:"C-B"`
+		B *int `cue:"C-A"`
+		C *int `cue:"A+B"`
+	}
+	one := 1
+	two := 2
+	fail := "some error"
+	_ = fail
+	_ = one
+	testCases := []struct {
+		name        string
+		value       interface{}
+		result      interface{}
+		constraints string
+		err         string
+	}{{
+		name:   "*Sum",
+		value:  &Sum{A: 1, B: 4, C: 5},
+		result: &Sum{A: 1, B: 4, C: 5},
+	}, {
+		name:   "*Sum",
+		value:  &Sum{A: 1, B: 4},
+		result: &Sum{A: 1, B: 4, C: 5},
+	}, {
+		name:   "*sump",
+		value:  &sump{A: &one, B: &one},
+		result: &sump{A: &one, B: &one, C: &two},
+	}, {
+		name:   "*Sum: backwards",
+		value:  &Sum{B: 4, C: 8},
+		result: &Sum{A: 4, B: 4, C: 8},
+	}, {
+		name:   "*Sum: sum too low",
+		value:  &Sum{A: 1, B: 3},
+		result: &Sum{A: 1, B: 3}, // Value should not be updated
+		err:    fail,
+	}, {
+		name:   "*Sum: sum underspecified",
+		value:  &Sum{A: 1},
+		result: &Sum{A: 1}, // Value should not be updated
+		err:    fail,
+	}, {
+		name:   "Sum: cannot modify",
+		value:  Sum{A: 3, B: 4, C: 7},
+		result: Sum{A: 3, B: 4, C: 7},
+		err:    fail,
+	}, {
+		name:   "*Sum: cannot update nil value",
+		value:  (*Sum)(nil),
+		result: (*Sum)(nil),
+		err:    fail,
+	}, {
+		name:   "cannot modify slice",
+		value:  []string{"a", "b", "c"},
+		result: []string{"a", "b", "c"},
+		err:    fail,
+	}, {
+		name: "composite values update",
+		// allocate a slice with uninitialized values and let Update fill
+		// out default values.
+		value: &updated{A: make([]*int, 3)},
+		result: &updated{
+			A: []*int{&one, &one, &one},
+			B: []int{1, 1, 1},
+			M: map[string]int(nil),
+		},
+	}, {
+		name:   "composite values update with unsatisfied map constraints",
+		value:  &updated{},
+		result: &updated{},
+
+		constraints: ` { M: {foo: bar, bar: foo} } `,
+		err:         fail, // incomplete values
+	}, {
+		name:        "composite values update with map constraints",
+		value:       &updated{M: map[string]int{"foo": 1}},
+		constraints: ` { M: {foo: bar, bar: foo} } `,
+		result: &updated{
+			// TODO: would be better if this is nil, but will not matter for
+			// JSON output: if omitempty is false, an empty list will be
+			// printed regardless, and if it is true, it will be omitted
+			// regardless.
+			A: []*int{},
+			B: []int{1, 1, 1},
+			M: map[string]int{"bar": 1, "foo": 1},
+		},
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			r := &cue.Runtime{}
+			codec := New(r, nil)
+
+			v, err := codec.ExtractType(tc.value)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if tc.constraints != "" {
+				inst, err := r.Compile(tc.name, tc.constraints)
+				if err != nil {
+					t.Fatal(err)
+				}
+				v = v.Unify(inst.Value())
+			}
+
+			err = codec.Complete(v, tc.value)
+			checkErr(t, err, tc.err)
+			if !reflect.DeepEqual(tc.value, tc.result) {
+				t.Errorf("value:\n got: %#v;\nwant: %#v", tc.value, tc.result)
+			}
+		})
+	}
+}
+
+func TestEncode(t *testing.T) {
+	testCases := []struct {
+		in   string
+		dst  interface{}
+		want interface{}
+	}{{
+		in:   "4",
+		dst:  new(int),
+		want: 4,
+	}}
+	r := &cue.Runtime{}
+	c := New(r, nil)
+
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			inst, err := r.Compile("test", tc.in)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = c.Encode(inst.Value(), tc.dst)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			got := reflect.ValueOf(tc.dst).Elem().Interface()
+			if !cmp.Equal(got, tc.want) {
+				t.Error(cmp.Diff(got, tc.want))
+			}
+		})
+	}
+}
+
+func TestDecode(t *testing.T) {
+	testCases := []struct {
+		in   interface{}
+		want string
+	}{{
+		in:   "str",
+		want: `"str"`,
+	}}
+	c := New(&cue.Runtime{}, nil)
+
+	for _, tc := range testCases {
+		t.Run("", func(t *testing.T) {
+			v, err := c.Decode(tc.in)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			got := fmt.Sprint(v)
+			if got != tc.want {
+				t.Errorf("got %v; want %v", got, tc.want)
+			}
+		})
+	}
+}
diff --git a/encoding/gocode/templates.go b/encoding/gocode/templates.go
new file mode 100644
index 0000000..db1b906
--- /dev/null
+++ b/encoding/gocode/templates.go
@@ -0,0 +1,99 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gocode
+
+import "text/template"
+
+// Inputs:
+// .pkgName  the Go package name
+var headerCode = template.Must(template.New("header").Parse(
+	`// Code generated by gogen.Generate; DO NOT EDIT.
+
+package {{.pkgName}}
+
+import (
+	"fmt"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/encoding/gocode/gocodec"
+)
+
+`))
+
+// Inputs:
+// .prefix 	  prefix to all generated variable names
+// .cueName   name of the top-level CUE value
+// .goType    Go type of the receiver or argument
+// .zero      zero value of the Go type; nil indicates no value
+// .validate  name of the validate function; "" means no validate
+// .complete  name of the complete function; "" means no complete
+var stubCode = template.Must(template.New("type").Parse(`
+var {{.prefix}}val{{.cueName}} = {{.prefix}}Make("{{.cueName}}", {{.zero}})
+
+{{ $sig := .goType | printf "(x %s)" -}}
+{{if .validate}}
+// {{.validate}}{{if .func}}{{.cueName}}{{end}} validates x.
+func {{if .func}}{{.validate}}{{.cueName}}{{$sig}}
+     {{- else -}}{{$sig}} {{.validate}}(){{end}} error {
+	return {{.prefix}}Codec.Validate({{.prefix}}val{{.cueName}}, x)
+}
+{{end}}
+{{if .complete}}
+// {{.complete}}{{if .func}}{{.cueName}}{{end}} completes x.
+func {{if .func}}{{.complete}}{{.cueName}}{{$sig}}
+     {{- else -}}{{$sig}} {{.complete}}(){{end}} error {
+	return {{.prefix}}Codec.Complete({{.prefix}}val{{.cueName}}, x)
+}
+{{end}}
+`))
+
+// Inputs:
+// .prefix 	  prefix to all generated variable names
+// .runtime   the variable name of a user-supplied runtime, if any
+// .data      bytes obtained from Instance.MarshalBinary
+var loadCode = template.Must(template.New("load").Parse(`
+var {{.prefix}}Codec, {{.prefix}}Instance = func() (*gocodec.Codec, *cue.Instance) {
+	var r *cue.Runtime
+	r = {{if .runtime}}{{.runtime}}{{else}}&cue.Runtime{}{{end}}
+	instances, err := r.Unmarshal({{.prefix}}InstanceData)
+	if err != nil {
+		panic(err)
+	}
+	if len(instances) != 1 {
+		panic("expected encoding of exactly one instance")
+	}
+	return gocodec.New(r, nil), instances[0]
+}()
+
+// {{.prefix}}Make is called in the init phase to initialize CUE values for
+// validation functions.
+func {{.prefix}}Make(name string, x interface{}) cue.Value {
+	v := {{.prefix}}Instance.Lookup(name)
+	if !v.Exists() {
+		panic(fmt.Errorf("could not find type %q in instance", name))
+	}
+	if x != nil {
+		w, err := {{.prefix}}Codec.ExtractType(x)
+		if err != nil {
+			panic(err)
+		}
+		v = v.Unify(w)
+	}
+	return v
+}
+
+// Data size: {{len .data}} bytes.
+var {{.prefix}}InstanceData = []byte({{printf "%+q" .data}})
+`))
diff --git a/encoding/gocode/test.cue b/encoding/gocode/test.cue
new file mode 100644
index 0000000..1d62a37
--- /dev/null
+++ b/encoding/gocode/test.cue
@@ -0,0 +1,3 @@
+import "strings"
+
+a: strings.ContainsAny("X") & "car"
diff --git a/encoding/gocode/testdata/cue.mod b/encoding/gocode/testdata/cue.mod
new file mode 100644
index 0000000..eaf98ca
--- /dev/null
+++ b/encoding/gocode/testdata/cue.mod
@@ -0,0 +1 @@
+module: "cuelang.org/go/encoding/gocode/testdata"
diff --git a/encoding/gocode/testdata/pkg1/code.go b/encoding/gocode/testdata/pkg1/code.go
new file mode 100644
index 0000000..4f5fc3b
--- /dev/null
+++ b/encoding/gocode/testdata/pkg1/code.go
@@ -0,0 +1,43 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pkg1
+
+import (
+	"time"
+
+	"cuelang.org/go/encoding/gocode/testdata/pkg2"
+)
+
+type MyStruct struct {
+	A int
+	B string
+	T time.Time // maps to builtin
+	O *OtherStruct
+	I *pkg2.ImportMe
+}
+
+type OtherStruct struct {
+	A string
+	// D time.Duration // maps to builtin
+	P pkg2.PickMe
+}
+
+type String string
+
+type Omit int
+
+type Ptr *struct {
+	A int
+}
diff --git a/encoding/gocode/testdata/pkg1/cue_gen.go b/encoding/gocode/testdata/pkg1/cue_gen.go
new file mode 100644
index 0000000..1fe592f
--- /dev/null
+++ b/encoding/gocode/testdata/pkg1/cue_gen.go
@@ -0,0 +1,83 @@
+// Code generated by gogen.Generate; DO NOT EDIT.
+
+package pkg1
+
+import (
+	"fmt"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/encoding/gocode/gocodec"
+)
+
+var cuegenvalMyStruct = cuegenMake("MyStruct", &MyStruct{})
+
+// Validate validates x.
+func (x *MyStruct) Validate() error {
+	return cuegenCodec.Validate(cuegenvalMyStruct, x)
+}
+
+// Complete completes x.
+func (x *MyStruct) Complete() error {
+	return cuegenCodec.Complete(cuegenvalMyStruct, x)
+}
+
+var cuegenvalOtherStruct = cuegenMake("OtherStruct", &OtherStruct{})
+
+// Validate validates x.
+func (x *OtherStruct) Validate() error {
+	return cuegenCodec.Validate(cuegenvalOtherStruct, x)
+}
+
+var cuegenvalString = cuegenMake("String", nil)
+
+// ValidateCUE validates x.
+func (x String) ValidateCUE() error {
+	return cuegenCodec.Validate(cuegenvalString, x)
+}
+
+var cuegenvalSpecialString = cuegenMake("SpecialString", nil)
+
+// ValidateSpecialString validates x.
+func ValidateSpecialString(x string) error {
+	return cuegenCodec.Validate(cuegenvalSpecialString, x)
+}
+
+var cuegenvalPtr = cuegenMake("Ptr", Ptr(nil))
+
+// ValidatePtr validates x.
+func ValidatePtr(x Ptr) error {
+	return cuegenCodec.Validate(cuegenvalPtr, x)
+}
+
+var cuegenCodec, cuegenInstance = func() (*gocodec.Codec, *cue.Instance) {
+	var r *cue.Runtime
+	r = &cue.Runtime{}
+	instances, err := r.Unmarshal(cuegenInstanceData)
+	if err != nil {
+		panic(err)
+	}
+	if len(instances) != 1 {
+		panic("expected encoding of exactly one instance")
+	}
+	return gocodec.New(r, nil), instances[0]
+}()
+
+// cuegenMake is called in the init phase to initialize CUE values for
+// validation functions.
+func cuegenMake(name string, x interface{}) cue.Value {
+	v := cuegenInstance.Lookup(name)
+	if !v.Exists() {
+		panic(fmt.Errorf("could not find type %q in instance", name))
+	}
+	if x != nil {
+		w, err := cuegenCodec.ExtractType(x)
+		if err != nil {
+			panic(err)
+		}
+		v = v.Unify(w)
+	}
+	return v
+}
+
+// Data size: 518 bytes.
+var cuegenInstanceData = []byte("\x01\x1f\x8b\b\x00\x00\x00\x00\x00\x00\xff\x94R]k\xd4@\x14\x9d\x9b\xae`.U\xf0\a\b\xe3<m\xa4\xcd~\x80\b\xa1Qk\xad\u0407v\x17\x8b\"\x88\x0f\xe3\xeclv\xd8l&$w\u0165\xb6\xa0\xd6\xda_\xe7\xab\xff\xa6\x91|\xb5\xabo\xcd\xcb\\n\xe6\x9c{\xe6\xdcs\xaf\xf8\xe5\x80S\\2(\xbe3\xf6\xb4\xf8\xb6\x01\xb0i\x92\x9cd\xa2\xf4+I\xb2\xec\xc3\x06t\xdeXK\xe00\xe8\x8c%\xcd`\x93\xc1\x9d\xd7&\xd69\x14\x17\x8c\xb1\x87\xc5O\a\xe0\xfe\x87\x8fj\xa9\xfd\xa9\x89\x1b\xe4\x05\x83\u2731n\xf1c\x03\xe0\xeeM\xff\x9c\x81\x03\x9d#\xb9\xd0%Q\xa7j\"c\xec\xca\xf9]\\2\a\x00\xb6\xd4R\xc72\x89|\x9bE\xbd\xc8\xf6t\xa2\xec\xc4$e\xad\xecD\xf7H\xe74\x91${\xe9<\x1a\x00\xc0\x83\xf2\ucd7a}\xb5\xd4p\x05\u007fR\xa9\xe62\u04bc\xfc\x89h\x16\xa9\u0348w\xd1\x15\xb7`\x1f\nt\xc5B\u04ac<s\xcaL\x12\xe5\x02=\xc4\xc3\xd51eKE\x01?Aw7\xe0|'\x1c\xf4\xd1}\x19p\x1e\x9e\t%I\xf0\xaf\xfc\xb1\x98\xd8H\xa0;z\x1e\xf0\x11\xcdtVc\xd0=\bx)k\xe8\x1fT\xaa\x0e5\x9e\xf2\x17\x91\xedn)\xbbHcM:\xdck\n\x0f\u05c0\xed\xb0F\x88\xbfg\x13\x92&\xc9w\x93UW\xbc\x17\x1e\xba\xe3\xa0\xe6\x1d\x1b5/Y\xf1\xb8\xba\x1a\xf0\xe6{\x14\n\xd1\xd6\xd5\xc0\xcf26\x13I:|\xd7\x14{o\xf7=<N\xb522n\xc1\xe1\x99\xc8\ub3a8Q\xb4JuX\xab\xf0p\xb40t=\x80s\x93\x10_\x1f\xb1\xed\xe1\x91M\xf6\xbf\x98\x9c*\xb2\x93\u02a5\x1a\xdc<{\xdb\u00e9\xb5A\t\xc51e\xed3K\xdf\xfd\xc3eL&\x8d\xf5h\xda\x1d\xf4=<E\u019c\xdb\xe4c\xd8\xe4c\xf8o>\xe4Z:\x86\xd7\xe9\xb8Y1\xb6\x9bi\xc5\xec\f\xfa\xfd5\xe5\xff\x99/?)Q\x8a\xab}\x0f\xf8\xb3'\xc8\xd8\xdf\x00\x00\x00\xff\xff\xa9a\xee\x8d^\x03\x00\x00")
diff --git a/encoding/gocode/testdata/pkg1/instance.cue b/encoding/gocode/testdata/pkg1/instance.cue
new file mode 100644
index 0000000..3358cbe
--- /dev/null
+++ b/encoding/gocode/testdata/pkg1/instance.cue
@@ -0,0 +1,37 @@
+package pkg1
+
+import (
+	"math"
+	"strings"
+	"cuelang.org/go/encoding/gocode/testdata/pkg2"
+)
+
+MyStruct: {
+	A:  <=10
+	B:  =~"cat" | *"dog"
+	O?: OtherStruct
+	I:  pkg2.ImportMe
+} @go(,complete=Complete)
+
+OtherStruct: {
+	A: strings.ContainsAny("X")
+	P: pkg2.PickMe
+}
+
+String: !="" @go(,validate=ValidateCUE)
+
+SpecialString: =~"special" @go(,type=string)
+
+Omit: int @go(-)
+
+// NonExisting will be omitted as there is no equivalent Go type.
+NonExisting: {
+	B: string
+} @go(-)
+
+// ignore unexported unless explicitly enabled.
+foo: int
+
+Ptr: {
+	A: math.MultipleOf(10)
+}
diff --git a/encoding/gocode/testdata/pkg2/code.go b/encoding/gocode/testdata/pkg2/code.go
new file mode 100644
index 0000000..3620911
--- /dev/null
+++ b/encoding/gocode/testdata/pkg2/code.go
@@ -0,0 +1,22 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pkg2
+
+type ImportMe struct {
+	A int    `json:"a"`
+	B string `json:"b"`
+}
+
+type PickMe int
diff --git a/encoding/gocode/testdata/pkg2/cue_gen.go b/encoding/gocode/testdata/pkg2/cue_gen.go
new file mode 100644
index 0000000..74917b3
--- /dev/null
+++ b/encoding/gocode/testdata/pkg2/cue_gen.go
@@ -0,0 +1,57 @@
+// Code generated by gogen.Generate; DO NOT EDIT.
+
+package pkg2
+
+import (
+	"fmt"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/encoding/gocode/gocodec"
+)
+
+var cuegenvalImportMe = cuegenMake("ImportMe", &ImportMe{})
+
+// Validate validates x.
+func (x *ImportMe) Validate() error {
+	return cuegenCodec.Validate(cuegenvalImportMe, x)
+}
+
+var cuegenvalPickMe = cuegenMake("PickMe", nil)
+
+// Validate validates x.
+func (x PickMe) Validate() error {
+	return cuegenCodec.Validate(cuegenvalPickMe, x)
+}
+
+var cuegenCodec, cuegenInstance = func() (*gocodec.Codec, *cue.Instance) {
+	var r *cue.Runtime
+	r = &cue.Runtime{}
+	instances, err := r.Unmarshal(cuegenInstanceData)
+	if err != nil {
+		panic(err)
+	}
+	if len(instances) != 1 {
+		panic("expected encoding of exactly one instance")
+	}
+	return gocodec.New(r, nil), instances[0]
+}()
+
+// cuegenMake is called in the init phase to initialize CUE values for
+// validation functions.
+func cuegenMake(name string, x interface{}) cue.Value {
+	v := cuegenInstance.Lookup(name)
+	if !v.Exists() {
+		panic(fmt.Errorf("could not find type %q in instance", name))
+	}
+	if x != nil {
+		w, err := cuegenCodec.ExtractType(x)
+		if err != nil {
+			panic(err)
+		}
+		v = v.Unify(w)
+	}
+	return v
+}
+
+// Data size: 276 bytes.
+var cuegenInstanceData = []byte("\x01\x1f\x8b\b\x00\x00\x00\x00\x00\x00\xffD\x8e\xc1J\x031\x10\x86\xe7\u07ee`C\x15|\x00a\xd9S\x05\u066d\x82\bE\x84\xaa\b\x1e\x94\xe2U<\x8ci\x8c\xa1mR\x9a\xecA\u0103Z\xabO\xe3+FR*\x9ef\xf8f\xfe\x9fo+~e\xc8\xe27!\xbe\x13\x1d\u01f7\x16\xd01\xd6\a\xb6R]p\xe0\xc4\xd1B~\xeb\\@F\u0207\x1c\x9e\xd0!l\\\x9a\x89\xf2\x88K\"\u068d\x9f\x19\xb0}w/\x1bU=\x9a\xc9:\xb9$\xc4\x05Q7~\xb4\x80\xcd\u007f\xbe d\xc8ox\xaaRQ\xbe\x82\x82\x88\xe2O\x12\x01\xb0/\x1b5a\xab+7\u05f5v\xb5\xb2\u048d\x8cM\xbbt#U\a\xe5\u00c8\x03\u05f3\xb1>\x04\xb0\x93f\xfd\xa7]\xc9F\x81g,\u01ecU\x91NB\x98\xe9\xcc\xcdCQ\xfa07V\xfbR\x88\xab\x15\xb9V\xfd\xe2E\xb4\a\xfd\xe2\xe4\xa0\xd7\x13\xed\xb3~\xb1~\xa9\u039d\rl\xac\x1f\xd8\xe7n\xc9\x0f\xb2\xdc\x13\xafbh\xe48eN\x8f\x04\xd1o\x00\x00\x00\xff\xff\ue135\t=\x01\x00\x00")
diff --git a/encoding/gocode/testdata/pkg2/instance.cue b/encoding/gocode/testdata/pkg2/instance.cue
new file mode 100644
index 0000000..5a6e606
--- /dev/null
+++ b/encoding/gocode/testdata/pkg2/instance.cue
@@ -0,0 +1,10 @@
+package pkg2
+
+import "strings"
+
+ImportMe: {
+	A: <100
+	B: strings.ContainsAny("abc")
+}
+
+PickMe: >5
diff --git a/internal/internal.go b/internal/internal.go
index d9b82a7..36cacc8 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package internal exposes some cue internals to other packages.
+//
+// A better name for this package would be technicaldebt.
 package internal // import "cuelang.org/go/internal"
 
 // TODO: refactor packages as to make this package unnecessary.
@@ -40,7 +43,7 @@
 // FromGoValue converts an arbitrary Go value to the corresponding CUE value.
 // instance must be of type *cue.Instance.
 // The returned value is a cue.Value, which the caller must cast to.
-var FromGoValue func(instance, x interface{}) interface{}
+var FromGoValue func(instance, x interface{}, allowDefault bool) interface{}
 
 // FromGoType converts an arbitrary Go type to the corresponding CUE value.
 // instance must be of type *cue.Instance.
@@ -56,3 +59,8 @@
 
 // GetRuntime reports the runtime for an Instance.
 var GetRuntime func(instance interface{}) interface{}
+
+// CheckAndForkRuntime checks that value is created using runtime, panicking
+// if it does not, and returns a forked runtime that will discard additional
+// keys.
+var CheckAndForkRuntime func(runtime, value interface{}) interface{}