diff --git a/docs/html/_sources/index.rst.txt b/docs/html/_sources/index.rst.txt
index f4c6a84..db3c5ed 100644
--- a/docs/html/_sources/index.rst.txt
+++ b/docs/html/_sources/index.rst.txt
@@ -12,6 +12,7 @@ PyBryt Documentation
annotations/index
reference_implementations
+ student_implementations
api_reference
PyBryt is an open source Python auto-assessment library for teaching and learning. Our goal is to empower students and educators to learn about technology through fun, guided, hands-on content aimed at specific learning goals. PyBryt is designed to work with existing autograding solutions and workflows such as `Otter Grader`_, `OkPy`_, and `Autolab`_.
diff --git a/docs/html/_sources/reference_implementations.rst.txt b/docs/html/_sources/reference_implementations.rst.txt
index d847f22..f520135 100644
--- a/docs/html/_sources/reference_implementations.rst.txt
+++ b/docs/html/_sources/reference_implementations.rst.txt
@@ -144,3 +144,28 @@ sequence generator:
Interacting with Reference Implementations
------------------------------------------
+
+The :py:class:`ReferenceImplementation` class defines an API for
+working with reference implementations. The core method for reconciling a student implementation,
+encoded as a list of 2-tuples, is
+:py:meth:`ReferenceImplementation.run`. This method is
+abstracted away by the :py:meth:`StudentImplementation.check`
+method, which calls it for that student implementation.
+
+
+.. _storing_refs:
+
+Storing Reference Implementations
+---------------------------------
+
+Reference implementation objects can be saved to a file by calling
+:py:meth:`ReferenceImplementation.dump`, which takes in the
+path to the file and uses the ``dill`` library to serialize the object. To load a reference
+implementation, or a list of reference implementations, from a file, use the static method
+:py:meth:`ReferenceImplementation.load`.
+
+.. code-block:: python
+
+ ref = pybryt.ReferenceImplementation([...])
+ ref.dump() # defaults to filename 'reference.pkl'
+ ref = pybryt.ReferenceImplementation.load('reference.pkl')
diff --git a/docs/html/_sources/student_implementations.rst.txt b/docs/html/_sources/student_implementations.rst.txt
new file mode 100644
index 0000000..6784e2f
--- /dev/null
+++ b/docs/html/_sources/student_implementations.rst.txt
@@ -0,0 +1,87 @@
+Student Implementations
+=======================
+
+For tracking and managing student implementations, stored in PyBryt as a list of 2-tuples of the
+objects observed while tracing students' code and the timestamps of those objects, PyBryt provides
+the :py:class:`StudentImplementation` class. The constructor for this
+class takes in either a path to a Jupyter Notebook file or a notebook object read in with
+``nbformat``.
+
+.. code-block:: python
+
+ stu = pybryt.StudentImplementation("subm.ipynb")
+
+ # or...
+ nb = nbformat.read("subm.ipynb")
+ stu = pybryt.StudentImplementation(nb)
+
+
+Notebook Execution
+------------------
+
+The constructor reads the notebook file and stores the student's code. It then proceeds to execute
+the student's notebook using ``nbformat``'s ``ExecutePreprocessor``. The memory footprint of the
+student's code is constructed by executing the notebook with a trace function that tracks every
+value created and accessed **by the student's code** and the timestamps at which those values were
+observed.
+
+To trace into code written in specific files, use the ``addl_filenames`` argument of the constructor
+to pass a list of absolute paths of files to trace inside of. This can be useful for cases in which
+a testing harness is being used to test student's code and the student's *actual* submission is
+written in a Python script (which PyBryt would by default not trace).
+
+.. code-block:: python
+
+ stu = pybryt.StudentImplementation("harness.ipynb", addl_filenames=["subm.py"])
+
+PyBryt also employs various custom notebook preprocessors for handling special cases that occur in
+the code to allow different types of values to be checked. To see the exact version of the code that
+PyBryt executes, set ``output`` to a path to a notebook that PyBryt will write with the executed
+notebook. This can be useful e.g. for debugging reference implementations by inserting ``print``
+statements that show the values at various stages of execution.
+
+.. code-block:: python
+
+ stu = pybryt.StudentImplementation("subm.ipynb", output="executed-subm.ipynb")
+
+
+Checking Implementations
+------------------------
+
+To reconcile a student implementation with a set of reference implementations, use the
+:py:meth:`StudentImplementation.check` method, which takes in
+a single :py:class:`ReferenceImplementation` object, or a list of
+them, and returns a :py:class:`ReferenceResult` object (or a list of them).
+This method simply abstracts away managing the memory footprint tracked by the
+:py:class:`StudentImplementation` object and calls the
+:py:meth:`ReferenceImplementation.run` method for each provided
+reference implementation.
+
+.. code-block:: python
+
+ ref = pybryt.ReferenceImplementation.load("reference.ipynb")
+ stu = pybryt.StudentImplementation("subm.ipynb")
+ stu.check(ref)
+
+To run the references for a single group of annotations, pass the ``group`` argument, which should
+be a string that corresponds to the name of a group of annotations. For example, to run the checks
+for a single question in a reference that contains multiple questions, the pattern might be
+
+.. code-block:: python
+
+ stu.check(ref, group="q1")
+
+
+Storing Implementations
+-----------------------
+
+Because generating the memory footprints of students' code can be time consuming and computationally
+expensive, :py:class:`StudentImplementation` objects can also be
+serialized to make multiple runs across sessions easier. The
+:py:class:`StudentImplementation` class provides the
+:py:class:`dump` and
+:py:class:`load` methods, which function the same as with
+:ref:`reference implementations`.
+:py:class:`StudentImplementation` objects can also be serialized to
+base-64-encoded strings using the :py:class:`dumps` and
+:py:class:`loads` methods.
diff --git a/docs/html/annotations/index.html b/docs/html/annotations/index.html
index 8389b2e..eb48a35 100644
--- a/docs/html/annotations/index.html
+++ b/docs/html/annotations/index.html
@@ -113,6 +113,7 @@
The ReferenceImplementation class defines an API for
+working with reference implementations. The core method for reconciling a student implementation,
+encoded as a list of 2-tuples, is
+ReferenceImplementation.run. This method is
+abstracted away by the StudentImplementation.check
+method, which calls it for that student implementation.
Reference implementation objects can be saved to a file by calling
+ReferenceImplementation.dump, which takes in the
+path to the file and uses the dill library to serialize the object. To load a reference
+implementation, or a list of reference implementations, from a file, use the static method
+ReferenceImplementation.load.
+
ref=pybryt.ReferenceImplementation([...])
+ref.dump()# defaults to filename 'reference.pkl'
+ref=pybryt.ReferenceImplementation.load('reference.pkl')
+