diff --git a/cue/binop.go b/cue/binop.go
index 682dd89..409d4a0 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -510,16 +510,26 @@
 
 func (x *nullLit) binOp(ctx *context, src source, op op, other evaluated) evaluated {
 	// TODO: consider using binSrc instead of src.base() for better traceability.
-	switch op {
-	case opEql:
-		return &boolLit{baseValue: src.base(), b: true}
-	case opNeq:
-		return &boolLit{baseValue: src.base(), b: false}
-	case opUnify:
-		return x
+	switch other.(type) {
+	case *nullLit:
+		switch op {
+		case opEql:
+			return &boolLit{baseValue: src.base(), b: true}
+		case opNeq:
+			return &boolLit{baseValue: src.base(), b: false}
+		case opUnify:
+			return x
+		}
+
 	default:
-		panic("unimplemented")
+		switch op {
+		case opEql:
+			return &boolLit{baseValue: src.base(), b: false}
+		case opNeq:
+			return &boolLit{baseValue: src.base(), b: true}
+		}
 	}
+	return ctx.mkIncompatible(src, op, x, other)
 }
 
 func (x *boolLit) binOp(ctx *context, src source, op op, other evaluated) evaluated {
diff --git a/cue/kind.go b/cue/kind.go
index 110ea48..86a16d0 100644
--- a/cue/kind.go
+++ b/cue/kind.go
@@ -54,8 +54,8 @@
 	// to move the reference to an assertion clause.
 	referenceKind
 
-	atomKind     = (listKind - 1)
-	concreteKind = (lambdaKind - 1)
+	atomKind     = (listKind - 1) &^ unknownKind
+	concreteKind = (lambdaKind - 1) &^ unknownKind
 
 	// doneKind indicates a value can not further develop on its own (i.e. not a
 	// reference). If doneKind is not set, but the result is ground, it
@@ -65,10 +65,10 @@
 	// unless the range is restricted by a root type.
 	numKind = intKind | floatKind
 
-	comparableKind = listKind - 1
+	comparableKind = (listKind - 1) &^ unknownKind
 	stringableKind = scalarKinds | stringKind
 	topKind        = (referenceKind - 1) // all kinds, but not references
-	typeKinds      = nonGround - 1
+	typeKinds      = (nonGround - 1) &^ unknownKind
 	okKinds        = typeKinds &^ bottomKind
 	fixedKinds     = okKinds &^ (structKind | lambdaKind)
 	scalarKinds    = numKind | durationKind
@@ -180,10 +180,20 @@
 	u := unifyType(a, b)
 	valBits := u & typeKinds
 	catBits := u &^ typeKinds
+	aGround := a&nonGround == 0
+	bGround := b&nonGround == 0
 	a = a & typeKinds
 	b = b & typeKinds
 	if valBits == bottomKind {
-		if op == opEql || op == opNeq {
+		if op == opEql || op == opNeq || op == opUnify {
+			// Set invert for better error messages
+			// invert = aGround && !bGround
+			if a&nullKind != 0 {
+				return boolKind, false
+			}
+			if b&nullKind != 0 {
+				return boolKind, true
+			}
 			return bottomKind, false
 		}
 		if a.isAnyOf(listKind) && b.isAnyOf(intKind) {
@@ -225,7 +235,7 @@
 	case op != opUnify && op != opLand && op != opLor:
 
 	default:
-		invert = a&nonGround == 0 && b&nonGround != 0
+		invert = aGround && !bGround
 	}
 	// a and b have overlapping types.
 	switch op {
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index c3d50a4..d9bef3a 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -334,12 +334,12 @@
 			unf: null & null
 
 			// errors
-			eqe1: null == 1
-			eqe2: 1 == null
-			nee1: "s" != null
+			eq1: null == 1
+			eq2: 1 == null
+			ne1: "s" != null
 			call: null()
 		`,
-		out: `<0>{eql: true, neq: false, unf: null, eqe1: _|_((null == 1):unsupported op ==(null, number)), eqe2: _|_((1 == null):unsupported op ==(number, null)), nee1: _|_(("s" != null):unsupported op !=(string, null)), call: _|_(null:cannot call non-function null (type null))}`,
+		out: `<0>{eql: true, neq: false, unf: null, eq1: false, eq2: false, ne1: true, call: _|_(null:cannot call non-function null (type null))}`,
 	}, {
 		desc: "self-reference cycles",
 		in: `
@@ -451,6 +451,17 @@
 				`,
 		out: `<0>{v1: 5e+11, v2: true, i1: 1, v5: 2, e1: _|_((2.0 % 3):unsupported op %(float, number)), e2: _|_((int & 2):unsupported op &((int)*, float))}`,
 	}, {
+		desc: "inequality",
+		in: `
+			a: 1 != 2
+			b: 1 != null
+			c: true == null
+			d: null != {}
+			e: null == []
+			f: 0 == 0.0    // types are unified first TODO: make this consistent
+		`,
+		out: `<0>{a: true, b: true, c: false, d: true, e: false, f: true}`,
+	}, {
 		desc: "null coalescing",
 		in: `
 				a: null
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index 8fba6dd..d68024a 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -1598,6 +1598,8 @@
 The ordering operators `<`, `<=`, `>`, and `>=` apply to operands that are ordered.
 These terms and the result of the comparisons are defined as follows:
 
+- Null is comparable with itself and any other type.
+  Two null values are always equal, null is unequal with anything else.
 - Boolean values are comparable.
   Two boolean values are equal if they are either both true or both false.
 - Integer values are comparable and ordered, in the usual way.
@@ -1606,16 +1608,12 @@
 - String values are comparable and ordered, lexically byte-wise after
   normalization to Unicode normal form NFC.
 - Struct are not comparable.
-  Two struct values are equal if their corresponding non-blank fields are equal.
-- Lists are comparable.
-  Two list values are equal if their corresponding elements are equal.
+- Lists are not comparable.
 ```
-c: 3 < 4
-
-x: int
-y: int
-
-b3: x == y // b3 has type bool
+a: 3 < 4       // true
+b: null == 2   // false
+c: null != {}  // true
+d: {} == {}    // _|_: structs are not comparable against structs
 ```
 
 <!-- jba