diff --git a/cue/ast.go b/cue/ast.go
index b6924b4..5e02b9e 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -112,7 +112,7 @@
 	ctx := v.ctx()
 	label := v.label(n.Name, true)
 	if r := v.resolveRoot; r != nil {
-		if value, _ := r.lookup(v.ctx(), label); value != nil {
+		if a := r.lookup(v.ctx(), label); a.val() != nil {
 			return &selectorExpr{newExpr(n),
 				&nodeRef{baseValue: newExpr(n), node: r}, label}
 		}
@@ -252,6 +252,7 @@
 		v.object.comprehensions = append(v.object.comprehensions, fc)
 
 	case *ast.Field:
+		opt := n.Optional != token.NoPos
 		switch x := n.Label.(type) {
 		case *ast.Interpolation:
 			yielder := &yield{baseValue: newNode(x)}
@@ -261,6 +262,7 @@
 			}
 			yielder.key = v.walk(x)
 			yielder.value = v.walk(n.Value)
+			yielder.opt = opt
 			v.object.comprehensions = append(v.object.comprehensions, fc)
 
 		case *ast.TemplateLabel:
@@ -289,7 +291,7 @@
 				return v.error(n.Label, "invalid field name: %v", n.Label)
 			}
 			if f != 0 {
-				v.object.insertValue(v.ctx(), f, v.walk(n.Value), attrs)
+				v.object.insertValue(v.ctx(), f, opt, v.walk(n.Value), attrs)
 			}
 
 		default:
diff --git a/cue/ast/ast.go b/cue/ast/ast.go
index b7d05c6..cc2e7eb 100644
--- a/cue/ast/ast.go
+++ b/cue/ast/ast.go
@@ -277,7 +277,8 @@
 // A Field represents a field declaration in a struct.
 type Field struct {
 	comments
-	Label Label // must have at least one element.
+	Label    Label // must have at least one element.
+	Optional token.Pos
 
 	// No colon: Value must be an StructLit with one field.
 	Colon token.Pos
diff --git a/cue/binop.go b/cue/binop.go
index 52f906c..2cbd9aa 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -530,7 +530,8 @@
 
 	for _, a := range x.arcs {
 		cp := ctx.copy(a.v)
-		obj.arcs = append(obj.arcs, arc{a.feature, cp, nil, a.attrs})
+		obj.arcs = append(obj.arcs,
+			arc{a.feature, a.optional, cp, nil, a.attrs})
 	}
 outer:
 	for _, a := range y.arcs {
@@ -539,6 +540,8 @@
 			if a.feature == b.feature {
 				v = mkBin(ctx, src.Pos(), opUnify, b.v, v)
 				obj.arcs[i].v = v
+				obj.arcs[i].cache = nil
+				obj.arcs[i].optional = a.optional && b.optional
 				attrs, err := unifyAttrs(ctx, src, a.attrs, b.attrs)
 				if err != nil {
 					return err
@@ -547,7 +550,8 @@
 				continue outer
 			}
 		}
-		obj.arcs = append(obj.arcs, arc{feature: a.feature, v: v, attrs: a.attrs})
+		a.setValue(v)
+		obj.arcs = append(obj.arcs, a)
 	}
 	sort.Stable(obj)
 
@@ -1054,7 +1058,7 @@
 			if isBottom(v) {
 				return v
 			}
-			arcs[i] = arc{x.arcs[i].feature, v, nil, nil}
+			arcs[i] = arc{feature: x.arcs[i].feature, v: v}
 		}
 
 		return lambda
diff --git a/cue/copy.go b/cue/copy.go
index edefaa0..75011c3 100644
--- a/cue/copy.go
+++ b/cue/copy.go
@@ -52,8 +52,8 @@
 		obj.template = t
 
 		for i, a := range x.arcs {
-			v := ctx.copy(a.v)
-			arcs[i] = arc{a.feature, v, nil, a.attrs}
+			a.setValue(ctx.copy(a.v))
+			arcs[i] = a
 		}
 
 		comp := make([]*fieldComprehension, len(x.comprehensions))
diff --git a/cue/debug.go b/cue/debug.go
index a9dec8d..136379d 100644
--- a/cue/debug.go
+++ b/cue/debug.go
@@ -269,6 +269,9 @@
 			str = str[1 : len(str)-1]
 		}
 		p.writef(str)
