diff --git a/cue/ast.go b/cue/ast.go
index 9bfc98e..b6924b4 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -280,12 +280,16 @@
 			}
 
 		case *ast.BasicLit, *ast.Ident:
+			attrs, err := createAttrs(v.ctx(), newNode(n), n.Attrs)
+			if err != nil {
+				return err
+			}
 			f, ok := v.nodeLabel(x)
 			if !ok {
 				return v.error(n.Label, "invalid field name: %v", n.Label)
 			}
 			if f != 0 {
-				v.object.insertValue(v.ctx(), f, v.walk(n.Value))
+				v.object.insertValue(v.ctx(), f, v.walk(n.Value), attrs)
 			}
 
 		default:
diff --git a/cue/ast/ast.go b/cue/ast/ast.go
index a468a8a..b7d05c6 100644
--- a/cue/ast/ast.go
+++ b/cue/ast/ast.go
@@ -264,6 +264,16 @@
 	return strings.Join(lines, "\n")
 }
 
+// An Attribute provides meta data about a field.
+type Attribute struct {
+	comments
+	At   token.Pos
+	Text string // must be a valid attribute format.
+}
+
+func (a *Attribute) Pos() token.Pos { return a.At }
+func (a *Attribute) End() token.Pos { return a.At.Add(len(a.Text)) }
+
 // A Field represents a field declaration in a struct.
 type Field struct {
 	comments
@@ -272,10 +282,17 @@
 	// No colon: Value must be an StructLit with one field.
 	Colon token.Pos
 	Value Expr // the value associated with this field.
+
+	Attrs []*Attribute
 }
 
 func (d *Field) Pos() token.Pos { return d.Label.Pos() }
-func (d *Field) End() token.Pos { return d.Value.End() }
+func (d *Field) End() token.Pos {
+	if len(d.Attrs) > 0 {
+		return d.Attrs[len(d.Attrs)-1].End()
+	}
+	return d.Value.End()
+}
 
 // An Alias binds another field to the alias name in the current struct.
 type Alias struct {
diff --git a/cue/ast/walk.go b/cue/ast/walk.go
index 4e53391..ce697ce 100644
--- a/cue/ast/walk.go
+++ b/cue/ast/walk.go
@@ -87,11 +87,17 @@
 			walk(v, c)
 		}
 
+	case *Attribute:
+		// nothing to do
+
 	case *Field:
 		walk(v, n.Label)
 		if n.Value != nil {
 			walk(v, n.Value)
 		}
