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)
+			}
+		})
+	}
+}