+		if x.optional {
+			p.write("?")
+		}
 		p.write(": ")
 		p.debugStr(n)
 		if x.attrs != nil {
@@ -289,6 +292,9 @@
 		writef(" yield ")
 		writef("(")
 		p.debugStr(x.key)
+		if x.opt {
+			writef("?")
+		}
 		writef("): ")
 		p.debugStr(x.value)
 
diff --git a/cue/eval.go b/cue/eval.go
index d7ee66a..b908013 100644
--- a/cue/eval.go
+++ b/cue/eval.go
@@ -56,13 +56,14 @@
 	v := e.eval(x.x, structKind|lambdaKind, msgType, x)
 
 	if e.is(v, structKind|lambdaKind, "") {
-		n, _ := v.(scope).lookup(ctx, x.feature)
-		if n == nil {
+		n := v.(scope).lookup(ctx, x.feature)
+		if n.val() == nil {
 			field := ctx.labelStr(x.feature)
 			//	m.foo undefined (type map[string]bool has no field or method foo)
 			return ctx.mkErr(x, "undefined field %q", field)
 		}
-		return n.evalPartial(ctx)
+		// TODO: do we need to evaluate here?
+		return n.cache.evalPartial(ctx)
 	}
 	return e.err(&selectorExpr{x.baseValue, v, x.feature})
 }
@@ -87,11 +88,11 @@
 		if e.is(index, stringKind, msgIndexType, k) {
 			s := index.strValue()
 			// TODO: must lookup
-			n, _ := v.lookup(ctx, ctx.strLabel(s))
-			if n == nil {
+			n := v.lookup(ctx, ctx.strLabel(s))
+			if n.val() == nil {
 				return ctx.mkErr(x, index, "undefined field %q", s)
 			}
-			return n
+			return n.cache
 		}
 	case atter:
 		if e.is(index, intKind, msgIndexType, k) {
@@ -241,7 +242,7 @@
 
 func (x *listComprehension) evalPartial(ctx *context) evaluated {
 	list := &list{baseValue: x.baseValue}
-	result := x.clauses.yield(ctx, func(k, v evaluated) *bottom {
+	result := x.clauses.yield(ctx, func(k, v evaluated, _ bool) *bottom {
 		if !k.kind().isAnyOf(intKind) {
 			return ctx.mkErr(k, "key must be of type int")
 		}
diff --git a/cue/export.go b/cue/export.go
index 4de8767..e5111d2 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -284,9 +284,14 @@
 						// TODO: add an invalid field instead?
 						continue
 					}
+					opt := token.NoPos
+					if yield.opt {
+						opt = 1 // anything but token.NoPos
+					}
 					f := &ast.Field{
-						Label: label,
-						Value: p.expr(yield.value),
+						Label:    label,
+						Optional: opt,
+						Value:    p.expr(yield.value),
 					}
 					var decl ast.Decl = f
 					if len(clauses) > 0 {
diff --git a/cue/format/format.go b/cue/format/format.go
index c2691c5..30df812 100644
--- a/cue/format/format.go
+++ b/cue/format/format.go
@@ -174,7 +174,12 @@
 	current  frame
 	nestExpr int
 
-	labelBuf []ast.Label
+	labelBuf []labelEntry
+}
+
+type labelEntry struct {
+	label    ast.Label
+	optional bool
 }
 
 func newFormatter(p *printer) *formatter {
diff --git a/cue/format/node.go b/cue/format/node.go
index 3199995..8c19372 100644
--- a/cue/format/node.go
+++ b/cue/format/node.go
@@ -115,7 +115,7 @@
 		// shortcut single-element structs.
 		lastSize := len(f.labelBuf)
 		f.labelBuf = f.labelBuf[:0]
-		first := n.Label
+		first, opt := n.Label, n.Optional != token.NoPos
 		for {
 			obj, ok := n.Value.(*ast.StructLit)
 			if !ok || len(obj.Elts) != 1 || (obj.Lbrace.IsValid() && !f.printer.cfg.simplify) {
@@ -138,7 +138,8 @@
 			if !ok {
 				break
 			}
-			f.labelBuf = append(f.labelBuf, mem.Label)
+			entry := labelEntry{mem.Label, mem.Optional != token.NoPos}
+			f.labelBuf = append(f.labelBuf, entry)
 			n = mem
 		}
 
@@ -147,10 +148,10 @@
 		}
 
 		f.before(nil)
-		f.label(first)
+		f.label(first, opt)
 		for _, x := range f.labelBuf {
 			f.print(blank, nooverride)
-			f.label(x)
+			f.label(x.label, x.optional)
 		}
 		f.after(nil)
 
@@ -243,7 +244,7 @@
 
 func (f *formatter) importSpec(x *ast.ImportSpec) {
 	if x.Name != nil {
-		f.label(x.Name)
+		f.label(x.Name, false)
 		f.print(blank)
 	} else {
 		f.current.pos++
@@ -253,7 +254,7 @@
 	f.print(newline)
 }
 
-func (f *formatter) label(l ast.Label) {
+func (f *formatter) label(l ast.Label, optional bool) {
 	switch n := l.(type) {
 	case *ast.Ident:
 		f.print(n.NamePos, n)
@@ -275,7 +276,7 @@
 
 	case *ast.TemplateLabel:
 		f.print(n.Langle, token.LSS, indent)
-		f.label(n.Ident)
+		f.label(n.Ident, false)
 		f.print(unindent, n.Rangle, token.GTR)
 
 	case *ast.Interpolation:
@@ -284,6 +285,9 @@
 	default:
 		panic(fmt.Sprintf("unknown label type %T", n))
 	}
+	if optional {
+		f.print(token.OPTION)
+	}
 }
 
 func (f *formatter) expr(x ast.Expr) {
@@ -436,13 +440,13 @@
 	case *ast.ForClause:
 		f.print(blank, n.For, "for", blank)
 		if n.Key != nil {
-			f.label(n.Key)
+			f.label(n.Key, false)
 			f.print(n.Colon, token.COMMA, blank)
 		} else {
 			f.current.pos++
 			f.visitComments(f.current.pos)
 		}
-		f.label(n.Value)
+		f.label(n.Value, false)
 		f.print(blank, n.In, "in", blank)
 		f.expr(n.Source)
 
diff --git a/cue/format/testdata/expressions.golden b/cue/format/testdata/expressions.golden
index 830b215..15480aa 100644
--- a/cue/format/testdata/expressions.golden
+++ b/cue/format/testdata/expressions.golden
@@ -6,10 +6,11 @@
 
 	b: 3
 
-	c b a:    4
-	c bb aaa: 5
+	c b a:       4
+	c? bb? aaa?: 5
 	c b <Name> a: int
 	alias = 3.14
+	"g\("en")"?: 4
 
 	alias2 = foo
 	aaalias = foo
diff --git a/cue/format/testdata/expressions.input b/cue/format/testdata/expressions.input
index f15e37e..cebb633 100644
--- a/cue/format/testdata/expressions.input
+++ b/cue/format/testdata/expressions.input
@@ -7,9 +7,10 @@
     b: 3
 
     c b a:  4
-    c bb aaa: 5
+    c? bb? aaa?: 5
     c b <Name> a: int
     alias = 3.14
+    "g\("en")"?: 4
 
     alias2 = foo
     aaalias = foo
diff --git a/cue/parser/parser.go b/cue/parser/parser.go
index 74dab9c..e8ce7a5 100644
--- a/cue/parser/parser.go
+++ b/cue/parser/parser.go
@@ -733,6 +733,11 @@
 			}
 		}
 
+		if tok != token.LSS && p.tok == token.OPTION {
+			m.Optional = p.pos
+			p.next()
+		}
+
 		if p.tok == token.COLON {
 			break
 		}
diff --git a/cue/parser/parser_test.go b/cue/parser/parser_test.go
index 52364d5..32c0bf8 100644
--- a/cue/parser/parser_test.go
+++ b/cue/parser/parser_test.go
@@ -77,10 +77,12 @@
 	}, {
 		"not emitted",
 		`a: true
-		 b: "2"
-		 c: 3
+		 b?: "2"
+		 c?: 3
+
+		 "g\("en")"?: 4
 		`,
-		`a: true, b: "2", c: 3`,
+		`a: true, b?: "2", c?: 3, "g\("en")"?: 4`,
 	}, {
 		"emitted referencing non-emitted",
 		`a: 1
diff --git a/cue/parser/print.go b/cue/parser/print.go
index 4bdcc13..4c9b3a0 100644
--- a/cue/parser/print.go
+++ b/cue/parser/print.go
@@ -137,6 +137,9 @@
 
 	case *ast.Field:
 		out := debugStr(v.Label)
+		if v.Optional != token.NoPos {
+			out += "?"
+		}
 		if v.Value != nil {
 			out += ": "
 			out += debugStr(v.Value)
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index f438981..1fe8383 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -619,6 +619,24 @@
 			`c: <3>{foo: 1 @bar() @baz(1) @foo()}, ` +
 			`e: _|_((<4>.a & <5>{foo: 1 @foo(other)}):conflicting attributes for key "foo")}`,
 	}, {
+		desc: "optional fields",
+		in: `
+			a: { foo?: string }
+			b: { foo: "foo" }
+			c: a & b
+			d: a & { "foo"?: "bar" }
+
+			g1: 1
+			"g\(1)"?: 1
+			"g\(2)"?: 2
+		`,
+		out: `<0>{a: <1>{foo?: string}, ` +
+			`b: <2>{foo: "foo"}, ` +
+			`c: <3>{foo: "foo"}, ` +
+			`d: <4>{foo?: "bar"}, ` +
+			`g1: 1, ` +
+			`g2?: 2}`,
+	}, {
 		desc: "bounds",
 		in: `
 			i1: >1 & 5
diff --git a/cue/rewrite.go b/cue/rewrite.go
index c7a5e93..fe7faeb 100644
--- a/cue/rewrite.go
+++ b/cue/rewrite.go
@@ -43,9 +43,9 @@
 	obj := &structLit{baseValue: x.baseValue, emit: emit, arcs: arcs}
 	changed := emit == x.emit
 	for i, a := range x.arcs {
-		v := rewrite(ctx, a.v, fn)
-		arcs[i] = arc{a.feature, v, nil, a.attrs}
-		changed = changed || arcs[i].v != v
+		a.setValue(rewrite(ctx, a.v, fn))
+		changed = changed || arcs[i].v != a.v
+		arcs[i] = a
 	}
 	if !changed {
 		return x
@@ -228,7 +228,7 @@
 	if key == x.key && value == x.value {
 		return x
 	}
-	return &yield{x.baseValue, key, value}
+	return &yield{x.baseValue, x.opt, key, value}
 }
 
 func (x *guard) rewrite(ctx *context, fn rewriteFunc) value {
diff --git a/cue/rewrite_test.go b/cue/rewrite_test.go
index fbcf2c3..5180509 100644
--- a/cue/rewrite_test.go
+++ b/cue/rewrite_test.go
@@ -78,7 +78,8 @@
 		arcs := make(arcs, len(x.arcs))
 		for i, a := range x.arcs {
 			v := x.at(ctx, i)
-			arcs[i] = arc{a.feature, rewriteRec(ctx, a.v, v, m), nil, a.attrs}
+			a.setValue(rewriteRec(ctx, a.v, v, m))
+			arcs[i] = a
 		}
 		t := x.template
 		if t != nil {
diff --git a/cue/scanner/scanner.go b/cue/scanner/scanner.go
index c5e182f..c18e50a 100644
--- a/cue/scanner/scanner.go
+++ b/cue/scanner/scanner.go
@@ -837,6 +837,9 @@
 		case ';':
 			tok = token.SEMICOLON
 			insertEOL = true
+		case '?':
+			tok = token.OPTION
+			insertEOL = true
 		case '.':
 			if '0' <= s.ch && s.ch <= '9' {
 				insertEOL = true
diff --git a/cue/scanner/scanner_test.go b/cue/scanner/scanner_test.go
index 87746a6..d1a0402 100644
--- a/cue/scanner/scanner_test.go
+++ b/cue/scanner/scanner_test.go
@@ -149,6 +149,7 @@
 	{token.LBRACE, "{", operator},
 	{token.COMMA, ",", operator},
 	{token.PERIOD, ".", operator},
+	{token.OPTION, "?", operator},
 
 	{token.RPAREN, ")", operator},
 	{token.RBRACK, "]", operator},
@@ -331,28 +332,28 @@
 
 var lines = []string{
 	// ~ indicates a comma present in the source
-	// ? indicates an automatically inserted comma
+	// ^ indicates an automatically inserted comma
 	"",
 	"\ufeff~,", // first BOM is ignored
 	"~,",
-	"foo?\n",
-	"_foo?\n",
-	"123?\n",
-	"1.2?\n",
-	"'x'?\n",
-	"_|_?\n",
-	"_|_?\n",
-	`"x"` + "?\n",
-	"#'x'#?\n",
+	"foo^\n",
+	"_foo^\n",
+	"123^\n",
+	"1.2^\n",
+	"'x'^\n",
+	"_|_^\n",
+	"_|_^\n",
+	`"x"` + "^\n",
+	"#'x'#^\n",
 	`"""
 		foo
-		"""` + "?\n",
+		"""` + "^\n",
 	// `"""
 	// 	foo \(bar)
-	// 	"""` + "?\n",
+	// 	"""` + "^\n",
 	`'''
 		foo
-		'''` + "?\n",
+		'''` + "^\n",
 
 	"+\n",
 	"-\n",
@@ -361,7 +362,7 @@
 	"%\n",
 
 	"&\n",
-	// "&?\n",
+	// "&^\n",
 	"|\n",
 
 	"&&\n",
@@ -389,41 +390,41 @@
 	"~,\n",
 	".\n",
 
-	")?\n",
-	"]?\n",
-	"]]?\n",
-	"}?\n",
-	"}}?\n",
+	")^\n",
+	"]^\n",
+	"]]^\n",
+	"}^\n",
+	"}}^\n",
 	":\n",
-	";?\n",
+	";^\n",
 
-	"true?\n",
-	"false?\n",
-	"null?\n",
+	"true^\n",
+	"false^\n",
+	"null^\n",
 
-	"foo?//comment\n",
-	"foo?//comment",
-	"foo?/*comment*/\n",
-	"foo?/*\n*/",
-	"foo?/*comment*/    \n",
-	"foo?/*\n*/    ",
+	"foo^//comment\n",
+	"foo^//comment",
+	"foo^/*comment*/\n",
+	"foo^/*\n*/",
+	"foo^/*comment*/    \n",
+	"foo^/*\n*/    ",
 
-	"foo    ?// comment\n",
-	"foo    ?// comment",
-	"foo    ?/*comment*/\n",
-	"foo    ?/*\n*/",
-	"foo    ?/*  */ /* \n */ bar?/**/\n",
-	"foo    ?/*0*/ /*1*/ /*2*/\n",
+	"foo    ^// comment\n",
+	"foo    ^// comment",
+	"foo    ^/*comment*/\n",
+	"foo    ^/*\n*/",
+	"foo    ^/*  */ /* \n */ bar^/**/\n",
+	"foo    ^/*0*/ /*1*/ /*2*/\n",
 
-	"foo    ?/*comment*/    \n",
-	"foo    ?/*0*/ /*1*/ /*2*/    \n",
-	"foo	?/**/ /*-------------*/       /*----\n*/bar       ?/*  \n*/baa?\n",
-	"foo    ?/* an EOF terminates a line */",
-	"foo    ?/* an EOF terminates a line */ /*",
-	"foo    ?/* an EOF terminates a line */ //",
+	"foo    ^/*comment*/    \n",
+	"foo    ^/*0*/ /*1*/ /*2*/    \n",
+	"foo	^/**/ /*-------------*/       /*----\n*/bar       ^/*  \n*/baa^\n",
+	"foo    ^/* an EOF terminates a line */",
+	"foo    ^/* an EOF terminates a line */ /*",
+	"foo    ^/* an EOF terminates a line */ //",
 
-	// "package main?\n\nfunc main() {\n\tif {\n\t\treturn /* */ }?\n}?\n",
-	// "package main?",
+	"package main^\n\nfoo: bar^",
+	"package main^",
 }
 
 func TestCommas(t *testing.T) {
@@ -723,7 +724,7 @@
 	err string
 }{
 	{"\a", token.ILLEGAL, 0, "", "illegal character U+0007"},
-	{`?`, token.ILLEGAL, 0, "", "illegal character U+003F '?'"},
+	{`^`, token.ILLEGAL, 0, "", "illegal character U+005E '^'"},
 	{`…`, token.ILLEGAL, 0, "", "illegal character U+2026 '…'"},
 	{`_|`, token.ILLEGAL, 0, "", "illegal token '_|'; expected '_'"},
 
diff --git a/cue/strip.go b/cue/strip.go
index bc90263..9e8ac78 100644
--- a/cue/strip.go
+++ b/cue/strip.go
@@ -34,8 +34,8 @@
 		if x.template != nil {
 			arcs := make(arcs, len(x.arcs))
 			for i, a := range x.arcs {
-				v := rewrite(ctx, x.at(ctx, i), stripRewriter)
-				arcs[i] = arc{a.feature, v, nil, a.attrs}
+				a.setValue(rewrite(ctx, x.at(ctx, i), stripRewriter))
+				arcs[i] = a
 			}
 			// TODO: verify that len(x.comprehensions) == 0
 			return &structLit{x.baseValue, x.emit, nil, nil, arcs, nil}, false
diff --git a/cue/subsume.go b/cue/subsume.go
index 2c94f68..29df434 100644
--- a/cue/subsume.go
+++ b/cue/subsume.go
@@ -97,8 +97,15 @@
 
 		// all arcs in n must exist in v and its values must subsume.
 		for _, a := range x.arcs {
-			b, _ := o.lookup(ctx, a.feature)
-			if b == nil || !subsumes(ctx, a.v, b, mode) {
+			b := o.lookup(ctx, a.feature)
+			if !a.optional && b.optional {
+				return false
+			} else if b.val() == nil {
+				// If field a is optional and has value top, neither the
+				// omission of the field nor the field defined with any value
+				// may cause unification to fail.
+				return a.optional && isTop(a.v)
+			} else if !subsumes(ctx, a.v, b.val(), mode) {
 				return false
 			}
 		}
diff --git a/cue/subsume_test.go b/cue/subsume_test.go
index 0e61344..70aeaee 100644
--- a/cue/subsume_test.go
+++ b/cue/subsume_test.go
@@ -333,6 +333,43 @@
 		// Disjunctions
 		330: {subsumes: true, in: `a: >5, b: >10 | 8`},
 		331: {subsumes: false, in: `a: >8, b: >10 | 8`},
+
+		// Optional fields
+		// Optional fields defined constraints on fields that are not yet
+		// defined. So even if such a field is not part of the output, it
+		// influences the lattice structure.
+		// For a given A and B, where A and B unify and where A has an optional
+		// field that is not defined in B, the addition of an incompatible
+		// value of that field in B can cause A and B to no longer unify.
+		//
+		400: {subsumes: false, in: `a: {foo: 1}, b: {}`},
+		401: {subsumes: false, in: `a: {foo?: 1}, b: {}`},
+		402: {subsumes: true, in: `a: {}, b: {foo: 1}`},
+		403: {subsumes: true, in: `a: {}, b: {foo?: 1}`},
+
+		404: {subsumes: true, in: `a: {foo: 1}, b: {foo: 1}`},
+		405: {subsumes: true, in: `a: {foo?: 1}, b: {foo: 1}`},
+		406: {subsumes: true, in: `a: {foo?: 1}, b: {foo?: 1}`},
+		407: {subsumes: false, in: `a: {foo: 1}, b: {foo?: 1}`},
+
+		408: {subsumes: false, in: `a: {foo: 1}, b: {foo: 2}`},
+		409: {subsumes: false, in: `a: {foo?: 1}, b: {foo: 2}`},
+		410: {subsumes: false, in: `a: {foo?: 1}, b: {foo?: 2}`},
+		411: {subsumes: false, in: `a: {foo: 1}, b: {foo?: 2}`},
+
+		412: {subsumes: true, in: `a: {foo: number}, b: {foo: 2}`},
+		413: {subsumes: true, in: `a: {foo?: number}, b: {foo: 2}`},
+		414: {subsumes: true, in: `a: {foo?: number}, b: {foo?: 2}`},
+		415: {subsumes: false, in: `a: {foo: number}, b: {foo?: 2}`},
+
+		416: {subsumes: false, in: `a: {foo: 1}, b: {foo: number}`},
+		417: {subsumes: false, in: `a: {foo?: 1}, b: {foo: number}`},
+		418: {subsumes: false, in: `a: {foo?: 1}, b: {foo?: number}`},
+		419: {subsumes: false, in: `a: {foo: 1}, b: {foo?: number}`},
+
+		// The one exception of the rule: there is no value of foo that can be
+		// added to b which would cause the unification of a and b to fail.
+		420: {subsumes: true, in: `a: {foo?: _}, b: {}`},
 	}
 
 	re := regexp.MustCompile(`a: (.*).*b: ([^\n]*)`)
diff --git a/cue/token/token.go b/cue/token/token.go
index 60e10bc..e94859f 100644
--- a/cue/token/token.go
+++ b/cue/token/token.go
@@ -86,8 +86,9 @@
 	RPAREN    // )
 	RBRACK    // ]
 	RBRACE    // }
-	SEMICOLON // :
+	SEMICOLON // ;
 	COLON     // :
+	OPTION    // ?
 	operatorEnd
 
 	keywordBeg
@@ -162,6 +163,7 @@
 	RBRACE:    "}",
 	SEMICOLON: ";",
 	COLON:     ":",
+	OPTION:    "?",
 
 	BOTTOM: "_|_",
 
diff --git a/cue/types.go b/cue/types.go
index 949df68..c11fb73 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -785,6 +785,10 @@
 	return nil, v.checkKind(ctx, stringKind|bytesKind)
 }
 
+// TODO: distinguish between optional, hidden, etc. Probably the best approach
+// is to mark options in context and have a single function for creating
+// a structVal.
+
 // structVal returns an structVal or an error if v is not a struct.
 func (v Value) structVal(ctx *context) (structValue, error) {
 	if err := v.checkKind(ctx, structKind); err != nil {
@@ -796,16 +800,18 @@
 	obj = obj.expandFields(ctx) // expand comprehensions
 
 	// check if any labels are hidden
+	hasOptional := false
 	f := label(0)
 	for _, a := range obj.arcs {
 		f |= a.feature
+		hasOptional = hasOptional || a.optional
 	}
 
-	if f&hidden != 0 {
+	if f&hidden != 0 || hasOptional {
 		arcs := make([]arc, len(obj.arcs))
 		k := 0
 		for _, a := range obj.arcs {
-			if a.feature&hidden == 0 {
+			if a.feature&hidden == 0 && !a.optional {
 				arcs[k] = a
 				k++
 			}
@@ -819,7 +825,6 @@
 			arcs,
 			nil,
 		}
-
 	}
 	return structValue{ctx, v.path, obj}, nil
 }
diff --git a/cue/types_test.go b/cue/types_test.go
index bef35e4..bb33193 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -1294,6 +1294,14 @@
 	}, {
 		value: `{a: 2, b: 3, c: ["A", "B"]}`,
 		json:  `{"a":2,"b":3,"c":["A","B"]}`,
+	}, {
+		value: `{foo?: 1, bar?: 2, baz: 3}`,
+		json:  `{"baz":3}`,
+	}, {
+		// Has an unresolved cycle, but should not matter as all fields involved
+		// are optional
+		value: `{foo?: bar, bar?: foo, baz: 3}`,
+		json:  `{"baz":3}`,
 	}}
 	for i, tc := range testCases {
 		t.Run(fmt.Sprintf("%d/%v", i, tc.value), func(t *testing.T) {
diff --git a/cue/value.go b/cue/value.go
index d39a875..c1f442e 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -50,7 +50,7 @@
 
 type scope interface {
 	value
-	lookup(*context, label) (e evaluated, raw value)
+	lookup(*context, label) arc
 }
 
 type atter interface {
@@ -162,8 +162,8 @@
 	return b
 }
 
-func (x baseValue) strValue() string { panic("unimplemented") }
-func (x baseValue) returnKind() kind { panic("unimplemented") }
+func (b baseValue) strValue() string { panic("unimplemented") }
+func (b baseValue) returnKind() kind { panic("unimplemented") }
 
 // top is the top of the value lattice. It subsumes all possible values.
 type top struct{ baseValue }
@@ -592,17 +592,18 @@
 func (x *structLit) Swap(i, j int)      { x.arcs[i], x.arcs[j] = x.arcs[j], x.arcs[i] }
 
 // lookup returns the node for the given label f, if present, or nil otherwise.
-func (x *structLit) lookup(ctx *context, f label) (v evaluated, raw value) {
+func (x *structLit) lookup(ctx *context, f label) arc {
 	x = x.expandFields(ctx)
 	// Lookup is done by selector or index references. Either this is done on
 	// literal nodes or nodes obtained from references. In the later case,
 	// noderef will have ensured that the ancestors were evaluated.
 	for i, a := range x.arcs {
 		if a.feature == f {
-			return x.at(ctx, i), a.v
+			a.cache = x.at(ctx, i)
+			return a
 		}
 	}
-	return nil, nil
+	return arc{}
 }
 
 func (x *structLit) iterAt(ctx *context, i int) arc {
@@ -672,9 +673,11 @@
 	emit := x.emit
 	template := x.template
 	newArcs := []arc{}
+	optional := false
 
 	for _, c := range comprehensions {
-		result := c.clauses.yield(ctx, func(k, v evaluated) *bottom {
+		result := c.clauses.yield(ctx, func(k, v evaluated, opt bool) *bottom {
+			optional = opt
 			if !k.kind().isAnyOf(stringKind) {
 				return ctx.mkErr(k, "key must be of type string")
 			}
@@ -727,11 +730,12 @@
 						ctx.labelStr(f))
 				} else {
 					x.arcs[i].v = mkBin(ctx, x.Pos(), opUnify, a.v, na.v)
+					x.arcs[i].optional = x.arcs[i].optional && optional
 				}
 				continue outer
 			}
 		}
-		x.arcs = append(x.arcs, arc{feature: f, v: na.v})
+		x.arcs = append(x.arcs, arc{feature: f, optional: optional, v: na.v})
 	}
 	sort.Stable(x)
 	return x
@@ -762,13 +766,23 @@
 // however, may have both. In this case, the value must ultimately evaluate
 // to a node, which will then be merged with the existing one.
 type arc struct {
-	feature label
+	feature  label
+	optional bool
 
 	v     value
 	cache evaluated // also used as newValue during unification.
 	attrs *attributes
 }
 
+func (a *arc) val() evaluated {
+	return a.cache
+}
+
+func (a *arc) setValue(v value) {
+	a.v = v
+	a.cache = nil
+}
+
 type arcInfo struct {
 	hidden bool
 	tags   []string // name:string
@@ -777,15 +791,18 @@
 var hiddenArc = &arcInfo{hidden: true}
 
 // insertValue is used during initialization but never during evaluation.
-func (x *structLit) insertValue(ctx *context, f label, value value, a *attributes) {
+func (x *structLit) insertValue(ctx *context, f label, optional bool, value value, a *attributes) {
 	for i, p := range x.arcs {
 		if f != p.feature {
 			continue
 		}
 		x.arcs[i].v = mkBin(ctx, token.NoPos, opUnify, p.v, value)
+		// TODO: should we warn if there is a mixed mode of optional and non
+		// optional fields at this point?
+		x.arcs[i].optional = x.arcs[i].optional && optional
 		return
 	}
-	x.arcs = append(x.arcs, arc{feature: f, v: value, attrs: a})
+	x.arcs = append(x.arcs, arc{f, optional, value, nil, a})
 	sort.Stable(x)
 }
 
@@ -855,7 +872,7 @@
 	if v == nil {
 		panic("nil node")
 	}
-	x.arcs = append(x.arcs, arc{f, v, nil, nil})
+	x.arcs = append(x.arcs, arc{feature: f, v: v})
 }
 
 func (x *params) iterAt(ctx *context, i int) (evaluated, value) {
@@ -877,16 +894,17 @@
 }
 
 // lookup returns the node for the given label f, if present, or nil otherwise.
-func (x *params) lookup(ctx *context, f label) (v evaluated, raw value) {
+func (x *params) lookup(ctx *context, f label) arc {
 	// Lookup is done by selector or index references. Either this is done on
 	// literal nodes or nodes obtained from references. In the later case,
 	// noderef will have ensured that the ancestors were evaluated.
 	for i, a := range x.arcs {
 		if a.feature == f {
-			return x.at(ctx, i), a.v
+			a.cache = x.at(ctx, i)
+			return a
 		}
 	}
-	return nil, nil
+	return arc{}
 }
 
 type lambdaExpr struct {
@@ -917,7 +935,7 @@
 		if isBottom(v) {
 			return v
 		}
-		arcs[i] = arc{a.feature, v, v, nil}
+		arcs[i] = arc{feature: a.feature, v: v, cache: v}
 	}
 	lambda := &lambdaExpr{x.baseValue, &params{arcs}, nil}
 	defer ctx.pushForwards(x, lambda).popForwards()
@@ -1102,7 +1120,7 @@
 	return topKind | nonGround
 }
 
-type yieldFunc func(k, v evaluated) *bottom
+type yieldFunc func(k, v evaluated, optional bool) *bottom
 
 type yielder interface {
 	value
@@ -1111,6 +1129,7 @@
 
 type yield struct {
 	baseValue
+	opt   bool
 	key   value
 	value value
 }
@@ -1131,7 +1150,7 @@
 	if isBottom(v) {
 		return v
 	}
-	if err := fn(k, v); err != nil {
+	if err := fn(k, v, x.opt); err != nil {
 		return err
 	}
 	return nil
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index 7ec05ba..4f5783b 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -992,8 +992,10 @@
 FieldDecl     = Label { Label } ":" Expression { attribute } .
 
 AliasDecl     = Label "=" Expression .
-Label         = identifier | simple_string_lit | TemplateLabel .
 TemplateLabel = "<" identifier ">" .
+ConcreteLabel = identifier | simple_string_lit
+OptionalLabel = ConcreteLabel "?"
+Label         = ConcreteLabel | OptionalLabel | TemplateLabel .
 
 attribute     = "@" identifier "(" attr_elem { "," attr_elem } ")" .
 attr_elem     =  attr_string | identifier "=" attr_string .
@@ -1102,6 +1104,74 @@
 }
 ```
 
+#### Optional fields
+
+An identifier or string label may be followed by a question mark `?`
+to indicate a field is optional.
+Constraints defined by an optional field should only be applied when
+a field is present.
+Fields with such markers may be omitted from output and should not cause
+an error when emitting a concrete configuration, even if its value is
+not concrete or bottom.
+The question mark is not part of the field name.
+The result of unifying two fields only has an optional marker
+if both fields have such a marker.
+
+<!--
+The optional marker solves the issue of having to print large amounts of
+boilerplate when dealing with large types with many optional or default
+values (such as Kubernetes).
+Writing such optional values in terms of *null | value is tedious,
+unpleasant to read, and as it is not well defined what can be dropped or not,
+all null values have to be emitted from the output, even if the user
+doesn't override them.
+Part of the issue is how null is defined. We could adopt a Typescript-like
+approach of introducing "void" or "undefined" to mean "not defined and not
+part of the output". But having all of null, undefined, and void can be
+confusing. If these ever are introduced anyway, the ? operator could be
+expressed along the lines of
+   foo?: bar
+being a shorthand for
+   foo: void | bar
+where void is the default if no other default is given.
+
+The current mechanical definition of "?" is straightforward, though, and
+probably avoids the need for void, while solving a big issue.
+
+Caveats:
+[1] this definition requires explicitly defined fields to be emitted, even
+if they could be elided (for instance if the explicit value is the default
+value defined an optional field). This is probably a good thing.
+
+[2] a default value may still need to be included in an output if it is not
+the zero value for that field and it is not known if any outside system is
+aware of defaults. For instance, which defaults are specified by the user
+and which by the schema understood by the receiving system.
+The use of "?" together with defaults should therefore be used carefully
+in non-schema definitions.
+Problematic cases should be easy to detect by a vet-like check, though.
+
+[3] It should be considered how this affects the trim command.
+Should values implied by optional fields be allowed to be removed?
+Probably not. This restriction is unlikely to limit the usefulness of trim,
+though.
+
+[4] There should be an option to emit all concrete optional values.
+```
+-->
+
+```
+Input                            Result
+a: { foo?: string }              {}
+b: { foo: "bar" }                { foo: "bar" }
+c: { foo?: *"bar" | string }     {}
+
+d: a & b                         { foo: "bar" }
+e: b & c                         { foo: "bar" }
+f: a & c                         {}
+g: a & { foo?: number }          _|_
+```
+
 
 ### Lists
 
diff --git a/go.mod b/go.mod
index 923920b..c89414f 100644
--- a/go.mod
+++ b/go.mod
@@ -1,9 +1,12 @@
 module cuelang.org/go
 
 require (
+	github.com/BurntSushi/toml v0.3.1 // indirect
 	github.com/cockroachdb/apd v1.1.0
 	github.com/ghodss/yaml v1.0.0
 	github.com/google/go-cmp v0.2.0
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/lib/pq v1.0.0 // indirect
 	github.com/mitchellh/go-homedir v1.0.0
 	github.com/pkg/errors v0.8.0 // indirect
 	github.com/spf13/cobra v0.0.3
diff --git a/go.sum b/go.sum
index 40485fd..3d202df 100644
--- a/go.sum
+++ b/go.sum
@@ -1,9 +1,12 @@
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I=
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -13,6 +16,10 @@
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
@@ -23,6 +30,7 @@
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
@@ -36,14 +44,11 @@
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/viper v1.3.1 h1:5+8j8FTpnFV4nEImW/ofkzEt8VoOiLXxdYIDsB73T38=
 github.com/spf13/viper v1.3.1/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/exp/errors v0.0.0-20181210123644-7d6377eee41f h1:B/8yFg7PHSFdahc+fMB+RUy3if9GlZmexAbcdfCwREI=
-golang.org/x/exp/errors v0.0.0-20181210123644-7d6377eee41f/go.mod h1:YgqsNsAu4fTvlab/7uiYK9LJrCIzKg/NiZUIH1/ayqo=
-golang.org/x/exp/errors v0.0.0-20181220081853-a8d4f384862a h1:juhXrq7Jv3Yw6H4azsxx0SGft00IiERvkUW6cNqnV1I=
-golang.org/x/exp/errors v0.0.0-20181220081853-a8d4f384862a/go.mod h1:YgqsNsAu4fTvlab/7uiYK9LJrCIzKg/NiZUIH1/ayqo=
 golang.org/x/exp/errors v0.0.0-20181221233300-b68661188fbf h1:4SQtY0VxhI0RZe/PFmCCfHyaPVuC5DgyXEqehsAWjwc=
 golang.org/x/exp/errors v0.0.0-20181221233300-b68661188fbf/go.mod h1:YgqsNsAu4fTvlab/7uiYK9LJrCIzKg/NiZUIH1/ayqo=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
@@ -54,6 +59,7 @@
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20181210225255-6a3e9aa2ab77 h1:s+6psEFi3o1QryeA/qyvUoVaHMCQkYVvZ0i2ZolwSJc=
 golang.org/x/tools v0.0.0-20181210225255-6a3e9aa2ab77/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=