diff --git a/CHANGELOG.md b/CHANGELOG.md
index 775d787..63b5475 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2023-08-25
+
+### Added
+* Anchor types tab to anchorlist, anchor classes in scope are automatically detected,
+    and can be dynamically added and removed.
+* Color delineation to anchors, each row in the anchorlist and anchor in anchorviz is
+    colored corresponding to anchor color (configurable in anchor types tab.)
+* Ability to change what anchor type is used when the "example" buttons are clicked.
+* Optional description and name class attributes to anchors for display in the interface.
+* Individual anchor-level `cache` dictionary that gets loaded and saved with the anchor
+* Access to anchor list cache through an anchor `global_cache` property.
+
+### Removed
+* Similarity functions from model constructor and the similarity function anchor
+    (subclass the `SimilarityAnchorBase` and provide it with a `featurize()`
+    function instead - see the `lm_similarity_example` notebook.)
+
+
+
+
 ## [0.6.0] - 2023-08-22
 
 ### Added
diff --git a/icat/__init__.py b/icat/__init__.py
index c773956..a3542fd 100644
--- a/icat/__init__.py
+++ b/icat/__init__.py
@@ -13,12 +13,12 @@
     table,
     view,
 )
-from icat.anchors import Anchor, DictionaryAnchor, SimilarityFunctionAnchor, TFIDFAnchor
+from icat.anchors import Anchor, DictionaryAnchor, TFIDFAnchor
 
 # make the important things directly accessible off top level module
 from icat.model import Model
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 
 def initialize(offline: bool = False):
diff --git a/icat/anchorlist.py b/icat/anchorlist.py
index 5000fd6..0f2fd0b 100644
--- a/icat/anchorlist.py
+++ b/icat/anchorlist.py
@@ -4,6 +4,7 @@
 import os
 import pickle
 from collections.abc import Callable
+from functools import partial
 
 import ipyvuetify as v
 import ipywidgets as ipw
@@ -14,12 +15,44 @@
 import traitlets
 from sklearn.feature_extraction.text import TfidfVectorizer
 
-from icat.anchors import Anchor, DictionaryAnchor, SimilarityFunctionAnchor, TFIDFAnchor
+from icat.anchors import Anchor, DictionaryAnchor, SimilarityAnchorBase, TFIDFAnchor
 from icat.utils import _kill_param_auto_docstring
 
 _kill_param_auto_docstring()
 
 
+ANCHOR_COLOR_PALLETE = [
+    [
+        "#2ABD7F",  # pleasant pale green
+        "#42803F",  # dark green
+    ],
+    [
+        "#8C27C1",  # dark purple
+        "#5B3D7B",  # darker purple
+    ],
+    [
+        "#2EA5A5",  # mid pale blue
+        "#424E80",  # dark washed blue
+    ],
+    [
+        "#BFA74C",  # gold
+        "#6E9613",  # olive green
+    ],
+    [
+        "#DA707C",  # salmon
+        "#A75B13",  # burnt orange
+    ],
+    [
+        "#CA3296",  # pink
+        "#881515",  # red
+    ],
+    [
+        "#8D6E63",  # brown
+        "#777777",  # grey
+    ],
+]
+
+
 class AnchorListTemplate(v.VuetifyTemplate):
     """The ipyvuetify contents of the anchorlist table. This handles all the special considerations
     like the slot for the expanded rows containing the anchor widgets, and the coverage v-html etc.
@@ -93,45 +126,47 @@ def _template(self):
             dense
             :loading="processing"
             :expanded.sync="expanded"
-            class="dense-table striped-table softhover-table"
+            class="dense-table striped-table"
             item-key="name"
         >
-            <template v-slot:item.anchor_name="{ item }">
-                <div><jupyter-widget :widget="item.anchor_name" /></div>
-            </template>
-
-            <template v-slot:item.in_viz="{ item }">
-                <div><jupyter-widget :widget="item.in_viz" /></div>
-            </template>
-
-            <template v-slot:item.in_model="{ item }">
-                <div><jupyter-widget :widget="item.in_model" /></div>
-            </template>
-
-            <template v-slot:item.pct_negative="{ item }">
-                <div class='blue--text darken-1'>{{ item.pct_negative }}</div>
-            </template>
-
-            <template v-slot:item.pct_positive="{ item }">
-                <div class='orange--text darken-1'>{{ item.pct_positive }}</div>
-            </template>
-
-            <template v-slot:item.delete="{ item }">
-                <v-btn
-                    icon
-                    x-small
-                    class='delete-button'
-                    @click="deleteAnchor(item.name)"
-                    :loading="item.processing"
-                >
-                    <v-icon>mdi-close-circle-outline</v-icon>
-                </v-btn>
+            <template v-slot:item="{ item, expand, isExpanded }">
+                <!--<tr :style="{ backgroundColor: item.color, backgroundImage: 'linear-gradient(rgb(0 0 0/40%) 0 0)' }">-->
+                <!--<tr>-->
+                <tr :style="{ backgroundColor: item.color, backgroundImage: 'linear-gradient(rgb(50 50 50/95%) 0 0)' }">
+                    <td>
+                        <v-btn icon x-small @click="expand(!isExpanded)" :style="{ backgroundColor: item.color }">
+                            <v-icon v-if="isExpanded" style="margin-left: -1px; margin-top: 1px;">mdi-chevron-down</v-icon>
+                            <v-icon v-if="!isExpanded" style="margin-left: -1px; margin-top: 1px;">mdi-chevron-up</v-icon>
+                        </v-btn>
+                    </td>
+
+
+                    <td><div><jupyter-widget :widget="item.anchor_name" /></div></td>
+                    <td><div>{{ item.coverage }}</div></td>
+                    <td><div class='blue--text darken-1'>{{ item.pct_negative }}</div></td>
+                    <td><div class='orange--text darken-1'>{{ item.pct_positive }}</div></td>
+                    <td><div><jupyter-widget :widget="item.in_viz" /></div></td>
+                    <td><div><jupyter-widget :widget="item.in_model" /></div></td>
+                    <td>
+                        <v-btn
+                            icon
+                            x-small
+                            class='delete-button'
+                            @click="deleteAnchor(item.name)"
+                            :loading="item.processing"
+                        >
+                            <v-icon>mdi-close-circle-outline</v-icon>
+                        </v-btn>
+                    </td>
+                </tr>
             </template>
 
             <template v-slot:expanded-item="{ headers, item }">
-                <td :colspan="headers.length">
-                    <jupyter-widget :widget="item.widget" />
-                </td>
+                <tr class="v-data-table__expanded__content" :style="{ backgroundColor: item.color, backgroundImage: 'linear-gradient(rgb(0 0 0/80%) 0 0)' }">
+                    <td :colspan="headers.length+1">
+                        <jupyter-widget :widget="item.widget" />
+                    </td>
+                </tr>
             </template>
         </v-data-table>
         <style id='table-styles'>
@@ -150,7 +185,7 @@ def _template(self):
                 background-color: rgba(0, 0, 0, 0.35);
             }
             .striped-table .v-data-table__expanded__content td {
-                background-color: #263238;
+                /*background-color: #263238; */
             }
             .dense-table .row {
                 flex-wrap: nowrap;
@@ -193,11 +228,137 @@ def _template(self):
             div .v-progress-linear {
                 left: -1px !important;
             }
-        </style>
-        """
 
+            /* this should probably go somewhere else, these are
+             vars for anchorviz. */
+            :host {
+                --selectedAnchorColor: #FFF;
+            }
+            </style>
+        """
 
-class AnchorList(pn.viewable.Layoutable, pn.viewable.Viewer):
+    # @traitlets.default("template")
+    # def _template_old(self):
+    #     return """
+    #     <v-data-table
+    #         :headers="headers"
+    #         :items="items"
+    #         hide-default-footer
+    #         show-expand
+    #         dense
+    #         :loading="processing"
+    #         :expanded.sync="expanded"
+    #         class="dense-table striped-table softhover-table"
+    #         item-key="name"
+    #     >
+    #         <template v-slot:item.anchor_name="{ item }">
+    #             <div><jupyter-widget :widget="item.anchor_name" /></div>
+    #         </template>
+
+    #         <template v-slot:item.in_viz="{ item }">
+    #             <div><jupyter-widget :widget="item.in_viz" /></div>
+    #         </template>
+
+    #         <template v-slot:item.in_model="{ item }">
+    #             <div><jupyter-widget :widget="item.in_model" /></div>
+    #         </template>
+
+    #         <template v-slot:item.pct_negative="{ item }">
+    #             <div class='blue--text darken-1'>{{ item.pct_negative }}</div>
+    #         </template>
+
+    #         <template v-slot:item.pct_positive="{ item }">
+    #             <div class='orange--text darken-1'>{{ item.pct_positive }}</div>
+    #         </template>
+
+    #         <template v-slot:item.delete="{ item }">
+    #             <v-btn
+    #                 icon
+    #                 x-small
+    #                 class='delete-button'
+    #                 @click="deleteAnchor(item.name)"
+    #                 :loading="item.processing"
+    #             >
+    #                 <v-icon>mdi-close-circle-outline</v-icon>
+    #             </v-btn>
+    #         </template>
+
+    #         <template v-slot:expanded-item="{ headers, item }">
+    #             <td :colspan="headers.length">
+    #                 <jupyter-widget :widget="item.widget" />
+    #             </td>
+    #         </template>
+    #     </v-data-table>
+    #     <style id='table-styles'>
+    #         .softhover-table table tbody tr:hover {
+    #             background-color: #333333 !important;
+    #         }
+    #         .delete-button {
+    #             margin: 0px;
+    #             margin-left: 6px;
+    #             color: var(--md-grey-500) !important;
+    #         }
+    #         .delete-button:hover {
+    #             color: var(--md-red-500) !important;
+    #         }
+    #         .striped-table tbody tr:nth-child(even) {
+    #             background-color: rgba(0, 0, 0, 0.35);
+    #         }
+    #         .striped-table .v-data-table__expanded__content td {
+    #             background-color: #263238;
+    #         }
+    #         .dense-table .row {
+    #             flex-wrap: nowrap;
+    #         }
+    #         .dense-table td {
+    #             padding: 0 4px !important;
+    #             height: 30px !important;
+    #             max-height: 30px !important;
+    #             vertical-align: middle;
+    #         }
+    #         .dense-table th {
+    #             padding: 0 4px !important;
+    #         }
+    #         .dense-table td .v-input {
+    #             margin: 0;
+    #             /* margin-top: 5px; */
+    #         }
+    #         .dense-table td .v-input__slot {
+    #             margin-bottom: 0;
+    #         }
+    #         .dense-table td .v-input--selection-controls__input {
+    #             margin-top: -5px;
+    #         }
+    #         .dense-table td .v-input--selection-controls__ripple {
+    #             margin: 7px;
+    #             height: 25px !important;
+    #             width: 25px !important;
+    #         }
+    #         .dense-table td .v-icon.v-icon::after {
+    #             transform: scale(1.2) !important;
+    #         }
+    #         .dense-table td .v-input .v-messages {
+    #             display: none;
+    #             height: 0;
+    #         }
+    #         .dense-table td .v-text-field__details {
+    #             height: 2px !important;
+    #             min-height: 2px !important;
+    #         }
+    #         div .v-progress-linear {
+    #             left: -1px !important;
+    #         }
+
+    #         /* this should probably go somewhere else, these are
+    #          vars for anchorviz. */
+    #         :host {
+    #             --selectedAnchorColor: #FFF;
+    #         }
+    #     </style>
+    #     """
+
+
+class AnchorList(pn.viewable.Viewer):
     """A model's list tracking and managing a collection of anchors.
 
     This is what handles creating features for a dataset. This class is also a
@@ -221,6 +382,13 @@ class AnchorList(pn.viewable.Layoutable, pn.viewable.Viewer):
         e.g. ``anchors = [my_anchor, some_anchor]``, work as expected.
     """
 
