diff --git a/cue/errors/errors.go b/cue/errors/errors.go
new file mode 100644
index 0000000..87edb74
--- /dev/null
+++ b/cue/errors/errors.go
@@ -0,0 +1,255 @@
+// Copyright 2018 The 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 errors defines shared types for handling CUE errors.
+package errors // import "cuelang.org/go/cue/errors"
+
+import (
+	"io"
+	"sort"
+
+	"cuelang.org/go/cue/token"
+	"golang.org/x/exp/errors"
+	"golang.org/x/exp/errors/fmt"
+)
+
+// New is a convenience wrapper for errors.New in the core library.
+func New(msg string) error {
+	return errors.New(msg)
+}
+
+// A Handler is a generic error handler used throughout CUE packages.
+//
+// The position points to the beginning of the offending value.
+type Handler func(pos token.Position, msg string)
+
+// Error is the common error message.
+type Error interface {
+	Position() token.Position
+
+	// Error reports the error message without position information.
+	Error() string
+}
+
+// // TODO: make Error an interface that returns a list of positions.
+
+// In an List, an error is represented by an *posError.
+// The position Pos, if valid, points to the beginning of
+// the offending token, and the error condition is described
+// by Msg.
+type posError struct {
+	pos token.Position
+	msg string
+
+	// The underlying error that triggered this one, if any.
+	err error
+}
+
+// E creates a new error.
+func E(args ...interface{}) error {
+	e := &posError{}
+	update(e, args)
+	return e
+}
+
+// Augment adorns an existing error with new information.
+func Augment(err error, args ...interface{}) error {
+	e, ok := err.(*posError)
+	if !ok {
+		e = &posError{err: err}
+	}
+	update(e, args)
+	return e
+}
+
+func update(e *posError, args []interface{}) {
+	err := e.err
+	for _, a := range args {
+		switch x := a.(type) {
+		case string:
+			e.msg = x
+		case token.Position:
+			e.pos = x
+		case []token.Position:
+			// TODO: do something more clever
+			if len(x) > 0 {
+				e.pos = x[0]
+			}
+		case *posError:
+			copy := *x
+			err = &copy
+			e.err = combine(e.err, err)
+		case error:
+			e.err = combine(e.err, x)
+		}
+	}
+}
+
+func combine(a, b error) error {
+	switch x := a.(type) {
+	case nil:
+		return b
+	case List:
+		x.add(toErr(b))
+		return x
+	default:
+		return List{toErr(a), toErr(b)}
+	}
+}
+
+func toErr(err error) Error {
+	if e, ok := err.(Error); ok {
+		return e
+	}
+	return &posError{err: err}
+}
+
+func (e posError) Position() token.Position {
+	return e.pos
+}
+
+// Error implements the error interface.
+func (e posError) Error() string { return fmt.Sprint(e) }
+
+func (e posError) Format(p errors.Printer) error {
+	next := e.err
+	if e.msg == "" {
+		next = errFormat(p, e.err)
+	} else {
+		p.Print(e.msg)
+	}
+	if p.Detail() && e.pos.Filename != "" || e.pos.IsValid() {
+		p.Printf("%s", e.pos.String())
+	}
+	return next
+
+}
+
+func errFormat(p errors.Printer, err error) (next error) {
+	switch v := err.(type) {
+	case errors.Formatter:
+		err = v.Format(p)
+	default:
+		p.Print(err)
+		err = nil
+	}
+
+	return err
+}
+
+// List is a list of *posError.
+// The zero value for an List is an empty List ready to use.
+//
+type List []Error
+
+func (p *List) add(err Error) {
+	*p = append(*p, err)
+}
+
+// AddNew adds an Error with given position and error message to an List.
+func (p *List) AddNew(pos token.Position, msg string) {
+	p.add(&posError{pos: pos, msg: msg})
+}
+
+// Add adds an Error with given position and error message to an List.
+func (p *List) Add(err error) {
+	p.add(toErr(err))
+}
+
+// Reset resets an List to no errors.
+func (p *List) Reset() { *p = (*p)[0:0] }
+
+// List implements the sort Interface.
+func (p List) Len() int      { return len(p) }
+func (p List) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+
+func (p List) Less(i, j int) bool {
+	e := p[i].Position()
+	f := p[j].Position()
+	// Note that it is not sufficient to simply compare file offsets because
+	// the offsets do not reflect modified line information (through //line
+	// comments).
+	if e.Filename != f.Filename {
+		return e.Filename < f.Filename
+	}
+	if e.Line != f.Line {
+		return e.Line < f.Line
+	}
+	if e.Column != f.Column {
+		return e.Column < f.Column
+	}
+	return p[i].Error() < p[j].Error()
+}
+
+// Sort sorts an List. *posError entries are sorted by position,
+// other errors are sorted by error message, and before any *posError
+// entry.
+//
+func (p List) Sort() {
+	sort.Sort(p)
+}
+
+// RemoveMultiples sorts an List and removes all but the first error per line.
+func (p *List) RemoveMultiples() {
+	sort.Sort(p)
+	var last token.Position // initial last.Line is != any legal error line
+	i := 0
+	for _, e := range *p {
+		pos := e.Position()
+		if pos.Filename != last.Filename || pos.Line != last.Line {
+			last = pos
+			(*p)[i] = e
+			i++
+		}
+	}
+	(*p) = (*p)[0:i]
+}
+
+// An List implements the error interface.
+func (p List) Error() string {
+	switch len(p) {
+	case 0:
+		return "no errors"
+	case 1:
+		return p[0].Error()
+	}
+	return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
+}
+
+// Err returns an error equivalent to this error list.
+// If the list is empty, Err returns nil.
+func (p List) Err() error {
+	if len(p) == 0 {
+		return nil
+	}
+	return p
+}
+
+// Print is a utility function that prints a list of errors to w,
+// one error per line, if the err parameter is an List. Otherwise
+// it prints the err string.
+//
+func Print(w io.Writer, err error) {
+	if list, ok := err.(List); ok {
+		for _, e := range list {
+			printError(w, e)
+		}
+	} else if err != nil {
+		printError(w, toErr(err))
+	}
+}
+
+func printError(w io.Writer, err Error) {
+	fmt.Fprintf(w, "%+v\n", err)
+}
diff --git a/cue/errors/errors_test.go b/cue/errors/errors_test.go
new file mode 100644
index 0000000..fb8e7ff
--- /dev/null
+++ b/cue/errors/errors_test.go
@@ -0,0 +1,192 @@
+// Copyright 2018 The 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 errors
+
+import (
+	"bytes"
+	"testing"
+
+	"cuelang.org/go/cue/token"
+)
+
+func TestError_Error(t *testing.T) {
+	tests := []struct {
+		name string
+		e    Error
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		if got := tt.e.Error(); got != tt.want {
+			t.Errorf("%q. Error.Error() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestErrorList_Add(t *testing.T) {
+	type args struct {
+		pos token.Position
+		msg string
+	}
+	tests := []struct {
+		name string
+		p    *List
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		tt.p.AddNew(tt.args.pos, tt.args.msg)
+	}
+}
+
+func TestErrorList_Reset(t *testing.T) {
+	tests := []struct {
+		name string
+		p    *List
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		tt.p.Reset()
+	}
+}
+
+func TestErrorList_Len(t *testing.T) {
+	tests := []struct {
+		name string
+		p    List
+		want int
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		if got := tt.p.Len(); got != tt.want {
+			t.Errorf("%q. List.Len() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestErrorList_Swap(t *testing.T) {
+	type args struct {
+		i int
+		j int
+	}
+	tests := []struct {
+		name string
+		p    List
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		tt.p.Swap(tt.args.i, tt.args.j)
+	}
+}
+
+func TestErrorList_Less(t *testing.T) {
+	type args struct {
+		i int
+		j int
+	}
+	tests := []struct {
+		name string
+		p    List
+		args args
+		want bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		if got := tt.p.Less(tt.args.i, tt.args.j); got != tt.want {
+			t.Errorf("%q. List.Less() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestErrorList_Sort(t *testing.T) {
+	tests := []struct {
+		name string
+		p    List
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		tt.p.Sort()
+	}
+}
+
+func TestErrorList_RemoveMultiples(t *testing.T) {
+	tests := []struct {
+		name string
+		p    *List
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		tt.p.RemoveMultiples()
+	}
+}
+
+func TestErrorList_Error(t *testing.T) {
+	tests := []struct {
+		name string
+		p    List
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		if got := tt.p.Error(); got != tt.want {
+			t.Errorf("%q. List.Error() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func TestErrorList_Err(t *testing.T) {
+	tests := []struct {
+		name    string
+		p       List
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		if err := tt.p.Err(); (err != nil) != tt.wantErr {
+			t.Errorf("%q. List.Err() error = %v, wantErr %v", tt.name, err, tt.wantErr)
+		}
+	}
+}
+
+func TestPrintError(t *testing.T) {
+	type args struct {
+		err error
+	}
+	tests := []struct {
+		name  string
+		args  args
+		wantW string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		w := &bytes.Buffer{}
+		Print(w, tt.args.err)
+		if gotW := w.String(); gotW != tt.wantW {
+			t.Errorf("%q. PrintError() = %v, want %v", tt.name, gotW, tt.wantW)
+		}
+	}
+}