diff --git a/encoding/jsonschema/constraints.go b/encoding/jsonschema/constraints.go
new file mode 100644
index 0000000..c4c5add
--- /dev/null
+++ b/encoding/jsonschema/constraints.go
@@ -0,0 +1,535 @@
+// 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 jsonschema
+
+import (
+	"math/big"
+	"net/url"
+	"path"
+	"strings"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/token"
+)
+
+type constraint struct {
+	key string
+
+	// phase indicates on which pass c constraint should be added. This ensures
+	// that constraints are applied in the correct order. For instance, the
+	// "required" constraint validates that a listed field is contained in
+	// "properties". For this to work, "properties" must be processed before
+	// "required" and thus must have a lower phase number than the latter.
+	phase int
+
+	// Indicates the draft number in which this constraint is defined.
+	draft int
+	fn    constraintFunc
+}
+
+// A constraintFunc converts a given JSON Schema constraint (specified in n)
+// to a CUE constraint recorded in state.
+type constraintFunc func(n cue.Value, s *state)
+
+func p0(name string, f constraintFunc) *constraint {
+	return &constraint{key: name, fn: f}
+}
+
+func p0d(name string, draft int, f constraintFunc) *constraint {
+	return &constraint{key: name, draft: draft, fn: f}
+}
+
+func p1(name string, f constraintFunc) *constraint {
+	return &constraint{key: name, phase: 1, fn: f}
+}
+
+func p2(name string, f constraintFunc) *constraint {
+	return &constraint{key: name, phase: 2, fn: f}
+}
+
+func combineSequence(name string, n cue.Value, s *state, op token.Token, f func(n cue.Value) ast.Expr) {
+	if n.Kind() != cue.ListKind {
+		s.errf(n, `value of %q must be an array, found %v`, name, n.Kind())
+	}
+	var a ast.Expr
+	for _, n := range list(n) {
+		if a == nil {
+			a = f(n)
+			continue
+		}
+		a = ast.NewBinExpr(token.OR, a, f(n))
+	}
+	if a == nil {
+		s.errf(n, `empty array for %q`, name)
+		return
+	}
+	s.add(a)
+}
+
+// TODO:
+// writeOnly, readOnly
+
+var constraintMap = map[string]*constraint{}
+
+func init() {
+	for _, c := range constraints {
+		constraintMap[c.key] = c
+	}
+}
+
+func addDefinitions(n cue.Value, s *state) {
+	s.kind |= cue.StructKind
+	if n.Kind() != cue.StructKind {
+		s.errf(n, `"definitions" expected an object, found %v`, n.Kind)
+	}
+
+	if len(s.path) != 1 {
+		s.errf(n, `"definitions" expected an object, found %v`, n.Kind)
+	}
+
+	s.processMap(n, func(key string, n cue.Value) {
+		f := &ast.Field{
+			Label: ast.NewString(s.path[len(s.path)-1]),
+			Token: token.ISA,
+			Value: s.schema(n),
+		}
+		f = &ast.Field{
+			Label: ast.NewIdent(rootDefs),
+			Value: &ast.StructLit{Elts: []ast.Decl{f}},
+		}
+		ast.SetRelPos(f, token.NewSection)
+		s.definitions = append(s.definitions, f)
+	})
+}
+
+var constraints = []*constraint{
+	// Meta data.
+
+	p0("$schema", func(n cue.Value, s *state) {
+		// Identifies this as a JSON schema and specifies its version.
+		// TODO: extract version.
+		s.jsonschema, _ = s.strValue(n)
+	}),
+
+	p0("$id", func(n cue.Value, s *state) {
+		// URL: https://domain.com/schemas/foo.json
+		// Use Title(foo) as CUE identifier.
+		// anchors: #identifier
+		//
+		// TODO: mark identifiers.
+		s.id, _ = s.strValue(n)
+	}),
+
+	// Generic constraint
+
+	p0("type", func(n cue.Value, s *state) {
+		switch n.Kind() {
+		case cue.StringKind:
+			s.types = append(s.types, n)
+		case cue.ListKind:
+			for i, _ := n.List(); i.Next(); {
+				s.types = append(s.types, i.Value())
+			}
+		default:
+			s.errf(n, `value of "type" must be a string or list of strings`)
+		}
+	}),
+
+	p0("enum", func(n cue.Value, s *state) {
+		combineSequence("enum", n, s, token.OR, s.value)
+		s.typeOptional = true
+	}),
+
+	p0d("const", 6, func(n cue.Value, s *state) {
+		s.add(s.value(n))
+	}),
+
+	p0("default", func(n cue.Value, s *state) {
+		s.default_ = s.value(n)
+		// must validate that the default is subsumed by the normal value,
+		// as CUE will otherwise broaden the accepted values with the default.
+		s.examples = append(s.examples, s.default_)
+	}),
+
+	p0("deprecated", func(n cue.Value, s *state) {
+		if s.boolValue(n) {
+			s.deprecated = true
+		}
+	}),
+
+	p0("examples", func(n cue.Value, s *state) {
+		if n.Kind() != cue.ListKind {
+			s.errf(n, `value of "examples" must be an array, found %v`, n.Kind)
+		}
+		for _, n := range list(n) {
+			s.examples = append(s.examples, s.schema(n))
+		}
+	}),
+
+	p0("description", func(n cue.Value, s *state) {
+		s.description, _ = s.strValue(n)
+	}),
+
+	p0("title", func(n cue.Value, s *state) {
+		s.title, _ = s.strValue(n)
+	}),
+
+	p0d("$comment", 7, func(n cue.Value, s *state) {
+	}),
+
+	p0("$def", addDefinitions),
+	p0("definitions", addDefinitions),
+	p0("$ref", func(n cue.Value, s *state) {
+		if str, ok := s.strValue(n); ok {
+			u, err := url.Parse(str)
+			if err != nil {
+				s.add(s.errf(n, "invalid JSON reference: %s", err))
+				return
+			}
+
+			if u.Host != "" || u.Path != "" {
+				s.add(s.errf(n, "external references (%s) not supported", str))
+				// TODO: handle
+				//    host:
+				//      If the host corresponds to a package known to cue,
+				//      load it from there. It would prefer schema converted to
+				//      CUE, although we could consider loading raw JSON schema
+				//      if present.
+				//      If not present, advise the user to run cue get.
+				//    path:
+				//      Look up on file system or relatively to authority location.
+				return
+			}
+
+			if !path.IsAbs(u.Fragment) {
+				s.add(s.errf(n, "anchors (%s) not supported", u.Fragment))
+				// TODO: support anchors
+				return
+			}
+
+			// NOTE: Go bug?: url.URL has no raw representation of the fragment.
+			// This means that %2F gets translated to `/` before it can be
+			// split. This, in turn, means that field names cannot have a `/`
+			// as name.
+			a := strings.Split(u.Fragment[1:], "/")
+			if a[0] != "definitions" && a[0] != "$def" {
+				s.add(s.errf(n, "reference %q must resolve to definition", u.Fragment))
+				return
+			}
+			s.add(ast.NewSel(ast.NewIdent(rootDefs), a[1:]...))
+
+			// TODO: technically, a references could reference a non-definition.
+			// In that case this will not resolve. We should detect cases that
+			// are not definitions and then resolve those as literal values.
+		}
+	}),
+
+	// Combinators
+
+	// TODO: work this out in more detail: oneOf and anyOf below have the same
+	// implementation in CUE. The distinction is that for anyOf a result is
+	// allowed to be ambiguous at the end, whereas for oneOf a disjunction must
+	// be fully resolved. There is currently no easy way to set this distinction
+	// in CUE.
+	//
+	// One could correctly write oneOf like this once 'not' is implemented:
+	//
+	//   oneOf(a, b, c) :-
+	//      anyOf(
+	//         allOf(a, not(b), not(c)),
+	//         allOf(not(a), b, not(c)),
+	//         allOf(not(a), not(b), c),
+	//   ))
+	//
+	// This is not necessary if the values are mutually exclusive/ have a
+	// discriminator.
+
+	p0("allOf", func(n cue.Value, s *state) {
+		combineSequence("allOf", n, s, token.AND, s.schema)
+	}),
+
+	p0("anyOf", func(n cue.Value, s *state) {
+		combineSequence("anyOf", n, s, token.OR, s.schema)
+	}),
+
+	p0("oneOf", func(n cue.Value, s *state) {
+		combineSequence("allOf", n, s, token.OR, s.schema)
+	}),
+
+	// String constraints
+
+	p0("pattern", func(n cue.Value, s *state) {
+		s.kind |= cue.StringKind
+		s.add(&ast.UnaryExpr{Op: token.MAT, X: s.string(n)})
+	}),
+
+	p0d("contentMediaType", 7, func(n cue.Value, s *state) {
+		s.kind |= cue.StringKind
+	}),
+
+	p0d("contentEncoding", 7, func(n cue.Value, s *state) {
+		s.kind |= cue.StringKind
+		// 7bit, 8bit, binary, quoted-printable and base64.
+		// RFC 2054, part 6.1.
+		// https://tools.ietf.org/html/rfc2045
+		// TODO: at least handle bytes.
+	}),
+
+	// Number constraints
+
+	p0("minimum", func(n cue.Value, s *state) {
+		s.kind |= cue.NumberKind
+		s.add(&ast.UnaryExpr{Op: token.GEQ, X: s.number(n)})
+	}),
+
+	p0("exclusiveMinimum", func(n cue.Value, s *state) {
+		// TODO: should we support Draft 4 booleans?
+		s.kind |= cue.NumberKind
+		s.add(&ast.UnaryExpr{Op: token.GTR, X: s.number(n)})
+	}),
+
+	p0("maximum", func(n cue.Value, s *state) {
+		s.kind |= cue.NumberKind
+		s.add(&ast.UnaryExpr{Op: token.LEQ, X: s.number(n)})
+	}),
+
+	p0("exclusiveMaximum", func(n cue.Value, s *state) {
+		// TODO: should we support Draft 4 booleans?
+		s.kind |= cue.NumberKind
+		s.add(&ast.UnaryExpr{Op: token.LSS, X: s.number(n)})
+	}),
+
+	p0("multipleOf", func(n cue.Value, s *state) {
+		s.kind |= cue.NumberKind
+		multiple := s.number(n)
+		var x big.Int
+		_, _ = n.MantExp(&x)
+		if x.Cmp(big.NewInt(0)) != 1 {
+			s.errf(n, `"multipleOf" value must be < 0; found %s`, n)
+		}
+		math := s.addImport("math")
+		s.add(ast.NewCall(ast.NewSel(math, "MultipleOf"), multiple))
+	}),
+
+	// Object constraints
+
+	p0("properties", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		if s.obj == nil {
+			s.obj = &ast.StructLit{}
+		}
+		if n.Kind() != cue.StructKind {
+			s.errf(n, `"properties" expected an object, found %v`, n.Kind)
+		}
+
+		s.processMap(n, func(key string, n cue.Value) {
+			// property?: value
+			expr, state := s.schemaState(n)
+			f := &ast.Field{Label: ast.NewString(key), Value: expr}
+			state.doc(f)
+			f.Optional = token.Blank.Pos()
+			if len(s.obj.Elts) > 0 && len(f.Comments()) > 0 {
+				// TODO: change formatter such that either a a NewSection on the
+				// field or doc comment will cause a new section.
+				ast.SetRelPos(f.Comments()[0], token.NewSection)
+			}
+			s.obj.Elts = append(s.obj.Elts, f)
+		})
+	}),
+
+	p1("required", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		if s.obj == nil {
+			s.errf(n, `"required" without a "properties" field`)
+		}
+		if n.Kind() != cue.ListKind {
+			s.errf(n, `value of "required" must be list of strings, found %v`, n.Kind)
+		}
+
+		// Create field map
+		fields := map[string]*ast.Field{}
+		for _, d := range s.obj.Elts {
+			f := d.(*ast.Field)
+			str, _, err := ast.LabelName(f.Label)
+			if err == nil {
+				fields[str] = f
+			}
+		}
+
+		for _, n := range list(n) {
+			str, ok := s.strValue(n)
+			f := fields[str]
+			if f == nil && ok {
+				s.errf(n, "required field %q not in properties", str)
+				continue
+			}
+			if f.Optional == token.NoPos {
+				s.errf(n, "duplicate required field %q", str)
+			}
+			f.Optional = token.NoPos
+		}
+	}),
+
+	p0d("propertyNames", 6, func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		// [=~pattern]: _
+		s.add(&ast.StructLit{Elts: []ast.Decl{&ast.Field{
+			Label: ast.NewList(s.schema(n)),
+			Value: ast.NewIdent("_"),
+		}}})
+	}),
+
+	p0("minProperties", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		pkg := s.addImport("struct")
+		s.add(ast.NewCall(ast.NewSel(pkg, "MinFields"), s.uint(n)))
+	}),
+
+	p0("maxProperties", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		pkg := s.addImport("struct")
+		s.add(ast.NewCall(ast.NewSel(pkg, "MaxFields"), s.uint(n)))
+	}),
+
+	p0("dependencies", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		// Schema and property dependencies.
+		// TODO: the easiest implementation is with comprehensions.
+		// The nicer implementation is with disjunctions. This has to be done
+		// at the very end, replacing properties.
+		/*
+			*{ property?: _|_ } | {
+				property: _
+				schema
+			}
+		*/
+	}),
+
+	p1("patternProperties", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		if n.Kind() != cue.StructKind {
+			s.errf(n, `value of "patternProperties" must be an an object, found %v`, n.Kind)
+		}
+		if s.obj == nil {
+			s.obj = &ast.StructLit{}
+		}
+		existing := excludeFields(s.obj.Elts)
+		s.processMap(n, func(key string, n cue.Value) {
+			// [!~(properties) & pattern]: schema
+			s.patterns = append(s.patterns,
+				&ast.UnaryExpr{Op: token.NMAT, X: ast.NewString(key)})
+			f := &ast.Field{
+				Label: ast.NewList(ast.NewBinExpr(token.AND,
+					&ast.UnaryExpr{Op: token.MAT, X: ast.NewString(key)},
+					existing)),
+				Value: s.schema(n),
+			}
+			ast.SetRelPos(f, token.NewSection)
+			s.obj.Elts = append(s.obj.Elts, f)
+		})
+	}),
+
+	p2("additionalProperties", func(n cue.Value, s *state) {
+		s.kind |= cue.StructKind
+		switch n.Kind() {
+		case cue.BoolKind:
+			s.closeStruct = !s.boolValue(n)
+
+		case cue.StructKind:
+			s.closeStruct = true
+			if s.obj == nil {
+				s.obj = &ast.StructLit{}
+			}
+			if len(s.obj.Elts) == 0 {
+				s.obj.Elts = append(s.obj.Elts, &ast.Field{
+					Label: ast.NewList(ast.NewIdent("string")),
+					Value: s.schema(n),
+				})
+				return
+			}
+			// [!~(properties|patternProperties)]: schema
+			existing := append(s.patterns, excludeFields(s.obj.Elts))
+			f := &ast.Field{
+				Label: ast.NewList(ast.NewBinExpr(token.AND, existing...)),
+				Value: s.schema(n),
+			}
+			ast.SetRelPos(f, token.NewSection)
+			s.obj.Elts = append(s.obj.Elts, f)
+
+		default:
+			s.errf(n, `value of "additionalProperties" must be an object or boolean`)
+		}
+	}),
+
+	// Array constraints.
+
+	p0("items", func(n cue.Value, s *state) {
+		s.kind |= cue.ListKind
+		if s.list != nil {
+			s.errf(n, `"items" declared more than once, previous declaration at %s`, s.list.Pos())
+		}
+		switch n.Kind() {
+		case cue.StructKind:
+			elem := s.schema(n)
+			ast.SetRelPos(elem, token.NoRelPos)
+			s.add(ast.NewList(&ast.Ellipsis{Type: elem}))
+
+		case cue.ListKind:
+			var a []ast.Expr
+			for _, n := range list(n) {
+				v := s.schema(n)
+				ast.SetRelPos(v, token.NoRelPos)
+				a = append(a, v)
+			}
+			s.add(ast.NewList(a...))
+
+		default:
+			s.errf(n, `value of "items" must be an object or array`)
+		}
+	}),
+
+	p0("contains", func(n cue.Value, s *state) {
+		s.kind |= cue.ListKind
+		list := s.addImport("list")
+		// TODO: Passing non-concrete values is not yet supported in CUE.
+		s.add(ast.NewCall(ast.NewSel(list, "Contains"), clearPos(s.schema(n))))
+	}),
+
+	p0("minItems", func(n cue.Value, s *state) {
+		s.kind |= cue.ListKind
+		list := s.addImport("list")
+		s.add(ast.NewCall(ast.NewSel(list, "MinItems"), clearPos(s.uint(n))))
+	}),
+
+	p0("maxItems", func(n cue.Value, s *state) {
+		s.kind |= cue.ListKind
+		list := s.addImport("list")
+		s.add(ast.NewCall(ast.NewSel(list, "MaxItems"), clearPos(s.uint(n))))
+	}),
+
+	p0("uniqueItems", func(n cue.Value, s *state) {
+		s.kind |= cue.ListKind
+		if s.boolValue(n) {
+			list := s.addImport("list")
+			s.add(ast.NewCall(ast.NewSel(list, "UniqueItems")))
+		}
+	}),
+}
+
+func clearPos(e ast.Expr) ast.Expr {
+	ast.SetRelPos(e, token.NoRelPos)
+	return e
+}
diff --git a/encoding/jsonschema/decode.go b/encoding/jsonschema/decode.go
new file mode 100644
index 0000000..dff0cc7
--- /dev/null
+++ b/encoding/jsonschema/decode.go
@@ -0,0 +1,427 @@
+// 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 jsonschema
+
+// TODO:
+// - replace converter from YAML to CUE to CUE (schema) to CUE.
+// - define OpenAPI definitions als CUE.
+
+import (
+	"fmt"
+	"path"
+	"sort"
+	"strings"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal"
+)
+
+const rootDefs = "def"
+
+func decode(filename string, inst *cue.Instance) (*ast.File, errors.Error) {
+	d := &decoder{
+		imports: map[string]*ast.Ident{},
+	}
+	e := d.decode(filename, inst)
+	if d.errs != nil {
+		return nil, d.errs
+	}
+	return e, nil
+}
+
+// A decoder converts JSON schema to CUE.
+type decoder struct {
+	errs    errors.Error
+	imports map[string]*ast.Ident
+
+	definitions []ast.Decl
+}
+
+// addImport registers
+func (d *decoder) addImport(pkg string) *ast.Ident {
+	ident, ok := d.imports[pkg]
+	if !ok {
+		ident = ast.NewIdent(pkg)
+		d.imports[pkg] = ident
+	}
+	return ident
+}
+
+func (d *decoder) decode(filename string, inst *cue.Instance) *ast.File {
+	root := state{decoder: d}
+	expr, state := root.schemaState(inst.Value())
+
+	var a []ast.Decl
+
+	name := filename
+	if state.id != "" {
+		name = strings.Trim(name, "#")
+	}
+	pkgName := path.Base(name)
+	pkgName = pkgName[:len(pkgName)-len(path.Ext(pkgName))]
+	pkg := &ast.Package{Name: ast.NewIdent(pkgName)}
+	state.doc(pkg)
+
+	a = append(a, pkg)
+
+	var imports []string
+	for k := range d.imports {
+		imports = append(imports, k)
+	}
+	sort.Strings(imports)
+
+	if len(imports) > 0 {
+		x := &ast.ImportDecl{}
+		for _, p := range imports {
+			x.Specs = append(x.Specs, ast.NewImport(nil, p))
+		}
+		a = append(a, x)
+	}
+
+	tags := []string{}
+	if state.jsonschema != "" {
+		tags = append(tags, fmt.Sprintf("schema=%q", state.jsonschema))
+	}
+	if state.id != "" {
+		tags = append(tags, fmt.Sprintf("id=%q", state.id))
+	}
+	if len(tags) > 0 {
+		a = append(a, addTag("Schema", "jsonschema", strings.Join(tags, ",")))
+	}
+
+	if state.deprecated {
+		a = append(a, addTag("Schema", "deprecated", ""))
+	}
+
+	f := &ast.Field{
+		Label: ast.NewIdent("Schema"),
+		Value: expr,
+	}
+
+	f.Token = token.ISA
+	a = append(a, f)
+	a = append(a, d.definitions...)
+
+	return &ast.File{Decls: a}
+}
+
+func (d *decoder) errf(n cue.Value, format string, args ...interface{}) ast.Expr {
+	d.warnf(n, format, args...)
+	return &ast.BadExpr{From: n.Pos()}
+}
+
+func (d *decoder) warnf(n cue.Value, format string, args ...interface{}) {
+	d.errs = errors.Append(d.errs, errors.Newf(n.Pos(), format, args...))
+}
+
+func (d *decoder) number(n cue.Value) ast.Expr {
+	return n.Syntax().(ast.Expr)
+}
+
+func (d *decoder) uint(n cue.Value) ast.Expr {
+	_, err := n.Uint64()
+	if err != nil {
+		d.errf(n, "invalid uint")
+	}
+	return n.Syntax().(ast.Expr)
+}
+
+func (d *decoder) bool(n cue.Value) ast.Expr {
+	return n.Syntax().(ast.Expr)
+}
+
+func (d *decoder) boolValue(n cue.Value) bool {
+	x, err := n.Bool()
+	if err != nil {
+		d.errf(n, "invalid bool")
+	}
+	return x
+}
+
+func (d *decoder) string(n cue.Value) ast.Expr {
+	return n.Syntax().(ast.Expr)
+}
+
+func (d *decoder) strValue(n cue.Value) (s string, ok bool) {
+	s, err := n.String()
+	if err != nil {
+		d.errf(n, "invalid string")
+		return "", false
+	}
+	return s, true
+}
+
+// const draftCutoff = 5
+
+type state struct {
+	*decoder
+
+	path []string
+
+	pos cue.Value
+
+	types        []cue.Value
+	typeOptional bool
+	kind         cue.Kind
+
+	default_    ast.Expr
+	examples    []ast.Expr
+	title       string
+	description string
+	deprecated  bool
+	jsonschema  string
+	id          string
+
+	conjuncts []ast.Expr
+
+	obj         *ast.StructLit
+	closeStruct bool
+	patterns    []ast.Expr
+
+	list *ast.ListLit
+}
+
+// finalize constructs a CUE type from the collected constraints.
+func (s *state) finalize() (e ast.Expr) {
+	if s.typeOptional || s.kind != 0 {
+		if len(s.types) > 1 {
+			s.errf(s.pos, "constraints require specific type")
+		}
+		s.types = nil
+	}
+
+	conjuncts := []ast.Expr{}
+	disjuncts := []ast.Expr{}
+	for _, n := range s.types {
+		add := func(e ast.Expr) {
+			disjuncts = append(disjuncts, setPos(e, n))
+		}
+		str, ok := s.strValue(n)
+		if !ok {
+			s.errf(n, "type value should be a string")
+			return
+		}
+		switch str {
+		case "null":
+			// TODO: handle OpenAPI restrictions.
+			add(ast.NewIdent("null"))
+		case "boolean":
+			add(ast.NewIdent("bool"))
+		case "string":
+			add(ast.NewIdent("string"))
+		case "number":
+			add(ast.NewIdent("number"))
+		case "integer":
+			add(ast.NewIdent("int"))
+		case "array":
+			if s.kind&cue.ListKind == 0 {
+				add(ast.NewList(&ast.Ellipsis{}))
+			}
+		case "object":
+			elps := &ast.Ellipsis{}
+			st := &ast.StructLit{Elts: []ast.Decl{elps}}
+			add(st)
+		default:
+			s.errf(n, "unknown type %q", n)
+		}
+	}
+	if len(disjuncts) > 0 {
+		conjuncts = append(conjuncts, ast.NewBinExpr(token.OR, disjuncts...))
+	}
+
+	conjuncts = append(conjuncts, s.conjuncts...)
+
+	if s.obj != nil {
+		if !s.closeStruct {
+			s.obj.Elts = append(s.obj.Elts, &ast.Ellipsis{})
+		}
+		conjuncts = append(conjuncts, s.obj)
+	}
+
+	if len(conjuncts) == 0 {
+		return ast.NewString(fmt.Sprint(s.pos))
+	}
+
+	e = ast.NewBinExpr(token.AND, conjuncts...)
+
+	if s.default_ != nil {
+		// check conditions where default can be skipped.
+		switch x := s.default_.(type) {
+		case *ast.ListLit:
+			if s.kind == cue.ListKind && len(x.Elts) == 0 {
+				return e
+			}
+		}
+		e = ast.NewBinExpr(token.OR, e, &ast.UnaryExpr{Op: token.MUL, X: s.default_})
+	}
+	return e
+}
+
+func (s *state) doc(n ast.Node) {
+	// Create documentation.
+	doc := strings.TrimSpace(s.title)
+	if s.description != "" {
+		if doc != "" {
+			doc += "\n\n"
+		}
+		doc += s.description
+		doc = strings.TrimSpace(doc)
+	}
+	if doc != "" {
+		ast.SetComments(n, []*ast.CommentGroup{
+			internal.NewComment(true, doc),
+		})
+	}
+
+	// TODO: add examples as well?
+}
+
+func (s *state) add(e ast.Expr) {
+	s.conjuncts = append(s.conjuncts, e)
+}
+
+func (s *state) schema(n cue.Value) ast.Expr {
+	expr, _ := s.schemaState(n)
+	// TODO: report unused doc.
+	return expr
+}
+
+func (s *state) schemaState(n cue.Value) (ast.Expr, *state) {
+	state := &state{path: s.path, pos: n, decoder: s.decoder}
+
+	if n.Kind() != cue.StructKind {
+		return s.errf(n, "schema expects mapping node, found %s", n.Kind()), state
+	}
+
+	// do multiple passes over the constraints to ensure they are done in order.
+	for pass := 0; pass < 3; pass++ {
+		state.processMap(n, func(key string, value cue.Value) {
+			// Convert each constraint into a either a value or a functor.
+			c := constraintMap[key]
+			if c == nil {
+				if pass == 0 {
+					s.warnf(n, "unsupported constraint %q", key)
+				}
+				return
+			}
+			if c.phase == pass {
+				c.fn(value, state)
+			}
+		})
+	}
+
+	return state.finalize(), state
+}
+
+func (s *state) value(n cue.Value) ast.Expr {
+	switch n.Kind() {
+	case cue.ListKind:
+		a := []ast.Expr{}
+		for i, _ := n.List(); i.Next(); {
+			a = append(a, s.value(i.Value()))
+		}
+		return setPos(ast.NewList(a...), n)
+
+	case cue.StructKind:
+		a := []ast.Decl{}
+		s.processMap(n, func(key string, n cue.Value) {
+			a = append(a, &ast.Field{
+				Label: ast.NewString(key),
+				Value: s.value(n),
+			})
+		})
+		a = append(a, &ast.Ellipsis{})
+		return setPos(&ast.StructLit{Elts: a}, n)
+
+	default:
+		if !n.IsConcrete() {
+			s.errf(n, "invalid non-concerte value")
+		}
+		return n.Syntax().(ast.Expr)
+	}
+}
+
+// processMap processes a yaml node, expanding merges.
+//
+// TODO: in some cases we can translate merges into CUE embeddings.
+// This may also prevent exponential blow-up (as may happen when
+// converting YAML to JSON).
+func (s *state) processMap(n cue.Value, f func(key string, n cue.Value)) {
+	saved := s.path
+	defer func() { s.path = saved }()
+
+	// TODO: intercept references to allow for optimized performance.
+	for i, _ := n.Fields(); i.Next(); {
+		key := i.Label()
+		s.path = append(saved, key)
+		f(key, i.Value())
+	}
+}
+
+func list(n cue.Value) (a []cue.Value) {
+	for i, _ := n.List(); i.Next(); {
+		a = append(a, i.Value())
+	}
+	return a
+}
+
+// excludeFields returns a CUE expression that can be used to exclude the
+// fields of the given declaration in a label expression. For instance, for
+//
+//    { foo: 1, bar: int }
+//
+// it creates
+//
+//    "^(foo|bar)$"
+//
+// which can be used in a label expression to define types for all fields but
+// those existing:
+//
+//   [!~"^(foo|bar)$"]: string
+//
+func excludeFields(decls []ast.Decl) ast.Expr {
+	var a []string
+	for _, d := range decls {
+		f, ok := d.(*ast.Field)
+		if !ok {
+			continue
+		}
+		str, _, _ := ast.LabelName(f.Label)
+		if str != "" {
+			a = append(a, str)
+		}
+	}
+	re := fmt.Sprintf("^(%s)$", strings.Join(a, "|"))
+	return &ast.UnaryExpr{Op: token.NMAT, X: ast.NewString(re)}
+}
+
+func addTag(field, tag, value string) *ast.Field {
+	return &ast.Field{
+		Label: ast.NewIdent(field),
+		Token: token.ISA,
+		Value: ast.NewIdent("_"),
+		Attrs: []*ast.Attribute{
+			&ast.Attribute{Text: fmt.Sprintf("@%s(%s)", tag, value)},
+		},
+	}
+}
+
+func setPos(e ast.Expr, v cue.Value) ast.Expr {
+	ast.SetPos(e, v.Pos())
+	return e
+}
diff --git a/encoding/jsonschema/decode_test.go b/encoding/jsonschema/decode_test.go
new file mode 100644
index 0000000..da64a24
--- /dev/null
+++ b/encoding/jsonschema/decode_test.go
@@ -0,0 +1,122 @@
+// 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 jsonschema
+
+import (
+	"bytes"
+	"flag"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/format"
+	"cuelang.org/go/encoding/json"
+	"cuelang.org/go/encoding/yaml"
+	"github.com/google/go-cmp/cmp"
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/tools/txtar"
+)
+
+var update = flag.Bool("update", false, "update the test files")
+
+// TestDecode reads the testdata/*.txtar files, converts the contained
+// JSON schema to CUE and compares it against the output.
+//
+// Use the --update flag to update test files with the corresponding output.
+func TestDecode(t *testing.T) {
+	err := filepath.Walk("testdata", func(fullpath string, info os.FileInfo, err error) error {
+		_ = err
+		if !strings.HasSuffix(fullpath, ".txtar") {
+			return nil
+		}
+
+		t.Run(fullpath, func(t *testing.T) {
+			a, err := txtar.ParseFile(fullpath)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			r := &cue.Runtime{}
+			var in *cue.Instance
+			var out, errout []byte
+			outIndex := -1
+
+			for i, f := range a.Files {
+				switch path.Ext(f.Name) {
+				case ".json":
+					in, err = json.Decode(r, f.Name, f.Data)
+				case ".yaml":
+					in, err = yaml.Decode(r, f.Name, f.Data)
+				case ".cue":
+					out = f.Data
+					outIndex = i
+				case ".err":
+					errout = f.Data
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			// TODO: use actual API.
+			expr, err := decode(fullpath, in)
+			if err != nil && errout == nil {
+				t.Fatal(errors.Details(err, nil))
+			}
+			got := []byte(nil)
+			if err != nil {
+				got = []byte(err.Error())
+			}
+			if !cmp.Equal(errout, got) {
+				t.Error(cmp.Diff(string(got), string(errout)))
+			}
+
+			if expr != nil {
+				b, err := format.Node(expr, format.Simplify())
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				// verify the generated CUE.
+				if _, err = r.Compile(fullpath, b); err != nil {
+					t.Fatal(errors.Details(err, nil))
+				}
+
+				b = bytes.TrimSpace(b)
+				out = bytes.TrimSpace(out)
+
+				if !cmp.Equal(b, out) {
+					if *update {
+						a.Files[outIndex].Data = b
+						b = txtar.Format(a)
+						err = ioutil.WriteFile(fullpath, b, 0644)
+						if err != nil {
+							t.Fatal(err)
+						}
+						return
+					}
+					t.Error(cmp.Diff(string(out), string(b)))
+				}
+			}
+		})
+		return nil
+	})
+	assert.NoError(t, err)
+}
diff --git a/encoding/jsonschema/doc.go b/encoding/jsonschema/doc.go
new file mode 100644
index 0000000..c0b813c
--- /dev/null
+++ b/encoding/jsonschema/doc.go
@@ -0,0 +1,19 @@
+// Copyright 2020 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 jsonschema converts JSON Schema to CUE
+//
+// JSON Schema data is presented in CUE, so any of the supported encodings
+// that can represent JSON Schema data can be used as a source.
+package jsonschema
diff --git a/encoding/jsonschema/testdata/basic.txtar b/encoding/jsonschema/testdata/basic.txtar
new file mode 100644
index 0000000..0c1b255
--- /dev/null
+++ b/encoding/jsonschema/testdata/basic.txtar
@@ -0,0 +1,53 @@
+-- basic.json --
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "type": "object",
+  "title": "Main schema",
+  "description": "Specify who you are and all.",
+
+  "properties": {
+    "person": {
+      "description": "A person is a human being.",
+      "type": "object",
+	  "required": [ "name" ],
+      "properties": {
+        "name": { "type": "string" },
+		"address": {
+			"description": "where does this person live?",
+			"type": "string"
+		},
+        "children": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": []
+        },
+		"home phone": {
+			"type": "string",
+			"deprecated": true
+		}
+      }
+    }
+  }
+}
+
+-- out.cue --
+// Main schema
+// 
+// Specify who you are and all.
+package basic
+
+Schema :: _ @jsonschema(schema="http://json-schema.org/draft-07/schema#")
+Schema :: {
+	// A person is a human being.
+	person?: {
+		name: string
+
+		// where does this person live?
+		address?: string
+		children?: [...string]
+		"home phone"?: string
+		...
+	}
+	...
+}
diff --git a/encoding/jsonschema/testdata/def.txtar b/encoding/jsonschema/testdata/def.txtar
new file mode 100644
index 0000000..d5d92e9
--- /dev/null
+++ b/encoding/jsonschema/testdata/def.txtar
@@ -0,0 +1,63 @@
+// This test tests the conversion and ordering of definitions.
+
+-- definition.json --
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+
+  "$id": "http://cuelang.org/go/encoding/openapi/testdata/order.json",
+
+  "definitions": {
+    "address": {
+      "type": "object",
+      "properties": {
+        "street_address": { "type": "string" },
+        "city":           { "type": "string" },
+        "state":          { "type": "string" }
+      },
+      "required": ["street_address", "city", "state"]
+    },
+    "person": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string" },
+        "children": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/person" },
+          "default": []
+        }
+      }
+    }
+  },
+
+  "type": "object",
+
+  "properties": {
+    "person": { "$ref": "#/definitions/person" },
+    "billing_address": { "$ref": "#/definitions/address" },
+    "shipping_address": { "$ref": "#/definitions/address" }
+  }
+}
+
+-- out.cue --
+package def
+
+Schema :: _ @jsonschema(schema="http://json-schema.org/draft-07/schema#",id="http://cuelang.org/go/encoding/openapi/testdata/order.json")
+Schema :: {
+	person?:           def.person
+	billing_address?:  def.address
+	shipping_address?: def.address
+	...
+}
+
+def: address :: {
+	street_address: string
+	city:           string
+	state:          string
+	...
+}
+
+def: person :: {
+	name?: string
+	children?: [...def.person]
+	...
+}
diff --git a/encoding/jsonschema/testdata/list.txtar b/encoding/jsonschema/testdata/list.txtar
new file mode 100644
index 0000000..d3046dd
--- /dev/null
+++ b/encoding/jsonschema/testdata/list.txtar
@@ -0,0 +1,36 @@
+-- list.yaml --
+type: object
+
+properties:
+  foo:
+    items:
+      type: string
+
+  tuple:
+    items:
+      - type: string
+      - type: integer
+      - const: 2
+
+  has:
+    contains:
+      const: 3
+
+  size:
+    minItems: 3
+    maxItems: 9
+    uniqueItems: true
+
+additionalProperties: false
+
+-- out.cue --
+package list
+
+import "list"
+
+Schema :: {
+	foo?: [...string]
+	tuple?: [string, int, 2]
+	has?:  list.Contains(3)
+	size?: list.MinItems(3) & list.MaxItems(9) & list.UniqueItems()
+}
diff --git a/encoding/jsonschema/testdata/num.txtar b/encoding/jsonschema/testdata/num.txtar
new file mode 100644
index 0000000..5652628
--- /dev/null
+++ b/encoding/jsonschema/testdata/num.txtar
@@ -0,0 +1,37 @@
+-- type.json --
+{
+  "type": "object",
+
+  "properties": {
+    "constant":  { "const": 2 },
+    "several": {
+      "enum": [ 1, 2, 3, 4 ]
+    },
+    "inclusive": {
+        "type": "number",
+        "minimum": 2,
+        "maximum": 3
+    },
+    "exclusive": {
+        "exclusiveMinimum": 2,
+        "exclusiveMaximum": 3
+    },
+    "cents": {
+      "multipleOf": 0.05
+    }
+  },
+  "additionalProperties": false
+}
+
+-- out.cue --
+package num
+
+import "math"
+
+Schema :: {
+	constant?:  2
+	several?:   1 | 2 | 3 | 4
+	inclusive?: >=2 & <=3
+	exclusive?: >2 & <3
+	cents?:     math.MultipleOf(0.05)
+}
diff --git a/encoding/jsonschema/testdata/object.txtar b/encoding/jsonschema/testdata/object.txtar
new file mode 100644
index 0000000..59bbbe3
--- /dev/null
+++ b/encoding/jsonschema/testdata/object.txtar
@@ -0,0 +1,103 @@
+-- type.json --
+{
+  "type": "object",
+  "title": "Main schema",
+
+  "properties": {
+    "fields" : {
+      "type": "object",
+      "minProperties": 3,
+      "maxProperties": 10,
+      "propertyNames": {
+        "pattern": "^\\P{Lu}"
+      }
+    },
+    "additional": {
+      "type": "object",
+      "properties": {
+        "foo": { "type": "number" },
+        "bar": { "type": "number" }
+      },
+      "additionalProperties": { "type": "string" }
+    },
+    "map": {
+      "type": "object",
+      "additionalProperties": { "type": "string" }
+    },
+    "patterns": {
+      "type": "object",
+      "properties": {
+        "foo": { "type": "number" },
+        "bar": { "type": "number" }
+      },
+      "patternProperties": {
+        "^\\P{Lu}": { "type": "string" },
+        "^\\P{Lo}": { "type": "integer" }
+      }
+    },
+    "patternsNoProps": {
+      "type": "object",
+      "patternProperties": {
+        "^\\P{Lu}": { "type": "string" },
+        "^\\P{Lo}": { "type": "integer" }
+      }
+    },
+    "complex": {
+      "type": "object",
+      "properties": {
+        "foo": { "type": "number" },
+        "bar": { "type": "number" }
+      },
+      "patternProperties": {
+        "^\\P{Lu}": { "type": "string" },
+        "^\\P{Lo}": { "type": "integer" }
+      },
+      "additionalProperties": { "type": "string" }
+    }
+  },
+  "additionalProperties": false
+}
+
+-- out.cue --
+// Main schema
+package object
+
+import "struct"
+
+Schema :: {
+	fields?: struct.MinFields(3) & struct.MaxFields(10) & {
+		[=~"^\\P{Lu}"]: _
+	}
+	additional?: {
+		foo?: number
+		bar?: number
+
+		[!~"^(foo|bar)$"]: string
+	}
+	map?: [string]: string
+	patterns?: {
+		foo?: number
+		bar?: number
+
+		[=~"^\\P{Lu}" & !~"^(foo|bar)$"]: string
+
+		[=~"^\\P{Lo}" & !~"^(foo|bar)$"]: int
+		...
+	}
+	patternsNoProps?: {
+		[=~"^\\P{Lu}" & !~"^()$"]: string
+
+		[=~"^\\P{Lo}" & !~"^()$"]: int
+		...
+	}
+	complex?: {
+		foo?: number
+		bar?: number
+
+		[=~"^\\P{Lu}" & !~"^(foo|bar)$"]: string
+
+		[=~"^\\P{Lo}" & !~"^(foo|bar)$"]: int
+
+		[!~"^\\P{Lu}" & !~"^\\P{Lo}" & !~"^(foo|bar)$"]: string
+	}
+}
diff --git a/encoding/jsonschema/testdata/type.txtar b/encoding/jsonschema/testdata/type.txtar
new file mode 100644
index 0000000..2c13d3f
--- /dev/null
+++ b/encoding/jsonschema/testdata/type.txtar
@@ -0,0 +1,44 @@
+-- type.json --
+{
+  "type": "object",
+  "title": "Main schema",
+
+  "properties": {
+    "intString": {
+      "description": "an integer or string.",
+      "type": [ "string", "integer", "boolean", "array", "null" ]
+    },
+    "object": {
+        "type": "object",
+        "default": {
+            "foo": "bar",
+            "baz": 1.3
+        }
+    },
+    "numOrList": {
+      "oneOf": [
+        { "type": "number" },
+        { "items": { "type": "number" } }
+      ],
+      "default": [ 1, 2, 3 ]
+    }
+  },
+  "additionalProperties": false
+}
+
+-- out.cue --
+// Main schema
+package type
+
+Schema :: {
+	// an integer or string.
+	intString?: string | int | bool | [...] | null
+	object?:    {
+			...
+	} | *{
+		foo: "bar"
+		baz: 1.3
+		...
+	}
+	numOrList?: number | [...number] | *[1, 2, 3]
+}