diff --git a/cmd/cue/cmd/testdata/script/def_jsonschema.txt b/cmd/cue/cmd/testdata/script/def_jsonschema.txt
new file mode 100644
index 0000000..cfb587b
--- /dev/null
+++ b/cmd/cue/cmd/testdata/script/def_jsonschema.txt
@@ -0,0 +1,44 @@
+cue def jsonschema: schema.json -p schema -l '"Person"::'
+cmp stdout expect-stdout
+
+-- expect-stdout --
+package schema
+
+Person :: {
+	// Person
+	Schema :: {
+		// The person's first name.
+		firstName?: string
+
+		// The person's last name.
+		lastName?: string
+
+		// Age in years which must be equal to or greater than zero.
+		age?: >=0
+		...
+	}
+}
+-- schema.json --
+{
+  "$id": "https://example.com/person.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Person",
+  "type": "object",
+  "properties": {
+    "firstName": {
+      "type": "string",
+      "description": "The person's first name."
+    },
+    "lastName": {
+      "type": "string",
+      "description": "The person's last name."
+    },
+    "age": {
+      "description": "Age in years which must be equal to or greater than zero.",
+      "type": "integer",
+      "minimum": 0
+    }
+  }
+}
+
+-- cue.mod --
diff --git a/cmd/cue/cmd/testdata/script/def_openapi.txt b/cmd/cue/cmd/testdata/script/def_openapi.txt
index cf62033..fa9cd51 100644
--- a/cmd/cue/cmd/testdata/script/def_openapi.txt
+++ b/cmd/cue/cmd/testdata/script/def_openapi.txt
@@ -1,11 +1,14 @@
 cue def foo.cue -o openapi:-
-cmp stdout expect-json
+cmp stdout expect-json-out
 
 cue def foo.cue -o openapi+cue:-
-cmp stdout expect-cue
+cmp stdout expect-cue-out
 
 cue def foo.cue -o openapi+yaml:-
-cmp stdout expect-yaml
+cmp stdout expect-yaml-out
+
+cue def -p foo openapi: expect-json-out
+cmp stdout expect-cue
 
 -- foo.cue --
 Foo :: {
@@ -17,7 +20,7 @@
     foo: Foo
 }
 
--- expect-json --
+-- expect-json-out --
 {
     "openapi": "3.0.0",
     "info": {},
@@ -55,30 +58,7 @@
         }
     }
 }
--- expect-cue --
-openapi: "3.0.0"
-info: {}
-paths: {}
-components: schemas: {
-	Foo: {
-		type: "object"
-		required: ["a", "b"]
-		properties: {
-			a: type: "integer"
-			b: {
-				type:             "integer"
-				minimum:          0
-				exclusiveMaximum: 10
-			}
-		}
-	}
-	Bar: {
-		type: "object"
-		required: ["foo"]
-		properties: foo: $ref: "#/components/schemas/Foo"
-	}
-}
--- expect-yaml --
+-- expect-yaml-out --
 openapi: 3.0.0
 info: {}
 paths: {}
@@ -103,3 +83,38 @@
             properties:
                 foo:
                     $ref: '#/components/schemas/Foo'
+-- expect-cue-out --
+openapi: "3.0.0"
+info: {}
+paths: {}
+components: schemas: {
+	Foo: {
+		type: "object"
+		required: ["a", "b"]
+		properties: {
+			a: type: "integer"
+			b: {
+				type:             "integer"
+				minimum:          0
+				exclusiveMaximum: 10
+			}
+		}
+	}
+	Bar: {
+		type: "object"
+		required: ["foo"]
+		properties: foo: $ref: "#/components/schemas/Foo"
+	}
+}
+-- expect-cue --
+package foo
+
+Foo :: {
+	a: int
+	b: >=0 & <10
+	...
+}
+Bar :: {
+	foo: Foo
+	...
+}
diff --git a/cmd/cue/cmd/testdata/script/fmt_stdin.txt b/cmd/cue/cmd/testdata/script/fmt_stdin.txt
index 4421470..99a0008 100644
--- a/cmd/cue/cmd/testdata/script/fmt_stdin.txt
+++ b/cmd/cue/cmd/testdata/script/fmt_stdin.txt
@@ -4,6 +4,8 @@
 
 -- feed --
 foo : 2