+		for _, a := range n.Attrs {
+			walk(v, a)
+		}
 
 	case *StructLit:
 		for _, f := range n.Elts {
diff --git a/cue/attr.go b/cue/attr.go
new file mode 100644
index 0000000..a00982d
--- /dev/null
+++ b/cue/attr.go
@@ -0,0 +1,228 @@
+// 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 cue
+
+import (
+	"sort"
+	"strings"
+
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/literal"
+)
+
+// This file includes functionality for parsing attributes.
+// These functions are slightly more permissive than the spec. Together with the
+// scanner and parser the full spec is implemented, though.
+
+// attributes is used to store per-key attribute text for a fields.
+// It deliberately does not implement the value interface, as it should
+// never act as a value in any way.
+type attributes struct {
+	attr []attr
+}
+type attr struct {
+	text   string
+	offset int
+}
+
+func (a *attr) key() string {
+	return a.text[1:a.offset]
+}
+
+func (a *attr) body() string {
+	return a.text[a.offset+1 : len(a.text)-1]
+}
+
+func createAttrs(ctx *context, src source, attrs []*ast.Attribute) (a *attributes, err evaluated) {
+	if len(attrs) == 0 {
+		return nil, nil
+	}
+	as := []attr{}
+	for _, a := range attrs {
+		index := strings.IndexByte(a.Text, '(')
+		n := len(a.Text)
+		if index < 2 || a.Text[0] != '@' || a.Text[n-1] != ')' {
+			return nil, ctx.mkErr(newNode(a), "invalid attribute %q", a.Text)
+		}
+		as = append(as, attr{a.Text[:n], index})
+	}
+
+	sort.Slice(as, func(i, j int) bool { return as[i].text < as[j].text })
+	for i := 1; i < len(as); i++ {
+		if ai, aj := as[i-1], as[i]; ai.key() == aj.key() {
+			n := newNode(attrs[0])
+			return nil, ctx.mkErr(n, "multiple attributes for key %q", ai.key())
+		}
+	}
+
+	for _, a := range attrs {
+		if err := parseAttrBody(ctx, src, a.Text, nil); err != nil {
+			return nil, err
+		}
+	}
+	return &attributes{as}, nil
+}
+
+// unifyAttrs merges the attributes from a and b. It may return either a or b
+// if a and b are identical.
+func unifyAttrs(ctx *context, src source, a, b *attributes) (atrs *attributes, err evaluated) {
+	if a == b {
+		return a, nil
+	}
+	if a == nil {
+		return b, nil
+	}
+	if b == nil {
+		return a, nil
+	}
+
+	if len(a.attr) == len(b.attr) {
+		for i, x := range a.attr {
+			if x != b.attr[i] {
+				goto notSame
+			}
+		}
+		return a, nil
+	}
+
+notSame:
+	as := append(a.attr, b.attr...)
+
+	// remove duplicates and error on conflicts
+	sort.Slice(as, func(i, j int) bool { return as[i].text < as[j].text })
+	k := 0
+	for i := 1; i < len(as); i++ {
+		if ak, ai := as[k], as[i]; ak.key() == ai.key() {
+			if ak.body() == ai.body() {
+				continue
+			}
+			return nil, ctx.mkErr(src, "conflicting attributes for key %q", ai.key())
+		}
+		k++
+		as[k] = as[i]
+	}
+
+	return &attributes{as[:k+1]}, nil
+}
+
+// parsedAttr holds positional information for a single parsedAttr.
+type parsedAttr struct {
+	fields []keyValue
+}
+
+type keyValue struct {
+	data  string
+	equal int // index of equal sign or 0 if non-existing
+}
+
+func (kv *keyValue) text() string  { return kv.data }
+func (kv *keyValue) key() string   { return kv.data[:kv.equal] }
+func (kv *keyValue) value() string { return kv.data[kv.equal+1:] }
+
+func parseAttrBody(ctx *context, src source, s string, a *parsedAttr) (err evaluated) {
+	i := 0
+	for {
+		// always scan at least one, possibly empty element.
+		n, err := scanAttributeElem(ctx, src, s[i:], a)
+		if err != nil {
+			return err
+		}
+		if i += n; i >= len(s) {
+			break
+		}
+		if s[i] != ',' {
+			return ctx.mkErr(src, "invalid attribute: expected comma")
+		}
+		i++
+	}
+	return nil
+}
+
+func scanAttributeElem(ctx *context, src source, s string, a *parsedAttr) (n int, err evaluated) {
+	// try CUE string
+	kv := keyValue{}
+	if n, kv.data, err = scanAttributeString(ctx, src, s); n == 0 {
+		// try key-value pair
+		p := strings.IndexAny(s, ",=") // ) is assumed to be stripped.
+		switch {
+		case p < 0:
+			kv.data = s
+			n = len(s)
+
+		default: // ','
+			n = p
+			kv.data = s[:n]
+
+		case s[p] == '=':
+			kv.equal = p
+			offset := p + 1
+			var str string
+			if p, str, err = scanAttributeString(ctx, src, s[offset:]); p > 0 {
+				n = offset + p
+				kv.data = s[:offset] + str
+			} else {
+				n = len(s)
+				if p = strings.IndexByte(s[offset:], ','); p >= 0 {
+					n = offset + p
+				}
+				kv.data = s[:n]
+			}
+		}
+	}
+	if a != nil {
+		a.fields = append(a.fields, kv)
+	}
+	return n, err
+}
+
+func scanAttributeString(ctx *context, src source, s string) (n int, str string, err evaluated) {
+	if s == "" || (s[0] != '#' && s[0] != '"' && s[0] != '\'') {
+		return 0, "", nil
+	}
+
+	nHash := 0
+	for {
+		if nHash < len(s) {
+			if s[nHash] == '#' {
+				nHash++
+				continue
+			}
+			if s[nHash] == '\'' || s[nHash] == '"' {
+				break
+			}
+		}
+		return nHash, s[:nHash], ctx.mkErr(src, "invalid attribute string")
+	}
+
+	// Determine closing quote.
+	nQuote := 1
+	if c := s[nHash]; nHash+6 < len(s) && s[nHash+1] == c && s[nHash+2] == c {
+		nQuote = 3
+	}
+	close := s[nHash:nHash+nQuote] + s[:nHash]
+
+	// Search for closing quote.
+	index := strings.Index(s[len(close):], close)
+	if index == -1 {
+		return len(s), "", ctx.mkErr(src, "attribute string not terminated")
+	}
+
+	index += 2 * len(close)
+	s, err2 := literal.Unquote(s[:index])
+	if err2 != nil {
+		return index, "", ctx.mkErr(src, "invalid attribute string: %v", err2)
+	}
+	return index, s, nil
+}
diff --git a/cue/attr_test.go b/cue/attr_test.go
new file mode 100644
index 0000000..d3f08fd
--- /dev/null
+++ b/cue/attr_test.go
@@ -0,0 +1,219 @@
+// 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 cue
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"cuelang.org/go/cue/ast"
+)
+
+func TestAttributeBody(t *testing.T) {
+	testdata := []struct {
+		in, out string
+		err     string
+	}{{
+		in:  "",
+		out: "[{ 0}]",
+	}, {
+		in:  "bb",
+		out: "[{bb 0}]",
+	}, {
+		in:  "a,",
+		out: "[{a 0} { 0}]",
+	}, {
+		in:  "a,b",
+		out: "[{a 0} {b 0}]",
+	}, {
+		in:  `foo,"bar",#"baz"#`,
+		out: "[{foo 0} {bar 0} {baz 0}]",
+	}, {
+		in:  `bar=str`,
+		out: "[{bar=str 3}]",
+	}, {
+		in:  `bar="str"`,
+		out: "[{bar=str 3}]",
+	}, {
+		in:  `bar=,baz=`,
+		out: "[{bar= 3} {baz= 3}]",
+	}, {
+		in:  `foo=1,bar="str",baz=free form`,
+		out: "[{foo=1 3} {bar=str 3} {baz=free form 3}]",
+	}, {
+		in: `"""
+		"""`,
+		out: "[{ 0}]",
+	}, {
+		in: `#'''
+			\#x20
+			'''#`,
+		out: "[{  0}]",
+	}, {
+		in:  "'' ,b",
+		err: "invalid attribute",
+	}, {
+		in:  "' ,b",
+		err: "not terminated",
+	}, {
+		in:  `"\ "`,
+		err: "invalid attribute",
+	}, {
+		in:  `# `,
+		err: "invalid attribute",
+	}}
+	for _, tc := range testdata {
+		t.Run(tc.in, func(t *testing.T) {
+			pa := &parsedAttr{}
+			err := parseAttrBody(&context{}, baseValue{}, tc.in, pa)
+
+			if tc.err != "" {
+				if !strings.Contains(debugStr(&context{}, err), tc.err) {
+					t.Errorf("error was %v; want %v", err, tc.err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if got := fmt.Sprint(pa.fields); got != tc.out {
+				t.Errorf("got %v; want %v", got, tc.out)
+			}
+		})
+	}
+}
+
+func TestCreateAttrs(t *testing.T) {
+	testdata := []struct {
+		// space-separated lists of attributes
+		in, out string
+		err     string
+	}{{
+		in:  "@foo()",
+		out: "foo:",
+	}, {
+		in:  "@b(bb) @aaa(aa,)",
+		out: "aaa:aa, b:bb",
+	}, {
+		in:  "@b(a,",
+		err: "invalid attribute",
+	}, {
+		in:  "@b(foo) @b(foo)",
+		err: "attributes",
+	}, {
+		in:  "@b('' ,b)",
+		err: "invalid attribute",
+	}}
+	for _, tc := range testdata {
+		t.Run(tc.in, func(t *testing.T) {
+			a := []*ast.Attribute{}
+			for _, s := range strings.Split(tc.in, " ") {
+				a = append(a, &ast.Attribute{Text: s})
+			}
+			attrs, err := createAttrs(&context{}, baseValue{}, a)
+
+			if tc.err != "" {
+				if !strings.Contains(debugStr(&context{}, err), tc.err) {
+					t.Errorf("error was %v; want %v", err, tc.err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			sa := []string{}
+			for _, a := range attrs.attr {
+				sa = append(sa, a.key()+":"+a.body())
+			}
+			if got := strings.Join(sa, " "); got != tc.out {
+				t.Errorf("got %v; want %v", got, tc.out)
+			}
+		})
+	}
+}
+
+func TestUnifyAttrs(t *testing.T) {
+	parse := func(s string) *attributes {
+		a := []*ast.Attribute{}
+		for _, s := range strings.Split(s, " ") {
+			a = append(a, &ast.Attribute{Text: s})
+		}
+		attrs, _ := createAttrs(&context{}, baseValue{}, a)
+		return attrs
+	}
+	foo := parse("@foo()")
+
+	testdata := []struct {
+		// space-separated lists of attributes
+		a, b, out *attributes
+		err       string
+	}{{
+		a:   nil,
+		b:   nil,
+		out: nil,
+	}, {
+		a:   nil,
+		b:   foo,
+		out: foo,
+	}, {
+		a:   foo,
+		b:   nil,
+		out: foo,
+	}, {
+		a:   foo,
+		b:   foo,
+		out: foo,
+	}, {
+		a:   foo,
+		b:   parse("@bar()"),
+		out: parse("@bar() @foo()"),
+	}, {
+		a:   foo,
+		b:   parse("@bar() @foo()"),
+		out: parse("@bar() @foo()"),
+	}, {
+		a:   parse("@bar() @foo()"),
+		b:   parse("@foo() @bar()"),
+		out: parse("@bar() @foo()"),
+	}, {
+		a:   parse("@bar() @foo()"),
+		b:   parse("@foo() @baz()"),
+		out: parse("@bar() @baz() @foo()"),
+	}, {
+		a:   parse("@foo(ab)"),
+		b:   parse("@foo(cd)"),
+		err: `conflicting attributes for key "foo"`,
+	}}
+	for _, tc := range testdata {
+		t.Run("", func(t *testing.T) {
+			attrs, err := unifyAttrs(&context{}, baseValue{}, tc.a, tc.b)
+			if tc.err != "" {
+				if !strings.Contains(debugStr(&context{}, err), tc.err) {
+					t.Errorf("error was %v; want %v", err, tc.err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(attrs, tc.out) {
+				t.Errorf("\ngot:  %v;\nwant: %v", attrs, tc.out)
+			}
+		})
+	}
+}
diff --git a/cue/binop.go b/cue/binop.go
index 3e836c1..52f906c 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -530,7 +530,7 @@
 
 	for _, a := range x.arcs {
 		cp := ctx.copy(a.v)
-		obj.arcs = append(obj.arcs, arc{a.feature, cp, nil})
+		obj.arcs = append(obj.arcs, arc{a.feature, cp, nil, a.attrs})
 	}
 outer:
 	for _, a := range y.arcs {
@@ -539,10 +539,15 @@
 			if a.feature == b.feature {
 				v = mkBin(ctx, src.Pos(), opUnify, b.v, v)
 				obj.arcs[i].v = v
+				attrs, err := unifyAttrs(ctx, src, a.attrs, b.attrs)
+				if err != nil {
+					return err
+				}
+				obj.arcs[i].attrs = attrs
 				continue outer
 			}
 		}
-		obj.arcs = append(obj.arcs, arc{feature: a.feature, v: v})
+		obj.arcs = append(obj.arcs, arc{feature: a.feature, v: v, attrs: a.attrs})
 	}
 	sort.Stable(obj)
 
@@ -1049,7 +1054,7 @@
 			if isBottom(v) {
 				return v
 			}
-			arcs[i] = arc{x.arcs[i].feature, v, nil}
+			arcs[i] = arc{x.arcs[i].feature, v, nil, nil}
 		}
 
 		return lambda
diff --git a/cue/copy.go b/cue/copy.go
index 880c769..edefaa0 100644
--- a/cue/copy.go
+++ b/cue/copy.go
@@ -53,7 +53,7 @@
 
 		for i, a := range x.arcs {
 			v := ctx.copy(a.v)
-			arcs[i] = arc{a.feature, v, nil}
+			arcs[i] = arc{a.feature, v, nil, a.attrs}
 		}
 
 		comp := make([]*fieldComprehension, len(x.comprehensions))
diff --git a/cue/debug.go b/cue/debug.go
index d2d1807..a9dec8d 100644
--- a/cue/debug.go
+++ b/cue/debug.go
@@ -271,6 +271,11 @@
 		p.writef(str)
 		p.write(": ")
 		p.debugStr(n)
+		if x.attrs != nil {
+			for _, a := range x.attrs.attr {
+				p.write(" ", a.text)
+			}
+		}
 
 	case *fieldComprehension:
 		p.debugStr(x.clauses)
diff --git a/cue/export.go b/cue/export.go
index cb9f923..4de8767 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -30,7 +30,8 @@
 
 const (
 	exportEval exportMode = 1 << iota
-	exportRaw  exportMode = 0
+	exportAttrs
+	exportRaw exportMode = 0
 )
 
 func export(ctx *context, v value, m exportMode) ast.Expr {
@@ -264,6 +265,11 @@
 			} else {
 				f.Value = p.expr(v)
 			}
+			if a.attrs != nil { // TODO: && p.mode&exportAttrs != 0 {
+				for _, at := range a.attrs.attr {
+					f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
+				}
+			}
 			obj.Elts = append(obj.Elts, f)
 		}
 
diff --git a/cue/export_test.go b/cue/export_test.go
index 80d0448..c77f59a 100644
--- a/cue/export_test.go
+++ b/cue/export_test.go
@@ -190,7 +190,7 @@
 		in: `{
 			job <Name>: {
 				name:     Name
-				replicas: uint | *1
+				replicas: uint | *1 @protobuf(10)
 				command:  string
 			}
 			
@@ -206,12 +206,12 @@
 			job: {
 				list: {
 					name:     "list"
-					replicas: 1
+					replicas: 1 @protobuf(10)
 					command:  "ls"
 				}
 				nginx: {
 					name:     "nginx"
-					replicas: 2
+					replicas: 2 @protobuf(10)
 					command:  "nginx"
 				}
 			}
diff --git a/cue/format/format.go b/cue/format/format.go
index 23644fc..c2691c5 100644
--- a/cue/format/format.go
+++ b/cue/format/format.go
@@ -303,12 +303,17 @@
 			printBlank = true
 		}
 		for _, c := range c.cg[0].List {
+			isEnd := strings.HasPrefix(c.Text, "//")
 			if !printBlank {
-				f.Print(vtab)
+				if isEnd {
+					f.Print(vtab)
+				} else {
+					f.Print(blank)
+				}
 			}
 			f.Print(c.Slash)
 			f.Print(c)
-			if strings.HasPrefix(c.Text, "//") {
+			if isEnd {
 				f.Print(newline)
 			}
 		}
diff --git a/cue/format/node.go b/cue/format/node.go
index 2a1464f..3199995 100644
--- a/cue/format/node.go
+++ b/cue/format/node.go
@@ -168,6 +168,15 @@
 			f.visitComments(f.current.pos)
 		}
 
+		space := tab
+		for _, a := range n.Attrs {
+			if f.before(a) {
+				f.print(space, a.At, a)
+			}
+			f.after(a)
+			space = blank
+		}
+
 		if nextFF {
 			f.print(formfeed)
 		}
diff --git a/cue/format/printer.go b/cue/format/printer.go
index 10a2b7b..148cdfd 100644
--- a/cue/format/printer.go
+++ b/cue/format/printer.go
@@ -138,6 +138,11 @@
 		}
 		return
 
+	case *ast.Attribute:
+		data = x.Text
+		impliedComma = true
+		p.lastTok = token.ATTRIBUTE
+
 	case *ast.Comment:
 		// TODO: if implied comma, postpone comment
 		data = x.Text
diff --git a/cue/format/testdata/expressions.golden b/cue/format/testdata/expressions.golden
index 15c6377..830b215 100644
--- a/cue/format/testdata/expressions.golden
+++ b/cue/format/testdata/expressions.golden
@@ -1,8 +1,8 @@
 package expressions
 
 {
-	a:   1
-	aaa: 2
+	a:   1  // comment
+	aaa: 22 // comment
 
 	b: 3
 
@@ -27,6 +27,14 @@
 		aaa: 10
 	}
 
+	attrs: {
+		a:    8 @go(A) // comment
+		aa:   8 @go(A) // comment
+		bb:   9
+		bbb:  10  @go(Bbb) @xml(,attr)          // comment
+		bbbb: 100 @go(Bbbb) /* a */ @xml(,attr) // comment
+	}
+
 	e:  1 + 2*3
 	e:  1 * 2 * 3 // error
 	e:  >=2 & <=3
diff --git a/cue/format/testdata/expressions.input b/cue/format/testdata/expressions.input
index 6b324a3..f15e37e 100644
--- a/cue/format/testdata/expressions.input
+++ b/cue/format/testdata/expressions.input
@@ -1,8 +1,8 @@
 package expressions
 
 {
-    a: 1
-    aaa: 2
+    a: 1 // comment
+    aaa: 22 // comment
 
     b: 3
 
@@ -27,6 +27,14 @@
         aaa: 10
     }
 
+    attrs: {
+        a: 8 @go(A) // comment
+        aa: 8 @go(A) // comment
+        bb: 9
+        bbb: 10 @go(Bbb) @xml(,attr) // comment
+        bbbb: 100 @go(Bbbb) /* a */ @xml(,attr) // comment
+    }
+
     e: 1+2*3
     e: 1*2*3 // error
     e: >=2 & <=3
diff --git a/cue/parser/parser.go b/cue/parser/parser.go
index 2874049..74dab9c 100644
--- a/cue/parser/parser.go
+++ b/cue/parser/parser.go
@@ -698,6 +698,8 @@
 	this := &ast.Field{Label: nil}
 	m := this
 
+	allowComprehension := true
+
 	for i := 0; ; i++ {
 		tok := p.tok
 
@@ -735,6 +737,12 @@
 			break
 		}
 
+		// TODO: consider disallowing comprehensions with more than one label.
+		// This can be a bit awkward in some cases, but it would naturally
+		// enforce the proper style that a comprehension be defined in the
+		// smallest possible scope.
+		// allowComprehension = false
+
 		switch p.tok {
 		default:
 			if !allowEmit || p.tok != token.COMMA {
@@ -762,6 +770,17 @@
 	p.expect(token.COLON)
 	m.Value = p.parseRHS()
 
+	p.openList()
+	for p.tok == token.ATTRIBUTE {
+		allowComprehension = false
+		c := p.openComments()
+		a := &ast.Attribute{At: p.pos, Text: p.lit}
+		p.next()
+		c.closeNode(p, a)
+		this.Attrs = append(this.Attrs, a)
+	}
+	p.closeList()
+
 	decl = this
 	var arrow token.Pos
 	switch p.tok {
@@ -770,6 +789,9 @@
 		fallthrough
 
 	case token.FOR, token.IF:
+		if !allowComprehension {
+			p.error(p.pos, "comprehension not alowed for this field")
+		}
 		clauses := p.parseComprehensionClauses()
 		return &ast.ComprehensionDecl{
 			Field:   this,
diff --git a/cue/parser/parser_test.go b/cue/parser/parser_test.go
index 2d3d587..ca6292b 100644
--- a/cue/parser/parser_test.go
+++ b/cue/parser/parser_test.go
@@ -66,6 +66,15 @@
 		}`,
 		`{a: 1, b: "2", c: 3}`,
 	}, {
+		"attributes",
+		`a: 1 @xml(,attr)
+		 b: 2 @foo(a,b=4) @go(Foo)
+		 c: {
+			 d: "x" @go(D) @json(,omitempty)
+			 e: "y" @ts(,type=string)
+		 }`,
+		`a: 1 @xml(,attr), b: 2 @foo(a,b=4) @go(Foo), c: {d: "x" @go(D) @json(,omitempty), e: "y" @ts(,type=string)}`,
+	}, {
 		"not emitted",
 		`a: true
 		 b: "2"
@@ -73,7 +82,7 @@
 		`,
 		`a: true, b: "2", c: 3`,
 	}, {
-		"emitted refrencing non-emitted",
+		"emitted referencing non-emitted",
 		`a: 1
 		 b: "2"
 		 c: 3
@@ -256,8 +265,8 @@
 		 b: 6 // lineb
 			  // next
 			`, // next is followed by EOF. Ensure it doesn't move to file.
-		"<[d0// doc] [l4// line] a: 5>, " +
-			"<[l4// lineb] [4// next] b: 6>",
+		"<[d0// doc] [l5// line] a: 5>, " +
+			"<[l5// lineb] [5// next] b: 6>",
 	}, {
 		"alt comments",
 		`// a ...
@@ -276,9 +285,9 @@
 		// about c
 
 		`,
-		"<[d0// a ...] [l4// line a] [4// about a] a: 5>, " +
-			"<[d0// b ...] [l2// lineb] [4// about b] b: 6>, " +
-			"<[4// about c] c: 7>",
+		"<[d0// a ...] [l5// line a] [5// about a] a: 5>, " +
+			"<[d0// b ...] [l2// lineb] [5// about b] b: 6>, " +
+			"<[5// about c] c: 7>",
 	}, {
 		"expr comments",
 		`
@@ -286,7 +295,7 @@
 		   3 +  // 3 +
 		   4    // 4
 		   `,
-		"<[l4// 4] a: <[l2// 3 +] <[l2// 2 +] 2+3>+4>>",
+		"<[l5// 4] a: <[l2// 3 +] <[l2// 2 +] 2+3>+4>>",
 	}, {
 		"composit comments",
 		`a : {
@@ -315,10 +324,16 @@
 		"a: <[d2// end] {a: 1, b: 2, c: 3, d: 4}>, " +
 			"b: <[d2// end] [1, 2, 3, 4, 5]>, " +
 			"c: [1, 2, 3, <[l1// here] 4>, 5, 6, 7, <[l1// and here] 8>], " +
-			"d: {<[2/* 8 */] [l4// Hello] a: 1>, <[d0// Doc] b: 2>}, " +
+			"d: {<[2/* 8 */] [l5// Hello] a: 1>, <[d0// Doc] b: 2>}, " +
 			"e1: <[d2// comment in list body] []>, " +
 			"e2: <[d1// comment in struct body] {}>",
 	}, {
+		"attribute comments",
+		`
+		a: 1 /* a */ @a() /* b */ @b() /* c */ // d
+		`,
+		`<[l5/* c */ // d] a: <[1/* a */] 1> <[1/* b */] @a()> @b()>`,
+	}, {
 		"emit comments",
 		`// a comment at the beginning of the file
 
diff --git a/cue/parser/print.go b/cue/parser/print.go
index 01d5d1c..4bdcc13 100644
--- a/cue/parser/print.go
+++ b/cue/parser/print.go
@@ -140,9 +140,16 @@
 		if v.Value != nil {
 			out += ": "
 			out += debugStr(v.Value)
+			for _, a := range v.Attrs {
+				out += " "
+				out += debugStr(a)
+			}
 		}
 		return out
 
+	case *ast.Attribute:
+		return v.Text
+
 	case *ast.Ident:
 		return v.Name
 
diff --git a/cue/parser/walk.go b/cue/parser/walk.go
index 8589b09..01a8220 100644
--- a/cue/parser/walk.go
+++ b/cue/parser/walk.go
@@ -81,11 +81,17 @@
 			walk(v, c)
 		}
 
+	case *ast.Attribute:
+		// nothing to do
+
 	case *ast.Field:
 		walk(v, n.Label)
 		if n.Value != nil {
 			walk(v, n.Value)
 		}
+		for _, a := range n.Attrs {
+			walk(v, a)
+		}
 
 	case *ast.StructLit:
 		for _, f := range n.Elts {
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index 07f7972..ee120cf 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -606,6 +606,19 @@
 		`,
 		out: `<0>{a: true, b: true, c: false, d: true, e: false, f: true}`,
 	}, {
+		desc: "attributes",
+		in: `
+			a: { foo: 1 @foo() @baz(1) }
+			b: { foo: 1 @bar() @foo() }
+			c: a & b
+
+			e: a & { foo: 1 @foo(other) }
+		`,
+		out: `<0>{a: <1>{foo: 1 @baz(1) @foo()}, ` +
+			`b: <2>{foo: 1 @bar() @foo()}, ` +
+			`c: <3>{foo: 1 @bar() @baz(1) @foo()}, ` +
+			`e: _|_((<4>.a & <5>{foo: 1 @foo(other)}):conflicting attributes for key "foo")}`,
+	}, {
 		desc: "bounds",
 		in: `
 			i1: >1 & 5
diff --git a/cue/rewrite.go b/cue/rewrite.go
index 479605c..85130f4 100644
--- a/cue/rewrite.go
+++ b/cue/rewrite.go
@@ -44,7 +44,7 @@
 	changed := emit == x.emit
 	for i, a := range x.arcs {
 		v := rewrite(ctx, a.v, fn)
-		arcs[i] = arc{a.feature, v, nil}
+		arcs[i] = arc{a.feature, v, nil, a.attrs}
 		changed = changed || arcs[i].v != v
 	}
 	if !changed {
diff --git a/cue/rewrite_test.go b/cue/rewrite_test.go
index 19e8d8b..fbcf2c3 100644
--- a/cue/rewrite_test.go
+++ b/cue/rewrite_test.go
@@ -78,7 +78,7 @@
 		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}
+			arcs[i] = arc{a.feature, rewriteRec(ctx, a.v, v, m), nil, a.attrs}
 		}
 		t := x.template
 		if t != nil {
diff --git a/cue/scanner/scanner.go b/cue/scanner/scanner.go
index 21b0aed..c5e182f 100644
--- a/cue/scanner/scanner.go
+++ b/cue/scanner/scanner.go
@@ -562,6 +562,92 @@
 	return c[:i]
 }
 
+// scanAttribute scans aa full attribute of the form @foo(str). An attribute
+// is a lexical entry and as such whitespace is treated as normal characters
+// within the attribute.
+func (s *Scanner) scanAttribute() (tok token.Token, lit string) {
+	offs := s.offset - 1 // @ already consumed
+
+	s.scanIdentifier()
+
+	if s.ch != '(' {
+		s.error(s.offset, "invalid attribute: expected '('")
+		return token.ATTRIBUTE, string(s.src[offs:s.offset])
+	}
+	s.next()
+
+	for {
+		s.scanAttributeElem()
+		if s.ch != ',' {
+			break
+		}
+		s.next()
+	}
+
+	if s.ch == ')' {
+		s.next()
+	} else {
+		s.error(s.offset, "attribute missing ')'")
+	}
+	return token.ATTRIBUTE, string(s.src[offs:s.offset])
+}
+
+func (s *Scanner) scanAttributeElem() {
+	// try CUE string
+	if s.scanAttributeString() {
+		return
+	}
+
+	// try key-value pair
+	if s.scanIdentifier() != "" && s.ch == '=' {
+		s.next()
+		if s.scanAttributeString() {
+			return
+		}
+	}
+
+	// raw element or key-value pair with raw value
+	for s.ch != ',' && s.ch != ')' && s.ch != '\n' && s.ch != -1 {
+		switch s.ch {
+		case '#', '\'', '"', '(', '=':
+			s.error(s.offset, "illegal character in attribute")
+			s.recoverParen(1)
+			return
+		}
+		s.next()
+	}
+}
+
+func (s *Scanner) scanAttributeString() bool {
+	if s.ch == '#' || s.ch == '"' || s.ch == '\'' {
+		if _, tok, _ := s.Scan(); tok == token.INTERPOLATION {
+			s.error(s.offset, "interpolation not allowed in attribute")
+			s.popInterpolation()
+			s.recoverParen(1)
+		}
+		return true
+	}
+	return false
+}
+
+// recoverParen is an approximate recovery mechanism to recover from invalid
+// attributes.
+func (s *Scanner) recoverParen(open int) {
+	for {
+		switch s.ch {
+		case '\n', -1:
+			return
+		case '(':
+			open++
+		case ')':
+			if open--; open == 0 {
+				return
+			}
+		}
+		s.next()
+	}
+}
+
 func (s *Scanner) skipWhitespace(inc int) {
 	for {
 		switch s.ch {
@@ -594,10 +680,15 @@
 	return tok0
 }
 
-// ResumeInterpolation resumes scanning of a string interpolation.
-func (s *Scanner) ResumeInterpolation() string {
+func (s *Scanner) popInterpolation() quoteInfo {
 	quote := s.quoteStack[len(s.quoteStack)-1]
 	s.quoteStack = s.quoteStack[:len(s.quoteStack)-1]
+	return quote
+}
+
+// ResumeInterpolation resumes scanning of a string interpolation.
+func (s *Scanner) ResumeInterpolation() string {
+	quote := s.popInterpolation()
 	_, str := s.scanString(1, quote)
 	return str
 }
@@ -706,7 +797,7 @@
 			}
 			insertEOL = true
 		case '\n':
-			// we only reach here if s.insertSemi was
+			// we only reach here if s.insertComma was
 			// set in the first place and exited early
 			// from s.skipWhitespace()
 			s.insertEOL = false // newline consumed
@@ -738,6 +829,9 @@
 				quote.numChar = n + 1
 				tok, lit = s.scanString(quote.numChar+quote.numHash, quote)
 			}
+		case '@':
+			insertEOL = true
+			tok, lit = s.scanAttribute()
 		case ':':
 			tok = token.COLON
 		case ';':
diff --git a/cue/scanner/scanner_test.go b/cue/scanner/scanner_test.go
index 422f9a8..87746a6 100644
--- a/cue/scanner/scanner_test.go
+++ b/cue/scanner/scanner_test.go
@@ -62,9 +62,18 @@
 	{token.COMMENT, "/*\r*/", special},
 	{token.COMMENT, "//\r\n", special},
 
+	// Attributes
+	{token.ATTRIBUTE, "@foo()", special},
+	{token.ATTRIBUTE, "@foo(,,)", special},
+	{token.ATTRIBUTE, "@foo(a)", special},
+	{token.ATTRIBUTE, "@foo(aa=b)", special},
+	{token.ATTRIBUTE, "@foo(,a=b)", special},
+	{token.ATTRIBUTE, `@foo(",a=b")`, special},
+	{token.ATTRIBUTE, `@foo(##"\(),a=b"##)`, special},
+	{token.ATTRIBUTE, `@foo("",a="")`, special},
+
 	// Identifiers and basic type literals
 	{token.BOTTOM, "_|_", literal},
-	{token.BOTTOM, "_|_", literal},
 
 	{token.IDENT, "foobar", literal},
 	{token.IDENT, "a۰۱۸", literal},
@@ -251,6 +260,8 @@
 			if elit[1] == '/' {
 				elit = elit[0 : len(elit)-1]
 			}
+		case token.ATTRIBUTE:
+			elit = e.lit
 		case token.IDENT:
 			elit = e.lit
 		case token.COMMA:
@@ -715,6 +726,18 @@
 	{`?`, token.ILLEGAL, 0, "", "illegal character U+003F '?'"},
 	{`…`, token.ILLEGAL, 0, "", "illegal character U+2026 '…'"},
 	{`_|`, token.ILLEGAL, 0, "", "illegal token '_|'; expected '_'"},
+
+	{`@`, token.ATTRIBUTE, 1, `@`, "invalid attribute: expected '('"},
+	{`@foo`, token.ATTRIBUTE, 4, `@foo`, "invalid attribute: expected '('"},
+	{`@foo(`, token.ATTRIBUTE, 5, `@foo(`, "attribute missing ')'"},
+	{`@foo( `, token.ATTRIBUTE, 6, `@foo( `, "attribute missing ')'"},
+	{`@foo( "")`, token.ATTRIBUTE, 6, `@foo( "")`, "illegal character in attribute"},
+	{`@foo(a=b=c)`, token.ATTRIBUTE, 8, `@foo(a=b=c)`, "illegal character in attribute"},
+	{`@foo("" )`, token.ATTRIBUTE, 7, `@foo(""`, "attribute missing ')'"},
+	{`@foo(""`, token.ATTRIBUTE, 7, `@foo(""`, "attribute missing ')'"},
+	{`@foo(aa`, token.ATTRIBUTE, 7, `@foo(aa`, "attribute missing ')'"},
+	{`@foo("\(())")`, token.ATTRIBUTE, 7, `@foo("\(())")`, "interpolation not allowed in attribute"},
+
 	// {`' '`, STRING, 0, `' '`, ""},
 	// {"`\0`", STRING, 3, `'\0'`, "illegal character U+0027 ''' in escape sequence"},
 	// {`'\07'`, STRING, 4, `'\07'`, "illegal character U+0027 ''' in escape sequence"},
diff --git a/cue/strip.go b/cue/strip.go
index aaf585a..bc90263 100644
--- a/cue/strip.go
+++ b/cue/strip.go
@@ -35,7 +35,7 @@
 			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}
+				arcs[i] = arc{a.feature, v, nil, a.attrs}
 			}
 			// TODO: verify that len(x.comprehensions) == 0
 			return &structLit{x.baseValue, x.emit, nil, nil, arcs, nil}, false
diff --git a/cue/token/token.go b/cue/token/token.go
index 87110b6..60e10bc 100644
--- a/cue/token/token.go
+++ b/cue/token/token.go
@@ -27,6 +27,7 @@
 	ILLEGAL Token = iota
 	EOF
 	COMMENT
+	ATTRIBUTE // @foo(bar,baz=4)
 
 	literalBeg
 	// Identifiers and basic type literals
@@ -115,6 +116,7 @@
 	// DURATION:      "DURATION", // TODO
 	STRING:        "STRING",
 	INTERPOLATION: "INTERPOLATION",
+	ATTRIBUTE:     "ATTRIBUTE",
 
 	ADD: "+",
 	SUB: "-",
diff --git a/cue/types.go b/cue/types.go
index 51f9ba7..1f0a368 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -21,6 +21,7 @@
 	"io"
 	"math"
 	"math/big"
+	"strconv"
 	"strings"
 
 	"cuelang.org/go/cue/ast"
@@ -130,13 +131,14 @@
 // An Iterator iterates over values.
 //
 type Iterator struct {
-	val  Value
-	ctx  *context
-	iter iterAtter
-	len  int
-	p    int
-	cur  Value
-	f    label
+	val   Value
+	ctx   *context
+	iter  iterAtter
+	len   int
+	p     int
+	cur   Value
+	f     label
+	attrs *attributes
 }
 
 // Next advances the iterator to the next value and reports whether there was
@@ -146,8 +148,8 @@
 		i.cur = Value{}
 		return false
 	}
-	eval, orig, f := i.iter.iterAt(i.ctx, i.p)
-	i.cur = i.val.makeChild(i.ctx, uint32(i.p), f, eval, orig)
+	eval, orig, f, attrs := i.iter.iterAt(i.ctx, i.p)
+	i.cur = i.val.makeChild(i.ctx, uint32(i.p), f, eval, orig, attrs)
 	i.f = f
 	i.p++
 	return true
@@ -442,6 +444,7 @@
 	index   uint32
 	v       evaluated
 	raw     value
+	attrs   *attributes
 }
 
 // Value holds any value, which may be a Boolean, Error, List, Null, Number,
@@ -453,22 +456,22 @@
 
 func newValueRoot(ctx *context, x value) Value {
 	v := x.evalPartial(ctx)
-	return Value{ctx.index, &valueData{nil, 0, 0, v, x}}
+	return Value{ctx.index, &valueData{nil, 0, 0, v, x, nil}}
 }
 
 func newChildValue(obj *structValue, i int) Value {
 	eval := obj.ctx.manifest(obj.n.at(obj.ctx, i))
 	a := obj.n.arcs[i]
-	return Value{obj.ctx.index, &valueData{obj.path, a.feature, uint32(i), eval, a.v}}
+	return Value{obj.ctx.index, &valueData{obj.path, a.feature, uint32(i), eval, a.v, a.attrs}}
 }
 
 func (v Value) ctx() *context {
 	return v.idx.newContext()
 }
 
-func (v Value) makeChild(ctx *context, i uint32, f label, eval evaluated, raw value) Value {
+func (v Value) makeChild(ctx *context, i uint32, f label, eval evaluated, raw value, attrs *attributes) Value {
 	eval = ctx.manifest(eval)
-	return Value{v.idx, &valueData{v.path, f, i, eval, raw}}
+	return Value{v.idx, &valueData{v.path, f, i, eval, raw, attrs}}
 }
 
 func (v Value) eval(ctx *context) value {
@@ -1061,3 +1064,101 @@
 		after(v)
 	}
 }
+
+// Attribute returns the attribute data for the given key.
+// The returned attribute will return an error for any of its methods if there
+// is no attribute for the requested key.
+func (v Value) Attribute(key string) Attribute {
+	// look up the attributes
+	if v.path == nil || v.path.attrs == nil {
+		return Attribute{err: errNotExists}
+	}
+	for _, a := range v.path.attrs.attr {
+		if a.key() != key {
+			continue
+		}
+		at := Attribute{}
+		if err := parseAttrBody(v.ctx(), nil, a.body(), &at.attr); err != nil {
+			return Attribute{err: err.(error)}
+		}
+		return at
+	}
+	return Attribute{err: errNotExists}
+}
+
+var (
+	errNoSuchAttribute = errors.New("entry for key does not exist")
+)
+
+// An Attribute contains meta data about a field.
+type Attribute struct {
+	attr parsedAttr
+	err  error
+}
+
+// Err returns the error associated with this Attribute or nil if this
+// attribute is valid.
+func (a *Attribute) Err() error {
+	return a.err
+}
+
+func (a *Attribute) hasPos(p int) error {
+	if a.err != nil {
+		return a.err
+	}
+	if p >= len(a.attr.fields) {
+		return fmt.Errorf("field does not exist")
+	}
+	return nil
+}
+
+// String reports the possibly empty string value at the given position or
+// an error the attribute is invalid or if the position does not exist.
+func (a *Attribute) String(pos int) (string, error) {
+	if err := a.hasPos(pos); err != nil {
+		return "", err
+	}
+	return a.attr.fields[pos].text(), nil
+}
+
+// Int reports the integer at the given position or an error if the attribute is
+// invalid, the position does not exist, or the value at the given position is
+// not an integer.
+func (a *Attribute) Int(pos int) (int64, error) {
+	if err := a.hasPos(pos); err != nil {
+		return 0, err
+	}
+	// TODO: use CUE's literal parser once it exists, allowing any of CUE's
+	// number types.
+	return strconv.ParseInt(a.attr.fields[pos].text(), 10, 64)
+}
+
+// Flag reports whether an entry with the given name exists at position pos or
+// onwards or an error if the attribute is invalid or if the first pos-1 entries
+// are not defined.
+func (a *Attribute) Flag(pos int, key string) (bool, error) {
+	if err := a.hasPos(pos - 1); err != nil {
+		return false, err
+	}
+	for _, kv := range a.attr.fields[pos:] {
+		if kv.text() == key {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// Lookup searches for an entry of the form key=value from position pos onwards
+// and reports the value if found. It reports an error if the attribute is
+// invalid or if the first pos-1 entries are not defined.
+func (a *Attribute) Lookup(pos int, key string) (val string, found bool, err error) {
+	if err := a.hasPos(pos - 1); err != nil {
+		return "", false, err
+	}
+	for _, kv := range a.attr.fields[pos:] {
+		if kv.key() == key {
+			return kv.value(), true, nil
+		}
+	}
+	return "", false, nil
+}
diff --git a/cue/types_test.go b/cue/types_test.go
index d895109..bef35e4 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -24,6 +24,7 @@
 	"strings"
 	"testing"
 
+	"cuelang.org/go/cue/errors"
 	"github.com/google/go-cmp/cmp"
 )
 
@@ -945,6 +946,293 @@
 	}
 }
 
+func cmpError(a, b error) bool {
+	if a == nil {
+		return b == nil
+	}
+	if b == nil {
+		return a == nil
+	}
+	return a.Error() == b.Error()
+}
+
+func TestAttributeErr(t *testing.T) {
+	const config = `
+	a: {
+		a: 0 @foo(a,b,c=1)
+		b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+	}
+	`
+	testCases := []struct {
+		path string
+		attr string
+		err  error
+	}{{
+		path: "a",
+		attr: "foo",
+		err:  nil,
+	}, {
+		path: "a",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "xx",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "e",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}}
+	for _, tc := range testCases {
+		t.Run(tc.path+"-"+tc.attr, func(t *testing.T) {
+			v := getInstance(t, config).Value().Lookup("a", tc.path)
+			a := v.Attribute(tc.attr)
+			err := a.Err()
+			if !cmpError(err, tc.err) {
+				t.Errorf("got %v; want %v", err, tc.err)
+			}
+		})
+	}
+}
+
+func TestAttributeString(t *testing.T) {
+	const config = `
+	a: {
+		a: 0 @foo(a,b,c=1)
+		b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+	}
+	`
+	testCases := []struct {
+		path string
+		attr string
+		pos  int
+		str  string
+		err  error
+	}{{
+		path: "a",
+		attr: "foo",
+		pos:  0,
+		str:  "a",
+	}, {
+		path: "a",
+		attr: "foo",
+		pos:  2,
+		str:  "c=1",
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  3,
+		str:  "d=1",
+	}, {
+		path: "e",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  4,
+		err:  errors.New("field does not exist"),
+	}}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+			v := getInstance(t, config).Value().Lookup("a", tc.path)
+			a := v.Attribute(tc.attr)
+			got, err := a.String(tc.pos)
+			if !cmpError(err, tc.err) {
+				t.Errorf("err: got %v; want %v", err, tc.err)
+			}
+			if got != tc.str {
+				t.Errorf("str: got %v; want %v", got, tc.str)
+			}
+		})
+	}
+}
+
+func TestAttributeInt(t *testing.T) {
+	const config = `
+	a: {
+		a: 0 @foo(1,3,c=1)
+		b: 1 @bar(a,-4,c,d=1) @foo(a,,d=1)
+	}
+	`
+	testCases := []struct {
+		path string
+		attr string
+		pos  int
+		val  int64
+		err  error
+	}{{
+		path: "a",
+		attr: "foo",
+		pos:  0,
+		val:  1,
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  1,
+		val:  -4,
+	}, {
+		path: "e",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  4,
+		err:  errors.New("field does not exist"),
+	}, {
+		path: "a",
+		attr: "foo",
+		pos:  2,
+		err:  errors.New(`strconv.ParseInt: parsing "c=1": invalid syntax`),
+	}}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+			v := getInstance(t, config).Value().Lookup("a", tc.path)
+			a := v.Attribute(tc.attr)
+			got, err := a.Int(tc.pos)
+			if !cmpError(err, tc.err) {
+				t.Errorf("err: got %v; want %v", err, tc.err)
+			}
+			if got != tc.val {
+				t.Errorf("val: got %v; want %v", got, tc.val)
+			}
+		})
+	}
+}
+
+func TestAttributeFlag(t *testing.T) {
+	const config = `
+	a: {
+		a: 0 @foo(a,b,c=1)
+		b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+	}
+	`
+	testCases := []struct {
+		path string
+		attr string
+		pos  int
+		flag string
+		val  bool
+		err  error
+	}{{
+		path: "a",
+		attr: "foo",
+		pos:  0,
+		flag: "a",
+		val:  true,
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  1,
+		flag: "a",
+		val:  false,
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  0,
+		flag: "c",
+		val:  true,
+	}, {
+		path: "e",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  4,
+		err:  errors.New("field does not exist"),
+	}}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+			v := getInstance(t, config).Value().Lookup("a", tc.path)
+			a := v.Attribute(tc.attr)
+			got, err := a.Flag(tc.pos, tc.flag)
+			if !cmpError(err, tc.err) {
+				t.Errorf("err: got %v; want %v", err, tc.err)
+			}
+			if got != tc.val {
+				t.Errorf("val: got %v; want %v", got, tc.val)
+			}
+		})
+	}
+}
+
+func TestAttributeLookup(t *testing.T) {
+	const config = `
+	a: {
+		a: 0 @foo(a,b,c=1)
+		b: 1 @bar(a,b,e=-5,d=1) @foo(a,,d=1)
+	}
+	`
+	testCases := []struct {
+		path string
+		attr string
+		pos  int
+		key  string
+		val  string
+		err  error
+	}{{
+		path: "a",
+		attr: "foo",
+		pos:  0,
+		key:  "c",
+		val:  "1",
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  1,
+		key:  "a",
+		val:  "",
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  0,
+		key:  "e",
+		val:  "-5",
+	}, {
+		path: "b",
+		attr: "bar",
+		pos:  0,
+		key:  "d",
+		val:  "1",
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  2,
+		key:  "d",
+		val:  "1",
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  2,
+		key:  "f",
+		val:  "",
+	}, {
+		path: "e",
+		attr: "bar",
+		err:  errors.New("undefined value"),
+	}, {
+		path: "b",
+		attr: "foo",
+		pos:  4,
+		err:  errors.New("field does not exist"),
+	}}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+			v := getInstance(t, config).Value().Lookup("a", tc.path)
+			a := v.Attribute(tc.attr)
+			got, _, err := a.Lookup(tc.pos, tc.key)
+			if !cmpError(err, tc.err) {
+				t.Errorf("err: got %v; want %v", err, tc.err)
+			}
+			if got != tc.val {
+				t.Errorf("val: got %v; want %v", got, tc.val)
+			}
+		})
+	}
+}
 func TestMashalJSON(t *testing.T) {
 	testCases := []struct {
 		value string
diff --git a/cue/value.go b/cue/value.go
index c65584e..f615bc3 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -60,9 +60,11 @@
 }
 
 type iterAtter interface {
+	// TODO: make iterAt return a struct type instead, possibly an arc!
+
 	// at returns the evaluated and its original value at the given position.
 	// If the original could not be found, it returns an error and nil.
-	iterAt(*context, int) (evaluated, value, label)
+	iterAt(*context, int) (evaluated, value, label, *attributes)
 }
 
 // caller must be implemented by any concrete lambdaKind
@@ -204,12 +206,12 @@
 func (x *bytesLit) kind() kind       { return bytesKind }
 func (x *bytesLit) strValue() string { return string(x.b) }
 
-func (x *bytesLit) iterAt(ctx *context, i int) (evaluated, value, label) {
+func (x *bytesLit) iterAt(ctx *context, i int) (evaluated, value, label, *attributes) {
 	if i >= len(x.b) {
-		return nil, nil, 0
+		return nil, nil, 0, nil
 	}
 	v := x.at(ctx, i)
-	return v, v, 0
+	return v, v, 0, nil
 }
 
 func (x *bytesLit) at(ctx *context, i int) evaluated {
@@ -258,13 +260,13 @@
 func (x *stringLit) kind() kind       { return stringKind }
 func (x *stringLit) strValue() string { return x.str }
 
-func (x *stringLit) iterAt(ctx *context, i int) (evaluated, value, label) {
+func (x *stringLit) iterAt(ctx *context, i int) (evaluated, value, label, *attributes) {
 	runes := []rune(x.str)
 	if i >= len(runes) {
-		return nil, nil, 0
+		return nil, nil, 0, nil
 	}
 	v := x.at(ctx, i)
-	return v, v, 0
+	return v, v, 0, nil
 }
 
 func (x *stringLit) at(ctx *context, i int) evaluated {
@@ -487,7 +489,7 @@
 // already have been evaluated. It returns an error and nil if there was an
 // issue evaluating the list itself.
 func (x *list) at(ctx *context, i int) evaluated {
-	e, _, _ := x.iterAt(ctx, i)
+	e, _, _, _ := x.iterAt(ctx, i)
 	if e == nil {
 		return ctx.mkErr(x, "index %d out of bounds", i)
 	}
@@ -497,24 +499,24 @@
 // iterAt returns the evaluated and original value of position i. List x must
 // already have been evaluated. It returns an error and nil if there was an
 // issue evaluating the list itself.
-func (x *list) iterAt(ctx *context, i int) (evaluated, value, label) {
+func (x *list) iterAt(ctx *context, i int) (evaluated, value, label, *attributes) {
 	if i < 0 {
-		return ctx.mkErr(x, "index %d out of bounds", i), nil, 0
+		return ctx.mkErr(x, "index %d out of bounds", i), nil, 0, nil
 	}
 	if i < len(x.a) {
-		return x.a[i].evalPartial(ctx), x.a[i], 0
+		return x.a[i].evalPartial(ctx), x.a[i], 0, nil
 	}
 	max := maxNum(x.len.(evaluated))
 	if max.kind().isGround() {
 		if max.kind()&intKind == bottomKind {
-			return ctx.mkErr(max, "length indicator of list not of type int"), nil, 0
+			return ctx.mkErr(max, "length indicator of list not of type int"), nil, 0, nil
 		}
 		n := max.(*numLit).intValue(ctx)
 		if i >= n {
-			return nil, nil, 0
+			return nil, nil, 0, nil
 		}
 	}
-	return x.typ.(evaluated), x.typ, 0
+	return x.typ.(evaluated), x.typ, 0, nil
 }
 
 func (x *list) isOpen() bool {
@@ -603,13 +605,13 @@
 	return nil, nil
 }
 
-func (x *structLit) iterAt(ctx *context, i int) (evaluated, value, label) {
+func (x *structLit) iterAt(ctx *context, i int) (evaluated, value, label, *attributes) {
 	x = x.expandFields(ctx)
 	if i >= len(x.arcs) {
-		return nil, nil, 0
+		return nil, nil, 0, nil
 	}
 	v := x.at(ctx, i)
-	return v, x.arcs[i].v, x.arcs[i].feature // TODO: return template & v for original?
+	return v, x.arcs[i].v, x.arcs[i].feature, x.arcs[i].attrs // TODO: return template & v for original?
 }
 
 func (x *structLit) at(ctx *context, i int) evaluated {
@@ -763,6 +765,7 @@
 
 	v     value
 	cache evaluated // also used as newValue during unification.
+	attrs *attributes
 }
 
 type arcInfo struct {
@@ -773,7 +776,7 @@
 var hiddenArc = &arcInfo{hidden: true}
 
 // insertValue is used during initialization but never during evaluation.
-func (x *structLit) insertValue(ctx *context, f label, value value) {
+func (x *structLit) insertValue(ctx *context, f label, value value, a *attributes) {
 	for i, p := range x.arcs {
 		if f != p.feature {
 			continue
@@ -781,7 +784,7 @@
 		x.arcs[i].v = mkBin(ctx, token.NoPos, opUnify, p.v, value)
 		return
 	}
-	x.arcs = append(x.arcs, arc{feature: f, v: value})
+	x.arcs = append(x.arcs, arc{feature: f, v: value, attrs: a})
 	sort.Stable(x)
 }
 
@@ -851,7 +854,7 @@
 	if v == nil {
 		panic("nil node")
 	}
-	x.arcs = append(x.arcs, arc{f, v, nil})
+	x.arcs = append(x.arcs, arc{f, v, nil, nil})
 }
 
 func (x *params) iterAt(ctx *context, i int) (evaluated, value) {
@@ -913,7 +916,7 @@
 		if isBottom(v) {
 			return v
 		}
-		arcs[i] = arc{a.feature, v, v}
+		arcs[i] = arc{a.feature, v, v, nil}
 	}
 	lambda := &lambdaExpr{x.baseValue, &params{arcs}, nil}
 	defer ctx.pushForwards(x, lambda).popForwards()
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index be367c3..b204d45 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -987,14 +987,18 @@
 field and is visible within the template value.
 
 ```
-StructLit     = "{" [ { Declaration "," } Declaration ] "}" .
+StructLit     = "{" [ Declaration { "," Declaration } [ "," ] ] "}" .
 Declaration   = FieldDecl | AliasDecl | ComprehensionDecl .
-FieldDecl     = Label { Label } ":" Expression .
+FieldDecl     = Label { Label } ":" Expression { attribute } .
 
 AliasDecl     = Label "=" Expression .
 Label         = identifier | simple_string_lit | TemplateLabel .
 TemplateLabel = "<" identifier ">" .
-Tag           = "#" identifier [ ":" json_string ] .
+
+attribute     = "@" identifier "(" attr_elem { "," attr_elem } ")" .
+attr_elem     =  attr_string | identifier "=" attr_string .
+attr_string   = { attr_char } | string_lit .
+attr_char     = /* an arbitrary Unicode code point except newline, ',', '"', `'`, '#', '=', '(', and ')' */ .
 ```
 
 ```
@@ -1021,6 +1025,44 @@
 {a: 1} & {a: 2}                        _|_
 ```
 
+Fields may be associated with attributes.
+Attributes define additional information about a field,
+such as a mapping to a protobuf tag or alternative
+name of the field when mapping to a different language.
+
+If a field has multiple attributes their identifiers must be unique.
+Attributes accumulate when unifying two fields, removing duplicate entries.
+It is an error for the resulting field to have two different attributes
+with the same identifier.
+
+Attributes are not directly part of the data model, but may be
+accessed through the API or other means of reflection.
+The interpretation of the attribute value
+(a comma-separated list of attribute elements) depends on the attribute.
+Interpolations are not allowed in attribute strings.
+
+The recommended convention, however, is to interpret the first
+`n` arguments as positional arguments,
+where duplicate conflicting entries are an error,
+and the remaining arguments as a combination of flags
+(an identifier) and key value pairs, separated by a `=`.
+
+```
+MyStruct1: {
+    field: string @go(Field)
+    attr:  int    @xml(,attr) @go(Attr)
+}
+
+MyStruct2: {
+    field: string @go(Field)
+    attr:  int    @xml(a1,attr) @go(Attr)
+}
+
+Combined: MyStruct1 & MyStruct2
+// field: string @go(Field)
+// attr:  int    @xml(,attr) @xml(a1,attr) @go(Attr)
+```
+
 In addition to fields, a struct literal may also define aliases.
 Aliases name values that can be referred to
 within the [scope](#declarations-and-scopes) of their
@@ -1927,8 +1969,14 @@
 in the clauses.
 Values of iterations that map to the same label unify into a single field.
 
+<!--
+TODO: consider allowing multiple labels for comprehensions
+(current implementation). Generally it is better to define comprehensions
+in the current scope, though, as it may prevent surprises given the
+restrictions on comprehensions.
+-->
 ```
-ComprehensionDecl   = Field [ "<-" ] Clauses .
+ComprehensionDecl   = Label ":" Expression [ "<-" ] Clauses .
 ListComprehension   = "[" Expression [ "<-" ] Clauses "]" .
 
 Clauses             = Clause { Clause } .