+    # TODO: I don't love that this dictionary is exactly replicating the info of one item
+    # in possible_anchor_types, could potentially lead to desyncing issues if not handled carefully
+    default_example_anchor_type_dict = param.Dict({})
+
+    possible_anchor_types = param.List([])
+    # will need to be dictionaries, with each containing string name, class type ref, and color
+
     # TODO: coupling: model is used to retrieve model.data.active_data
     # NOTE: one way around this would be to have a "reference_data" property,
     # where the setter (which could be hooked up through a model event) re-
@@ -230,10 +398,17 @@ def __init__(
         model=None,
         table_width: int = 700,
         table_height: int = 150,
+        anchor_types: list[type | dict[str, any]] = None,
         **params,
     ):
         super().__init__(**params)  # required for panel components
 
+        if anchor_types is None:
+            anchor_types = [
+                DictionaryAnchor,
+                {"ref": TFIDFAnchor, "color": ANCHOR_COLOR_PALLETE[0][1]},
+            ]
+
         self.coverage_info = {}
         """Dictionary associating panel id of anchor with dictionary of 'coverage', 'pct_positive',
         and 'pct_negative' stats."""
@@ -244,6 +419,11 @@ def __init__(
             x_small=True,
             plain=True,
             children=[v.Icon(children=["mdi-expand-all"])],
+            visible=False,
+            style_="position: absolute; margin-top: 28px; margin-left: 10px;",
+            # jaaaaaaaaank, but it works and this way I don't have to re-implement the entire
+            # header row slot in the anchorlisttemplate, which would have to include the sorting
+            # actions and icons etc.
             v_on="tooltip.on",
         )
         self.expand_toggle.on_event("click", self._handle_ipv_expand_toggle_click)
@@ -261,45 +441,85 @@ def __init__(
             children=["Collapse/expand all."],
         )
 
-        button_stylesheet = """
-            button {
-                background-color: #1e88e5 !important;
-            }
-        """
+        self.table = AnchorListTemplate()
+        self.table.on_anchor_removal(self._handle_table_anchor_deleted)
 
