diff --git a/src/isolator/hei_isolator.cpp b/src/isolator/hei_isolator.cpp
new file mode 100644
index 0000000..64cfe3e
--- /dev/null
+++ b/src/isolator/hei_isolator.cpp
@@ -0,0 +1,42 @@
+
+#include <isolator/hei_isolator.hpp>
+
+namespace libhei
+{
+
+ReturnCode Isolator::initialize( void * i_buffer, size_t i_bufferSize,
+                                 bool i_forceInit )
+{
+    ReturnCode rc;
+
+    // BEGIN temporary code
+    HEI_INF( "Isolator::initialize(%p,%lu,%d)", i_buffer, i_bufferSize,
+             i_forceInit );
+    // END temporary code
+
+    return rc;
+}
+
+void Isolator::uninitialize()
+{
+    // BEGIN temporary code
+    HEI_INF( "Isolator::uninitialize()" );
+    // END temporary code
+}
+
+ReturnCode Isolator::isolate( IsolationData & o_isoData ) const
+{
+    ReturnCode rc;
+
+    // Flush the isolation data to ensure a clean slate.
+    o_isoData.clear();
+
+    // BEGIN temporary code
+    HEI_INF( "Isolator::isolate(%p,%u)", o_isoData.getChip(),
+             o_isoData.getChipType() );
+    // END temporary code
+
+    return rc;
+}
+
+} // end namespace libhei
diff --git a/src/isolator/hei_isolator.hpp b/src/isolator/hei_isolator.hpp
new file mode 100644
index 0000000..4687b4f
--- /dev/null
+++ b/src/isolator/hei_isolator.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <hei_includes.hpp>
+#include <hei_isolation_data.hpp>
+#include <chip_data/hei_chip_data.hpp>
+
+namespace libhei
+{
+
+/**
+ * @brief This class is a complement to the main APIs. Its purpose is to store
+ *        and maintain all of the objects necessary for isolation.
+ *
+ * The intended flow is to:
+ *  - Create a singleton instance of an Isolator object via getSingleton().
+ *  - Use initialize() to input each necessary Chip Data File provided by the
+ *    user application.
+ *  - Call isolate() each time you want to find all active errors being
+ *    reported by a chip.
+ *  - Once isolation is no longer needed, use uninitialize() to free up
+ *    internal resources.
+ *
+ * The purpose of the singleton instance is to avoid initializing the object
+ * each time isolation is required. The data provided by the Chip Data Files is
+ * static. So reinitializing would be a waste of time, unless for some reason
+ * the Chip Data Files themselves are updated, which would require
+ * reinitialization anyway. Of course, leaving the object in memory chews up
+ * resources. So, some users may need to weigh performance vs. memory usage.
+ */
+class Isolator
+{
+  private: // This class cannot be instantiated. Use getSingleton() instead.
+
+    /** @brief Default constructor. */
+    Isolator() = default;
+
+    /** @brief Destructor. */
+    ~Isolator()
+    {
+        // Clear out all of the internal isolation objects.
+        uninitialize();
+    }
+
+    /** @brief Copy constructor. */
+    Isolator( const Isolator & ) = delete;
+
+    /** @brief Assignment operator. */
+    Isolator & operator=( const Isolator & ) = delete;
+
+  public:
+
+    /** @brief Provides access to a singleton instance of this object. */
+    static Isolator & getSingleton()
+    {
+        static Isolator theIsolator;
+        return theIsolator;
+    }
+
+    /** @brief See API wrapper description in hei_main.hpp. */
+    ReturnCode initialize( void * i_buffer, size_t i_bufferSize,
+                           bool i_forceInit = false );
+
+    /**
+     * @brief See API wrapper description in hei_main.hpp.
+     *
+     * This function is called in the destructor. Therefore, it should never
+     * throw an exception.
+     */
+    void uninitialize();
+
+    /** @brief See API wrapper description in hei_main.hpp. */
+    ReturnCode isolate( IsolationData & o_isoData ) const;
+
+  private:
+
+}; // end class Isolator
+
+} // end namespace libhei