diff --git a/api.go b/api.go
index fec6b3129..d47ba1ff4 100644
--- a/api.go
+++ b/api.go
@@ -230,7 +230,7 @@ func (api *API) CreateFrame(ctx context.Context, indexName string, frameName str
 	}
 
 	// Create frame.
-	frame, err := index.CreateFrame(frameName, options)
+	frame, err := index.CreateField(frameName, options)
 	if err != nil {
 		return nil, errors.Wrap(err, "creating frame")
 	}
@@ -265,7 +265,7 @@ func (api *API) DeleteFrame(ctx context.Context, indexName string, frameName str
 	}
 
 	// Delete frame from the index.
-	if err := index.DeleteFrame(frameName); err != nil {
+	if err := index.DeleteField(frameName); err != nil {
 		return errors.Wrap(err, "deleting frame")
 	}
 
@@ -357,7 +357,7 @@ func (api *API) UnmarshalFragment(ctx context.Context, indexName string, frameNa
 	// Retrieve frame.
 	f := api.Holder.Frame(indexName, frameName)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Retrieve view.
@@ -497,7 +497,7 @@ func (api *API) Views(ctx context.Context, indexName string, frameName string) (
 	// Retrieve views.
 	f := api.Holder.Frame(indexName, frameName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Fetch views.
@@ -514,7 +514,7 @@ func (api *API) DeleteView(ctx context.Context, indexName string, frameName stri
 	// Retrieve frame.
 	f := api.Holder.Frame(indexName, frameName)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Delete the view.
@@ -582,7 +582,7 @@ func (api *API) FrameAttrDiff(ctx context.Context, indexName string, frameName s
 	// Retrieve index from holder.
 	f := api.Holder.Frame(indexName, frameName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Retrieve local blocks.
@@ -695,10 +695,10 @@ func (api *API) indexFrame(indexName string, frameName string, slice uint64) (*I
 	}
 
 	// Retrieve frame.
-	frame := index.Frame(frameName)
+	frame := index.Field(frameName)
 	if frame == nil {
-		api.Logger.Printf("frame error: index=%s, frame=%s, slice=%d, err=%s", indexName, frameName, slice, ErrFrameNotFound.Error())
-		return nil, nil, ErrFrameNotFound
+		api.Logger.Printf("frame error: index=%s, frame=%s, slice=%d, err=%s", indexName, frameName, slice, ErrFieldNotFound.Error())
+		return nil, nil, ErrFieldNotFound
 	}
 	return index, frame, nil
 }
diff --git a/client.go b/client.go
index 4c8ba2157..d186746c7 100644
--- a/client.go
+++ b/client.go
@@ -273,7 +273,7 @@ func (c *InternalHTTPClient) Import(ctx context.Context, index, frame string, sl
 	if index == "" {
 		return ErrIndexRequired
 	} else if frame == "" {
-		return ErrFrameRequired
+		return ErrFieldRequired
 	}
 
 	buf, err := marshalImportPayload(index, frame, slice, bits)
@@ -302,7 +302,7 @@ func (c *InternalHTTPClient) ImportK(ctx context.Context, index, frame string, c
 	if index == "" {
 		return ErrIndexRequired
 	} else if frame == "" {
-		return ErrFrameRequired
+		return ErrFieldRequired
 	}
 
 	buf, err := marshalImportPayloadK(index, frame, columns)
@@ -332,7 +332,7 @@ func (c *InternalHTTPClient) EnsureIndex(ctx context.Context, name string, optio
 
 func (c *InternalHTTPClient) EnsureFrame(ctx context.Context, indexName string, frameName string, options FieldOptions) error {
 	err := c.CreateFrame(ctx, indexName, frameName, options)
-	if err == nil || err == ErrFrameExists {
+	if err == nil || err == ErrFieldExists {
 		return nil
 	}
 	return err
@@ -424,7 +424,7 @@ func (c *InternalHTTPClient) ImportValue(ctx context.Context, index, frame strin
 	if index == "" {
 		return ErrIndexRequired
 	} else if frame == "" {
-		return ErrFrameRequired
+		return ErrFieldRequired
 	}
 
 	buf, err := marshalImportValuePayload(index, frame, slice, vals)
@@ -511,7 +511,7 @@ func (c *InternalHTTPClient) ExportCSV(ctx context.Context, index, frame string,
 	if index == "" {
 		return ErrIndexRequired
 	} else if frame == "" {
-		return ErrFrameRequired
+		return ErrFieldRequired
 	}
 
 	// Retrieve a list of nodes that own the slice.
@@ -658,7 +658,7 @@ func (c *InternalHTTPClient) CreateFrame(ctx context.Context, index, frame strin
 	case http.StatusOK:
 		return nil // ok
 	case http.StatusConflict:
-		return ErrFrameExists
+		return ErrFieldExists
 	default:
 		return errors.New(string(body))
 	}
@@ -822,7 +822,7 @@ func (c *InternalHTTPClient) RowAttrDiff(ctx context.Context, index, frame strin
 	switch resp.StatusCode {
 	case http.StatusOK: // ok
 	case http.StatusNotFound:
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	default:
 		return nil, fmt.Errorf("unexpected status: code=%d", resp.StatusCode)
 	}
diff --git a/cluster.go b/cluster.go
index 63f4f62b8..deabf2d06 100644
--- a/cluster.go
+++ b/cluster.go
@@ -627,7 +627,7 @@ func (c *Cluster) fragsByHost(idx *Index) fragsByHost {
 	// frameViews is a map of frame to slice of views.
 	frameViews := make(viewsByFrame)
 
-	for _, frame := range idx.Frames() {
+	for _, frame := range idx.Fields() {
 		for _, view := range frame.Views() {
 			frameViews.addView(frame.Name(), view.Name())
 
@@ -1242,7 +1242,7 @@ func (c *Cluster) FollowResizeInstruction(instr *internal.ResizeInstruction) err
 				// Retrieve frame.
 				f := c.Holder.Frame(src.Index, src.Frame)
 				if f == nil {
-					return ErrFrameNotFound
+					return ErrFieldNotFound
 				}
 
 				// Create view.
diff --git a/cluster_internal_test.go b/cluster_internal_test.go
index acccd37d3..9453fc16b 100644
--- a/cluster_internal_test.go
+++ b/cluster_internal_test.go
@@ -145,7 +145,7 @@ func TestFragSources(t *testing.T) {
 	c5.addNodeBasicSorted(node3)
 
 	idx := newIndexWithTempPath("i")
-	frame, err := idx.CreateFrameIfNotExists("f", FieldOptions{})
+	frame, err := idx.CreateFieldIfNotExists("f", FieldOptions{})
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/ctl/export.go b/ctl/export.go
index 5ee8d2120..988403272 100644
--- a/ctl/export.go
+++ b/ctl/export.go
@@ -58,7 +58,7 @@ func (cmd *ExportCommand) Run(ctx context.Context) error {
 	if cmd.Index == "" {
 		return pilosa.ErrIndexRequired
 	} else if cmd.Frame == "" {
-		return pilosa.ErrFrameRequired
+		return pilosa.ErrFieldRequired
 	}
 
 	// Use output file, if specified.
diff --git a/ctl/export_test.go b/ctl/export_test.go
index 469ca7d75..6948b810f 100644
--- a/ctl/export_test.go
+++ b/ctl/export_test.go
@@ -38,8 +38,8 @@ func TestExportCommand_Validation(t *testing.T) {
 
 	cm.Index = "i"
 	err = cm.Run(context.Background())
-	if err != pilosa.ErrFrameRequired {
-		t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFrameRequired, err)
+	if err != pilosa.ErrFieldRequired {
+		t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFieldRequired, err)
 	}
 }
 
diff --git a/ctl/import.go b/ctl/import.go
index 3a7835cb2..68229ed72 100644
--- a/ctl/import.go
+++ b/ctl/import.go
@@ -84,7 +84,7 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 	if cmd.Index == "" {
 		return pilosa.ErrIndexRequired
 	} else if cmd.Frame == "" {
-		return pilosa.ErrFrameRequired
+		return pilosa.ErrFieldRequired
 	} else if len(cmd.Paths) == 0 {
 		return errors.New("path required")
 	}
@@ -110,7 +110,7 @@ func (cmd *ImportCommand) Run(ctx context.Context) error {
 	}
 	for _, index := range schema {
 		if index.Name == cmd.Index {
-			for _, frame := range index.Frames {
+			for _, frame := range index.Fields {
 				if frame.Name == cmd.Frame {
 					frameType = frame.Options.Type
 				}
diff --git a/ctl/import_test.go b/ctl/import_test.go
index 7c64944f6..9b6dd3c6e 100644
--- a/ctl/import_test.go
+++ b/ctl/import_test.go
@@ -39,8 +39,8 @@ func TestImportCommand_Validation(t *testing.T) {
 
 	cm.Index = "i"
 	err = cm.Run(context.Background())
-	if err != pilosa.ErrFrameRequired {
-		t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFrameRequired, err)
+	if err != pilosa.ErrFieldRequired {
+		t.Fatalf("Command not working, expect: %s, actual: '%s'", pilosa.ErrFieldRequired, err)
 	}
 
 	cm.Frame = "f"
diff --git a/diagnostics.go b/diagnostics.go
index 10ecfa22d..f97f5f6aa 100644
--- a/diagnostics.go
+++ b/diagnostics.go
@@ -225,7 +225,7 @@ func (d *DiagnosticsCollector) EnrichWithSchemaProperties() {
 	for _, index := range d.server.Holder.Indexes() {
 		numSlices += index.MaxSlice() + 1
 		numIndexes += 1
-		for _, frame := range index.Frames() {
+		for _, frame := range index.Fields() {
 			numFrames += 1
 			if frame.Type() == FieldTypeInt {
 				bsiFieldCount += 1
diff --git a/executor.go b/executor.go
index fd98f7189..b3e4f5aad 100644
--- a/executor.go
+++ b/executor.go
@@ -313,7 +313,7 @@ func (e *Executor) executeBitmapCall(ctx context.Context, index string, c *pql.C
 					return nil, err
 				} else {
 					frame, _ := c.Args["frame"].(string)
-					if fr := idx.Frame(frame); fr != nil {
+					if fr := idx.Field(frame); fr != nil {
 						rowID, _, err := c.UintArg(rowLabel)
 						if err != nil {
 							return nil, errors.Wrap(err, "getting row")
@@ -634,7 +634,7 @@ func (e *Executor) executeBitmapSlice(ctx context.Context, index string, c *pql.
 	}
 	f := e.Holder.Frame(index, frame)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	rowID, rowOK, rowErr := c.UintArg(rowLabel)
@@ -694,9 +694,9 @@ func (e *Executor) executeRangeSlice(ctx context.Context, index string, c *pql.C
 	}
 
 	// Retrieve base frame.
-	f := idx.Frame(frame)
+	f := idx.Field(frame)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// Read row & column id.
@@ -769,7 +769,7 @@ func (e *Executor) executeBSIGroupRangeSlice(ctx context.Context, index string,
 
 	f := e.Holder.Frame(index, frameName)
 	if f == nil {
-		return nil, ErrFrameNotFound
+		return nil, ErrFieldNotFound
 	}
 
 	// EQ null           (not implemented: flip frag.NotNull with max ColumnID)
@@ -959,9 +959,9 @@ func (e *Executor) executeClearBit(ctx context.Context, index string, c *pql.Cal
 	if idx == nil {
 		return false, ErrIndexNotFound
 	}
-	f := idx.Frame(frame)
+	f := idx.Field(frame)
 	if f == nil {
-		return false, ErrFrameNotFound
+		return false, ErrFieldNotFound
 	}
 
 	// Read fields using labels.
@@ -1024,9 +1024,9 @@ func (e *Executor) executeSetBit(ctx context.Context, index string, c *pql.Call,
 	if idx == nil {
 		return false, ErrIndexNotFound
 	}
-	f := idx.Frame(frame)
+	f := idx.Field(frame)
 	if f == nil {
-		return false, ErrFrameNotFound
+		return false, ErrFieldNotFound
 	}
 
 	// Read fields using labels.
@@ -1110,7 +1110,7 @@ func (e *Executor) executeSetValue(ctx context.Context, index string, c *pql.Cal
 		// Retrieve frame.
 		frame := e.Holder.Frame(index, name)
 		if frame == nil {
-			return ErrFrameNotFound
+			return ErrFieldNotFound
 		}
 
 		switch value := value.(type) {
@@ -1159,7 +1159,7 @@ func (e *Executor) executeSetRowAttrs(ctx context.Context, index string, c *pql.
 	// Retrieve frame.
 	frame := e.Holder.Frame(index, frameName)
 	if frame == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Parse labels.
@@ -1219,7 +1219,7 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 		// Retrieve frame.
 		f := e.Holder.Frame(index, frame)
 		if f == nil {
-			return nil, ErrFrameNotFound
+			return nil, ErrFieldNotFound
 		}
 
 		rowID, ok, err := c.UintArg(rowLabel)
@@ -1257,7 +1257,7 @@ func (e *Executor) executeBulkSetRowAttrs(ctx context.Context, index string, cal
 		// Retrieve frame.
 		frame := e.Holder.Frame(index, name)
 		if frame == nil {
-			return nil, ErrFrameNotFound
+			return nil, ErrFieldNotFound
 		}
 
 		// Set attributes.
diff --git a/executor_test.go b/executor_test.go
index 0d70ae37f..b8f7aa317 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -388,9 +388,9 @@ func TestExecutor_Execute_TopN(t *testing.T) {
 	// Set columns for rows 0, 10, & 20 across two slices.
 	if idx, err := hldr.CreateIndex("i", pilosa.IndexOptions{}); err != nil {
 		t.Fatal(err)
-	} else if _, err := idx.CreateFrame("f", pilosa.FieldOptions{}); err != nil {
+	} else if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
-	} else if _, err := idx.CreateFrame("other", pilosa.FieldOptions{}); err != nil {
+	} else if _, err := idx.CreateField("other", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	} else if _, err := e.Execute(context.Background(), "i", test.MustParse(`
 		SetBit(frame=f, row=0, col=0)
@@ -572,11 +572,11 @@ func TestExecutor_Execute_MinMax(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("x", pilosa.FieldOptions{}); err != nil {
+	if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("f", pilosa.FieldOptions{
+	if _, err := idx.CreateField("f", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  -10,
 		Max:  100,
@@ -667,11 +667,11 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("x", pilosa.FieldOptions{}); err != nil {
+	if _, err := idx.CreateField("x", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("foo", pilosa.FieldOptions{
+	if _, err := idx.CreateField("foo", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  10,
 		Max:  100,
@@ -679,7 +679,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{
+	if _, err := idx.CreateField("bar", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  100000,
@@ -687,7 +687,7 @@ func TestExecutor_Execute_Sum(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("other", pilosa.FieldOptions{
+	if _, err := idx.CreateField("other", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  1000,
@@ -780,11 +780,11 @@ func TestExecutor_Execute_Range(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("f", pilosa.FieldOptions{}); err != nil {
+	if _, err := idx.CreateField("f", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("foo", pilosa.FieldOptions{
+	if _, err := idx.CreateField("foo", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  10,
 		Max:  100,
@@ -792,7 +792,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{
+	if _, err := idx.CreateField("bar", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  100000,
@@ -800,7 +800,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("other", pilosa.FieldOptions{
+	if _, err := idx.CreateField("other", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  0,
 		Max:  1000,
@@ -808,7 +808,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if _, err := idx.CreateFrame("edge", pilosa.FieldOptions{
+	if _, err := idx.CreateField("edge", pilosa.FieldOptions{
 		Type: pilosa.FieldTypeInt,
 		Min:  -100,
 		Max:  100,
@@ -945,7 +945,7 @@ func TestExecutor_Execute_Range(t *testing.T) {
 	})
 
 	t.Run("ErrFrameNotFound", func(t *testing.T) {
-		if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(bad_frame >= 20)`), nil, nil); err != pilosa.ErrFrameNotFound {
+		if _, err := e.Execute(context.Background(), "i", test.MustParse(`Range(bad_frame >= 20)`), nil, nil); err != pilosa.ErrFieldNotFound {
 			t.Fatal(err)
 		}
 	})
diff --git a/fragment_test.go b/fragment_test.go
index 2d618aa81..71dff2b71 100644
--- a/fragment_test.go
+++ b/fragment_test.go
@@ -961,7 +961,7 @@ func TestFragment_RankCache_Persistence(t *testing.T) {
 	}
 
 	// Re-fetch fragment.
-	f = index.Frame("f").View(pilosa.ViewStandard).Fragment(0)
+	f = index.Field("f").View(pilosa.ViewStandard).Fragment(0)
 
 	// Re-verify correct cache type and size.
 	if cache, ok := f.Cache().(*pilosa.RankCache); !ok {
diff --git a/handler.go b/handler.go
index 4cc64fbb2..a57a40204 100644
--- a/handler.go
+++ b/handler.go
@@ -522,7 +522,7 @@ func (h *Handler) handlePostFrame(w http.ResponseWriter, r *http.Request) {
 		switch errors.Cause(err) {
 		case ErrIndexNotFound:
 			http.Error(w, err.Error(), http.StatusNotFound)
-		case ErrFrameExists:
+		case ErrFieldExists:
 			http.Error(w, err.Error(), http.StatusConflict)
 		default:
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -749,7 +749,7 @@ func (h *Handler) handlePostImport(w http.ResponseWriter, r *http.Request) {
 		switch errors.Cause(err) {
 		case ErrIndexNotFound:
 			fallthrough
-		case ErrFrameNotFound:
+		case ErrFieldNotFound:
 			http.Error(w, err.Error(), http.StatusNotFound)
 		case ErrClusterDoesNotOwnSlice:
 			http.Error(w, err.Error(), http.StatusPreconditionFailed)
@@ -802,7 +802,7 @@ func (h *Handler) handlePostImportValue(w http.ResponseWriter, r *http.Request)
 		switch errors.Cause(err) {
 		case ErrIndexNotFound:
 			fallthrough
-		case ErrFrameNotFound:
+		case ErrFieldNotFound:
 			http.Error(w, err.Error(), http.StatusNotFound)
 		case ErrClusterDoesNotOwnSlice:
 			http.Error(w, err.Error(), http.StatusPreconditionFailed)
diff --git a/handler_test.go b/handler_test.go
index c378a30cf..74b1702fa 100644
--- a/handler_test.go
+++ b/handler_test.go
@@ -712,7 +712,7 @@ func TestHandler_DeleteFrame(t *testing.T) {
 		t.Fatalf("unexpected status code: %d", w.Code)
 	} else if body := w.Body.String(); body != `{}`+"\n" {
 		t.Fatalf("unexpected body: %s", body)
-	} else if f := hldr.Index("i0").Frame("f1"); f != nil {
+	} else if f := hldr.Index("i0").Field("f1"); f != nil {
 		t.Fatal("expected nil frame")
 	}
 }
diff --git a/holder.go b/holder.go
index 3a3bcca0c..f0c6d027c 100644
--- a/holder.go
+++ b/holder.go
@@ -214,15 +214,15 @@ func (h *Holder) Schema() []*IndexInfo {
 	var a []*IndexInfo
 	for _, index := range h.Indexes() {
 		di := &IndexInfo{Name: index.Name()}
-		for _, frame := range index.Frames() {
+		for _, frame := range index.Fields() {
 			fi := &FieldInfo{Name: frame.Name(), Options: frame.Options()}
 			for _, view := range frame.Views() {
 				fi.Views = append(fi.Views, &ViewInfo{Name: view.Name()})
 			}
 			sort.Sort(viewInfoSlice(fi.Views))
-			di.Frames = append(di.Frames, fi)
+			di.Fields = append(di.Fields, fi)
 		}
-		sort.Sort(fieldInfoSlice(di.Frames))
+		sort.Sort(fieldInfoSlice(di.Fields))
 		a = append(a, di)
 	}
 	sort.Sort(indexInfoSlice(a))
@@ -241,7 +241,7 @@ func (h *Holder) ApplySchema(schema *internal.Schema) error {
 		// Create frames that don't exist.
 		for _, f := range index.Frames {
 			opt := decodeFieldOptions(f.Meta)
-			frame, err := idx.CreateFrameIfNotExists(f.Name, *opt)
+			frame, err := idx.CreateFieldIfNotExists(f.Name, *opt)
 			if err != nil {
 				return errors.Wrap(err, "creating frame")
 			}
@@ -396,7 +396,7 @@ func (h *Holder) Frame(index, name string) *Field {
 	if idx == nil {
 		return nil
 	}
-	return idx.Frame(name)
+	return idx.Field(name)
 }
 
 // View returns the view for an index, frame, and name.
@@ -435,7 +435,7 @@ func (h *Holder) monitorCacheFlush() {
 
 func (h *Holder) flushCaches() {
 	for _, index := range h.Indexes() {
-		for _, frame := range index.Frames() {
+		for _, frame := range index.Fields() {
 			for _, view := range frame.Views() {
 				for _, fragment := range view.Fragments() {
 					select {
@@ -600,7 +600,7 @@ func (s *HolderSyncer) SyncHolder() error {
 		}
 
 		tf := time.Now()
-		for _, fi := range di.Frames {
+		for _, fi := range di.Fields {
 			// Verify syncer has not closed.
 			if s.IsClosing() {
 				return nil
@@ -713,7 +713,7 @@ func (s *HolderSyncer) syncFrame(index, name string) error {
 		// Retrieve attributes from differing blocks.
 		// Skip update and recomputation if no attributes have changed.
 		m, err := client.RowAttrDiff(context.Background(), index, name, blks)
-		if err == ErrFrameNotFound {
+		if err == ErrFieldNotFound {
 			continue // frame not created remotely yet, skip
 		} else if err != nil {
 			return errors.Wrap(err, "getting differing blocks")
@@ -742,7 +742,7 @@ func (s *HolderSyncer) syncFragment(index, frame, view string, slice uint64) err
 	// Retrieve local frame.
 	f := s.Holder.Frame(index, frame)
 	if f == nil {
-		return ErrFrameNotFound
+		return ErrFieldNotFound
 	}
 
 	// Ensure view exists locally.
@@ -806,7 +806,7 @@ func (c *HolderCleaner) CleanHolder() error {
 		containedSlices := c.Cluster.ContainsSlices(index.Name(), index.MaxSlice(), c.Node)
 
 		// Get the fragments registered in memory.
-		for _, frame := range index.Frames() {
+		for _, frame := range index.Fields() {
 			for _, view := range frame.Views() {
 				for _, fragment := range view.Fragments() {
 					fragSlice := fragment.Slice()
diff --git a/holder_test.go b/holder_test.go
index 0081b105c..664bf16a0 100644
--- a/holder_test.go
+++ b/holder_test.go
@@ -100,7 +100,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if err := h.Holder.Close(); err != nil {
 			t.Fatal(err)
@@ -119,7 +119,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if err := h.Holder.Close(); err != nil {
 			t.Fatal(err)
@@ -137,7 +137,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if _, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if _, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if err := h.Holder.Close(); err != nil {
 			t.Fatal(err)
@@ -159,7 +159,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
@@ -183,7 +183,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if _, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
@@ -208,7 +208,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
@@ -231,7 +231,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
@@ -257,7 +257,7 @@ func TestHolder_Open(t *testing.T) {
 
 		if idx, err := h.CreateIndex("foo", pilosa.IndexOptions{}); err != nil {
 			t.Fatal(err)
-		} else if frame, err := idx.CreateFrame("bar", pilosa.FieldOptions{}); err != nil {
+		} else if frame, err := idx.CreateField("bar", pilosa.FieldOptions{}); err != nil {
 			t.Fatal(err)
 		} else if view, err := frame.CreateViewIfNotExists(pilosa.ViewStandard); err != nil {
 			t.Fatal(err)
diff --git a/index.go b/index.go
index 8421f8273..727989914 100644
--- a/index.go
+++ b/index.go
@@ -34,8 +34,8 @@ type Index struct {
 	path string
 	name string
 
-	// Frames by name.
-	frames map[string]*Field
+	// Fields by name.
+	fields map[string]*Field
 
 	// Max Slice on any node in the cluster, according to this node.
 	remoteMaxSlice uint64
@@ -61,7 +61,7 @@ func NewIndex(path, name string) (*Index, error) {
 	return &Index{
 		path:   path,
 		name:   name,
-		frames: make(map[string]*Field),
+		fields: make(map[string]*Field),
 
 		remoteMaxSlice: 0,
 
@@ -106,7 +106,7 @@ func (i *Index) Open() error {
 		return errors.Wrap(err, "loading meta file")
 	}
 
-	if err := i.openFrames(); err != nil {
+	if err := i.openFields(); err != nil {
 		return errors.Wrap(err, "opening frames")
 	}
 
@@ -117,8 +117,8 @@ func (i *Index) Open() error {
 	return nil
 }
 
-// openFrames opens and initializes the frames inside the index.
-func (i *Index) openFrames() error {
+// openFields opens and initializes the frames inside the index.
+func (i *Index) openFields() error {
 	f, err := os.Open(i.path)
 	if err != nil {
 		return errors.Wrap(err, "opening directory")
@@ -135,14 +135,14 @@ func (i *Index) openFrames() error {
 			continue
 		}
 
-		fr, err := i.newFrame(i.FramePath(filepath.Base(fi.Name())), filepath.Base(fi.Name()))
+		fld, err := i.newField(i.FieldPath(filepath.Base(fi.Name())), filepath.Base(fi.Name()))
 		if err != nil {
 			return ErrName
 		}
-		if err := fr.Open(); err != nil {
-			return fmt.Errorf("open frame: name=%s, err=%s", fr.Name(), err)
+		if err := fld.Open(); err != nil {
+			return fmt.Errorf("open frame: name=%s, err=%s", fld.Name(), err)
 		}
-		i.frames[fr.Name()] = fr
+		i.fields[fld.Name()] = fld
 	}
 	return nil
 }
@@ -198,12 +198,12 @@ func (i *Index) Close() error {
 	i.columnAttrStore.Close()
 
 	// Close all frames.
-	for _, f := range i.frames {
+	for _, f := range i.fields {
 		if err := f.Close(); err != nil {
 			return errors.Wrap(err, "closing frame")
 		}
 	}
-	i.frames = make(map[string]*Field)
+	i.fields = make(map[string]*Field)
 
 	return nil
 }
@@ -217,7 +217,7 @@ func (i *Index) MaxSlice() uint64 {
 	defer i.mu.RUnlock()
 
 	max := i.remoteMaxSlice
-	for _, f := range i.frames {
+	for _, f := range i.fields {
 		if slice := f.MaxSlice(); slice > max {
 			max = slice
 		}
@@ -234,25 +234,25 @@ func (i *Index) SetRemoteMaxSlice(newmax uint64) {
 	i.remoteMaxSlice = newmax
 }
 
-// FramePath returns the path to a frame in the index.
-func (i *Index) FramePath(name string) string { return filepath.Join(i.path, name) }
+// FieldPath returns the path to a field in the index.
+func (i *Index) FieldPath(name string) string { return filepath.Join(i.path, name) }
 
-// Frame returns a frame in the index by name.
-func (i *Index) Frame(name string) *Field {
+// Field returns a frame in the index by name.
+func (i *Index) Field(name string) *Field {
 	i.mu.RLock()
 	defer i.mu.RUnlock()
-	return i.frame(name)
+	return i.field(name)
 }
 
-func (i *Index) frame(name string) *Field { return i.frames[name] }
+func (i *Index) field(name string) *Field { return i.fields[name] }
 
-// Frames returns a list of all frames in the index.
-func (i *Index) Frames() []*Field {
+// Fields returns a list of all fields in the index.
+func (i *Index) Fields() []*Field {
 	i.mu.RLock()
 	defer i.mu.RUnlock()
 
-	a := make([]*Field, 0, len(i.frames))
-	for _, f := range i.frames {
+	a := make([]*Field, 0, len(i.fields))
+	for _, f := range i.fields {
 		a = append(a, f)
 	}
 	sort.Sort(fieldSlice(a))
@@ -262,37 +262,37 @@ func (i *Index) Frames() []*Field {
 
 // RecalculateCaches recalculates caches on every frame in the index.
 func (i *Index) RecalculateCaches() {
-	for _, frame := range i.Frames() {
+	for _, frame := range i.Fields() {
 		frame.RecalculateCaches()
 	}
 }
 
-// CreateFrame creates a frame.
-func (i *Index) CreateFrame(name string, opt FieldOptions) (*Field, error) {
+// CreateField creates a field.
+func (i *Index) CreateField(name string, opt FieldOptions) (*Field, error) {
 	i.mu.Lock()
 	defer i.mu.Unlock()
 
 	// Ensure frame doesn't already exist.
-	if i.frames[name] != nil {
-		return nil, ErrFrameExists
+	if i.fields[name] != nil {
+		return nil, ErrFieldExists
 	}
-	return i.createFrame(name, opt)
+	return i.createField(name, opt)
 }
 
-// CreateFrameIfNotExists creates a frame with the given options if it doesn't exist.
-func (i *Index) CreateFrameIfNotExists(name string, opt FieldOptions) (*Field, error) {
+// CreateFieldIfNotExists creates a field with the given options if it doesn't exist.
+func (i *Index) CreateFieldIfNotExists(name string, opt FieldOptions) (*Field, error) {
 	i.mu.Lock()
 	defer i.mu.Unlock()
 
 	// Find frame in cache first.
-	if f := i.frames[name]; f != nil {
+	if f := i.fields[name]; f != nil {
 		return f, nil
 	}
 
-	return i.createFrame(name, opt)
+	return i.createField(name, opt)
 }
 
-func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
+func (i *Index) createField(name string, opt FieldOptions) (*Field, error) {
 	if name == "" {
 		return nil, errors.New("frame name required")
 	} else if opt.CacheType != "" && !IsValidCacheType(opt.CacheType) {
@@ -305,7 +305,7 @@ func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
 	}
 
 	// Initialize frame.
-	f, err := i.newFrame(i.FramePath(name), name)
+	f, err := i.newField(i.FieldPath(name), name)
 	if err != nil {
 		return nil, errors.Wrap(err, "initializing")
 	}
@@ -327,12 +327,12 @@ func (i *Index) createFrame(name string, opt FieldOptions) (*Field, error) {
 	}
 
 	// Add to index's frame lookup.
-	i.frames[name] = f
+	i.fields[name] = f
 
 	return f, nil
 }
 
-func (i *Index) newFrame(path, name string) (*Field, error) {
+func (i *Index) newField(path, name string) (*Field, error) {
 	f, err := NewField(path, i.name, name)
 	if err != nil {
 		return nil, err
@@ -344,13 +344,13 @@ func (i *Index) newFrame(path, name string) (*Field, error) {
 	return f, nil
 }
 
-// DeleteFrame removes a frame from the index.
-func (i *Index) DeleteFrame(name string) error {
+// DeleteField removes a field from the index.
+func (i *Index) DeleteField(name string) error {
 	i.mu.Lock()
 	defer i.mu.Unlock()
 
 	// Ignore if frame doesn't exist.
-	f := i.frame(name)
+	f := i.field(name)
 	if f == nil {
 		return nil
 	}
@@ -361,12 +361,12 @@ func (i *Index) DeleteFrame(name string) error {
 	}
 
 	// Delete frame directory.
-	if err := os.RemoveAll(i.FramePath(name)); err != nil {
+	if err := os.RemoveAll(i.FieldPath(name)); err != nil {
 		return errors.Wrap(err, "removing directory")
 	}
 
 	// Remove reference.
-	delete(i.frames, name)
+	delete(i.fields, name)
 
 	return nil
 }
@@ -380,7 +380,7 @@ func (p indexSlice) Less(i, j int) bool { return p[i].Name() < p[j].Name() }
 // IndexInfo represents schema information for an index.
 type IndexInfo struct {
 	Name   string       `json:"name"`
-	Frames []*FieldInfo `json:"frames"`
+	Fields []*FieldInfo `json:"fields"`
 }
 
 type indexInfoSlice []*IndexInfo
@@ -402,7 +402,7 @@ func EncodeIndexes(a []*Index) []*internal.Index {
 func encodeIndex(d *Index) *internal.Index {
 	return &internal.Index{
 		Name:   d.name,
-		Frames: encodeFields(d.Frames()),
+		Frames: encodeFields(d.Fields()),
 	}
 }
 
diff --git a/index_test.go b/index_test.go
index be6288ad8..ada9be7f1 100644
--- a/index_test.go
+++ b/index_test.go
@@ -44,7 +44,7 @@ func TestIndex_CreateFrameIfNotExists(t *testing.T) {
 		t.Fatal("frame mismatch")
 	}
 
-	if f.Field != index.Frame("f") {
+	if f.Field != index.Field("f") {
 		t.Fatal("frame mismatch")
 	}
 }
@@ -89,7 +89,7 @@ func TestIndex_CreateFrame(t *testing.T) {
 			// Reopen the index & verify the fields are loaded.
 			if err := index.Reopen(); err != nil {
 				t.Fatal(err)
-			} else if f := index.Frame("f"); !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
+			} else if f := index.Field("f"); !reflect.DeepEqual(f.Type(), pilosa.FieldTypeInt) {
 				t.Fatalf("unexpected type after reopen: %#v", f.Type())
 			}
 		})
@@ -185,14 +185,14 @@ func TestIndex_DeleteFrame(t *testing.T) {
 	}
 
 	// Delete frame & verify it's gone.
-	if err := index.DeleteFrame("f"); err != nil {
+	if err := index.DeleteField("f"); err != nil {
 		t.Fatal(err)
-	} else if index.Frame("f") != nil {
+	} else if index.Field("f") != nil {
 		t.Fatal("expected nil frame")
 	}
 
 	// Delete again to make sure it doesn't error.
-	if err := index.DeleteFrame("f"); err != nil {
+	if err := index.DeleteField("f"); err != nil {
 		t.Fatal(err)
 	}
 }
diff --git a/pilosa.go b/pilosa.go
index 21bfdd822..2c0a8502d 100644
--- a/pilosa.go
+++ b/pilosa.go
@@ -31,10 +31,10 @@ var (
 	ErrIndexExists   = errors.New("index already exists")
 	ErrIndexNotFound = errors.New("index not found")
 
-	// ErrFrameRequired is returned when no frame is specified.
-	ErrFrameRequired = errors.New("frame required")
-	ErrFrameExists   = errors.New("frame already exists")
-	ErrFrameNotFound = errors.New("frame not found")
+	// ErrFieldRequired is returned when no field is specified.
+	ErrFieldRequired = errors.New("field required")
+	ErrFieldExists   = errors.New("field already exists")
+	ErrFieldNotFound = errors.New("field not found")
 
 	ErrBSIGroupNotFound         = errors.New("bsigroup not found")
 	ErrBSIGroupExists           = errors.New("bsigroup already exists")
diff --git a/server.go b/server.go
index d0585c992..d92c5949e 100644
--- a/server.go
+++ b/server.go
@@ -461,13 +461,13 @@ func (s *Server) ReceiveMessage(pb proto.Message) error {
 			return fmt.Errorf("Local Index not found: %s", obj.Index)
 		}
 		opt := decodeFieldOptions(obj.Meta)
-		_, err := idx.CreateFrame(obj.Frame, *opt)
+		_, err := idx.CreateField(obj.Frame, *opt)
 		if err != nil {
 			return err
 		}
 	case *internal.DeleteFrameMessage:
 		idx := s.Holder.Index(obj.Index)
-		if err := idx.DeleteFrame(obj.Frame); err != nil {
+		if err := idx.DeleteField(obj.Frame); err != nil {
 			return err
 		}
 	case *internal.CreateViewMessage:
diff --git a/server/cluster_test.go b/server/cluster_test.go
index 1b4e0b807..f445ce415 100644
--- a/server/cluster_test.go
+++ b/server/cluster_test.go
@@ -66,7 +66,7 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 	received0 := map[string][]string{}
 	for _, idx := range schema0 {
 		received0[idx.Name] = []string{}
-		for _, frame := range idx.Frames {
+		for _, frame := range idx.Fields {
 			received0[idx.Name] = append(received0[idx.Name], frame.Name)
 		}
 	}
@@ -82,7 +82,7 @@ func TestMain_SendReceiveMessage(t *testing.T) {
 	received1 := map[string][]string{}
 	for _, idx := range schema1 {
 		received1[idx.Name] = []string{}
-		for _, frame := range idx.Frames {
+		for _, frame := range idx.Fields {
 			received1[idx.Name] = append(received1[idx.Name], frame.Name)
 		}
 	}
diff --git a/stats_test.go b/stats_test.go
index 47521fbf8..992055166 100644
--- a/stats_test.go
+++ b/stats_test.go
@@ -298,7 +298,7 @@ func TestStatsCount_DeleteFrame(t *testing.T) {
 	called := false
 	// Create index.
 	indx, _ := hldr.CreateIndexIfNotExists("i", pilosa.IndexOptions{})
-	if _, err := indx.CreateFrameIfNotExists("test", pilosa.FieldOptions{}); err != nil {
+	if _, err := indx.CreateFieldIfNotExists("test", pilosa.FieldOptions{}); err != nil {
 		t.Fatal(err)
 	}
 	s.Handler.API.Holder.Stats = &MockStats{
diff --git a/test/cluster.go b/test/cluster.go
index 4c0bd45a0..e293764ad 100644
--- a/test/cluster.go
+++ b/test/cluster.go
@@ -120,7 +120,7 @@ func (t *TestCluster) CreateFrame(index, frame string, opt pilosa.FieldOptions)
 		if err != nil {
 			return err
 		}
-		if _, err := idx.CreateFrame(frame, opt); err != nil {
+		if _, err := idx.CreateField(frame, opt); err != nil {
 			return err
 		}
 	}
diff --git a/test/index.go b/test/index.go
index 5689afda3..93fa99cad 100644
--- a/test/index.go
+++ b/test/index.go
@@ -75,7 +75,7 @@ func (i *Index) Reopen() error {
 
 // CreateFrame creates a frame with the given options.
 func (i *Index) CreateFrame(name string, opt pilosa.FieldOptions) (*Frame, error) {
-	f, err := i.Index.CreateFrame(name, opt)
+	f, err := i.Index.CreateField(name, opt)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +84,7 @@ func (i *Index) CreateFrame(name string, opt pilosa.FieldOptions) (*Frame, error
 
 // CreateFrameIfNotExists creates a frame with the given options if it doesn't exist.
 func (i *Index) CreateFrameIfNotExists(name string, opt pilosa.FieldOptions) (*Frame, error) {
-	f, err := i.Index.CreateFrameIfNotExists(name, opt)
+	f, err := i.Index.CreateFieldIfNotExists(name, opt)
 	if err != nil {
 		return nil, err
 	}
diff --git a/utils_test.go b/utils_test.go
index 7773db06c..ccb39ef54 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -110,7 +110,7 @@ func (t *ClusterCluster) CreateFrame(index, frame string, opt FieldOptions) erro
 		if err != nil {
 			return err
 		}
-		if _, err := idx.CreateFrame(frame, opt); err != nil {
+		if _, err := idx.CreateField(frame, opt); err != nil {
 			return err
 		}
 	}