diff --git a/doc/tutorial/basics/Readme.md b/doc/tutorial/basics/Readme.md
index 44f9f49..1fe53eb 100644
--- a/doc/tutorial/basics/Readme.md
+++ b/doc/tutorial/basics/Readme.md
@@ -1,62 +1,17 @@
-# CUE Tutorial
+# CUE Tour
 
 ## About this tutorial
 
-This tutorial teaches the fundamentals of CUE.
+The files in this directory are used to generate the tour in
+
+    https://cuelang.org/docs/tutorials/tour/
+
+They are kept here to ensure the examples are in sync with the latest update
+of CUE.
+
 To try out the examples in the tutorial you can follow the
 [installation instructions](../../install.md)
 to get a working setup of CUE.
 
 Use the `cue eval` or `cue export` commands to evaluate an example.
 
-[Click here to start](json.md)
-
-## TOC
-
-- [JSON Sugar and other Goodness](json.md)
-  - [Quotes are Optional for Field Names](fieldname.md)
-  - [Commas are Optional after Fields](commas.md)
-  - [Commas are Still Required in Lists](commaslists.md)
-  - [Curly Braces](curly.md)
-  - [Folding of Single-Field Structs](fold.md)
-  - [Folding all Fields](foldany.md)
-  - [Comments](comments.md)
-  - [Number Literals](numberlit.md)
-  - [String Literals](stringlit.md)
-  - ["Raw" Strings](stringraw.md)
-  - [Bytes](bytes.md)
-- References and Visibility
-  - [References and Scopes](scopes.md)
-  - [Accessing Fields](selectors.md)
-  - [Aliases](aliases.md)
-  - [Emit Values](emit.md)
-  - [Hidden Values](hidden.md)
-- Types ~~and~~ are Values
-  - [Duplicate Fields](duplicates.md)
-  - [Bottom / Error](bottom.md)
-  - [Basic Types](types.md)
-  - [Order is Irrelevant](unification.md)
-  - [Disjunctions](disjunctions.md)
-  - [Default Values](defaults.md)
-  - [Disjunctions of Structs](sumstruct.md)
-  - [Numbers](numbers.md)
-  - [Ranges](ranges.md)
-  - [Predefined Ranges](rangedef.md)
-  - [Lists](lists.md)
-  - [Templates](templates.md)
-- [Modules, Packages, and Instances](instances.md)
-  - [Packages](packages.md)
-  - [Imports](imports.md)
-- Expressions
-  - [Operators](operators.md)
-  - [Interpolation](interpolation.md)
-  - [Interpolation of Field Names](interpolfield.md)
-  - [List Comprehensions](listcomp.md)
-  - [Field Comprehensions](fieldcomp.md)
-  - [Conditional Fields](conditional.md)
-  - [Null or Error coalescing](coalesce.md)
-- Cycles
-  - [Reference Cycles](cycle.md)
-  - [Cycles in Fields](cycleref.md)
-  <!-- - Conversions -->
-  <!-- - Functions (simulating) -->
diff --git a/doc/tutorial/basics/aliases.md b/doc/tutorial/basics/aliases.md
deleted file mode 100644
index 11959a4..0000000
--- a/doc/tutorial/basics/aliases.md
+++ /dev/null
@@ -1,41 +0,0 @@
-[TOC](Readme.md) [Prev](selectors.md) [Next](emit.md)
-
-_References and Visibility_
-
-# Aliases
-
-An alias defines a local macro.
-
-A typical use case is to provide access to a shadowed field.
-
-Aliases are not members of a struct. They can be referred to only within the
-struct, and they do not appear in the output.
-
-<!-- CUE editor -->
-_alias.cue:_
-```
-A = a  // A is an alias for a
-a: {
-    d: 3
-}
-b: {
-    a: {
-        // A provides access to the outer "a" which would
-        // otherwise be hidden by the inner one.
-        c: A.d
-    }
-}
-```
-
-<!-- result -->
-`$ cue eval alias.cue`
-```
-a: {
-    d: 3
-}
-b: {
-    a: {
-        c: 3
-    }
-}
-```
diff --git a/doc/tutorial/basics/bottom.md b/doc/tutorial/basics/bottom.md
deleted file mode 100644
index e76188f..0000000
--- a/doc/tutorial/basics/bottom.md
+++ /dev/null
@@ -1,39 +0,0 @@
-[TOC](Readme.md) [Prev](duplicates.md) [Next](types.md)
-
-_Types ~~and~~ are Values_
-
-# Bottom / Error
-
-Specifying duplicate fields with conflicting values results in an error
-or bottom.
-_Bottom_ is a special value in CUE, denoted `_|_`, that indicates an
-error such as conflicting values.
-Any error in CUE results in `_|_`.
-Logically all errors are equal, although errors may be associated with
-metadata such as an error message.
-
-Note that an error is different from `null`: `null` is a valid value,
-whereas `_|_` is not.
-
-<!-- CUE editor -->
-_bottom.cue:_
-```
-a: 4
-a: 5
-
-l: [ 1, 2 ]
-l: [ 1, 3 ]
-
-list: [0, 1, 2]
-val: list[3]
-```
-
-<!-- result -->
-`$ cue eval -i bottom.cue`
-```
-list: [0, 1, 2]
-a: _|_ // conflicting values 4 and 5
-l: [1, _|_, // conflicting values 2 and 3
-]
-val: _|_ // index 3 out of bounds
-```
diff --git a/doc/tutorial/basics/bytes.md b/doc/tutorial/basics/bytes.md
deleted file mode 100644
index 6013e79..0000000
--- a/doc/tutorial/basics/bytes.md
+++ /dev/null
@@ -1,28 +0,0 @@
-[TOC](Readme.md) [Prev](stringraw.md) [Next](scopes.md)
-
-_JSON Sugar and other Goodness_
-
-# Bytes
-
-CUE distinguishes between a `string` and a `bytes` type.
-Bytes are converted to base64 when emitting JSON.
-Byte literals are defined with single quotes.
-The following additional escape sequences are allowed in byte literals:
-
-    \xnn   // arbitrary byte value defined as a 2-digit hexadecimal number
-    \nnn   // arbitrary byte value defined as a 3-digit octal number
-<!-- jba: this contradicts the spec, which has \nnn (no leading zero) -->
-
-<!-- CUE editor -->
-_bytes.cue:_
-```
-a: '\x03abc'
-```
-
-<!-- result -->
-`$ cue export bytes.cue`
-```json
-{
-    "a": "A2FiYw=="
-}
-```
diff --git a/doc/tutorial/basics/coalesce.md b/doc/tutorial/basics/coalesce.md
deleted file mode 100644
index d1e0495..0000000
--- a/doc/tutorial/basics/coalesce.md
+++ /dev/null
@@ -1,48 +0,0 @@
-[TOC](Readme.md) [Prev](conditional.md) [Next](cycle.md)
-
-_Expressions_
-
-# Null Coalescing
-
-<!-- jba: the terms here are confusing. "Null coalescing" is actually not
-  that, but then there is something called "actual null coalescing."
-  
-  Just say that because _|_ | X evaluates to X, you can use disjunction
-  to represent fallback values.
-  
-  And then you can use that to effectively type-check with a default value.
--->
-
-With null coalescing we really mean error, or bottom, coalescing.
-The defaults mechanism for disjunctions can also be
-used to provide fallback values in case an expression evaluates to bottom.
-
-In the example the fallback values are specified
-for `a` and `b` in case the list index is out of bounds.
-
-To do actual null coalescing one can unify a result with the desired type
-to force an error.
-In that case the default will be used if either the lookup fails or
-the result is not of the desired type.
-
-<!-- CUE editor -->
-_coalesce.cue:_
-```
-list: [ "Cat", "Mouse", "Dog" ]
-
-a: *list[0] | "None"
-b: *list[5] | "None"
-
-n: [null]
-v: *n[0]&string | "default"
-```
-
-<!-- result -->
-`$ cue eval coalesce.cue`
-```
-list: ["Cat", "Mouse", "Dog"]
-a: "Cat"
-b: "None"
-n: [null]
-v: "default"
-```
diff --git a/doc/tutorial/basics/commas.md b/doc/tutorial/basics/commas.md
deleted file mode 100644
index 6ee539b..0000000
--- a/doc/tutorial/basics/commas.md
+++ /dev/null
@@ -1,36 +0,0 @@
-[TOC](Readme.md) [Prev](fieldname.md) [Next](commaslists.md)
-
-_JSON Sugar and other Goodness_
-
-# Commas are Optional after Fields
-
-Commas are optional at the end of fields.
-This is also true for the last field.
-The convention is to omit them.
-
-<!-- Side Note -->
-_CUE borrows a trick from Go to achieve this: the formal grammar still
-requires commas, but the scanner inserts commas according to a small set
-of simple rules._
-
-<!-- CUE editor -->
-_commas.cue:_
-```
-{
-    one: 1
-    two: 2
-
-    "two-and-a-half": 2.5
-}
-```
-
-
-<!-- result -->
-`$ cue export commas.cue`
-```json
-{
-    "one": 1,
-    "two": 2,
-    "two-and-a-half": 2.5
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/commaslists.md b/doc/tutorial/basics/commaslists.md
deleted file mode 100644
index a58cc79..0000000
--- a/doc/tutorial/basics/commaslists.md
+++ /dev/null
@@ -1,29 +0,0 @@
-[TOC](Readme.md) [Prev](commas.md) [Next](curly.md)
-
-_JSON Sugar and other Goodness_
-
-# Commas are Still Required in Lists
-
-
-Commas are still required as separators in lists.
-The last element of a list may also have a comma.
-
-<!-- CUE editor -->
-_commas2.cue:_
-```
-[
-    1,
-    2,
-    3,
-]
-```
-
-<!-- result -->
-`$ cue export commas2.cue`
-```json
-[
-    1,
-    2,
-    3
-]
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/comments.md b/doc/tutorial/basics/comments.md
deleted file mode 100644
index ead2ec8..0000000
--- a/doc/tutorial/basics/comments.md
+++ /dev/null
@@ -1,24 +0,0 @@
-[TOC](Readme.md) [Prev](foldany.md) [Next](numberlit.md)
-
-_JSON Sugar and other Goodness_
-
-# Comments
-
-CUE supports C-style line comments.
-
-<!-- CUE editor -->
-_comments.cue:_
-```
-// a doc comment
-one: 1
-two: 2 // a line comment
-```
-
-<!-- result -->
-`$ cue export comments.cue`
-```json
-{
-    "one": 1,
-    "two": 2
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/conditional.md b/doc/tutorial/basics/conditional.md
deleted file mode 100644
index 2cbf2d0..0000000
--- a/doc/tutorial/basics/conditional.md
+++ /dev/null
@@ -1,32 +0,0 @@
-[TOC](Readme.md) [Prev](fieldcomp.md) [Next](coalesce.md)
-
-_Expressions_
-
-# Conditional Fields
-
-Field comprehensions can also be used to
-add a single field conditionally.
-
-Converting the resulting configuration to JSON results in an error
-as `justification` is required yet no concrete value is given.
-
-
-<!-- CUE editor -->
-_conditional.cue:_
-```
-price: number
-
-// Require a justification if price is too high
-if price > 100 {
-    justification: string
-}
-
-price: 200
-```
-
-<!-- result -->
-`$ cue eval conditional.cue`
-```
-price:         200
-justification: string
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/curly.md b/doc/tutorial/basics/curly.md
deleted file mode 100644
index 32ed49b..0000000
--- a/doc/tutorial/basics/curly.md
+++ /dev/null
@@ -1,29 +0,0 @@
-[TOC](Readme.md) [Prev](commaslists.md) [Next](fold.md)
-
-_JSON Sugar and other Goodness_
-
-# Curly Braces
-
-The outer curly braces may be omitted for the top-level struct.
-CUE also allows both, which has a specific meaning.
-[We will come back to that later](emit.md).
-
-<!-- CUE editor -->
-_curly.cue:_
-```
-one: 1
-two: 2
-
-"two-and-a-half": 2.5
-```
-
-<!-- result -->
-`$ cue export curly.cue`
-```json
-{
-    "one": 1,
-    "two": 2,
-    "two-and-a-half": 2.5
-}
-```
-
diff --git a/doc/tutorial/basics/cycle.md b/doc/tutorial/basics/cycle.md
deleted file mode 100644
index 50c623b..0000000
--- a/doc/tutorial/basics/cycle.md
+++ /dev/null
@@ -1,38 +0,0 @@
-[TOC](Readme.md) [Prev](coalesce.md) [Next](cycleref.md)
-
-_Cycles_
-
-# Reference Cycles
-
-CUE can handle many types of cycles just fine.
-Because all values are final, a field with a concrete value of, say `200`,
-can only be valid if it is that value.
-So if it is unified with another expression, we can delay the evaluation of
-this until later.
-
-By postponing that evaluation, we can often break cycles.
-This is very useful for template writers that may not know what fields
-a user will want to fill out.
-
-
-<!-- CUE editor -->
-_cycle.cue:_
-```
-// CUE knows how to resolve the following:
-x: 200
-x: y + 100
-y: x - 100
-
-// If a cycle is not broken, CUE will just report it.
-a: b + 100
-b: a - 100
-```
-
-<!-- result -->
-`$ cue eval -i -c cycle.cue`
-```
-x: 200
-y: 100
-a: _|_ // cycle detected
-b: _|_ // cycle detected
-```
diff --git a/doc/tutorial/basics/cycleref.md b/doc/tutorial/basics/cycleref.md
deleted file mode 100644
index 91f4f73..0000000
--- a/doc/tutorial/basics/cycleref.md
+++ /dev/null
@@ -1,33 +0,0 @@
-[TOC](Readme.md) [Prev](cycle.md) _Next_
-
-_Cycles_
-
-# Cycles in Fields
-
-Also, we know that unifying a field with itself will result in the same value.
-Thus if we have a cycle between some fields, all we need to do is ignore
-the cycle and unify their values once to achieve the same result as
-merging them ad infinitum.
-
-<!-- CUE editor -->
-_cycleref.cue:_
-```
-labels: selectors
-labels: {app: "foo"}
-
-selectors: labels
-selectors: {name: "bar"}
-```
-
-<!-- result -->
-`$ cue eval cycleref.cue`
-```
-labels: {
-    name: "bar"
-    app:  "foo"
-}
-selectors: {
-    name: "bar"
-    app:  "foo"
-}
-```
diff --git a/doc/tutorial/basics/defaults.md b/doc/tutorial/basics/defaults.md
deleted file mode 100644
index c348c25..0000000
--- a/doc/tutorial/basics/defaults.md
+++ /dev/null
@@ -1,33 +0,0 @@
-[TOC](Readme.md) [Prev](disjunctions.md) [Next](sumstruct.md)
-
-_Types ~~and~~ are Values_
-
-# Default Values
-
-Elements of a disjunction may be marked as preferred.
-If there is only one mark, or the users constraints a field enough such that
-only one mark remains, that value is the default value.
-
-In the example, `replicas` defaults to `1`.
-In the case of `protocol`, however, there are multiple definitions with
-different, mutually incompatible defaults.
-In that case, both `"tcp"` and `"udp"` are preferred and one must explicitly
-specify either `"tcp"` or `"udp"` as if no marks were given.
-
-<!-- CUE editor -->
-_defaults.cue:_
-```
-// any positive number, 1 is the default
-replicas: uint | *1
-
-// the default value is ambiguous
-protocol: *"tcp" | "udp"
-protocol: *"udp" | "tcp"
-```
-
-<!-- result -->
-`$ cue eval defaults.cue`
-```
-replicas: 1
-protocol: "tcp" | "udp" | *_|_
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/disjunctions.md b/doc/tutorial/basics/disjunctions.md
deleted file mode 100644
index 031a068..0000000
--- a/doc/tutorial/basics/disjunctions.md
+++ /dev/null
@@ -1,28 +0,0 @@
-[TOC](Readme.md) [Prev](unification.md) [Next](defaults.md)
-
-_Types ~~and~~ are Values_
-
-# Disjunctions
-
-Disjunctions, or sum types, define a new type that is one of several things.
-
-In the example, `conn` defines a `protocol` field that must be one of two
-values: `"tcp"` or `"udp"`.
-It is an error for a concrete `conn`
-to define anything else than these two values.
-
-<!-- CUE editor -->
-_disjunctions.cue_
-```
-conn: {
-    address:  string
-    port:     int
-    protocol: "tcp" | "udp"
-}
-
-lossy: conn & {
-    address:  "1.2.3.4"
-    port:     8888
-    protocol: "udp"
-}
-```
diff --git a/doc/tutorial/basics/duplicates.md b/doc/tutorial/basics/duplicates.md
deleted file mode 100644
index 08a2d03..0000000
--- a/doc/tutorial/basics/duplicates.md
+++ /dev/null
@@ -1,42 +0,0 @@
-[TOC](Readme.md) [Prev](hidden.md) [Next](bottom.md)
-
-_Types ~~and~~ are Values_
-
-# Duplicate Fields
-
-CUE allows duplicated field definitions as long as they don't conflict.
-
-For values of basic types this means they must be equal.
-
-For structs, fields are merged and duplicated fields are handled recursively.
-
-For lists, all elements must match accordingly
-([we discuss open-ended lists later](lists.md).)
-
-<!-- CUE editor -->
-_dup.cue:_
-```
-a: 4
-a: 4
-
-s: {
-    x: 1
-}
-s: {
-    y: 2
-}
-
-l: [ 1, 2 ]
-l: [ 1, 2 ]
-```
-
-<!-- result -->
-`$ cue eval dup.cue`
-```
-a: 4
-s: {
-    x: 1
-    y: 2
-}
-l: [1, 2]
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/emit.md b/doc/tutorial/basics/emit.md
deleted file mode 100644
index 23b2d61..0000000
--- a/doc/tutorial/basics/emit.md
+++ /dev/null
@@ -1,26 +0,0 @@
-[TOC](Readme.md) [Prev](aliases.md) [Next](hidden.md)
-
-_References and Visibility_
-
-# Emit Values
-
-By default all top-level fields are emitted when evaluating a configuration.
-Embedding a value at top-level will cause that value to be emitted instead.
-
-Emit values allow CUE configurations, like JSON,
-to define any type, instead of just structs, while keeping the common case
-of defining structs light.
-
-<!-- CUE editor -->
-_emit.cue:_
-```
-"Hello \(who)!"
-
-who: "world"
-```
-
-<!-- result -->
-`$ cue eval emit.cue`
-```
-"Hello world!"
-```
diff --git a/doc/tutorial/basics/fieldcomp.md b/doc/tutorial/basics/fieldcomp.md
deleted file mode 100644
index b7bbc96..0000000
--- a/doc/tutorial/basics/fieldcomp.md
+++ /dev/null
@@ -1,48 +0,0 @@
-[TOC](Readme.md) [Prev](listcomp.md) [Next](conditional.md)
-
-_Expressions_
-
-# Field Comprehensions
-
-CUE also supports comprehensions for fields.
-
-One cannot refer to generated fields with references.
-Instead, one must use indexing.
-
-<!-- CUE editor -->
-_fieldcomp.cue:_
-```
-import "strings"
-
-a: [ "Barcelona", "Shanghai", "Munich" ]
-
-{
-    for k, v in a {
-        "\( strings.ToLower(v) )": {
-            pos:     k + 1
-            name:    v
-            nameLen: len(v)
-        }
-    }
-}
-```
-
-<!-- result -->
-`$ cue eval fieldcomp.cue`
-```
-barcelona: {
-    name:    "Barcelona"
-    pos:     1
-    nameLen: 9
-}
-shanghai: {
-    name:    "Shanghai"
-    pos:     2
-    nameLen: 8
-}
-munich: {
-    name:    "Munich"
-    pos:     3
-    nameLen: 6
-}
-```
diff --git a/doc/tutorial/basics/fieldname.md b/doc/tutorial/basics/fieldname.md
deleted file mode 100644
index 54ba0ae..0000000
--- a/doc/tutorial/basics/fieldname.md
+++ /dev/null
@@ -1,33 +0,0 @@
-[TOC](Readme.md) [Prev](json.md) [Next](commas.md)
-
-_JSON Sugar and other Goodness_
-
-# Quotes are Optional for Field Names
-
-JSON objects are called structs in CUE.
-An object member is called a field.
-
-
-Double quotes may be omitted from field names if their name contains no
-special characters and does not start with a number:
-
-<!-- CUE editor -->
-_fieldname.cue:_
-```
-{
-    one: 1,
-    two: 2,
-
-    "two-and-a-half": 2.5
-}
-```
-
-<!-- result -->
-`$ cue export fieldname.cue`
-```json
-{
-    "one": 1,
-    "two": 2,
-    "two-and-a-half": 2.5
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/fold.md b/doc/tutorial/basics/fold.md
deleted file mode 100644
index b1967e4..0000000
--- a/doc/tutorial/basics/fold.md
+++ /dev/null
@@ -1,25 +0,0 @@
-[TOC](Readme.md) [Prev](curly.md) [Next](foldany.md)
-
-_JSON Sugar and other Goodness_
-
-# Folding of Single-Field Structs
-
-CUE allows a shorthand for structs with single members.
-
-<!-- CUE editor -->
-_fold.cue:_
-```
-outer middle inner: 3
-```
-
-<!-- result -->
-`$ cue export fold.cue`
-```json
-{
-    "outer": {
-        "middle": {
-            "inner": 3
-        }
-    }
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/foldany.md b/doc/tutorial/basics/foldany.md
deleted file mode 100644
index 5175d4b..0000000
--- a/doc/tutorial/basics/foldany.md
+++ /dev/null
@@ -1,32 +0,0 @@
-[TOC](Readme.md) [Prev](fold.md) [Next](comments.md)
-
-_JSON Sugar and other Goodness_
-
-# Folding all Fields
-
-This also works if a struct has more than one member.
-
-In general, any JSON object can be expressed as a collection of
-path-leaf pairs without using any curly braces.
-
-<!-- CUE editor -->
-_foldany.cue:_
-```
-outer middle1 inner: 3
-outer middle2 inner: 7
-```
-
-<!-- result -->
-`$ cue export foldany.cue`
-```json
-{
-    "outer": {
-        "middle1": {
-            "inner": 3
-        },
-        "middle2": {
-            "inner": 7
-        }
-    }
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/gen.go b/doc/tutorial/basics/gen.go
deleted file mode 100644
index 8f3666e..0000000
--- a/doc/tutorial/basics/gen.go
+++ /dev/null
@@ -1,181 +0,0 @@
-// 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.
-
-// +build ignore
-
-// gen generates Hugo files from the given current script files.
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-	"text/template"
-
-	"github.com/rogpeppe/testscript/txtar"
-)
-
-func main() {
-	log.SetFlags(log.Lshortfile)
-	index := ""
-	filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
-		if x, ok := chapter[path]; ok {
-			index = x
-		}
-		if !strings.HasSuffix(path, ".txt") ||
-			filepath.Base(path) == "out.txt" {
-			return nil
-		}
-		generate(path, index)
-		return nil
-	})
-}
-
-var chapter = map[string]string{
-	"intro":       "0",
-	"types":       "2",
-	"references":  "4",
-	"expressions": "6",
-	"packages":    "8",
-}
-
-type Page struct {
-	FrontMatter string
-	Weight      int
-	Body        string
-	Command     string
-	Inputs      []File
-	Out         File
-}
-
-type File struct {
-	Name string
-	Data string
-	Type string
-}
-
-var hugoPage = template.Must(template.New("page").Delims("[[", "]]").Parse(`+++
-[[ .FrontMatter ]]
-weight = [[ .Weight ]]
-layout = "tutorial"
-+++
-[[.Body -]]
-[[- if .Inputs ]]
-<a id="td-block-padding" class="td-offset-anchor"></a>
-<section class="row td-box td-box--white td-box--gradient td-box--height-auto">
-<div class="col-lg-6 mr-0">
-[[ range .Inputs -]]
-<i>[[ .Name ]]</i>
-<p>
-{{< highlight go >}}
-[[ .Data -]]
-{{< /highlight >}}
-<br>
-[[end -]]
-</div>
-
-<div class="col-lg-6 ml-0">
-[[- if .Out.Data -]]
-<i>$ [[ .Command ]]</i>
-<p>
-{{< highlight go >}}
-[[ .Out.Data -]]
-{{< /highlight >}}
-[[end -]]
-</div>
-</section>
-[[- end -]]
-`))
-
-func generate(filename, index string) {
-	a, err := txtar.ParseFile(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	re := regexp.MustCompile(`(\d+)_`)
-	for _, m := range re.FindAllStringSubmatch(filename, 2) {
-		index += m[1]
-	}
-	weight, err := strconv.Atoi(index)
-	if err != nil {
-		log.Fatal(err)
-	}
-	filename = re.ReplaceAllLiteralString(filename, "")
-	filename = filename[:len(filename)-len(".txt")] + ".md"
-	filename = filepath.Join("tour", filename)
-	fmt.Println(index, filename)
-
-	comments := strings.Split(string(a.Comment), "\n")[0]
-	comments = strings.TrimLeft(comments, "! ")
-	page := &Page{
-		Command: comments,
-		Weight:  2000 + weight,
-	}
-
-	for _, f := range a.Files {
-		data := string(f.Data)
-		file := File{Name: f.Name, Data: data}
-
-		switch s := f.Name; {
-		case s == "frontmatter.toml":
-			page.FrontMatter = strings.TrimSpace(data)
-
-		case strings.HasSuffix(s, ".md"):
-			page.Body = data
-
-		case strings.HasSuffix(s, ".cue"):
-			file.Type = "cue"
-			page.Inputs = append(page.Inputs, file)
-
-		case strings.HasSuffix(s, ".json"):
-			file.Type = "json"
-			page.Inputs = append(page.Inputs, file)
-
-		case strings.HasSuffix(s, ".yaml"):
-			file.Type = "yaml"
-			page.Inputs = append(page.Inputs, file)
-
-		case strings.HasSuffix(s, "stdout-cue"):
-			file.Type = "cue"
-			page.Out = file
-
-		case strings.HasSuffix(s, "stdout-json"):
-			file.Type = "json"
-			page.Out = file
-
-		case strings.HasSuffix(s, "stderr"):
-			page.Out = file
-
-		default:
-			log.Fatalf("unknown file type %q", s)
-		}
-	}
-
-	_ = os.MkdirAll(filepath.Dir(filename), 0755)
-
-	w, err := os.Create(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer w.Close()
-
-	if err = hugoPage.Execute(w, page); err != nil {
-		log.Fatal(err)
-	}
-}
diff --git a/doc/tutorial/basics/hidden.md b/doc/tutorial/basics/hidden.md
deleted file mode 100644
index 2345a6b..0000000
--- a/doc/tutorial/basics/hidden.md
+++ /dev/null
@@ -1,30 +0,0 @@
-[TOC](Readme.md) [Prev](emit.md) [Next](duplicates.md)
-
-_References and Visibility_
-
-# Hidden Fields
-
-A non-quoted field name that starts with an underscore (`_`) is not
-emitted from the output.
-To include fields in the configuration that start with an underscore
-put them in quotes.
-
-Quoted and non-quoted fields share the same namespace unless they start
-with an underscore.
-
-<!-- CUE editor -->
-_hidden.cue:_
-```
-"_foo": 2
-_foo:   3
-foo:    4
-```
-
-<!-- result -->
-`$ cue export hidden.cue`
-```
-{
-    "_foo": 2,
-    "foo": 4
-}
-```
diff --git a/doc/tutorial/basics/imports.md b/doc/tutorial/basics/imports.md
deleted file mode 100644
index 03b923a..0000000
--- a/doc/tutorial/basics/imports.md
+++ /dev/null
@@ -1,38 +0,0 @@
-[TOC](Readme.md) [Prev](packages.md) [Next](operators.md)
-
-_Modules, Packages, and Instances_
-
-# Imports
-
-A CUE file may import definitions from builtin or user-defined packages.
-A CUE file does not need to be part of a package to use imports.
-
-The example here shows the use of builtin packages.
-
-This code groups the imports into a parenthesized, "factored" import statement.
-
-You can also write multiple import statements, like:
-
-```
-import "encoding/json"
-import "math"
-```
-
-But it is good style to use the factored import statement.
-
-<!-- CUE editor -->
-_imports.cue:_
-```
-import (
-	"encoding/json"
-	"math"
-)
-
-data: json.Marshal({ a: math.Sqrt(7) })
-```
-
-<!-- result -->
-`$ cue eval imports.cue`
-```
-data: "{\"a\":2.6457513110645907}"
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/instances.md b/doc/tutorial/basics/instances.md
deleted file mode 100644
index 861248e..0000000
--- a/doc/tutorial/basics/instances.md
+++ /dev/null
@@ -1,70 +0,0 @@
-[TOC](Readme.md) [Prev](templates.md) [Next](packages.md)
-
-# Modules, Packages, and Instances
-
-## Packages
-
-A CUE file is a standalone file by default.
-A `package` clause allows a single configuration to be split across multiple
-files.
-
-## Instances
-
-All files within a directory hierarchy with the same package identifier belong
-to the same package.
-Each directory within this hierarchy provides a different "view" of this package
-called an _instance_.
-An instance of a package for a directory is defined by all CUE files in that
-directory and all of its ancestor directories, belonging to the same package.
-This allows common configuration to be shared and policies to be enforced
-across a collection of related configurations.
-
-See the [Kubernetes Tutorial](../kubernetes/README.md) for a concrete example
-of instances.
-
-
-## Modules
-
-A _module_ is the directory hierarchy containing the CUE files of a package.
-The root of this directory hierarchy is the _module root_.
-It may be explicitly marked with a `cue.mod` file.
-
-The module root may contain a `pkg` directory containing packages that are
-importable with import.
-The first package path component needs to be a domain name, else the cue tool
-is unable to import non-core packages.
-The convention is to use the URL from which the package is retrieved.
-
-## Example
-
-For importing a package from the `pkg` directory you can create the directory
-layout as follows:
-
-```sh
-touch cue.mod
-mkdir -p pkg/cuelang.org/example
-```
-
-In our example the package `cuelang.org` contains the following content.
-Note that only identifiers starting with a capital letter may be imported.
-
-_pkg/cuelang.org/example/example.cue:_
-```
-package example
-
-Foo: 100
-```
-
-_a.cue:_
-```
-package a
-
-import "cuelang.org/example"
-
-bar: example.Foo
-```
-
-`$ cue eval a.cue`
-```
-bar: 100
-```
diff --git a/doc/tutorial/basics/interpolation.md b/doc/tutorial/basics/interpolation.md
deleted file mode 100644
index b13afbd..0000000
--- a/doc/tutorial/basics/interpolation.md
+++ /dev/null
@@ -1,25 +0,0 @@
-[TOC](Readme.md) [Prev](operators.md) [Next](interpolfield.md)
-
-_Expressions_
-
-# Interpolation
-
-String and bytes literals support interpolation.
-
-Any valid CUE expression may be used inside the escaped parentheses.
-Interpolation may also be used in multiline string and byte literals.
-
-<!-- CUE editor -->
-_interpolation.cue:_
-```
-"You are \( cost - budget ) dollars over budget!"
-
-cost:   102
-budget: 88
-```
-
-<!-- result -->
-`$ cue eval interpolation.cue`
-```
-"You are 14 dollars over budget!"
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/interpolfield.md b/doc/tutorial/basics/interpolfield.md
deleted file mode 100644
index e928aa2..0000000
--- a/doc/tutorial/basics/interpolfield.md
+++ /dev/null
@@ -1,31 +0,0 @@
-[TOC](Readme.md) [Prev](interpolation.md) [Next](listcomp.md)
-
-_Expressions_
-
-# Interpolation of Field Names
-
-String interpolations may also be used in field names.
-
-One cannot refer to generated fields with references.
-
-<!-- CUE editor -->
-_genfield.cue:_
-```
-sandwich: {
-    type:            "Cheese"
-    "has\(type)":    true
-    hasButter:       true
-    butterAndCheese: hasButter && hasCheese
-}
-```
-
-<!-- result -->
-`$ cue eval -i genfield.cue`
-```
-sandwich: {
-    type:            "Cheese"
-    hasButter:       true
-    butterAndCheese: _|_ // reference "hasCheese" not found
-    hasCheese:       true
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/json.md b/doc/tutorial/basics/json.md
deleted file mode 100644
index 2d54758..0000000
--- a/doc/tutorial/basics/json.md
+++ /dev/null
@@ -1,10 +0,0 @@
-[TOC](Readme.md) _Prev_ [Next](fieldname.md)
-
-
-# JSON sugar and other Goodness
-
-CUE is an extension of JSON.
-This improves familiarity and makes it easy to get going quickly.
-
-In its simplest use case, CUE can substitute for a more pleasant way to write
-JSON.
diff --git a/doc/tutorial/basics/listcomp.md b/doc/tutorial/basics/listcomp.md
deleted file mode 100644
index 7d465fb..0000000
--- a/doc/tutorial/basics/listcomp.md
+++ /dev/null
@@ -1,24 +0,0 @@
-[TOC](Readme.md) [Prev](interpolfield.md) [Next](fieldcomp.md)
-
-_Expressions_
-
-# List Comprehensions
-
-Lists can be created with list comprehensions.
-
-The example shows the use of `for` loops and `if` guards.
-
-
-<!-- CUE editor -->
-_listcomp.cue:_
-```
-[ x*x for x in items if x rem 2 == 0]
-
-items: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
-```
-
-<!-- result -->
-`$ cue eval listcomp.cue`
-```
-[4, 16, 36, 64]
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/lists.md b/doc/tutorial/basics/lists.md
deleted file mode 100644
index 1bde51e..0000000
--- a/doc/tutorial/basics/lists.md
+++ /dev/null
@@ -1,45 +0,0 @@
-[TOC](Readme.md) [Prev](regexp.md) [Next](templates.md)
-
-_Types ~~and~~ are Values_
-
-# Lists
-
-Lists define arbitrary sequences of CUE values.
-A list can be closed or open ended.
-Open-ended lists may have some predefined elements, but may have
-additional, possibly typed elements.
-
-In the example we define `IP` to be a list of `4` elements of type `uint8`, which
-is a predeclared value of `>=0 & <=255`.
-`PrivateIP` defines the IP ranges defined for private use.
-Note that as it is already defined to be an `IP`, the length of the list
-is already fixed at `4` and we do not have to specify a value for all elements.
-Also note that instead of writing `...uint8`, we could have written `...`
-as the type constraint is already already implied by `IP`.
-
-The output contains a valid private IP address (`myIP`)
-and an invalid one (`yourIP`).
-
-<!-- CUE editor -->
-_lists.cue:_
-```
-IP: 4 * [ uint8 ]
-
-PrivateIP: IP
-PrivateIP: [10, ...uint8] | [192, 168, ...] | [172, >=16 & <=32, ...]
-
-myIP: PrivateIP
-myIP: [10, 2, 3, 4]
-
-yourIP: PrivateIP
-yourIP: [11, 1, 2, 3]
-```
-
-<!-- result -->
-`$ cue eval -i lists.cue`
-```
-IP: [uint8, uint8, uint8, uint8]
-PrivateIP: [10, uint8, uint8, uint8] | [192, 168, uint8, uint8] | [172, >=16 & <=32 & uint8, uint8, uint8]
-myIP: [10, 2, 3, 4]
-yourIP: _|_ // empty disjunction: [((10 & (int & >=0 & int & <=255)) & 11),((int & >=0 & int & <=255) & 1),((int & >=0 & int & <=255) & 2),((int & >=0 & int & <=255) & 3)]
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/numberlit.md b/doc/tutorial/basics/numberlit.md
deleted file mode 100644
index 0ee001b..0000000
--- a/doc/tutorial/basics/numberlit.md
+++ /dev/null
@@ -1,30 +0,0 @@
-[TOC](Readme.md) [Prev](comments.md) [Next](stringlit.md)
-
-_JSON Sugar and other Goodness_
-
-# Number Literals
-
-
-CUE adds a variety of sugar for writing numbers.
-
-<!-- CUE editor -->
-_numlit.cue:_
-```
-[
-    1_234,       // 1234
-    5M,          // 5_000_000
-    1.5Gi,       // 1_610_612_736
-    0x1000_0000, // 268_435_456
-]
-```
-
-<!-- result -->
-`$ cue export numlit.cue`
-```json
-[
-    1234,
-    5000000,
-    1610612736,
-    268435456
-]
-```
diff --git a/doc/tutorial/basics/numbers.md b/doc/tutorial/basics/numbers.md
deleted file mode 100644
index e5495cc..0000000
--- a/doc/tutorial/basics/numbers.md
+++ /dev/null
@@ -1,39 +0,0 @@
-[TOC](Readme.md) [Prev](sumstruct.md) [Next](ranges.md)
-
-_Types ~~and~~ are Values_
-
-# Numbers
-
-CUE defines two kinds of numbers.
-Integers, denoted `int`, are whole, or integral, numbers.
-Floats, denoted `float`, are decimal floating point numbers.
-
-An integer literal (e.g. `4`) can be of either type, but defaults to `int`.
-A floating point literal (e.g. `4.0`) is only compatible with `float`.
-
-In the example, the result of `b` is a `float` and cannot be
-used as an `int` without conversion.
-
-<!-- CUE editor -->
-_numbers.cue:_
-```
-a: int
-a: 4 // type int
-
-b: number
-b: 4.0 // type float
-
-c: int
-c: 4.0
-
-d: 4  // will evaluate to type int (default)
-```
-
-<!-- result -->
-`$ cue eval -i numbers.cue`
-```
-a: 4
-b: 4.0
-c: _|_ // conflicting values int and 4.0 (mismatched types int and float)
-d: 4
-```
diff --git a/doc/tutorial/basics/operators.md b/doc/tutorial/basics/operators.md
deleted file mode 100644
index 6512c97..0000000
--- a/doc/tutorial/basics/operators.md
+++ /dev/null
@@ -1,34 +0,0 @@
-[TOC](Readme.md) [Prev](imports.md) [Next](interpolation.md)
-
-_Expressions_
-
-# Operators
-
-CUE supports many common arithmetic and boolean operators.
-
-The operators for division and remainder are different for `int` and `float`.
-For `float` CUE supports the `/` and `%`  operators with the usual meaning.
-For `int` CUE supports both Euclidean division (`div` and `mod`)
-and truncated division (`quo` and `rem`).
-
-<!-- CUE editor -->
-_op.cue:_
-```
-a: 3 / 2   // type float
-b: 3 div 2 // type int: Euclidean division
-
-c: 3 * "blah"
-d: 3 * [1, 2, 3]
-
-e: 8 < 10
-```
-
-<!-- result -->
-`$ cue eval -i op.cue`
-```
-a: 1.5
-b: 1
-c: "blahblahblah"
-d: [1, 2, 3, 1, 2, 3, 1, 2, 3]
-e: true
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/packages.md b/doc/tutorial/basics/packages.md
deleted file mode 100644
index 9cc0d19..0000000
--- a/doc/tutorial/basics/packages.md
+++ /dev/null
@@ -1,41 +0,0 @@
-[TOC](Readme.md) [Prev](instances.md) [Next](imports.md)
-
-_Modules, Packages, and Instances_
-
-# Packages
-
-A CUE file is a standalone file by default.
-A `package` clause allows a single configuration to be split across multiple
-files.
-
-The configuration for a package is defined by the concatenation of all its
-files, after stripping the package clauses and not considering imports.
-
-Duplicate definitions are treated analogously to duplicate definitions within
-the same file.
-The order in which files are loaded is undefined, but any order will result
-in the same outcome, given that order does not matter.
-
-<!-- CUE editor -->
-_a.cue:_
-```
-package config
-
-foo: 100
-bar: int
-```
-
-<!-- CUE editor -->
-_b.cue:_
-```
-package config
-
-bar: 200
-```
-
-<!-- result -->
-`$ cue eval a.cue b.cue`
-```
-foo: 100
-bar: 200
-```
diff --git a/doc/tutorial/basics/rangedef.md b/doc/tutorial/basics/rangedef.md
deleted file mode 100644
index ea97bd5..0000000
--- a/doc/tutorial/basics/rangedef.md
+++ /dev/null
@@ -1,49 +0,0 @@
-[TOC](Readme.md) [Prev](ranges.md) [Next](regexp.md)
-
-_Types ~~and~~ are Values_
-
-# Predefined Ranges
-
-CUE numbers have arbitrary precision.
-Also there is no unsigned integer type.
-
-CUE defines the following predefined identifiers to restrict the ranges of
-integers to common values.
-
-```
-uint      >=0
-uint8     >=0 & <=255
-int8      >=-128 & <=127
-uint16    >=0 & <=65536
-int16     >=-32_768 & <=32_767
-rune      >=0 & <=0x10FFFF
-uint32    >=0 & <=4_294_967_296
-int32     >=-2_147_483_648 & <=2_147_483_647
-uint64    >=0 & <=18_446_744_073_709_551_615
-int64     >=-9_223_372_036_854_775_808 & <=9_223_372_036_854_775_807
-int128    >=-170_141_183_460_469_231_731_687_303_715_884_105_728 &
-              <=170_141_183_460_469_231_731_687_303_715_884_105_727
-uint128   >=0 & <=340_282_366_920_938_463_463_374_607_431_768_211_455
-```
-
-<!-- CUE editor -->
-_range.cue:_
-```
-positive: uint
-byte:     uint8
-word:     int32
-
-{
-    a: positive & -1
-    b: byte & 128
-    c: word & 2_000_000_000
-}
-```
-
-<!-- result -->
-`$ cue eval -i range.cue`
-```
-a: _|_ // invalid value -1 (out of bound int & >=0)
-b: 128
-c: 2000000000
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/ranges.md b/doc/tutorial/basics/ranges.md
deleted file mode 100644
index fa637ba..0000000
--- a/doc/tutorial/basics/ranges.md
+++ /dev/null
@@ -1,43 +0,0 @@
-[TOC](Readme.md) [Prev](numbers.md) [Next](rangedef.md)
-
-_Types ~~and~~ are Values_
-
-# Bounds
-
-Bounds define a lower bound, upper bound, or inequality for a certain value.
-They work on numbers, strings, bytes, and and null.
-
-The bound is defined for all values for which the corresponding comparison
-operation is define.
-For instance `>5.0` allows all floating point values greater than `5.0`,
-whereas `<0` allows all negative numbers (int or float).
-
-<!-- CUE editor -->
-_bounds.cue:_
-```
-rn: >=3 & <8        // type int | float
-ri: >=3 & <8 & int  // type int
-rf: >=3 & <=8.0     // type float
-rs: >="a" & <"mo"
-
-{
-    a: rn & 3.5
-    b: ri & 3.5
-    c: rf & 3
-    d: rs & "ma"
-    e: rs & "mu"
-
-    r1: rn & >=5 & <10
-}
-```
-
-<!-- result -->
-`$ cue eval -i bounds.cue`
-```
-a:  3.5
-b:  _|_ // conflicting values ri and 3.5 (mismatched types int and float)
-c:  3
-d:  "ma"
-e:  _|_ // invalid value "mu" (out of bound <"mo")
-r1: >=5 & <8
-```
diff --git a/doc/tutorial/basics/regexp.md b/doc/tutorial/basics/regexp.md
deleted file mode 100644
index c1f2abd..0000000
--- a/doc/tutorial/basics/regexp.md
+++ /dev/null
@@ -1,39 +0,0 @@
-[TOC](Readme.md) [Prev](rangedef.md) [Next](lists.md)
-
-_Expressions_
-
-# Regular expressions
-
-The `=~` and `!~` operators can be used to check against regular expressions.
-
-The expression `a =~ b` is true if `a` matches `b`, while
-`a !~ b` is true if `a` does _not_ match `b`.
-
-Just as with comparison operators, these operators may be used
-as unary versions to define a set of strings.
-
-
-<!-- CUE editor -->
-_regexp.cue:_
-```
-a: "foo bar" =~ "foo [a-z]{3}"
-b: "maze" !~ "^[a-z]{3}$"
-
-c: =~"^[a-z]{3}$" // any string with lowercase ASCII of length 3
-
-d: c
-d: "foo"
-
-e: c
-e: "foo bar"
-```
-
-<!-- result -->
-`$ cue eval -i regexp.cue`
-```
-a: true
-b: true
-c: =~"^[a-z]{3}$"
-d: "foo"
-e: _|_ // invalid value "foo bar" (does not match =~"^[a-z]{3}$")
-```
diff --git a/doc/tutorial/basics/scopes.md b/doc/tutorial/basics/scopes.md
deleted file mode 100644
index 429dbfd..0000000
--- a/doc/tutorial/basics/scopes.md
+++ /dev/null
@@ -1,39 +0,0 @@
-[TOC](Readme.md) [Prev](bytes.md) [Next](selectors.md)
-
-_References and Visibility_
-
-# References and Scopes
-
-A reference refers to the value of the field defined within nearest
-enclosing scope.
-
-If no field matches the reference within the file, it may match a top-level
-field defined in any other file of the same package.
-
-If there is still no match, it may match a predefined value.
-
-<!-- CUE editor -->
-_scopes.cue:_
-```
-v: 1
-a: {
-    v: 2
-    b: v // matches the inner v
-}
-a: {
-    c: v // matches the top-level v
-}
-b: v
-```
-
-<!-- result -->
-`$ cue eval scopes.cue`
-```
-v: 1
-a: {
-    v: 2
-    b: 2
-    c: 1
-}
-b: 1
-```
diff --git a/doc/tutorial/basics/selectors.md b/doc/tutorial/basics/selectors.md
deleted file mode 100644
index 1547e81..0000000
--- a/doc/tutorial/basics/selectors.md
+++ /dev/null
@@ -1,32 +0,0 @@
-[TOC](Readme.md) [Prev](scopes.md) [Next](aliases.md)
-
-_References and Visibility_
-
-# Accessing Fields
-
-Selectors access fields within a struct using the `.` notation.
-This only works if a field name is a valid identifier and it is not computed.
-For other cases one can use the indexing notation.
-
-
-<!-- CUE editor -->
-_selectors.cue:_
-```
-a: {
-    b: 2
-    "c-e": 5
-}
-v: a.b
-w: a["c-e"]
-```
-
-<!-- result -->
-`$ cue eval selectors.cue`
-```
-a: {
-    b:     2
-    "c-e": 5
-}
-v: 2
-w: 5
-```
diff --git a/doc/tutorial/basics/stringlit.md b/doc/tutorial/basics/stringlit.md
deleted file mode 100644
index b213392..0000000
--- a/doc/tutorial/basics/stringlit.md
+++ /dev/null
@@ -1,37 +0,0 @@
-[TOC](Readme.md) [Prev](numberlit.md) [Next](stringraw.md)
-
-_JSON Sugar and other Goodness_
-
-# String Literals
-
-CUE strings allow a richer set of escape sequences than JSON.
-
-CUE also supports multi-line strings, enclosed by a pair of triple quotes `"""`.
-The opening quote must be followed by a newline.
-The closing quote must also be on a newline.
-The whitespace directly preceding the closing quote must match the preceding
-whitespace on all other lines and is removed from these lines.
-
-Strings may also contain [interpolations](interpolation.md).
-
-<!-- CUE editor -->
-_stringlit.cue:_
-```
-// 21-bit unicode characters
-a: "\U0001F60E" // 😎
-
-// multiline strings
-b: """
-    Hello
-    World!
-    """
-```
-
-<!-- result -->
-`$ cue export stringlit.cue`
-```json
-{
-    "a": "😎",
-    "b": "Hello\nWorld!"
-}
-```
diff --git a/doc/tutorial/basics/stringraw.md b/doc/tutorial/basics/stringraw.md
deleted file mode 100644
index d618984..0000000
--- a/doc/tutorial/basics/stringraw.md
+++ /dev/null
@@ -1,42 +0,0 @@
-[TOC](Readme.md) [Prev](stringlit.md) [Next](bytes.md)
-
-_JSON Sugar and other Goodness_
-
-# "Raw" Strings
-
-CUE does not support raw strings in the strictest sense.
-Instead it allows modifying the escape delimiter by requiring
-an arbitrary number of hash `#` signs after the backslash by
-enclosing a string literal in an equal number of hash signs on either end.
-
-This works for normal and interpolated strings.
-Quotes do not have to be escaped in such strings.
-
-<!-- CUE editor -->
-_stringraw.cue:_
-```
-msg1: #"The sequence "\U0001F604" renders as \#U0001F604."#
-
-msg2: ##"""
-    A regular expression can conveniently be written as:
-
-        #"\d{3}"#
-
-    This construct works for bytes, strings and their
-    multi-line variants.
-    """##
-```
-
-<!-- result -->
-`$ cue eval stringraw.cue`
-```
-msg1: "The sequence \"\\U0001F604\" renders as 😄."
-msg2: """
-        A regular expression can conveniently be written as:
-        
-            #\"\\d{3}\"#
-        
-        This construct works for bytes, strings and their
-        multi-line variants.
-        """
-```
diff --git a/doc/tutorial/basics/sumstruct.md b/doc/tutorial/basics/sumstruct.md
deleted file mode 100644
index 319c162..0000000
--- a/doc/tutorial/basics/sumstruct.md
+++ /dev/null
@@ -1,29 +0,0 @@
-[TOC](Readme.md) [Prev](defaults.md) [Next](numbers.md)
-
-_Types ~~and~~ are Values_
-
-# Disjunctions of Structs
-
-Disjunctions work for any type.
-
-In this example we see that a `floor` of some specific house
-has an exit on level 0 and 1, but not on any other floor.
-
-<!-- CUE editor -->
-_sumstruct.cue:_
-```
-// floor defines the specs of a floor in some house.
-floor: {
-    level:   int  // the level on which this floor resides
-    hasExit: bool // is there a door to exit the house?
-}
-
-// constraints on the possible values of floor.
-floor: {
-    level: 0 | 1
-    hasExit: true
-} | {
-    level: -1 | 2 | 3
-    hasExit: false
-}
-```
diff --git a/doc/tutorial/basics/templates.md b/doc/tutorial/basics/templates.md
deleted file mode 100644
index f24984d..0000000
--- a/doc/tutorial/basics/templates.md
+++ /dev/null
@@ -1,50 +0,0 @@
-[TOC](Readme.md) [Prev](lists.md) [Next](instances.md)
-
-_Types ~~and~~ are Values_
-
-# Templates
-
-<!-- jba: this is not in the spec, aside from the TemplateLabel grammar rule. -->
-
-One of CUE's most powerful features is templates.
-A template defines a value to be unified with each field of a struct.
-
-The template's identifier (in angular brackets) is bound to name of each
-of its sibling fields and is visible within the template value
-that is unified with each of the siblings.
-
-<!-- CUE editor -->
-_templates.cue:_
-```
-// The following struct is unified with all elements in job.
-// The name of each element is bound to Name and visible in the struct.
-job <Name>: {
-    name:     Name
-    replicas: uint | *1
-    command:  string
-}
-
-job list command: "ls"
-
-job nginx: {
-    command:  "nginx"
-    replicas: 2
-}
-```
-
-<!-- result -->
-`$ cue eval templates.cue`
-```
-job: {
-    list: {
-        name:     "list"
-        replicas: 1
-        command:  "ls"
-    }
-    nginx: {
-        name:     "nginx"
-        replicas: 2
-        command:  "nginx"
-    }
-}
-```
diff --git a/doc/tutorial/basics/types.md b/doc/tutorial/basics/types.md
deleted file mode 100644
index 7f49e4c..0000000
--- a/doc/tutorial/basics/types.md
+++ /dev/null
@@ -1,69 +0,0 @@
-[TOC](Readme.md) [Prev](bottom.md) [Next](unification.md)
-
-_Types ~~and~~ are Values_
-
-# Basic Types
-
-CUE defines the following basic types
-
-```
-null bool string bytes int float
-```
-in addition to the error type mentioned in the previous section.
-
-CUE does not distinguish between types and values.
-A field value can be a type (using one of the above names), a concrete value,
-or, in case of composite types (lists and structs), anything in between.
-
-In the example, `point` defines an arbitrary point, while `xaxis` and `yaxis`
-define the points on the respective lines.
-We say that `point`, `xaxis`, and `yaxis` are abstract points, as these
-points are underspecified.
-Such abstract values cannot be represented as JSON,
-which requires all values to be concrete.
-
-The only concrete point is `origin`.
-The `origin` is defined to be both on the x-axis and y-axis, which means it
-must be at `0, 0`.
-Here we see constraints in action:
-`origin` evalutes to `0, 0`, even though we did not specify its coordinates
-explicitly.
-
-
-<!-- CUE editor -->
-_types.cue:_
-```
-point: {
-    x: number
-    y: number
-}
-
-xaxis: point
-xaxis x: 0
-
-yaxis: point
-yaxis y: 0
-
-origin: xaxis & yaxis
-```
-
-<!-- result -->
-`$ cue eval types.cue`
-```
-point: {
-    x: number
-    y: number
-}
-xaxis: {
-    x: 0
-    y: number
-}
-yaxis: {
-    x: number
-    y: 0
-}
-origin: {
-    x: 0
-    y: 0
-}
-```
\ No newline at end of file
diff --git a/doc/tutorial/basics/unification.md b/doc/tutorial/basics/unification.md
deleted file mode 100644
index e6bb943..0000000
--- a/doc/tutorial/basics/unification.md
+++ /dev/null
@@ -1,60 +0,0 @@
-[TOC](Readme.md) [Prev](types.md) [Next](disjunctions.md)
-
-_Types ~~and~~ are Values_
-
-# Order is Irrelevant
-
-As mentioned before, values of duplicates fields are combined.
-This process is called unification.
-Unification can also be written explicitly with the `&` operator.
-
-There is always a single unique result, possibly bottom,
-for unifying any two CUE values.
-
-Unification is commutative, associative, and idempotent.
-In other words, order doesn't matter and unifying a given set of values
-in any order always gives the same result.
-
-<!-- CUE editor -->
-_unification.cue:_
-```
-a: { x: 1, y: 2 }
-b: { y: 2, z: 3 }
-c: { x: 1, z: 4 }
-
-q: a & b & c
-r: b & c & a
-s: c & b & a
-```
-
-<!-- result -->
-`$ cue eval -i unification.cue`
-```
-a: {
-    x: 1
-    y: 2
-}
-b: {
-    y: 2
-    z: 3
-}
-c: {
-    x: 1
-    z: 4
-}
-q: {
-    x: 1
-    y: 2
-    z: _|_ // conflicting values 3 and 4
-}
-r: {
-    x: 1
-    y: 2
-    z: _|_ // conflicting values 3 and 4
-}
-s: {
-    x: 1
-    y: 2
-    z: _|_ // conflicting values 4 and 3
-}
-```
\ No newline at end of file