+a: {b: 3} // a comment
 -- expect-stdout --
 foo: 2
+a: {b: 3} // a comment
 -- fmt/cue.mod --
diff --git a/cue/format/format.go b/cue/format/format.go
index 99767c0..7a4d557 100644
--- a/cue/format/format.go
+++ b/cue/format/format.go
@@ -15,6 +15,13 @@
 // Package format implements standard formatting of CUE configurations.
 package format // import "cuelang.org/go/cue/format"
 
+// TODO: this package is in need of a rewrite. When doing so, the API should
+// allow for reformatting an AST, without actually writing bytes.
+//
+// In essence, formatting determines the relative spacing to tokens. It should
+// be possible to have an abstract implementation providing such information
+// that can be used to either format or update an AST in a single walk.
+
 import (
 	"bytes"
 	"fmt"
diff --git a/internal/encoding/encoder.go b/internal/encoding/encoder.go
index 04be952..2098102 100644
--- a/internal/encoding/encoder.go
+++ b/internal/encoding/encoder.go
@@ -204,6 +204,7 @@
 	if interpret == nil && e.encFile != nil {
 		return e.encFile(f)
 	}
+	e.autoSimplify = true
 	var r cue.Runtime
 	inst, err := r.CompileFile(f)
 	if err != nil {
diff --git a/internal/encoding/encoding.go b/internal/encoding/encoding.go
index f6187e8..83de8a3 100644
--- a/internal/encoding/encoding.go
+++ b/internal/encoding/encoding.go
@@ -22,6 +22,7 @@
 	"fmt"
 	"io"
 	"io/ioutil"
+	"net/url"
 	"os"
 	"strings"
 
@@ -33,6 +34,8 @@
 	"cuelang.org/go/cue/parser"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/encoding/json"
+	"cuelang.org/go/encoding/jsonschema"
+	"cuelang.org/go/encoding/openapi"
 	"cuelang.org/go/encoding/protobuf"
 	"cuelang.org/go/internal/filetypes"
 	"cuelang.org/go/internal/third_party/yaml"
@@ -171,6 +174,39 @@
 		return i
 	}
 
+	switch f.Interpretation {
+	case "":
+	case build.OpenAPI:
+		i.interpret = func(i *cue.Instance) (file *ast.File, id string, err error) {
+			cfg := &openapi.Config{PkgName: cfg.PkgName}
+			file, err = simplify(openapi.Extract(i, cfg))
+			return file, "", err
+		}
+	case build.JSONSchema:
+		i.interpret = func(i *cue.Instance) (file *ast.File, id string, err error) {
+			id = f.Tags["id"]
+			if id == "" {
+				id, _ = i.Lookup("$id").String()
+			}
+			if id != "" {
+				u, err := url.Parse(id)
+				if err != nil {
+					return nil, "", errors.Wrapf(err, token.NoPos, "invalid id")
+				}
+				u.Scheme = ""
+				id = strings.TrimPrefix(u.String(), "//")
+			}
+			cfg := &jsonschema.Config{
+				ID:      id,
+				PkgName: cfg.PkgName,
+			}
+			file, err = simplify(jsonschema.Extract(i, cfg))
+			return file, id, err
+		}
+	default:
+		i.err = fmt.Errorf("unsupported interpretation %q", f.Interpretation)
+	}
+
 	path := f.Filename
 	switch f.Encoding {
 	case build.CUE:
@@ -341,3 +377,19 @@
 	}
 	return ok
 }
+
+// simplify reformats a File. To be used as a wrapper for Extract functions.
+//
+// It currently does so by formatting the file using fmt.Format and then
+// reparsing it. This is not ideal, but the package format does not provide a
+// way to do so differently.
+func simplify(f *ast.File, err error) (*ast.File, error) {
+	if err != nil {
+		return nil, err
+	}
+	b, err := format.Node(f, format.Simplify())
+	if err != nil {
+		return nil, err
+	}
+	return parser.ParseFile(f.Filename, b, parser.ParseComments)
+}