-        # creating objects for adding new anchors to list
-        self.dictionary_button = pn.widgets.Button(
-            name="Add Dictionary Anchor",
-            stylesheets=[button_stylesheet],
+        # self.anchors_layout = pn.Column(
+        #     pn.Row(
+        #         self.expand_toggle_tooltip,
+        #         self.dictionary_button,
+        #         self.tfidf_button,
+        #         self.similarity_button,
+        #     ),
+        #     self.table,
+        #     height=table_height,
+        #     width=table_width,
+        # )
+        self.anchor_buttons = v.Row(
+            children=[
+                self.expand_toggle_tooltip,
+            ]
         )
-        self.dictionary_button.on_click(self._handle_pnl_new_dictionary_btn_clicked)
-        self.tfidf_button = pn.widgets.Button(
-            name="Add TF-IDF Anchor",
-            stylesheets=[button_stylesheet],
+        self.anchors_layout = v.Col(
+            children=[
+                self.anchor_buttons,
+                self.table,
+            ],
+            style_=f"padding-left: 0; padding-right: 0px; padding-bottom: 0px; width: {table_width}px;",
         )
-        self.tfidf_button.on_click(self._handle_pnl_new_tfidf_btn_clicked)
+        """The full component layout for panel to display."""
 
-        self.similarity_button = pn.widgets.Button(
-            name="Add Similarity Anchor",
-            stylesheets=[button_stylesheet],
+        self.anchor_types_layout = v.Col(style_=f"width: {table_width}px")
+
+        self.example_anchor_types_dropdown = v.Select(
+            label="Default example anchor type", items=[]
+        )
+        self.example_anchor_types_dropdown.on_event(
+            "change", self._handle_ipv_default_example_anchor_type_changed
         )
-        self.similarity_button.on_click(self._handle_pnl_new_similarity_btn_clicked)
 
-        self.table = AnchorListTemplate()
-        self.table.on_anchor_removal(self._handle_table_anchor_deleted)
+        self.anchor_settings_layout = v.Col(
+            children=[self.example_anchor_types_dropdown],
+            style_=f"width: {table_width}px",
+        )
 
+        self.tabs_component = v.Tabs(
+            v_model=0,
+            height=35,
+            background_color="primary",
+            width=table_width,
+            children=[
+                v.Tab(children=["Anchors"]),
+                v.Tab(children=["Anchor Types"]),
+                v.Tab(children=["Settings"]),
+            ],
+        )
+        self.tabs_items_component = v.TabsItems(
+            v_model=0,
+            width=table_width,
+            children=[
+                v.TabItem(children=[self.anchors_layout]),
+                v.TabItem(children=[self.anchor_types_layout]),
+                v.TabItem(children=[self.anchor_settings_layout]),
+            ],
+        )
+        ipw.jslink(
+            (self.tabs_component, "v_model"), (self.tabs_items_component, "v_model")
+        )
+
+        self.layout_stack = v.Container(
+            children=[self.tabs_component, self.tabs_items_component],
+            width=table_width,
+            style_="padding: 0px;",
+        )
         self.layout = pn.Column(
-            pn.Row(
-                self.expand_toggle_tooltip,
-                self.dictionary_button,
-                self.tfidf_button,
-                self.similarity_button,
-            ),
-            self.table,
-            height=table_height,
+            self.layout_stack,
             width=table_width,
+            styles={"padding": "0px"},
+        )
+        self.widget = v.Container(
+            children=[self.layout_stack], width=table_width, style_="padding: 0px;"
         )
-        """The full component layout for panel to display."""
 
         self.cache: dict[str, any] = {}
         """This cache gets pickled on save, useful for anchors to store results of
@@ -315,6 +535,10 @@ def __init__(
         self._anchor_changed_callbacks: list[Callable] = []
         self._anchor_added_callbacks: list[Callable] = []
         self._anchor_removed_callbacks: list[Callable] = []
+        self._anchor_types_changed_callbacks: list[Callable] = []
+        self._default_example_anchor_type_changed_callbacks: list[Callable] = []
+
+        self.add_anchor_types(anchor_types)
 
     # ============================================================
     # EVENT HANDLERS
@@ -325,20 +549,6 @@ def _handle_table_anchor_deleted(self, name: str):
         anchor = self.get_anchor_by_panel_id(name)
         self.remove_anchor(anchor)
 
-    def _handle_pnl_new_dictionary_btn_clicked(self, event):
-        # TODO: since the renaming logic will be basically the same, we should probably
-        # move that to the add_anchor logic instead.
-        name = self.get_unique_anchor_name()
-        self.add_anchor(DictionaryAnchor(anchor_name=name))
-
-    def _handle_pnl_new_tfidf_btn_clicked(self, event):
-        name = self.get_unique_anchor_name()
-        self.add_anchor(TFIDFAnchor(anchor_name=name))
-
-    def _handle_pnl_new_similarity_btn_clicked(self, event):
-        name = self.get_unique_anchor_name()
-        self.add_anchor(SimilarityFunctionAnchor(anchor_name=name))
-
     def _handle_ipv_expand_toggle_click(self, widget, event, data):
         # if any are expanded, set expanded to blank list
         if len(self.table.expanded) > 0:
@@ -346,6 +556,80 @@ def _handle_ipv_expand_toggle_click(self, widget, event, data):
         else:
             self.table.expanded = [{"name": item["name"]} for item in self.table.items]
 
+    def _handle_ipv_new_anchor_generic_click(self, widget, event, data, type_ref):
+        # must be assigned with partial and assigning type_ref
+        name = self.get_unique_anchor_name()
+        self.add_anchor(type_ref(anchor_name=name))
+
+    def _handle_ipv_new_anchor_type_add_click(
+        self, widget, event, data, type_ref, text_field_ref: v.TextField
+    ):
+        # must be assigned with partial and assigning type_ref and text_field_ref
+        self.add_anchor_type(type_ref, name=text_field_ref.v_model)
+
+    def _handle_ipv_rm_anchor_type_btn_click(self, widget, event, data, type_ref: type):
+        # must be assigned with partial assigning type_ref
+        self.remove_anchor_type(type_ref)
+
+    def _handle_ipv_color_picker_input(self, widget, event, data, anchor_type: type):
+        # NOTE: need to set this up with a partial that specifies the anchor_type
+        self.modify_anchor_type(anchor_type, "color", data)
+
+    def _handle_ipv_anchor_type_name_changed(
+        self, widget, event, data, anchor_type: type
+    ):
+        # NOTE: need to set this up with a partial that specifies the anchor_type
+        self.modify_anchor_type(anchor_type, "name", widget.v_model)
+
+    @param.depends("possible_anchor_types", watch=True)
+    def _handle_pnl_possible_anchor_types_changed(self):
+        new_anchor_buttons = []
+        for anchor_type_dict in self.possible_anchor_types:
+            new_button = v.Btn(
+                children=[anchor_type_dict["name"]],
+                small=True,
+                color=anchor_type_dict["color"],
+                style_="margin-left: 2px; margin-right: 2px",
+                v_on="tooltip.on",
+            )
+            new_button.on_event(
+                "click",
+                partial(
+                    self._handle_ipv_new_anchor_generic_click,
+                    type_ref=anchor_type_dict["ref"],
+                ),
+            )
+
+            button_tooltip = v.Tooltip(
+                bottom=True,
+                open_delay=500,
+                max_width=400,
+                v_slots=[
+                    {
+                        "name": "activator",
+                        "variable": "tooltip",
+                        "children": new_button,
+                    }
+                ],
+                children=[anchor_type_dict["ref"].DESCRIPTION],
+            )
+
+            new_anchor_buttons.append(button_tooltip)
+        self.anchor_buttons.children = [
+            self.expand_toggle_tooltip,
+            v.Html(
+                tag="p",
+                children=["New:"],
+                style_="margin-bottom: 0px; margin-left: 18px; margin-top: 4px; margin-right: 3px;",
+            ),
+            *new_anchor_buttons,
+        ]
+        self.refresh_anchors_table()
+
+    def _handle_ipv_default_example_anchor_type_changed(self, widget, event, data):
+        self.default_example_anchor_type_dict = self.possible_anchor_types[data]
+        self.fire_on_default_example_anchor_type_changed()
+
     # ============================================================
     # EVENT SPAWNERS
     # ============================================================
@@ -376,6 +660,24 @@ def on_anchor_removed(self, callback: Callable):
         """
         self._anchor_removed_callbacks.append(callback)
 
+    def on_anchor_types_changed(self, callback: Callable):
+        """Register a callback functino for the "anchor types changed" event.
+
+        Callbacks for this event should take the list of dictionaries of type information,
+        expect each dictionary to contain "name", "ref", and "color".
+        """
+        self._anchor_types_changed_callbacks.append(callback)
+
+    def on_default_example_anchor_type_changed(self, callback: Callable):
+        """Register a callback function for the "default example anchor changed
+        event.
+
+        Callbacks for this event should take the anchor type config dictionary, which
+        contains "name", "ref", and "color".
+        """
+        self._default_example_anchor_type_changed_callbacks.append(callback)
+        pass
+
     def fire_on_anchor_added(self, anchor: Anchor):
         """Trigger the event to notify that a new anchor was added.
 
@@ -409,6 +711,17 @@ def fire_on_anchor_changed(self, name: str, key: str, value):
         for callback in self._anchor_changed_callbacks:
             callback(name, key, value)
 
+    def fire_on_anchor_types_changed(self):
+        """Trigger the event to notify that the anchor types have been changed."""
+        for callback in self._anchor_types_changed_callbacks:
+            callback(self.possible_anchor_types)
+
+    def fire_on_default_example_anchor_type_changed(self):
+        """Trigger the event to notify that the default anchor type used for 'example'
+        instances is changed."""
+        for callback in self._default_example_anchor_type_changed_callbacks:
+            callback(self.default_example_anchor_type_dict)
+
     # ============================================================
     # INTERNAL FUNCTIONS
     # ============================================================
@@ -501,10 +814,292 @@ def _combo_col_row_normalize(
 
         return feature_vals
 
+    def _populate_anchor_types_col(self):
+        children = []
+        # for anchor_type in Anchor.anchor_types():
+        for anchor_type_dict in self.possible_anchor_types:
+            color_picker = v.ColorPicker(
+                hide_inputs=True,
+                v_model=anchor_type_dict["color"],
+                hide_canvas=True,
+                hideSliders=True,
+                hide_mode_switch=True,
+                hide_sliders=True,
+                disabled=True,
+                show_swatches=True,
+                swatches=ANCHOR_COLOR_PALLETE,
+                width=250,
+            )
+            color_picker.on_event(
+                "input",
+                partial(
+                    self._handle_ipv_color_picker_input,
+                    anchor_type=anchor_type_dict["ref"],
+                ),
+            )
+
+            rm_btn = v.Btn(
+                small=True,
+                icon=True,
+                v_on="tooltip.on",
+                children=[v.Icon(children=["close"])],
+                style_="margin-top: 32px;",
+            )
+            rm_btn.on_event(
+                "click",
+                partial(
+                    self._handle_ipv_rm_anchor_type_btn_click,
+                    type_ref=anchor_type_dict["ref"],
+                ),
+            )
+            rm_btn_tooltip = v.Tooltip(
+                bottom=True,
+                open_delay=500,
+                max_width=400,
+                v_slots=[
+                    {
+                        "name": "activator",
+                        "variable": "tooltip",
+                        "children": rm_btn,
+                    }
+                ],
+                children=[
+                    "Remove this anchor type (will remove all current anchors of this type.)"
+                ],
+            )
+
+            anchor_type_name = v.TextField(v_model=anchor_type_dict["name"], width=100)
+            anchor_type_name.on_event(
+                "change",
+                partial(
+                    self._handle_ipv_anchor_type_name_changed,
+                    anchor_type=anchor_type_dict["ref"],
+                ),
+            )
+            anchor_type_name.on_event(
+                "blur",
+                partial(
+                    self._handle_ipv_anchor_type_name_changed,
+                    anchor_type=anchor_type_dict["ref"],
+                ),
+            )
+
+            children.append(
+                v.Row(
+                    children=[
+                        v.Col(
+                            children=[
+                                anchor_type_name,
+                                v.Html(
+                                    tag="p",
+                                    style_="color: grey; margin-top: -18px; margin-bottom: 2px;",
+                                    children=[
+                                        v.Html(
+                                            tag="small",
+                                            children=[f"({anchor_type_dict['ref']})"],
+                                        )
+                                    ],
+                                ),
+                                v.Html(
+                                    tag="p",
+                                    children=[f"{anchor_type_dict['ref'].DESCRIPTION}"],
+                                ),
+                            ]
+                        ),
+                        rm_btn_tooltip,
+                        v.Spacer(),
+                        color_picker,
+                    ]
+                )
+            )
+
+        refresh_btn = v.Btn(
+            children=["Refresh unused anchor types"], style_="margin-left: 10px;"
+        )
+        refresh_btn.on_event("click", lambda w, e, d: self.refresh_anchor_types())
+        children.append(v.Row(children=[refresh_btn]))
+
+        for anchor_type in Anchor.anchor_types():
+            # check if we've already added it
+            found = False
+            for anchor_type_dict in self.possible_anchor_types:
+                if anchor_type_dict["ref"] == anchor_type:
+                    found = True
+                    break
+            if not found and anchor_type.__qualname__ not in [
+                "Anchor",
+                "SimilarityAnchorBase",
+            ]:
+                if anchor_type.NAME != "":
+                    default_name = anchor_type.NAME
+                else:
+                    default_name = anchor_type.__qualname__
+                new_anchor_type_name_text = v.TextField(v_model=default_name, width=100)
+                add_btn = v.Btn(
+                    children=["add"],
+                    style_="margin-top: 20px; margin-right: 20px;",
+                )
+                add_btn.on_event(
+                    "click",
+                    partial(
+                        self._handle_ipv_new_anchor_type_add_click,
+                        type_ref=anchor_type,
+                        text_field_ref=new_anchor_type_name_text,
+                    ),
+                )
+
+                children.append(
+                    v.Row(
+                        children=[
+                            v.Col(
+                                children=[
+                                    new_anchor_type_name_text,
+                                    v.Html(
+                                        tag="p",
+                                        style_="color: grey; margin-top: -18px; margin-bottom: 2px;",
+                                        children=[
+                                            v.Html(
+                                                tag="small",
+                                                children=[f"({str(anchor_type)})"],
+                                            )
+                                        ],
+                                    ),
+                                    v.Html(
+                                        tag="p",
+                                        children=[f"{anchor_type.DESCRIPTION}"],
+                                    ),
+                                ]
+                            ),
+                            add_btn,
+                        ]
+                    )
+                )
+
+        self.anchor_types_layout.children = children
+
+    def _populate_example_anchor_types_dropdown(self):
+        items = []
+        for i, anchor_type_dict in enumerate(self.possible_anchor_types):
+            if isinstance(anchor_type_dict["ref"](), SimilarityAnchorBase):
+                items.append(dict(text=anchor_type_dict["name"], value=i))
+        self.example_anchor_types_dropdown.items = items
+
     # ============================================================
     # PUBLIC FUNCTIONS
     # ============================================================
 
+    def refresh_anchor_types(self):
+        """Re-populate lists of anchor types in the interface."""
+        self._populate_anchor_types_col()
+        self._populate_example_anchor_types_dropdown()
+
+    def add_anchor_types(self, anchor_types: list[type | dict[str, any]]):
+        for anchor_type in anchor_types:
+            if isinstance(anchor_type, type):
+                self.add_anchor_type(anchor_type)
+            if isinstance(anchor_type, dict):
+                ref = anchor_type.pop("ref")
+                self.add_anchor_type(ref, **anchor_type)
+
+    def add_anchor_type(
+        self, anchor_type: type, name: str = None, color: str = "#777777"
+    ):
+        if name is not None:
+            # if the user specified a specific name, use that.
+            anchor_type_name = name
+        elif anchor_type.NAME != "":
+            # otherwise, if there's a static name specified in the class, use _that_.
+            anchor_type_name = anchor_type.NAME
+        else:
+            # otherwise directly use the class name
+            anchor_type_name = anchor_type.__qualname__
+
+        new_anchor_type_dict = {
+            "name": anchor_type_name,
+            "ref": anchor_type,
+            "color": color,
+        }
+        self.possible_anchor_types = [
+            *self.possible_anchor_types,
+            new_anchor_type_dict,
+        ]
+        self.refresh_anchor_types()
+
+        # assign anchor type to the default example anchor type if we don't already have one, and
+        # this new anchor meets the criteria (subclasses similarity base)
+        if "ref" not in self.default_example_anchor_type_dict:
+            if isinstance(anchor_type(), SimilarityAnchorBase):
+                self.example_anchor_types_dropdown.v_model = (
+                    self.possible_anchor_types.index(new_anchor_type_dict)
+                )
+                self.default_example_anchor_type_dict = new_anchor_type_dict
+                self.fire_on_default_example_anchor_type_changed()
+
+    def modify_anchor_type(self, anchor_type: type, key: str, val: str):
+        prev_anchors = []
+        updated_anchor = None
+        next_anchors = []
+
+        for anchor_type_dict in self.possible_anchor_types:
+            if anchor_type_dict["ref"] == anchor_type:
+                anchor_type_dict[key] = val
+                updated_anchor = anchor_type_dict
+            elif updated_anchor is None:
+                prev_anchors.append(anchor_type_dict)
+            else:
+                next_anchors.append(anchor_type_dict)
+
+        if updated_anchor is None:
+            # TODO: error, wasn't found
+            pass
+
+        self.possible_anchor_types = [*prev_anchors, updated_anchor, *next_anchors]
+        self.fire_on_anchor_types_changed()
+
+        # check if it was the default example anchor and if we need to modify its dictinoary too
+        if (
+            "ref" in self.default_example_anchor_type_dict
+            and self.default_example_anchor_type_dict["ref"] == anchor_type
+        ):
+            self.default_example_anchor_type_dict[key] = val
+            self.fire_on_default_example_anchor_type_changed()
+
+        self.refresh_anchor_types()
+
+    def remove_anchor_type(self, anchor_type: type):
+        """Removes this anchor type from the current possible anchor types list, and
+        removes any corresponding anchors."""
+        anchors_to_remove = [a for a in self.anchors if type(a) == anchor_type]
+        for anchor in anchors_to_remove:
+            # NOTE: yes use ==, need strict check, not including inheritance.
+            if type(anchor) == anchor_type:
+                self.remove_anchor(anchor)
+
+        remaining_anchor_types = []
+        for anchor_type_dict in self.possible_anchor_types:
+            if anchor_type_dict["ref"] != anchor_type:
+                remaining_anchor_types.append(anchor_type_dict)
+        self.possible_anchor_types = remaining_anchor_types
+        self.fire_on_anchor_types_changed()
+
+        # make sure to unset default exaxmple anchor type if it was this one.
+        # TODO: at some point it would be helpful if when this occurs, we automatically
+        # search through remaining anchor types and auto re-assign. Not MVP right now.
+        if (
+            "ref" in self.default_example_anchor_type_dict
+            and self.default_example_anchor_type_dict["ref"] == anchor_type
+        ):
+            self.default_example_anchor_type_dict = {}
+            self.fire_on_default_example_anchor_type_changed()
+
+        self.refresh_anchor_types()
+
+    def get_anchor_type_config(self, anchor_type: type):
+        for anchor_type_dict in self.possible_anchor_types:
+            if anchor_type_dict["ref"] == anchor_type:
+                return anchor_type_dict
+        return None
+
     def get_unique_anchor_name(self) -> str:
         """Returns a name for a new anchor that won't conflict with any existing."""
         name = "New Anchor"
@@ -522,6 +1117,17 @@ def refresh_anchors_table(self):
         """Re-populate the list of anchors and coverage stats. This function is
         called automatically anytime the anchors property changes.
         """
+
+        # show or hide the collapse/expand anchors button based on whether there's
+        # any anchors or not (otherwise header will cover the button)
+        if len(self.anchors) == 0:
+            if "visibility" not in self.expand_toggle.style_:
+                self.expand_toggle.style_ += "visibility: hidden;"
+        else:
+            self.expand_toggle.style_ = self.expand_toggle.style_.removesuffix(
+                "visibility: hidden;"
+            )
+
         items = []
         for anchor in self.anchors:
             coverage = ""
@@ -533,6 +1139,7 @@ def refresh_anchors_table(self):
                 pct_positive = self.coverage_info[anchor.name]["pos_text"]
 
             item = dict(
+                color=self.get_anchor_type_config(type(anchor))["color"],
                 name=anchor.name,
                 anchor_name=anchor._anchor_name_input,
                 coverage=coverage,
@@ -726,6 +1333,17 @@ def save(self, path: str):
 
         os.makedirs(f"{path}/anchors", exist_ok=True)
 
+        # save the pickled list of anchor types
+        with open(f"{path}/anchorlist_anchortypes.pkl", "wb") as outfile:
+            pickle.dump(self.possible_anchor_types, outfile)
+
+        # save the current settings
+        with open(f"{path}/anchorlist_settings.json", "w") as outfile:
+            settings = dict(
+                example_anchor_type_index=self.example_anchor_types_dropdown.v_model
+            )
+            json.dump(settings, outfile)
+
         # save each individual anchor and collect its information
         for anchor in self.anchors:
             name = anchor.anchor_name
@@ -750,15 +1368,32 @@ def save(self, path: str):
             pickle.dump(self.cache, outfile)
 
         # save the anchor information
-        with open(f"{path}/anchorlist.json", "w") as outfile:
+        with open(f"{path}/anchorlist_anchors.json", "w") as outfile:
             json.dump(anchors_info, outfile, indent=4)
 
     def load(self, path: str):
         """Reload parameters for and re-add all anchors from specified location, as
         well as unpickle any previously saved cache.
         """
+
+        # load anchor types
+        with open(f"{path}/anchorlist_anchortypes.pkl", "rb") as infile:
+            anchor_types = pickle.load(infile)
+            self.add_anchor_types(anchor_types)
+
+        # load anchor settings
+        with open(f"{path}/anchorlist_settings.json") as infile:
+            settings = json.load(infile)
+            self.example_anchor_types_dropdown.v_model = settings[
+                "example_anchor_type_index"
+            ]
+            self.default_example_anchor_type_dict = self.possible_anchor_types[
+                settings["example_anchor_type_index"]
+            ]
+            self.fire_on_default_example_anchor_type_changed()
+
         # load the anchor information
-        with open(f"{path}/anchorlist.json") as infile:
+        with open(f"{path}/anchorlist_anchors.json") as infile:
             anchors_info = json.load(infile)
 
         # load the cache
diff --git a/icat/anchors.py b/icat/anchors.py
index 94f84e4..982de4b 100644
--- a/icat/anchors.py
+++ b/icat/anchors.py
@@ -9,6 +9,7 @@
 # NOTE: "container" refers to the containing anchorlist instance
 
 import json
+import pickle
 from collections.abc import Callable
 
 import ipyvuetify as v
@@ -40,6 +41,9 @@ class Anchor(param.Parameterized):
         in_model (bool): Whether to include this feature in the training process.
     """
 
+    DESCRIPTION: str = ""
+    NAME: str = ""
+
     anchor_name = param.String(default="New Anchor")
     """Not to be confused with just ``name``, which is the panel component id."""
     weight = param.Number(1.0, bounds=(0.0, 5.0))
@@ -53,12 +57,28 @@ class Anchor(param.Parameterized):
     in the featurization call and will update locations inside anchorviz, it simply
     won't be passed to the model.)"""
 
+    @property
+    def global_cache(self) -> dict[str, any]:
+        """An anchor list level cache, (dictionary of key-value pairs) any keys set
+        here are accessible by all other anchors.
+
+        This is useful to use if a particular anchor type has computation heavy steps
+        that should only need to run once, e.g. if a transformer needs to pre-compute
+        the embeddings of all points in the dataset (and every anchor using that
+        transformer should have access to the same embeddings.)
+        """
+        return self.container.cache
+
     def __init__(self, container=None, **params):
         self.container = container
         # self.processing = True
         # self.event_to_trigger = None
         super().__init__(**params)
 
+        self.cache: dict[str, any] = {}
+        """A dictionary of key-value pairs specific to this one anchor instance that
+        gets saved when ``save()`` is called (by default)."""
+
         self._anchor_name_input = v.TextField(
             dense=True, label="Anchor Name", v_model=self.anchor_name, single_line=True
         )
@@ -117,6 +137,9 @@ def _handle_pnl_name_changed(self):
 
     @param.depends("weight", watch=True)
     def _handle_pnl_weight_changed(self):
+        """Panel event handler for when the weight changes. This is goes in the
+        _other_ direction from the ipv_weight_input_changed above, making sure
+        the ipyvuetify widget is synced with the param."""
         self._weight_input.v_model = self.weight
         self.fire_on_anchor_changed("weight", self.weight)
 
@@ -160,6 +183,20 @@ def featurize(self, data: pd.DataFrame) -> pd.Series:
         """
         raise NotImplementedError()
 
+    @staticmethod
+    def anchor_types():
+        """Get a list of references to all defined Anchor subclasses (directly and indirectly.)"""
+        # https://stackoverflow.com/questions/5881873/python-find-all-classes-which-inherit-from-this-one
+        subclasses = []
+        to_process = [Anchor]
+        while to_process:
+            parent_class = to_process.pop()
+            for child_class in parent_class.__subclasses__():
+                if child_class not in subclasses:
+                    subclasses.append(child_class)
+                    to_process.append(child_class)
+        return subclasses
+
     def row_view(self) -> pn.Row:
         return pn.Row(self.param)
 
@@ -173,35 +210,20 @@ def to_dict(self) -> dict[str, any]:
             in_model=self.in_model,
         )
 
-    # def save(self, path: str):
-    #     """Save the information for this anchor at the specified path, such that calling
-    #     load() with the same path will return all values as they were.
-
-    #     Note:
-    #         Expected to be overriden in subclasses. It's recommended that you implement
-    #         a ``to_dict`` function that updates a dictionary from the parent anchor's
-    #         ``to_dict`` function to get all relevant information.
-    #     """
-    #     raise NotImplementedError()
-
-    # def load(self, path: str):
-    #     """Load an anchor's parameters from the specified path.
-
-    #     Note:
-    #         Expected to be overriden in subclasses.
-    #     """
-    #     raise NotImplementedError()
-
     def save(self, path: str):
         """Save anchor to specified path."""
         with open(f"{path}.json", "w") as outfile:
             json.dump(self.to_dict(), outfile, indent=4)
+        with open(f"{path}_cache.pkl", "wb") as outfile:
+            pickle.dump(self.cache, outfile)
 
     def load(self, path: str):
         """Load anchor from specified path."""
         with open(f"{path}.json") as infile:
             params = json.load(infile)
         icat.utils.populate_anchor_from_dictionary(self, params)
+        with open(f"{path}_cache.pkl", "rb") as infile:
+            self.cache = pickle.load(infile)
 
 
 class DictionaryAnchor(Anchor):
@@ -221,6 +243,9 @@ class DictionaryAnchor(Anchor):
             my_model.add_anchor(my_keywords_anchor)
     """
 
+    DESCRIPTION = "Bag of Words (feature is count of specified keyword occurrences.)"
+    NAME = "Dictionary"
+
     keywords_str = param.String(label="Keywords")
     """The direct 'backend model' for what's in the keywords text field. This is really
     only needed for internal use, any programmatic manipulation of the anchor's keywords
@@ -396,7 +421,7 @@ def __init__(self, container=None, *args, **kwargs):
                         ),
                         v.Col(
                             dense=True,
-                            style_="padding: 0",
+                            style_="padding: 0; margin-left: 5px;",
                             class_="col-2",
                             children=[self._add_button],
                         ),
@@ -508,6 +533,9 @@ def to_dict(self) -> dict[str, any]:
 
 
 class TFIDFAnchor(SimilarityAnchorBase):
+    DESCRIPTION = "Uses cosine similarity between TF-IDF vectors of data and target text as the feature value."
+    NAME = "TF-IDF"
+
     def __init__(self, container=None, *args, **kwargs):
         super().__init__(container, *args, **kwargs)
 
@@ -566,54 +594,54 @@ def featurize(self, data: pd.DataFrame) -> pd.Series:
 
 
 # TODO: probably instead of this extending TF-IDFAnchor, we should have them extend from same root?
-class SimilarityFunctionAnchor(SimilarityAnchorBase):
-    similarity_function = param.String("")
-
-    # TODO: need a dropdown for the possible similarity functions
-    def __init__(self, container=None, *args, **kwargs):
-        super().__init__(container, *args, **kwargs)
-
-        self.sim_function_options = v.Select(label="Similarity function", items=[{}])
-        self.sim_function_options.on_event(
-            "change", self._handle_ipv_sim_function_change
-        )
-
-        self.widget.children = [
-            *self.widget.children,
-            v.Row(
-                dense=True,
-                children=[self.sim_function_options],
-            ),
-        ]
-        self._populate_items()
-
-    # TODO: need dropdown event handlers to modify similarity_function
-
-    def _handle_ipv_sim_function_change(self, widget, event, data):
-        self.similarity_function = data
-        self.fire_on_anchor_changed("similarity_function", data)
-
-    def _populate_items(self):
-        items = []
-        if self.container is not None and self.container.model is not None:
-            items = list(self.container.model.similarity_functions.keys())
-        self.sim_function_options.items = items
-
-    def featurize(self, data: pd.DataFrame) -> pd.Series:
-        if len(self.reference_texts) == 0:
-            return pd.Series(0, index=data.index)
-
-        if self.similarity_function == "":
-            return pd.Series(0, index=data.index)
-
-        model_fn = self.container.model.similarity_functions[self.similarity_function]
-        # results = model_fn(data, self.container, self.reference_texts[0], self.text_col)
-        results = model_fn(data, self)
-        return results
-
-    def to_dict(self) -> dict[str, any]:
-        """Get a dictionary of all relevant parameters that define this anchor."""
-        params = super().to_dict()
-        self_params = dict(similarity_function=self.similarity_function)
-        params.update(self_params)
-        return params
+# class SimilarityFunctionAnchor(SimilarityAnchorBase):
+#     similarity_function = param.String("")
+
+#     # TODO: need a dropdown for the possible similarity functions
+#     def __init__(self, container=None, *args, **kwargs):
+#         super().__init__(container, *args, **kwargs)
+
+#         self.sim_function_options = v.Select(label="Similarity function", items=[{}])
+#         self.sim_function_options.on_event(
+#             "change", self._handle_ipv_sim_function_change
+#         )
+
+#         self.widget.children = [
+#             *self.widget.children,
+#             v.Row(
+#                 dense=True,
+#                 children=[self.sim_function_options],
+#             ),
+#         ]
+#         self._populate_items()
+
+#     # TODO: need dropdown event handlers to modify similarity_function
+
+#     def _handle_ipv_sim_function_change(self, widget, event, data):
+#         self.similarity_function = data
+#         self.fire_on_anchor_changed("similarity_function", data)
+
+#     def _populate_items(self):
+#         items = []
+#         if self.container is not None and self.container.model is not None:
+#             items = list(self.container.model.similarity_functions.keys())
+#         self.sim_function_options.items = items
+
+#     def featurize(self, data: pd.DataFrame) -> pd.Series:
+#         if len(self.reference_texts) == 0:
+#             return pd.Series(0, index=data.index)
+
+#         if self.similarity_function == "":
+#             return pd.Series(0, index=data.index)
+
+#         model_fn = self.container.model.similarity_functions[self.similarity_function]
+#         # results = model_fn(data, self.container, self.reference_texts[0], self.text_col)
+#         results = model_fn(data, self)
+#         return results
+
+#     def to_dict(self) -> dict[str, any]:
+#         """Get a dictionary of all relevant parameters that define this anchor."""
+#         params = super().to_dict()
+#         self_params = dict(similarity_function=self.similarity_function)
+#         params.update(self_params)
+#         return params
diff --git a/icat/data.py b/icat/data.py
index 09b97b3..064d782 100644
--- a/icat/data.py
+++ b/icat/data.py
@@ -17,7 +17,7 @@
 import param
 
 import icat
-from icat.anchors import DictionaryAnchor, TFIDFAnchor
+from icat.anchors import DictionaryAnchor
 from icat.item import ItemViewer
 from icat.table import TableContentsTemplate
 from icat.utils import _kill_param_auto_docstring, add_highlights
@@ -154,6 +154,17 @@ def __init__(
         self.table.on_add_example(self._handle_example_added)
         self.table.on_add_to_sample(self._handle_sample_added)
 
+        if self.model is not None:
+            self.model.anchor_list.on_default_example_anchor_type_changed(
+                self._handle_default_example_anchor_type_changed
+            )
+            # in case the anchor list has already been initialized with anchor types,
+            # make sure to grab the existing anchor type as needed.
+            if "ref" in self.model.anchor_list.default_example_anchor_type_dict:
+                self._handle_default_example_anchor_type_changed(
+                    self.model.anchor_list.default_example_anchor_type_dict
+                )
+
         self.filtered_df = None
 
         self.label_all_i_btn = v.Btn(
@@ -220,14 +231,14 @@ def __init__(
                 ),
             ],
             height=height,
-            width=width,
+            style_=f"width: {width}px",
         )
 
         self.tabs_component = v.Tabs(
             v_model=0,
             height=35,
             background_color="primary",
-            width=width,
+            style_=f"width: {width}px",
             children=[
                 v.Tab(children=["Data"]),
                 v.Tab(children=["Item"]),
@@ -236,7 +247,7 @@ def __init__(
         )
         self.tabs_items_component = v.TabsItems(
             v_model=0,
-            width=width,
+            style_=f"width: {width}px",
             children=[
                 v.TabItem(children=[data_layout_stack]),
                 v.TabItem(children=[self.item_viewer.widget]),
@@ -249,13 +260,15 @@ def __init__(
 
         layout_stack = v.Container(
             children=[self.tabs_component, self.tabs_items_component],
-            style_="padding: 0px;",
+            style_=f"padding: 0px; width: {width}px",
         )
         self.layout = pn.Column(
             layout_stack, height=height, width=width, styles={"padding": "0px"}
         )
         self.widget = v.Container(
-            children=[layout_stack], height=height, width=width, style_="padding: 0px;"
+            children=[layout_stack],
+            height=height,
+            style_=f"padding: 0px; width: {width}px",
         )
 
         self._data_label_callbacks: list[Callable] = []
@@ -285,7 +298,7 @@ def _handle_ipv_search_add_new_btn_click(self, widget, event, data):
 
     def _handle_ipv_search_add_sel_btn_click(self, widget, event, data):
         """Event handler for when the add search box text to new anchor button is clicked."""
-        if self.search_value != "":
+        if self.search_value != "" and self.model is not None:
             anchor = self.model.anchor_list.get_anchor_by_panel_id(
                 self.model.view.anchorviz.selectedAnchorID
             )
@@ -346,9 +359,10 @@ def _handle_row_selected(self, point_id):
     def _handle_example_added(self, point_id):
         """Event handler for when the 'example' button is clicked."""
         if self.model is not None:
-            new_anchor = TFIDFAnchor(
+            new_anchor = self.model.anchor_list.default_example_anchor_type_dict["ref"](
                 text_col=self.text_col, container=self.model.anchor_list
             )
+
             # TODO: an example of where it would be cleaner to just be able to pass in ID's
             # directly on init
             new_anchor.reference_texts = [self.active_data.loc[point_id, self.text_col]]
@@ -371,6 +385,18 @@ def _handle_label_changed(self, index: int | list[int], new_label: int | list[in
         self.fire_on_data_labeled(index, new_label)
         self._apply_filters()  # ....this doesn't feel good, but some filters depend on labeling?
 
+    def _handle_default_example_anchor_type_changed(
+        self, anchor_type_dict: dict[str, any]
+    ):
+        if "name" in anchor_type_dict:
+            self.table.example_btn_color = anchor_type_dict["color"]
+            self.table.example_type_name = anchor_type_dict["name"]
+        else:
+            # if we get here, a blank dictionary was likely passed, which means the example
+            # anchor type was removed.
+            self.table.example_btn_color = ""
+            self.table.example_type_name = "similarity"
+
     # ============================================================
     # EVENT SPAWNERS
     # ============================================================
diff --git a/icat/model.py b/icat/model.py
index a49d735..6afe96c 100644
--- a/icat/model.py
+++ b/icat/model.py
@@ -5,7 +5,6 @@
 
 import json
 import os
-from collections.abc import Callable
 from datetime import datetime
 
 import joblib
@@ -15,7 +14,7 @@
 
 import icat
 from icat.anchorlist import AnchorList
-from icat.anchors import Anchor, DictionaryAnchor, SimilarityFunctionAnchor, TFIDFAnchor
+from icat.anchors import Anchor, DictionaryAnchor, TFIDFAnchor
 from icat.data import DataManager
 from icat.utils import _kill_param_auto_docstring
 from icat.view import InteractiveView
@@ -30,11 +29,6 @@ class Model:
     Args:
         data (pd.DataFrame): The data to explore with.
         text_col (str): The name of the text column in the passed data.
-        similarity_functions (list[Callable]): A set of additional functions that can
-            be used for similarity-based features. Any function passed should take a
-            dataframe (representing all of the currently active data,) and an anchor
-            instance. It should return a pandas series with the output similarity values,
-            using the same index as that in the passed dataframe.
         default_sample_size (int): The initial number of points to sample for the
             visualizations.
     """
@@ -43,9 +37,18 @@ def __init__(
         self,
         data: pd.DataFrame,
         text_col: str,
-        similarity_functions: list[Callable] = [],
+        anchor_types: list[type | dict[str, any]] = None,
         default_sample_size: int = 100,
     ):
+        if anchor_types is None:
+            anchor_types = [
+                DictionaryAnchor,
+                {
+                    "ref": TFIDFAnchor,
+                    "color": icat.anchorlist.ANCHOR_COLOR_PALLETE[0][1],
+                },
+            ]
+
         self.training_data: pd.DataFrame = None
         """The rows (and only those rows) of the original data explicitly used for training."""
         self.text_col = text_col
@@ -54,7 +57,7 @@ def __init__(
             class_weight="balanced"
         )
 
-        self.anchor_list: AnchorList = AnchorList(model=self)
+        self.anchor_list: AnchorList = AnchorList(model=self, anchor_types=anchor_types)
         self.data: DataManager = DataManager(
             data=data,
             text_col=text_col,
@@ -74,11 +77,6 @@ def __init__(
         """Keep track of anchor names so when the name of one updates we can
         remove the previous column name. The key is the panel id."""
 
-        # self.similarity_functions = similarity_functions
-        self.similarity_functions: dict[str, Callable] = {
-            str(func.__name__): func for func in similarity_functions
-        }
-
         self.anchor_list.build_tfidf_features()
 
     def _on_data_label(self, index: int | list[int], new_label: int | list[int]):
@@ -161,15 +159,9 @@ def _on_anchor_remove(self, anchor: Anchor):
     def _on_anchor_add(self, anchor: Anchor):
         """Event handler for anchorlist."""
         # TODO: it's possible this should be handled inside the anchorlist?
-        if (
-            type(anchor) == DictionaryAnchor
-            or type(anchor) == TFIDFAnchor
-            or type(anchor) == SimilarityFunctionAnchor
-        ) and anchor.text_col == "":
+        if hasattr(anchor, "text_col") and anchor.text_col == "":
             anchor.text_col = self.text_col
             self.anchor_list.anchors[-1].text_col = self.text_col
-        if type(anchor) == SimilarityFunctionAnchor:
-            anchor._populate_items()
         self.fit()
         self.view.refresh_data()
 
@@ -414,10 +406,9 @@ def save(self, path: str):
         # save any relevant model metadata
         model_information = {
             "icat_version": icat.__version__,
-            "timestamp": datetime.strftime(datetime.now(), "%d/%m/%y %H:%M:%S"),
+            "timestamp": datetime.strftime(datetime.now(), "%m/%d/%y %H:%M:%S"),
             "text_col": self.text_col,
             "sample_size": self.data.sample_size_txt.v_model,
-            "similarity_function_keys": list(self.similarity_functions.keys()),
         }
         with open(f"{path}/model_info.json", "w") as outfile:
             json.dump(model_information, outfile)
@@ -437,39 +428,54 @@ def save(self, path: str):
         # save the classifier
         joblib.dump(self.classifier, f"{path}/classifier.joblib")
 
-    def load(self, path: str):
-        """Reload into this model all of the data and anchors from the specified location."""
-        # TODO: warn if the same similarity functions are not available as were saved
+    @staticmethod
+    def load(path: str) -> "Model":
+        """Reload the model with all of the data and anchors from the specified location.
+
+        Example:
+
+            .. code-block:: python
+                import icat
+
+                m1 = icat.Model(my_data, text_col="text")
+                m1.save("~/tmp/my_model")
+
+                m2 = icat.Model.load("~/tmp/my_model")
+        """
 
         # load relevant model metadata
         with open(f"{path}/model_info.json") as infile:
             model_information = json.load(infile)
-        self.text_col = model_information["text_col"]
-        self.data.text_col = self.text_col
-        if "sample_size" in model_information:
-            self.data.sample_size_txt.v_model = model_information["sample_size"]
-
-        # check to make sure we have the correct similarity functions
-        for key in model_information["similarity_function_keys"]:
-            if key not in self.similarity_functions.keys():
-                print(
-                    "WARNING - Similarity function '%s' not passed into model init, please load the function in with 'model.similarity_functions[\"%s\"] = %s'"
-                    % (key, key, key)
-                )
 
-        # load the classifier
-        self.classifier = joblib.load(f"{path}/classifier.joblib")
+        # version check
+        saved_major, saved_minor, saved_patch = (
+            int(i) for i in model_information["icat_version"].split(".")
+        )
+        major, minor, patch = (int(i) for i in icat.__version__.split("."))
+        if major != saved_major or saved_minor < 7:
+            print("ERROR - Model was saved with incompatible version of icat")
+            return None
 
-        # load the active data into the data manager
-        self.data.set_data(pd.read_pickle(f"{path}/active_data.pkl"))
+        data = pd.read_pickle(f"{path}/active_data.pkl")
 
-        # load the sample set into the data manager
-        with open(f"{path}/active_data_sample.json") as infile:
-            self.data.sample_indices = json.load(infile)
+        # init with no anchor types because anchor_list loading will handle that
+        model = Model(
+            data=data, anchor_types=[], text_col=model_information["text_col"]
+        )
+        model.data.sample_size_txt.v_model = model_information["sample_size"]
+
+        # load the classifier
+        model.classifier = joblib.load(f"{path}/classifier.joblib")
 
         # load the training data
         if os.path.exists(f"{path}/training_data.pkl"):
-            self.training_data = pd.read_pickle(f"{path}/training_data.pkl")
+            model.training_data = pd.read_pickle(f"{path}/training_data.pkl")
+
+        # load the sample set into the data manager
+        with open(f"{path}/active_data_sample.json") as infile:
+            model.data.sample_indices = json.load(infile)
 
         # load the anchorlist
-        self.anchor_list.load(path)
+        model.anchor_list.load(path)
+
+        return model
diff --git a/icat/table.py b/icat/table.py
index 0f893c6..4163309 100644
--- a/icat/table.py
+++ b/icat/table.py
@@ -21,6 +21,10 @@ class TableContentsTemplate(v.VuetifyTemplate):
 
     options = traitlets.Dict().tag(sync=True)
 
+    example_btn_color = traitlets.Unicode("").tag(sync=True)
+    example_type_name = traitlets.Unicode("similarity").tag(sync=True)
+    # example_btn_color = traitlets.Unicode("#FFEE22").tag(sync=True)
+
     def __init__(self, *args, **kwargs):
         self._add_selected_text_callbacks: list[Callable] = []
         self._select_point_callbacks: list[Callable] = []
@@ -154,13 +158,13 @@ def _template(self):
                                 </template>
                                 <span>Label this item as <span class="orange--text lighten-5"><b>interesting</b></span> (warm).</span>
                             </v-tooltip>
-                            <v-tooltip bottom open-delay=500>
+                            <v-tooltip bottom open-delay=500 v-if="example_btn_color != ''">
                                 <template v-slot:activator="{ on, attrs }">
-                                    <v-btn x-small class="purple darken-1" @click.stop="addToExampleAnchor(item.id)" v-bind="attrs" v-on="on">
+                                    <v-btn x-small :style="{ backgroundColor: example_btn_color }" @click.stop="addToExampleAnchor(item.id)" v-bind="attrs" v-on="on">
                                         example
                                     </v-btn>
                                 </template>
-                                <span>Create a similarity anchor with this item as the target.</span>
+                                <span>Create a {{ example_type_name }} anchor with this item as the target.</span>
                             </v-tooltip>
                             <v-tooltip bottom open-delay=500>
                                 <template v-slot:activator="{ on, attrs }">
diff --git a/icat/view.py b/icat/view.py
index cf2d705..26bde11 100644
--- a/icat/view.py
+++ b/icat/view.py
@@ -11,7 +11,7 @@
 import panel as pn
 from ipyanchorviz import AnchorViz
 
-from icat.anchors import Anchor, DictionaryAnchor, SimilarityFunctionAnchor, TFIDFAnchor
+from icat.anchors import Anchor, DictionaryAnchor
 from icat.histograms import Histograms
 from icat.utils import _kill_param_auto_docstring
 
@@ -63,6 +63,9 @@ def __init__(self, model, **params):
         )
         self.model.anchor_list.on_anchor_added(self._update_data_table_on_anchor_added)
         self.model.anchor_list.on_anchor_removed(self._remove_list_anchor_from_viz)
+        self.model.anchor_list.on_anchor_types_changed(
+            self._update_viz_anchor_colors_from_type
+        )
         self.anchorviz.on_anchor_add(self._add_viz_anchor_to_list)
         self.anchorviz.observe(
             self._trigger_selected_points_change, names="lassoedPointIDs"
@@ -105,10 +108,13 @@ def _add_list_anchor_to_viz(self, anchor: Anchor):
             anchor.theta if hasattr(anchor, "theta") else random.uniform(0, 2 * 3.14)
         )
         anchor_dict = dict(id=anchor.name, name=anchor.anchor_name, theta=theta)
-        if type(anchor) == TFIDFAnchor:
-            anchor_dict["color"] = "#8e24aa"
-        elif type(anchor) == SimilarityFunctionAnchor:
-            anchor_dict["color"] = "#248eaa"
+        # if type(anchor) == TFIDFAnchor:
+        #     anchor_dict["color"] = "#8e24aa"
+        # elif type(anchor) == SimilarityFunctionAnchor:
+        #     anchor_dict["color"] = "#248eaa"
+        anchor_dict["color"] = self.model.anchor_list.get_anchor_type_config(
+            type(anchor)
+        )["color"]
         self.anchorviz.add_anchor(anchor_dict)
 
     def _remove_list_anchor_from_viz(self, anchor: Anchor):
@@ -135,9 +141,27 @@ def _add_viz_anchor_to_list(self, content: dict):
         # send the actual name to be the id for the visualization
         self.anchorviz.modify_anchor_by_id(new_anchor_dict["id"], "id", new_anchor.name)
         self.anchorviz.modify_anchor_by_id(new_anchor.name, "name", name)
+        self.anchorviz.modify_anchor_by_id(
+            new_anchor.name,
+            "color",
+            self.model.anchor_list.get_anchor_type_config(type(new_anchor))["color"],
+        )
 
         self.model.anchor_list.add_anchor(new_anchor)
 
+    def _update_viz_anchor_colors_from_type(
+        self, anchor_type_dicts: list[dict[str, any]]
+    ):
+        for anchor in self.model.anchor_list.anchors:
+            if anchor.in_view:
+                self.anchorviz.modify_anchor_by_id(
+                    anchor.name,
+                    "color",
+                    self.model.anchor_list.get_anchor_type_config(type(anchor))[
+                        "color"
+                    ],
+                )
+
     # TODO: need tests for this one
     def _send_anchorlist_anchor_modification_to_viz(
         self, id: str, property: str, value: Any
diff --git a/notebooks/archive/Example3-Model.ipynb b/notebooks/archive/Example3-Model.ipynb
index ef16b6b..265abae 100644
--- a/notebooks/archive/Example3-Model.ipynb
+++ b/notebooks/archive/Example3-Model.ipynb
@@ -77,7 +77,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "1bd04a06-9ddc-4f6d-8608-8876b761ccfa",
+   "id": "6b7022fe-773d-4712-a3d3-14fc8a932ab2",
    "metadata": {
     "tags": []
    },
@@ -86,6 +86,43 @@
     "model.view"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b843410-e2b2-462d-8dc9-f018082d23a4",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "model.save(\"testingmodel\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67408b28-d92e-4e67-91df-7ad873aaed0d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "m2 = Model.load(\"testingmodel\")\n",
+    "m2.view"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c43f18a-92f8-4b6c-aa9b-c2f576da1702",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "model.anchor_list.possible_anchor_types"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/notebooks/lm_similarity_example.ipynb b/notebooks/lm_similarity_example.ipynb
index 416e728..8a3aaee 100644
--- a/notebooks/lm_similarity_example.ipynb
+++ b/notebooks/lm_similarity_example.ipynb
@@ -75,70 +75,77 @@
     "\n",
     "import icat\n",
     "\n",
-    "def lm_similarity(data: pd.DataFrame, anchor: icat.SimilarityFunctionAnchor):\n",
-    "    anchor_list = anchor.container  # we get the containing anchor list so we can\n",
-    "                                    # store and retrieve values from its `cache`\n",
-    "    target_text = anchor.reference_texts[0]  # the target text we're computing similarity to.\n",
-    "                                             # Note that for simplicity we only use the first\n",
-    "                                             # referenced text, but in principle this function\n",
-    "                                             # could be implemented to handle multiple targets,\n",
-    "                                             # e.g. use the average embedding.\n",
-    "    source_text = data[anchor.text_col].tolist()\n",
+    "class LMSimAnchor(icat.anchors.SimilarityAnchorBase):\n",
+    "    NAME = \"BERT\"  # optional attribute to set default name inside ICAT UI\n",
+    "    DESCRIPTION = \"Use cosine similarity between BERT embeddings of data and target.\"\n",
+    "    # optional attribute to set description of anchor type in ICAT UI\n",
     "    \n",
-    "    # if we haven't computed the embeddings for the dataframe yet, do so now.\n",
-    "    # NOTE: this works on the assumption that the dataset isn't going to change,\n",
-    "    # special considerations are required if we put new data through this function\n",
-    "    if f\"similarity_embeddings_{MODEL_NAME}\" not in anchor_list.cache:\n",
-    "        embedded_batches = []\n",
+    "    def featurize(self, data: pd.DataFrame) -> pd.Series:\n",
+    "        target_text = self.reference_texts[0] # the target text we're computing similarity to.\n",
+    "                                              # Note that for simplicity we only use the first\n",
+    "                                              # referenced text, but in principle this function\n",
+    "                                              # could be implemented to handle multiple targets,\n",
+    "                                              # e.g. use the average embedding.\n",
+    "        source_text = data[self.text_col].tolist()\n",
     "        \n",
-    "        # run the tokenizer and model embedding on batches\n",
-    "        max_batches = data.shape[0] // BATCH_SIZE + 1\n",
-    "        last_batch = data.shape[0] // BATCH_SIZE\n",
-    "        for batch in range(max_batches):\n",
-    "            # compute range for this batch\n",
-    "            batch_start = batch * BATCH_SIZE\n",
-    "            batch_end = data.shape[0] if batch == last_batch else batch_start + BATCH_SIZE\n",
-    "            \n",
-    "            # get the texts within the batch range\n",
-    "            batch_text = source_text[batch_start:batch_end]\n",
-    "            \n",
-    "            # tokenize and embed with the model\n",
-    "            tokenized = tokenizer(\n",
-    "                batch_text, \n",
-    "                return_tensors='pt', \n",
-    "                truncation=True, \n",
-    "                padding=\"max_length\",\n",
-    "            )[\"input_ids\"].to(DEVICE).detach()\n",
-    "            text_embeddings = text_model(tokenized).last_hidden_state.detach().cpu().numpy()\n",
-    "            embedded_batches.append(text_embeddings)\n",
-    "            \n",
-    "        # stack all the embeddings and average the token embeddings to get the full text \n",
-    "        # representation for each\n",
-    "        embeddings = np.concatenate(embedded_batches, axis=0)\n",
-    "        embeddings = embeddings.mean(axis=1)\n",
+    "        # if we haven't computed the embeddings for the dataframe yet, do so now.\n",
+    "        # NOTE: this works on the assumption that the dataset isn't going to change,\n",
+    "        # special considerations are required if we put new data through this function\n",
+    "        cache_key = f\"similarity_embeddings_{MODEL_NAME}\"\n",
+    "        if cache_key not in self.global_cache:\n",
+    "            # we check for/save any embeddings in the global cache, which is stored on the\n",
+    "            # anchorlist and accessible to all anchors (meaning any other anchors of this type\n",
+    "            # can all access the same set of embeddings/only need to compute them once.\n",
+    "            embedded_batches = []\n",
     "        \n",
-    "        anchor_list.cache[f\"similarity_embeddings_{MODEL_NAME}\"] = embeddings\n",
-    "    \n",
-    "    # tokenize and get the full text embedding for the target text\n",
-    "    tokenized_target = tokenizer(\n",
-    "        batch_text, \n",
-    "        return_tensors='pt', \n",
-    "        truncation=True, \n",
-    "        padding=\"max_length\",\n",
-    "    )[\"input_ids\"].to(DEVICE).detach()\n",
-    "    target_embedding = text_model(tokenized_target).last_hidden_state.detach().cpu().numpy()\n",
-    "    target_embedding = target_embedding.mean(axis=1)\n",
-    "    \n",
-    "    # compute cosine similarity between the target text embedding and all the embeddings\n",
-    "    # from the dataframe\n",
-    "    similarities = cosine_similarity(target_embedding, anchor_list.cache[f\"similarity_embeddings_{MODEL_NAME}\"])\n",
-    "    \n",
-    "    # massage the similarity values a little to get better spread in the visualization \n",
-    "    # and put a minimum threshold on \"activation\"\n",
-    "    similarities = similarities * 2 - 1\n",
-    "    similarities[similarities < 0.25] = 0.0\n",
-    "    \n",
-    "    return pd.Series(similarities[0], index=data.index)"
+    "            # run the tokenizer and model embedding on batches\n",
+    "            max_batches = data.shape[0] // BATCH_SIZE + 1\n",
+    "            last_batch = data.shape[0] // BATCH_SIZE\n",
+    "            for batch in range(max_batches):\n",
+    "                # compute range for this batch\n",
+    "                batch_start = batch * BATCH_SIZE\n",
+    "                batch_end = data.shape[0] if batch == last_batch else batch_start + BATCH_SIZE\n",
+    "\n",
+    "                # get the texts within the batch range\n",
+    "                batch_text = source_text[batch_start:batch_end]\n",
+    "\n",
+    "                # tokenize and embed with the model\n",
+    "                tokenized = tokenizer(\n",
+    "                    batch_text, \n",
+    "                    return_tensors='pt', \n",
+    "                    truncation=True, \n",
+    "                    padding=\"max_length\",\n",
+    "                )[\"input_ids\"].to(DEVICE).detach()\n",
+    "                text_embeddings = text_model(tokenized).last_hidden_state.detach().cpu().numpy()\n",
+    "                embedded_batches.append(text_embeddings)\n",
+    "                \n",
+    "            # stack all the embeddings and average the token embeddings to get the full text \n",
+    "            # representation for each\n",
+    "            embeddings = np.concatenate(embedded_batches, axis=0)\n",
+    "            embeddings = embeddings.mean(axis=1)\n",
+    "\n",
+    "            self.global_cache[cache_key] = embeddings\n",
+    "            \n",
+    "        # tokenize and get the full text embedding for the target text\n",
+    "        tokenized_target = tokenizer(\n",
+    "            target_text, \n",
+    "            return_tensors='pt', \n",
+    "            truncation=True, \n",
+    "            padding=\"max_length\",\n",
+    "        )[\"input_ids\"].to(DEVICE).detach()\n",
+    "        target_embedding = text_model(tokenized_target).last_hidden_state.detach().cpu().numpy()\n",
+    "        target_embedding = target_embedding.mean(axis=1)\n",
+    "\n",
+    "        # compute cosine similarity between the target text embedding and all the embeddings\n",
+    "        # from the dataframe\n",
+    "        similarities = cosine_similarity(target_embedding, self.global_cache[cache_key])\n",
+    "\n",
+    "        # massage the similarity values a little to get better spread in the visualization \n",
+    "        # and put a minimum threshold on \"activation\"\n",
+    "        similarities = similarities * 2 - 1\n",
+    "        similarities[similarities < 0.25] = 0.0\n",
+    "\n",
+    "        return pd.Series(similarities[0], index=data.index)"
    ]
   },
   {
@@ -146,7 +153,7 @@
    "id": "f3fa9719-c708-408f-84cf-421df9c8e46c",
    "metadata": {},
    "source": [
-    "We load in a dataset to work with and initialize panel"
+    "We load in a dataset to work with"
    ]
   },
   {
@@ -158,22 +165,40 @@
    },
    "outputs": [],
    "source": [
-    "import panel as pn\n",
     "from sklearn.datasets import fetch_20newsgroups\n",
-    "pn.extension('vega')\n",
     "\n",
     "dataset = fetch_20newsgroups(subset=\"train\")\n",
     "df = pd.DataFrame({\"text\": dataset[\"data\"], \"category\": [dataset[\"target_names\"][i] for i in dataset[\"target\"]]})\n",
-    "#df = df.iloc[0:2000]\n",
+    "df = df.iloc[0:1999]\n",
     "df.head()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "2b1a3c0d-0fef-4d6d-8f94-cf5a1f2cfb41",
+   "metadata": {},
+   "source": [
+    "ICAT has to be initialized before use, taking care of things like panel and pre-requisite UI setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b10d7254-e8ae-488c-bf65-38c18fe55cd5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "icat.initialize()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "66b5d51f-ad83-496e-9eeb-9edbcec98ca2",
    "metadata": {},
    "source": [
-    "Now we create a model and pass our similarity function into the constructor. Internally, `model.similarity_functions` resolves to a dictionary, where the key is the name of the function. These keys are what display in the dropdown of the `SimilarityFunctionAnchor`"
+    "Now we create a model to explore with. ICAT's \"anchor types\" tab will automatically detect any `Anchor` class definitions, allowing you to dynamically add that anchor type to work with directly within the interface. Alternatively, you can pass the types you want to use to the constructor, or subsequently call `model.anchor_list.add_anchor_type(LMSimAnchor)`"
    ]
   },
   {
@@ -185,7 +210,7 @@
    },
    "outputs": [],
    "source": [
-    "model = icat.Model(df, text_col=\"text\", similarity_functions=[lm_similarity])"
+    "model = icat.Model(df, text_col=\"text\")"
    ]
   },
   {
diff --git a/pyproject.toml b/pyproject.toml
index 5d7bf33..4b177f9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,2 +1,9 @@
 [tool.isort]
 profile = "black"
+
+[tool.pytest.ini_options]
+markers = [
+    "integration",
+    "vue",
+    "panel"
+]
diff --git a/tests/test_anchorlist.py b/tests/test_anchorlist.py
index 005d6ec..0460486 100644
--- a/tests/test_anchorlist.py
+++ b/tests/test_anchorlist.py
@@ -3,7 +3,7 @@
 import pytest
 
 from icat.anchorlist import AnchorList
-from icat.anchors import DictionaryAnchor
+from icat.anchors import Anchor, DictionaryAnchor, TFIDFAnchor
 from icat.model import Model
 
 
@@ -18,7 +18,7 @@ def catch_addition(anchor):
         returns.append(anchor)
 
     al.on_anchor_added(catch_addition)
-    al._handle_pnl_new_dictionary_btn_clicked(None)
+    al._handle_ipv_new_anchor_generic_click(None, None, None, DictionaryAnchor)
     assert len(al.anchors) == 1
     assert len(al.table.items) == 1
     assert len(returns) == 1
@@ -187,7 +187,7 @@ def test_save_load_anchorlist(data_file_loc, fun_df):
 
     model.anchor_list.save(data_file_loc)
 
-    model2 = Model(fun_df, "text")
+    model2 = Model(fun_df, "text", anchor_types=[])
     model2.anchor_list.load(data_file_loc)
     assert model2.anchor_list.cache["test_cache"] == 13
 
@@ -205,3 +205,182 @@ def test_save_load_anchorlist(data_file_loc, fun_df):
             assert anchor["theta"] == 1.5
         else:
             raise Exception("what.")
+
+    assert len(model2.anchor_list.possible_anchor_types) == 2
+    assert model2.anchor_list.default_example_anchor_type_dict["ref"] == TFIDFAnchor
+
+
+# --- below may all go in another test file other
+@pytest.mark.integration
+def test_add_example_anchor_type_populates_example_type_dropdown():
+    """Adding an anchor type that can be used for examples should add it to the
+    example anchor type dropdown, and also auto assign if it hasn't already."""
+    model = Model(None, "text", anchor_types=[])
+    assert len(model.anchor_list.example_anchor_types_dropdown.items) == 0
+
+    model.anchor_list.add_anchor_type(DictionaryAnchor)
+    assert len(model.anchor_list.example_anchor_types_dropdown.items) == 0
+    assert "ref" not in model.anchor_list.default_example_anchor_type_dict
+
+    model.anchor_list.add_anchor_type(TFIDFAnchor)
+    assert len(model.anchor_list.example_anchor_types_dropdown.items) == 1
+    assert "ref" in model.anchor_list.default_example_anchor_type_dict
+    assert model.data.table.example_type_name == "TF-IDF"
+    assert model.data.table.example_btn_color == "#777777"
+
+
+@pytest.mark.integration
+def test_change_example_anchor_color_changes_av_and_table(fun_df):
+    """Changing the color of the example anchor type should change both anchors in anchorviz
+    and the button color in the table."""
+    model = Model(fun_df, "text")
+    anchor = TFIDFAnchor(anchor_name="test", reference_texts=["0"])
+    model.add_anchor(anchor)
+
+    model.anchor_list.modify_anchor_type(TFIDFAnchor, "color", "#00FF00")
+    assert model.view.anchorviz.anchors[0]["color"] == "#00FF00"
+    assert model.data.table.example_btn_color == "#00FF00"
+
+
+def test_adding_anchor_type_adds_button():
+    """When an anchor type is added to the anchorlist, a corresponding button should be
+    added to main anchorlist section."""
+    al = AnchorList(None, anchor_types=[])
+    assert len(al.anchor_buttons.children) == 1
+
+    al.add_anchor_type(DictionaryAnchor)
+    assert len(al.anchor_buttons.children) == 3
+    assert (
+        al.anchor_buttons.children[2].v_slots[0]["children"].children[0] == "Dictionary"
+    )
+
+
+@pytest.mark.integration
+def test_anchor_type_button_click_adds_anchor_of_type(fun_df):
+    """The anchor buttons should add anchors of their appropriate types"""
+    model = Model(fun_df, "text", anchor_types=[])
+    assert len(model.anchor_list.anchor_buttons.children) == 1
+    model.anchor_list.add_anchor_type(DictionaryAnchor, color="#FF0000")
+    model.anchor_list.add_anchor_type(TFIDFAnchor, color="#0000FF")
+    assert len(model.anchor_list.anchor_buttons.children) == 4
+
+    assert (
+        model.anchor_list.anchor_buttons.children[2].v_slots[0]["children"].children[0]
+        == "Dictionary"
+    )
+    assert (
+        model.anchor_list.anchor_buttons.children[2].v_slots[0]["children"].color
+        == "#FF0000"
+    )
+    assert (
+        model.anchor_list.anchor_buttons.children[3].v_slots[0]["children"].children[0]
+        == "TF-IDF"
+    )
+    assert (
+        model.anchor_list.anchor_buttons.children[3].v_slots[0]["children"].color
+        == "#0000FF"
+    )
+
+    model.anchor_list.anchor_buttons.children[2].v_slots[0]["children"].fire_event(
+        "click", None
+    )
+    assert type(model.anchor_list.anchors[0]) == DictionaryAnchor
+    assert model.view.anchorviz.anchors[0]["color"] == "#FF0000"
+
+    model.anchor_list.anchor_buttons.children[3].v_slots[0]["children"].fire_event(
+        "click", None
+    )
+    assert type(model.anchor_list.anchors[1]) == TFIDFAnchor
+    assert model.view.anchorviz.anchors[1]["color"] == "#0000FF"
+
+
+def test_changing_anchor_type_color_changes_btn_color():
+    """Setting the anchor type color should set the color of the associated button as well"""
+    al = AnchorList(None, anchor_types=[{"ref": DictionaryAnchor, "color": "#FF00FF"}])
+    assert len(al.anchor_buttons.children) == 3
+    assert al.anchor_buttons.children[2].v_slots[0]["children"].color == "#FF00FF"
+
+    al.modify_anchor_type(DictionaryAnchor, "color", "#330044")
+    assert al.anchor_buttons.children[2].v_slots[0]["children"].color == "#330044"
+
+
+def test_changing_anchor_type_name_changes_btn_text():
+    """Setting the anchor type color should set the color of the associated button as well"""
+    al = AnchorList(None, anchor_types=[{"ref": DictionaryAnchor}])
+    assert len(al.anchor_buttons.children) == 3
+    assert (
+        al.anchor_buttons.children[2].v_slots[0]["children"].children[0] == "Dictionary"
+    )
+
+    al.modify_anchor_type(DictionaryAnchor, "name", "dict")
+    assert al.anchor_buttons.children[2].v_slots[0]["children"].children[0] == "dict"
+
+
+def test_defining_anchor_type_in_scope_adds_new_add_btn():
+    """Defining a new anchor type should add a section for it in the anchor types tab."""
+
+    class MyAnchor(Anchor):
+        pass
+
+    al = AnchorList()
+    assert (
+        al.anchor_types_layout.children[-1].children[0].children[0].v_model
+        == "test_defining_anchor_type_in_scope_adds_new_add_btn.<locals>.MyAnchor"
+    )
+
+
+def test_defining_anchor_type_and_changin_name_adds_appropriately_named_btn():
+    """When you add an anchor type it should use the name the user specified."""
+
+    class MyAnchor(Anchor):
+        pass
+
+    al = AnchorList()
+    al.anchor_types_layout.children[-1].children[0].children[0].v_model = "Something"
+    al.anchor_types_layout.children[-1].children[-1].fire_event("click", None)
+    assert (
+        al.anchor_buttons.children[4].v_slots[0]["children"].children[0] == "Something"
+    )
+
+
+@pytest.mark.integration
+def test_removing_default_example_anchor_type_resets(fun_df):
+    """Removing the anchor type that is the default anchor type should reset
+    the dropdown, the default_example_type property and the table."""
+    model = Model(fun_df, "text")
+    model.anchor_list.remove_anchor_type(TFIDFAnchor)
+    assert len(model.anchor_list.example_anchor_types_dropdown.items) == 0
+    assert model.anchor_list.default_example_anchor_type_dict == {}
+    assert model.data.table.example_type_name == "similarity"
+    assert model.data.table.example_btn_color == ""
+
+
+@pytest.mark.integration
+def test_removing_anchor_type_removes_those_anchors(fun_df):
+    """Removing an anchor type should remove all associated anchors of that
+    type, both in anchorviz and the list."""
+    model = Model(fun_df, "text")
+    a1 = DictionaryAnchor(keywords=["thing1"])
+    a2 = DictionaryAnchor(keywords=["thing2"])
+    model.add_anchor(a1)
+    model.add_anchor(a2)
+    assert len(model.anchor_list.anchors) == 2
+    assert len(model.view.anchorviz.anchors) == 2
+    model.anchor_list.remove_anchor_type(DictionaryAnchor)
+    assert len(model.anchor_list.anchors) == 0
+    assert len(model.view.anchorviz.anchors) == 0
+
+
+def test_removing_anchor_type_removes_btn():
+    """Removing an anchor type should remove the associated add button."""
+    al = AnchorList(None, anchor_types=[])
+    assert len(al.anchor_buttons.children) == 1
+
+    al.add_anchor_type(DictionaryAnchor)
+    assert len(al.anchor_buttons.children) == 3
+    assert (
+        al.anchor_buttons.children[2].v_slots[0]["children"].children[0] == "Dictionary"
+    )
+
+    al.remove_anchor_type(DictionaryAnchor)
+    assert len(al.anchor_buttons.children) == 2
diff --git a/tests/test_anchors.py b/tests/test_anchors.py
index 724626a..e314d8d 100644
--- a/tests/test_anchors.py
+++ b/tests/test_anchors.py
@@ -1,8 +1,7 @@
-import numpy as np
 import pandas as pd
 import pytest
 
-from icat.anchors import Anchor, DictionaryAnchor, SimilarityFunctionAnchor, TFIDFAnchor
+from icat.anchors import Anchor, DictionaryAnchor, TFIDFAnchor
 from icat.model import Model
 
 
@@ -319,30 +318,6 @@ def test_similarity_anchor_gets_short_from_text_entry(fun_df):
     assert len(anchor._chips_container.children) == 1
 
 
-@pytest.mark.integration
-def test_changing_similarity_function_fires_change_event(fun_df):
-    """Changing the selected similarity function should fire an event."""
-    returns = []
-
-    def catch_change(name, key, value):
-        nonlocal returns
-        returns.append((name, key, value))
-
-    def simple_sim(data, anchor):
-        return pd.Series(np.ones(len(data)), index=data.index)
-
-    model = Model(fun_df, "text", similarity_functions=[simple_sim])
-    anchor = SimilarityFunctionAnchor()
-    anchor.on_anchor_changed(catch_change)
-    model.add_anchor(anchor)
-
-    assert anchor.sim_function_options.items == ["simple_sim"]
-    anchor.sim_function_options.v_model = "simple_sim"
-    anchor.sim_function_options.fire_event("change", "simple_sim")
-
-    assert returns[0][2] == "simple_sim"
-
-
 def test_save_load_dictionary_anchor(data_file_loc):
     """Saving an anchor and then loading should be populated with all of the
     correct parameters."""
@@ -355,10 +330,11 @@ def test_save_load_dictionary_anchor(data_file_loc):
     a1.text_col = "my_text"
     a1.keywords_str = "thing"
     a1.keywords = ["thing"]
-    a1.save("test/exampledata/test")
+    a1.cache["test"] = 13
+    a1.save(data_file_loc)
 
     a2 = DictionaryAnchor()
-    a2.load("test/exampledata/test")
+    a2.load(data_file_loc)
     assert a2.anchor_name == "I am an anchor"
     assert a2.weight == 1.2
     assert not a2.in_view
@@ -366,28 +342,4 @@ def test_save_load_dictionary_anchor(data_file_loc):
     assert a2.text_col == "my_text"
     assert a2.keywords_str == "thing"
     assert a2.keywords == ["thing"]
-
-
-def test_save_load_similarity_anchor(data_file_loc):
-    """Saving an anchor and then loading should be populated with all of the
-    correct parameters."""
-
-    a1 = SimilarityFunctionAnchor()
-    a1.anchor_name = "I am an anchor"
-    a1.weight = 1.2
-    a1.in_view = False
-    a1.in_model = False
-    a1.text_col = "my_text"
-    a1.reference_texts = ["I am a powerful potato"]
-    a1.reference_short = ["I am a"]
-    a1.save(data_file_loc)
-
-    a2 = SimilarityFunctionAnchor()
-    a2.load(data_file_loc)
-    assert a2.anchor_name == "I am an anchor"
-    assert a2.weight == 1.2
-    assert not a2.in_view
-    assert not a2.in_model
-    assert a2.text_col == "my_text"
-    assert a2.reference_texts == ["I am a powerful potato"]
-    assert a2.reference_short == ["I am a"]
+    assert a2.cache["test"] == 13
diff --git a/tests/test_model.py b/tests/test_model.py
index 022d7df..dbc50f3 100644
--- a/tests/test_model.py
+++ b/tests/test_model.py
@@ -290,8 +290,7 @@ def test_save_load_model(data_file_loc, fun_df, dummy_anchor):
     model.data.apply_label(0, 1)
     model.save(data_file_loc)
 
-    model2 = Model(None, text_col="")
-    model2.load(data_file_loc)
+    model2 = Model.load(data_file_loc)
     assert len(model2.data.active_data) == 12
     assert model2.text_col == "text"
     assert len(model2.anchor_list.anchors) == 1
diff --git a/tests/test_view.py b/tests/test_view.py
index 329290e..3f79504 100644
--- a/tests/test_view.py
+++ b/tests/test_view.py
@@ -47,7 +47,9 @@ def test_add_anchor_from_list_button_works(fun_df):
     """The anchorlist adding a dictionary anchor won't have a text_col by
     default, this should be added by model and shouldn't crash."""
     model = Model(fun_df, text_col="text")
-    model.anchor_list._handle_pnl_new_dictionary_btn_clicked(None)
+    model.anchor_list._handle_ipv_new_anchor_generic_click(
+        None, None, None, DictionaryAnchor
+    )
     assert len(model.anchor_list.anchors) == 1
     assert model.anchor_list.anchors[0].text_col == "text"