diff --git a/examples/rendering/Rendering.cxx b/examples/rendering/Rendering.cxx
index 6d1545631..be59b7780 100644
--- a/examples/rendering/Rendering.cxx
+++ b/examples/rendering/Rendering.cxx
@@ -138,7 +138,7 @@ main(int argc, char* argv[])
 
     vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
     vtkm::rendering::CanvasGL canvas;
-    vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
+    vtkm::rendering::MapperGL mapper;
 
     vtkm::rendering::Scene scene;
     scene.AddActor(vtkm::rendering::Actor(ds.GetCellSet(),
diff --git a/vtkm/rendering/CMakeLists.txt b/vtkm/rendering/CMakeLists.txt
index 0ff221a6f..908f2fb24 100644
--- a/vtkm/rendering/CMakeLists.txt
+++ b/vtkm/rendering/CMakeLists.txt
@@ -56,6 +56,11 @@ set(sources
   ColorBarAnnotation.cxx
   ColorTable.cxx
   DecodePNG.cxx
+  Mapper.cxx
+  MapperRayTracer.cxx
+  MapperVolume.cxx
+
+  internal/RunTriangulator.cxx
   )
 
 set(opengl_headers
@@ -67,6 +72,7 @@ set(opengl_headers
 
 set(opengl_sources
   CanvasGL.cxx
+  MapperGL.cxx
   )
 
 set(egl_headers
diff --git a/vtkm/rendering/CanvasRayTracer.cxx b/vtkm/rendering/CanvasRayTracer.cxx
index 6299ae9e5..b69db36ff 100644
--- a/vtkm/rendering/CanvasRayTracer.cxx
+++ b/vtkm/rendering/CanvasRayTracer.cxx
@@ -60,6 +60,7 @@ struct ClearBuffersInvokeFunctor
   ColorBufferType ColorBuffer;
   DepthBufferType DepthBuffer;
 
+  VTKM_CONT_EXPORT
   ClearBuffersInvokeFunctor(const vtkm::rendering::Color &backgroundColor,
                             const ColorBufferType &colorBuffer,
                             const DepthBufferType &depthBuffer)
@@ -69,8 +70,11 @@ struct ClearBuffersInvokeFunctor
   {  }
 
   template<typename Device>
+  VTKM_CONT_EXPORT
   bool operator()(Device) const
   {
+    VTKM_IS_DEVICE_ADAPTER_TAG(Device);
+
     vtkm::worklet::DispatcherMapField<ClearBuffers, Device>
         dispatcher(this->Worklet);
     dispatcher.Invoke( this->ColorBuffer, this->DepthBuffer);
@@ -101,7 +105,7 @@ void CanvasRayTracer::Finish()
 
 void CanvasRayTracer::Clear()
 {
-  // TODO: Should the rendering library support policies or some other wayt to
+  // TODO: Should the rendering library support policies or some other way to
   // configure with custom devices?
   vtkm::cont::TryExecute(
         internal::ClearBuffersInvokeFunctor(this->GetBackgroundColor(),
diff --git a/vtkm/rendering/Mapper.cxx b/vtkm/rendering/Mapper.cxx
new file mode 100644
index 000000000..f11960f2d
--- /dev/null
+++ b/vtkm/rendering/Mapper.cxx
@@ -0,0 +1,34 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/rendering/Mapper.h>
+
+namespace vtkm {
+namespace rendering {
+
+Mapper::~Mapper() {  }
+
+void Mapper::SetActiveColorTable(const vtkm::rendering::ColorTable &colorTable)
+{
+  colorTable.Sample(1024, this->ColorMap);
+}
+
+}
+}
diff --git a/vtkm/rendering/Mapper.h b/vtkm/rendering/Mapper.h
index ef8f80325..a3c979395 100644
--- a/vtkm/rendering/Mapper.h
+++ b/vtkm/rendering/Mapper.h
@@ -20,7 +20,6 @@
 #ifndef vtk_m_rendering_Mapper_h
 #define vtk_m_rendering_Mapper_h
 
-#include <vtkm/cont/DataSet.h>
 #include <vtkm/rendering/Camera.h>
 #include <vtkm/rendering/Canvas.h>
 #include <vtkm/rendering/ColorTable.h>
@@ -35,9 +34,10 @@ public:
   {
   }
 
-  VTKM_CONT_EXPORT
-  virtual ~Mapper()
-  {}
+  VTKM_RENDERING_EXPORT
+  virtual ~Mapper();
+
+  VTKM_RENDERING_EXPORT
 
   virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
                            const vtkm::cont::CoordinateSystem &coords,
@@ -46,27 +46,16 @@ public:
                            const vtkm::rendering::Camera &camera,
                            const vtkm::Range &scalarRange) = 0;
 
-  VTKM_CONT_EXPORT
-  virtual void SetActiveColorTable(const ColorTable &ct)
-  {
-      ct.Sample(1024, ColorMap);
-  }
+  VTKM_RENDERING_EXPORT
+  virtual void SetActiveColorTable(const ColorTable &ct);
+
+  VTKM_RENDERING_EXPORT
+  virtual void StartScene() = 0;
+  VTKM_RENDERING_EXPORT
+  virtual void EndScene() = 0;
+  VTKM_RENDERING_EXPORT
+  virtual void SetCanvas(vtkm::rendering::Canvas *canvas) = 0;
 
-  VTKM_CONT_EXPORT
-  virtual void Render() {}
-  VTKM_CONT_EXPORT
-  virtual void Finish() {}
-  VTKM_CONT_EXPORT
-  virtual void StartScene()
-  {
-  }
-  VTKM_CONT_EXPORT
-  virtual void EndScene()
-  {
-  }
-  virtual void SetCanvas(Canvas *vtkmNotUsed(canvas))
-  {
-  }
 protected:
   vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,4> > ColorMap;
 };
diff --git a/vtkm/rendering/MapperGL.cxx b/vtkm/rendering/MapperGL.cxx
new file mode 100644
index 000000000..1fb9676cd
--- /dev/null
+++ b/vtkm/rendering/MapperGL.cxx
@@ -0,0 +1,144 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/rendering/MapperGL.h>
+
+#include <vtkm/cont/TryExecute.h>
+#include <vtkm/rendering/internal/OpenGLHeaders.h>
+#include <vtkm/rendering/internal/RunTriangulator.h>
+
+namespace vtkm {
+namespace rendering {
+
+namespace {
+
+
+template <typename PtType>
+VTKM_CONT_EXPORT
+void RenderTriangles(vtkm::Id numTri, const PtType &verts,
+                     const vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > &indices,
+                     const vtkm::cont::ArrayHandle<vtkm::Float32> &scalar,
+                     const vtkm::rendering::ColorTable &ct,
+                     const vtkm::Range &scalarRange)
+{
+  vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
+  vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
+  vtkm::Float32 sDiff = sMax-sMin;
+
+  glBegin(GL_TRIANGLES);
+  for (int i = 0; i < numTri; i++)
+  {
+    vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
+    vtkm::Id i1 = idx[1];
+    vtkm::Id i2 = idx[2];
+    vtkm::Id i3 = idx[3];
+
+    vtkm::Vec<vtkm::Float32, 3> p1 = verts.GetPortalConstControl().Get(idx[1]);
+    vtkm::Vec<vtkm::Float32, 3> p2 = verts.GetPortalConstControl().Get(idx[2]);
+    vtkm::Vec<vtkm::Float32, 3> p3 = verts.GetPortalConstControl().Get(idx[3]);
+
+    vtkm::Float32 s = scalar.GetPortalConstControl().Get(i1);
+    s = (s-sMin)/sDiff;
+
+    Color color = ct.MapRGB(s);
+    glColor3f(color.Components[0], color.Components[1], color.Components[2]);
+    glVertex3f(p1[0],p1[1],p1[2]);
+
+    s = scalar.GetPortalConstControl().Get(i2);
+    s = (s-sMin)/sDiff;
+    color = ct.MapRGB(s);
+    glColor3f(color.Components[0], color.Components[1], color.Components[2]);
+    glVertex3f(p2[0],p2[1],p2[2]);
+
+    s = scalar.GetPortalConstControl().Get(i3);
+    s = (s-sMin)/sDiff;
+    color = ct.MapRGB(s);
+    glColor3f(color.Components[0], color.Components[1], color.Components[2]);
+    glVertex3f(p3[0],p3[1],p3[2]);
+  }
+  glEnd();
+}
+
+} // anonymous namespace
+
+void MapperGL::RenderCells(const vtkm::cont::DynamicCellSet &cellset,
+                           const vtkm::cont::CoordinateSystem &coords,
+                           const vtkm::cont::Field &scalarField,
+                           const vtkm::rendering::ColorTable &colorTable,
+                           const vtkm::rendering::Camera &,
+                           const vtkm::Range &scalarRange)
+{
+  vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
+  vtkm::Id numTri;
+  vtkm::rendering::internal::RunTriangulator(cellset, indices, numTri);
+
+  vtkm::cont::ArrayHandle<vtkm::Float32> sf;
+  sf = scalarField.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32> >();
+
+  vtkm::cont::DynamicArrayHandleCoordinateSystem dcoords = coords.GetData();
+  vtkm::cont::ArrayHandleUniformPointCoordinates uVerts;
+  vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > eVerts;
+
+  if(dcoords.IsSameType(vtkm::cont::ArrayHandleUniformPointCoordinates()))
+  {
+    uVerts = dcoords.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
+    RenderTriangles(numTri, uVerts, indices, sf, colorTable, scalarRange);
+  }
+  else if(dcoords.IsSameType(vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> >()))
+  {
+    eVerts = dcoords.Cast<vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > > ();
+    RenderTriangles(numTri, eVerts, indices, sf, colorTable, scalarRange);
+  }
+  else if(dcoords.IsSameType(vtkm::cont::ArrayHandleCartesianProduct<
+                             vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+                             vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+                             vtkm::cont::ArrayHandle<vtkm::FloatDefault> >()))
+  {
+    vtkm::cont::ArrayHandleCartesianProduct<
+        vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+        vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+        vtkm::cont::ArrayHandle<vtkm::FloatDefault> > rVerts;
+    rVerts = dcoords.Cast<vtkm::cont::ArrayHandleCartesianProduct<
+                              vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+                              vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
+                              vtkm::cont::ArrayHandle<vtkm::FloatDefault> > > ();
+    RenderTriangles(numTri, rVerts, indices, sf, colorTable, scalarRange);
+  }
+  glFinish();
+  glFlush();
+}
+
+void MapperGL::StartScene()
+{
+  // Nothing needs to be done.
+}
+
+void MapperGL::EndScene()
+{
+  // Nothing needs to be done.
+}
+
+void MapperGL::SetCanvas(vtkm::rendering::Canvas *)
+{
+  // Nothing needs to be done.
+}
+
+}
+} // namespace vtkm::rendering
diff --git a/vtkm/rendering/MapperGL.h b/vtkm/rendering/MapperGL.h
index bea0c2bf9..b95c90d4b 100644
--- a/vtkm/rendering/MapperGL.h
+++ b/vtkm/rendering/MapperGL.h
@@ -20,124 +20,36 @@
 #ifndef vtk_m_rendering_MapperGL_h
 #define vtk_m_rendering_MapperGL_h
 
-#include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/CoordinateSystem.h>
-#include <vtkm/cont/DynamicArrayHandle.h>
 #include <vtkm/rendering/Camera.h>
 #include <vtkm/rendering/ColorTable.h>
 #include <vtkm/rendering/Mapper.h>
-#include <vtkm/rendering/Triangulator.h>
+
 #include <vtkm/rendering/internal/OpenGLHeaders.h>
 
-#include <stdio.h>
-#include <iostream>
-#include <fstream>
-
-
 namespace vtkm {
 namespace rendering {
 
-template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
 class MapperGL : public Mapper
 {
 public:
   VTKM_CONT_EXPORT
   MapperGL() {}
 
-  VTKM_CONT_EXPORT
-  virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
-                           const vtkm::cont::CoordinateSystem &coords,
-                           const vtkm::cont::Field &scalarField,
-                           const vtkm::rendering::ColorTable &colorTable,
-                           const vtkm::rendering::Camera &,
-                           const vtkm::Range &scalarRange)
-  {
-    vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
-    vtkm::Id numTri;
-    Triangulator<DeviceAdapter> triangulator;
-    triangulator.run(cellset, indices, numTri);
+  VTKM_RENDERING_EXPORT
+  void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
+                   const vtkm::cont::CoordinateSystem &coords,
+                   const vtkm::cont::Field &scalarField,
+                   const vtkm::rendering::ColorTable &colorTable,
+                   const vtkm::rendering::Camera &,
+                   const vtkm::Range &scalarRange) VTKM_OVERRIDE;
 
-    vtkm::cont::ArrayHandle<vtkm::Float32> sf;
-    sf = scalarField.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32> >();
-
-    vtkm::cont::DynamicArrayHandleCoordinateSystem dcoords = coords.GetData();
-    vtkm::cont::ArrayHandleUniformPointCoordinates uVerts;
-    vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > eVerts;
-
-    if(dcoords.IsSameType(vtkm::cont::ArrayHandleUniformPointCoordinates()))
-    {
-      uVerts = dcoords.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
-      RenderTriangles(numTri, uVerts, indices, sf, colorTable, scalarRange);
-    }
-    else if(dcoords.IsSameType(vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> >()))
-    {
-      eVerts = dcoords.Cast<vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > > ();
-      RenderTriangles(numTri, eVerts, indices, sf, colorTable, scalarRange);
-    }
-    else if(dcoords.IsSameType(vtkm::cont::ArrayHandleCartesianProduct<
-                               vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-                               vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-                               vtkm::cont::ArrayHandle<vtkm::FloatDefault> >()))
-    {
-      vtkm::cont::ArrayHandleCartesianProduct<
-          vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-          vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-          vtkm::cont::ArrayHandle<vtkm::FloatDefault> > rVerts;
-      rVerts = dcoords.Cast<vtkm::cont::ArrayHandleCartesianProduct<
-                                vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-                                vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
-                                vtkm::cont::ArrayHandle<vtkm::FloatDefault> > > ();
-      RenderTriangles(numTri, rVerts, indices, sf, colorTable, scalarRange);
-    }
-    glFinish();
-    glFlush();
-  }
-
-  template <typename PtType>
-  VTKM_CONT_EXPORT
-  void RenderTriangles(vtkm::Id numTri, const PtType &verts,
-                       const vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > &indices,
-                       const vtkm::cont::ArrayHandle<vtkm::Float32> &scalar,
-                       const vtkm::rendering::ColorTable &ct,
-                       const vtkm::Range &scalarRange)
-  {
-    vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
-    vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
-    vtkm::Float32 sDiff = sMax-sMin;
-
-    glBegin(GL_TRIANGLES);
-    for (int i = 0; i < numTri; i++)
-    {
-      vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
-      vtkm::Id i1 = idx[1];
-      vtkm::Id i2 = idx[2];
-      vtkm::Id i3 = idx[3];
-
-      vtkm::Vec<vtkm::Float32, 3> p1 = verts.GetPortalConstControl().Get(idx[1]);
-      vtkm::Vec<vtkm::Float32, 3> p2 = verts.GetPortalConstControl().Get(idx[2]);
-      vtkm::Vec<vtkm::Float32, 3> p3 = verts.GetPortalConstControl().Get(idx[3]);
-
-      vtkm::Float32 s = scalar.GetPortalConstControl().Get(i1);
-      s = (s-sMin)/sDiff;
-
-      Color color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p1[0],p1[1],p1[2]);
-
-      s = scalar.GetPortalConstControl().Get(i2);
-      s = (s-sMin)/sDiff;
-      color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p2[0],p2[1],p2[2]);
-
-      s = scalar.GetPortalConstControl().Get(i3);
-      s = (s-sMin)/sDiff;
-      color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p3[0],p3[1],p3[2]);
-    }
-    glEnd();
-  }
+  VTKM_RENDERING_EXPORT
+  void StartScene() VTKM_OVERRIDE;
+  VTKM_RENDERING_EXPORT
+  void EndScene() VTKM_OVERRIDE;
+  VTKM_RENDERING_EXPORT
+  void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
 };
 
 }} //namespace vtkm::rendering
diff --git a/vtkm/rendering/MapperRayTracer.cxx b/vtkm/rendering/MapperRayTracer.cxx
new file mode 100644
index 000000000..ff696966f
--- /dev/null
+++ b/vtkm/rendering/MapperRayTracer.cxx
@@ -0,0 +1,192 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/rendering/MapperRayTracer.h>
+
+#include <vtkm/cont/TryExecute.h>
+#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
+#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
+
+#include <vtkm/rendering/CanvasRayTracer.h>
+#include <vtkm/rendering/internal/RunTriangulator.h>
+#include <vtkm/rendering/raytracing/RayTracer.h>
+#include <vtkm/rendering/raytracing/Camera.h>
+
+namespace vtkm {
+namespace rendering {
+
+struct MapperRayTracer::InternalsType
+{
+  vtkm::rendering::CanvasRayTracer *Canvas;
+  vtkm::cont::internal::RuntimeDeviceTracker DeviceTracker;
+  boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
+      RayTracerContainer;
+
+  VTKM_CONT_EXPORT
+  InternalsType()
+    : Canvas(nullptr)
+  {  }
+
+  template<typename Device>
+  VTKM_CONT_EXPORT
+  vtkm::rendering::raytracing::RayTracer<Device> *GetRayTracer(Device)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(Device);
+
+    typedef vtkm::rendering::raytracing::RayTracer<Device> RayTracerType;
+    typedef vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>
+        ContainerType;
+    RayTracerType *tracer = NULL;
+    if (this->RayTracerContainer)
+    {
+      ContainerType *container =
+          dynamic_cast<ContainerType *>(this->RayTracerContainer.get());
+      if (container)
+      {
+        tracer = &container->Item;
+      }
+    }
+
+    if (tracer == NULL)
+    {
+      ContainerType *container
+          = new vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>;
+      tracer = &container->Item;
+      this->RayTracerContainer.reset(container);
+    }
+
+    return tracer;
+  }
+};
+
+MapperRayTracer::MapperRayTracer()
+  : Internals(new InternalsType)
+{  }
+
+void MapperRayTracer::SetCanvas(vtkm::rendering::Canvas *canvas)
+{
+  if(canvas != nullptr)
+  {
+    this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
+    if(this->Internals->Canvas == nullptr)
+    {
+      throw vtkm::cont::ErrorControlBadValue(
+        "Ray Tracer: bad canvas type. Must be CanvasRayTracer");
+    }
+  }
+  else
+  {
+    this->Internals->Canvas = nullptr;
+  }
+}
+
+struct MapperRayTracer::RenderFunctor
+{
+  vtkm::rendering::MapperRayTracer *Self;
+  vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4> > TriangleIndices;
+  vtkm::Id NumberOfTriangles;
+  vtkm::cont::CoordinateSystem Coordinates;
+  vtkm::cont::Field ScalarField;
+  vtkm::rendering::Camera Camera;
+  vtkm::Range ScalarRange;
+
+  VTKM_CONT_EXPORT
+  RenderFunctor(vtkm::rendering::MapperRayTracer *self,
+                const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
+                vtkm::Id numberOfTriangles,
+                const vtkm::cont::CoordinateSystem &coordinates,
+                const vtkm::cont::Field &scalarField,
+                const vtkm::rendering::Camera &camera,
+                const vtkm::Range &scalarRange)
+    : Self(self),
+      TriangleIndices(indices),
+      NumberOfTriangles(numberOfTriangles),
+      Coordinates(coordinates),
+      ScalarField(scalarField),
+      Camera(camera),
+      ScalarRange(scalarRange)
+  {  }
+
+  template<typename Device>
+  bool operator()(Device)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(Device);
+
+    vtkm::rendering::raytracing::RayTracer<Device> *tracer =
+        this->Self->Internals->GetRayTracer(Device());
+
+    tracer->GetCamera().SetParameters(this->Camera,
+                                      *this->Self->Internals->Canvas);
+
+    vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
+
+    tracer->SetData(this->Coordinates.GetData(),
+                    this->TriangleIndices,
+                    this->ScalarField,
+                    this->NumberOfTriangles,
+                    this->ScalarRange,
+                    dataBounds);
+    tracer->SetColorMap(this->Self->ColorMap);
+    tracer->SetBackgroundColor(
+          this->Self->Internals->Canvas->GetBackgroundColor().Components);
+    tracer->Render(this->Self->Internals->Canvas);
+
+    return true;
+  }
+};
+
+void MapperRayTracer::RenderCells(
+    const vtkm::cont::DynamicCellSet &cellset,
+    const vtkm::cont::CoordinateSystem &coords,
+    const vtkm::cont::Field &scalarField,
+    const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
+    const vtkm::rendering::Camera &camera,
+    const vtkm::Range &scalarRange)
+{
+  vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> >  indices;
+  vtkm::Id numberOfTriangles;
+  vtkm::rendering::internal::RunTriangulator(
+        cellset, indices, numberOfTriangles, this->Internals->DeviceTracker);
+
+  RenderFunctor functor(this,
+                        indices,
+                        numberOfTriangles,
+                        coords,
+                        scalarField,
+                        camera,
+                        scalarRange);
+  vtkm::cont::TryExecute(functor,
+                         this->Internals->DeviceTracker,
+                         VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
+}
+
+void MapperRayTracer::StartScene()
+{
+  // Nothing needs to be done.
+}
+
+void MapperRayTracer::EndScene()
+{
+  // Nothing needs to be done.
+}
+
+
+}
+} // vtkm::rendering
diff --git a/vtkm/rendering/MapperRayTracer.h b/vtkm/rendering/MapperRayTracer.h
index bf86e76bc..ec2a5fd08 100644
--- a/vtkm/rendering/MapperRayTracer.h
+++ b/vtkm/rendering/MapperRayTracer.h
@@ -19,82 +19,48 @@
 //============================================================================
 #ifndef vtk_m_rendering_MapperRayTracer_h
 #define vtk_m_rendering_MapperRayTracer_h
-#include <vtkm/cont/Timer.h>
-#include <vtkm/cont/internal/DeviceAdapterTagSerial.h>
+
 #include <vtkm/rendering/ColorTable.h>
 #include <vtkm/rendering/Mapper.h>
-#include <vtkm/rendering/Triangulator.h>
-#include <vtkm/rendering/raytracing/RayTracer.h>
-#include <vtkm/rendering/raytracing/Camera.h>
-#include <vtkm/rendering/CanvasRayTracer.h>
 #include <vtkm/rendering/Camera.h>
+
+VTKM_THIRDPARTY_PRE_INCLUDE
+#include <boost/smart_ptr.hpp>
+VTKM_THIRDPARTY_POST_INCLUDE
+
 namespace vtkm {
 namespace rendering {
 
-//  static bool doOnce = true;
-template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
 class MapperRayTracer : public Mapper
 {
-protected:
-  vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,4> > ColorMap;
-  vtkm::rendering::raytracing::RayTracer<DeviceAdapter> Tracer;
-  CanvasRayTracer *Canvas;
 public:
-  VTKM_CONT_EXPORT
-  MapperRayTracer()
-  {
-    this->Canvas = nullptr;
-  }
-  VTKM_CONT_EXPORT
-  void SetCanvas(vtkm::rendering::Canvas *canvas)
-  {
-    if(canvas != nullptr)
-    {
+  VTKM_RENDERING_EXPORT
+  MapperRayTracer();
 
-      this->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
-      if(this->Canvas == nullptr)
-      {
-        throw vtkm::cont::ErrorControlBadValue(
-          "Ray Tracer: bad canvas type. Must be CanvasRayTracer");
-      }
-    }
-  }
-  VTKM_CONT_EXPORT
-  void SetActiveColorTable(const ColorTable &colorTable)
-  {
-    colorTable.Sample(1024, ColorMap);
-  }
+  VTKM_RENDERING_EXPORT
+  void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
 
-  VTKM_CONT_EXPORT
+  VTKM_RENDERING_EXPORT
   void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
                    const vtkm::cont::CoordinateSystem &coords,
                    const vtkm::cont::Field &scalarField,
-                   const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
+                   const vtkm::rendering::ColorTable &colorTable,
                    const vtkm::rendering::Camera &camera,
-                   const vtkm::Range &scalarRange)
-  {
+                   const vtkm::Range &scalarRange) VTKM_OVERRIDE;
 
-    const vtkm::cont::DynamicArrayHandleCoordinateSystem dynamicCoordsHandle = coords.GetData();
-    vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> >  indices;
-    this->Tracer.GetCamera().SetParameters(camera, *this->Canvas);
-    vtkm::Id numberOfTriangles;
+  VTKM_RENDERING_EXPORT
+  virtual void StartScene() VTKM_OVERRIDE;
+  VTKM_RENDERING_EXPORT
+  virtual void EndScene() VTKM_OVERRIDE;
 
-    vtkm::Bounds dataBounds = coords.GetBounds(DeviceAdapter());
+private:
+  struct InternalsType;
+  boost::shared_ptr<InternalsType> Internals;
 
-    Triangulator<DeviceAdapter> triangulator;
-    triangulator.run(cellset, indices, numberOfTriangles);//,dynamicCoordsHandle,dataBounds);
-
-    this->Tracer.SetData(dynamicCoordsHandle,
-                         indices,
-                         scalarField,
-                         numberOfTriangles,
-                         scalarRange,
-                         dataBounds);
-    this->Tracer.SetColorMap(this->ColorMap);
-    this->Tracer.SetBackgroundColor(
-          this->Canvas->GetBackgroundColor().Components);
-    this->Tracer.Render(this->Canvas);
-  }
+  struct RenderFunctor;
 };
-}} //namespace vtkm::rendering
+
+}
+} //namespace vtkm::rendering
+
 #endif //vtk_m_rendering_MapperRayTracer_h
diff --git a/vtkm/rendering/MapperVolume.cxx b/vtkm/rendering/MapperVolume.cxx
new file mode 100644
index 000000000..0cd2e0568
--- /dev/null
+++ b/vtkm/rendering/MapperVolume.cxx
@@ -0,0 +1,196 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/rendering/MapperVolume.h>
+
+#include <vtkm/cont/TryExecute.h>
+#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
+#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
+
+#include <vtkm/rendering/CanvasRayTracer.h>
+
+#include <vtkm/rendering/internal/RunTriangulator.h>
+
+#include <vtkm/rendering/raytracing/Camera.h>
+#include <vtkm/rendering/raytracing/VolumeRendererStructured.h>
+
+#include <typeinfo>
+
+namespace vtkm {
+namespace rendering {
+
+struct MapperVolume::InternalsType
+{
+  vtkm::rendering::CanvasRayTracer *Canvas;
+  vtkm::cont::internal::RuntimeDeviceTracker DeviceTracker;
+  boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
+      RayTracerContainer;
+
+  VTKM_CONT_EXPORT
+  InternalsType()
+    : Canvas(nullptr)
+  {  }
+
+  template<typename Device>
+  VTKM_CONT_EXPORT
+  vtkm::rendering::raytracing::VolumeRendererStructured<Device> *
+  GetRayTracer(Device)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(Device);
+
+    typedef vtkm::rendering::raytracing::VolumeRendererStructured<Device>
+        RayTracerType;
+    typedef vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>
+        ContainerType;
+    RayTracerType *tracer = NULL;
+    if (this->RayTracerContainer)
+    {
+      ContainerType *container =
+          dynamic_cast<ContainerType *>(this->RayTracerContainer.get());
+      if (container)
+      {
+        tracer = &container->Item;
+      }
+    }
+
+    if (tracer == NULL)
+    {
+      ContainerType *container
+          = new vtkm::cont::internal::SimplePolymorphicContainer<RayTracerType>;
+      tracer = &container->Item;
+      this->RayTracerContainer.reset(container);
+    }
+
+    return tracer;
+  }
+};
+
+MapperVolume::MapperVolume()
+  : Internals(new InternalsType)
+{  }
+
+void MapperVolume::SetCanvas(vtkm::rendering::Canvas *canvas)
+{
+  if(canvas != nullptr)
+  {
+    this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
+    if(this->Internals->Canvas == nullptr)
+    {
+      throw vtkm::cont::ErrorControlBadValue(
+        "Ray Tracer: bad canvas type. Must be CanvasRayTracer");
+    }
+  }
+  else
+  {
+    this->Internals->Canvas = nullptr;
+  }
+}
+
+struct MapperVolume::RenderFunctor
+{
+  vtkm::rendering::MapperVolume *Self;
+  vtkm::cont::CellSetStructured<3> CellSet;
+  vtkm::cont::CoordinateSystem Coordinates;
+  vtkm::cont::Field ScalarField;
+  vtkm::rendering::Camera Camera;
+  vtkm::Range ScalarRange;
+
+  VTKM_CONT_EXPORT
+  RenderFunctor(vtkm::rendering::MapperVolume *self,
+                const vtkm::cont::CellSetStructured<3> cellSet,
+                const vtkm::cont::CoordinateSystem &coordinates,
+                const vtkm::cont::Field &scalarField,
+                const vtkm::rendering::Camera &camera,
+                const vtkm::Range &scalarRange)
+    : Self(self),
+      CellSet(cellSet),
+      Coordinates(coordinates),
+      ScalarField(scalarField),
+      Camera(camera),
+      ScalarRange(scalarRange)
+  {  }
+
+  template<typename Device>
+  bool operator()(Device)
+  {
+    VTKM_IS_DEVICE_ADAPTER_TAG(Device);
+
+    vtkm::rendering::raytracing::VolumeRendererStructured<Device> *tracer =
+        this->Self->Internals->GetRayTracer(Device());
+
+    tracer->GetCamera().SetParameters(this->Camera,
+                                      *this->Self->Internals->Canvas);
+
+    vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
+
+    tracer->SetData(this->Coordinates,
+                    this->ScalarField,
+                    dataBounds,
+                    this->CellSet,
+                    this->ScalarRange);
+    tracer->SetColorMap(this->Self->ColorMap);
+    tracer->SetBackgroundColor(
+          this->Self->Internals->Canvas->GetBackgroundColor().Components);
+    tracer->Render(this->Self->Internals->Canvas);
+
+    return true;
+  }
+};
+
+void MapperVolume::RenderCells(
+    const vtkm::cont::DynamicCellSet &cellset,
+    const vtkm::cont::CoordinateSystem &coords,
+    const vtkm::cont::Field &scalarField,
+    const vtkm::rendering::ColorTable &vtkmNotUsed(colorTable),
+    const vtkm::rendering::Camera &camera,
+    const vtkm::Range &scalarRange)
+{
+  if(!cellset.IsSameType(vtkm::cont::CellSetStructured<3>()))
+  {
+    std::cerr<<"ERROR cell set type not currently supported\n";
+    std::string theType = typeid(cellset).name();
+    std::cerr<<"Type : "<<theType<<std::endl;
+  }
+  else
+  {
+    RenderFunctor functor(this,
+                          cellset.Cast<vtkm::cont::CellSetStructured<3> >(),
+                          coords,
+                          scalarField,
+                          camera,
+                          scalarRange);
+    vtkm::cont::TryExecute(functor,
+                           this->Internals->DeviceTracker,
+                           VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
+  }
+}
+
+void MapperVolume::StartScene()
+{
+  // Nothing needs to be done.
+}
+
+void MapperVolume::EndScene()
+{
+  // Nothing needs to be done.
+}
+
+}
+} // namespace vtkm::rendering
diff --git a/vtkm/rendering/MapperVolume.h b/vtkm/rendering/MapperVolume.h
index 9a7e8d93c..9cc82021f 100644
--- a/vtkm/rendering/MapperVolume.h
+++ b/vtkm/rendering/MapperVolume.h
@@ -20,87 +20,45 @@
 #ifndef vtk_m_rendering_MapperVolume_h
 #define vtk_m_rendering_MapperVolume_h
 
-#include <vtkm/rendering/Camera.h>
-#include <vtkm/rendering/CanvasRayTracer.h>
-#include <vtkm/rendering/ColorTable.h>
 #include <vtkm/rendering/Mapper.h>
-#include <vtkm/rendering/Triangulator.h>
-#include <vtkm/rendering/raytracing/VolumeRendererStructured.h>
-#include <vtkm/rendering/raytracing/Camera.h>
 
-#include <typeinfo>
+VTKM_THIRDPARTY_PRE_INCLUDE
+#include <boost/smart_ptr.hpp>
+VTKM_THIRDPARTY_POST_INCLUDE
 
 namespace vtkm {
 namespace rendering {
-template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
+
 class MapperVolume : public Mapper
 {
-protected:
-  vtkm::rendering::raytracing::VolumeRendererStructured<DeviceAdapter>  Tracer;
-  CanvasRayTracer *Canvas;
 public:
-  VTKM_CONT_EXPORT
-  MapperVolume()
-  {
-    this->Canvas = nullptr;
-  }
+  VTKM_RENDERING_EXPORT
+  MapperVolume();
 
-  VTKM_CONT_EXPORT
-  void SetNumberOfSamples(const vtkm::Int32 &numSamples)
-  {
-    Tracer.SetNumberOfSamples(numSamples);
-  }
+  VTKM_RENDERING_EXPORT
+  void SetCanvas(vtkm::rendering::Canvas *canvas) VTKM_OVERRIDE;
 
-  VTKM_CONT_EXPORT
-  void SetCanvas(vtkm::rendering::Canvas *canvas)
-  {
-    if(canvas != nullptr)
-    {
-
-      this->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
-      if(this->Canvas == nullptr)
-      {
-        throw vtkm::cont::ErrorControlBadValue(
-          "Volume Render: bad canvas type. Must be CanvasRayTracer");
-      }
-    }
-  }
-
-  VTKM_CONT_EXPORT
+  VTKM_RENDERING_EXPORT
   virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
                            const vtkm::cont::CoordinateSystem &coords,
                            const vtkm::cont::Field &scalarField,
                            const vtkm::rendering::ColorTable &, //colorTable
                            const vtkm::rendering::Camera &camera,
-                           const vtkm::Range &scalarRange)
-  {
-//    vtkm::cont::DynamicArrayHandleCoordinateSystem dynamicCoordsHandle = coords.GetData();
-    vtkm::Bounds coordsBounds = coords.GetBounds(DeviceAdapter());
+                           const vtkm::Range &scalarRange) VTKM_OVERRIDE;
 
-    if(!cellset.IsSameType(vtkm::cont::CellSetStructured<3>()))
-    {
-      std::cerr<<"ERROR cell set type not currently supported\n";
-      std::string theType = typeid(cellset).name();
-      std::cerr<<"Type : "<<theType<<std::endl;
-    }
-    else
-    {
-      vtkm::cont::CellSetStructured<3> cellSetStructured3D = cellset.Cast<vtkm::cont::CellSetStructured<3> >();
-      //vtkm::cont::ArrayHandleUniformPointCoordinates vertices;
-      //vertices = dynamicCoordsHandle.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
-      this->Tracer.GetCamera().SetParameters(camera, *this->Canvas);
-      this->Tracer.SetData(coords,
-                           scalarField,
-                           coordsBounds,
-                           cellSetStructured3D,
-                           scalarRange);
-      this->Tracer.SetColorMap(this->ColorMap);
-      this->Tracer.SetBackgroundColor(
-            this->Canvas->GetBackgroundColor().Components);
-      this->Tracer.Render(this->Canvas);
-    }
+  VTKM_RENDERING_EXPORT
+  virtual void StartScene() VTKM_OVERRIDE;
+  VTKM_RENDERING_EXPORT
+  virtual void EndScene() VTKM_OVERRIDE;
 
-  }
+private:
+  struct InternalsType;
+  boost::shared_ptr<InternalsType> Internals;
+
+  struct RenderFunctor;
 };
-}} //namespace vtkm::rendering
+
+}
+} //namespace vtkm::rendering
+
 #endif //vtk_m_rendering_MapperVolume_h
diff --git a/vtkm/rendering/Triangulator.h b/vtkm/rendering/Triangulator.h
index 933f1cc13..a70465f3a 100644
--- a/vtkm/rendering/Triangulator.h
+++ b/vtkm/rendering/Triangulator.h
@@ -457,7 +457,7 @@ public:
   }
 
   VTKM_CONT_EXPORT
-  void run(const vtkm::cont::DynamicCellSet &cellset,
+  void Run(const vtkm::cont::DynamicCellSet &cellset,
            vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id,4> > &outputIndices,
            vtkm::Id &outputTriangles)
   {
diff --git a/vtkm/rendering/internal/CMakeLists.txt b/vtkm/rendering/internal/CMakeLists.txt
index e7cce6b7c..489e607a7 100644
--- a/vtkm/rendering/internal/CMakeLists.txt
+++ b/vtkm/rendering/internal/CMakeLists.txt
@@ -20,6 +20,7 @@
 
 set(headers
   OpenGLHeaders.h
+  RunTriangulator.h
   )
 
 vtkm_declare_headers(${headers})
diff --git a/vtkm/rendering/internal/RunTriangulator.cxx b/vtkm/rendering/internal/RunTriangulator.cxx
new file mode 100644
index 000000000..b3724c3c8
--- /dev/null
+++ b/vtkm/rendering/internal/RunTriangulator.cxx
@@ -0,0 +1,85 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/rendering/internal/RunTriangulator.h>
+
+#include <vtkm/cont/TryExecute.h>
+#include <vtkm/rendering/Triangulator.h>
+
+namespace vtkm {
+namespace rendering {
+namespace internal {
+
+namespace {
+
+struct TriangulatorFunctor
+{
+  vtkm::cont::DynamicCellSet CellSet;
+  vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > Indices;
+  vtkm::Id NumberOfTriangles;
+
+  VTKM_CONT_EXPORT
+  TriangulatorFunctor(vtkm::cont::DynamicCellSet cellSet)
+    : CellSet(cellSet)
+  {  }
+
+  template<typename Device>
+  VTKM_CONT_EXPORT
+  bool operator()(Device)
+  {
+    vtkm::rendering::Triangulator<Device> triangulator;
+    triangulator.Run(this->CellSet, this->Indices, this->NumberOfTriangles);
+    return true;
+  }
+};
+
+} // anonymous namespace
+
+void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
+                     vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
+                     vtkm::Id &numberOfTriangles,
+                     vtkm::cont::internal::RuntimeDeviceTracker &tracker)
+{
+  // TODO: Should the rendering library support policies or some other way to
+  // configure with custom devices?
+  TriangulatorFunctor triangulatorFunctor(cellSet);
+  if (!vtkm::cont::TryExecute(triangulatorFunctor,
+                              tracker,
+                              VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG()))
+  {
+    throw vtkm::cont::ErrorExecution("Failed to execute triangulator.");
+  }
+
+  indices = triangulatorFunctor.Indices;
+  numberOfTriangles = triangulatorFunctor.NumberOfTriangles;
+}
+
+void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
+                     vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
+                     vtkm::Id &numberOfTriangles)
+{
+  vtkm::cont::internal::RuntimeDeviceTracker tracker;
+  vtkm::rendering::internal::RunTriangulator(
+        cellSet, indices, numberOfTriangles, tracker);
+}
+
+}
+}
+} // namespace vtkm::rendering::internal
diff --git a/vtkm/rendering/internal/RunTriangulator.h b/vtkm/rendering/internal/RunTriangulator.h
new file mode 100644
index 000000000..dd9cffb4f
--- /dev/null
+++ b/vtkm/rendering/internal/RunTriangulator.h
@@ -0,0 +1,52 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2016 Sandia Corporation.
+//  Copyright 2016 UT-Battelle, LLC.
+//  Copyright 2016 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtk_m_rendering_internal_RunTriangulator_h
+#define vtk_m_rendering_internal_RunTriangulator_h
+
+#include <vtkm/rendering/vtkm_rendering_export.h>
+
+#include <vtkm/cont/ArrayHandle.h>
+#include <vtkm/cont/DynamicCellSet.h>
+#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
+
+namespace vtkm {
+namespace rendering {
+namespace internal {
+
+/// This is a wrapper around the Triangulator worklet so that the
+/// implementation of the triangulator only gets compiled once. This function
+/// really is a stop-gap. Eventually, the Triangulator should be moved to
+/// filters, and filters should be compiled in a library (for the same reason).
+///
+VTKM_RENDERING_EXPORT
+void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
+                     vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
+                     vtkm::Id &numberOfTriangles);
+VTKM_RENDERING_EXPORT
+void RunTriangulator(const vtkm::cont::DynamicCellSet &cellSet,
+                     vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id,4> > &indices,
+                     vtkm::Id &numberOfTriangles,
+                     vtkm::cont::internal::RuntimeDeviceTracker &tracker);
+
+}
+}
+} // namespace vtkm::rendering::internal
+
+#endif //vtk_m_rendering_internal_RunTriangulator_h
diff --git a/vtkm/rendering/testing/UnitTestMapperRayTracer.cxx b/vtkm/rendering/testing/UnitTestMapperRayTracer.cxx
index b2a5db796..266c735f5 100644
--- a/vtkm/rendering/testing/UnitTestMapperRayTracer.cxx
+++ b/vtkm/rendering/testing/UnitTestMapperRayTracer.cxx
@@ -53,7 +53,7 @@ void Render(const vtkm::cont::DataSet &ds,
 {
     const vtkm::Int32 W = 512, H = 512;
     const vtkm::cont::CoordinateSystem coords = ds.GetCoordinateSystem();
-    vtkm::rendering::MapperRayTracer<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
+    vtkm::rendering::MapperRayTracer mapper;
 
     vtkm::rendering::Camera camera;
     Set3DView(camera, coords);
diff --git a/vtkm/rendering/testing/UnitTestMapperVolume.cxx b/vtkm/rendering/testing/UnitTestMapperVolume.cxx
index e416abb81..f251d8988 100644
--- a/vtkm/rendering/testing/UnitTestMapperVolume.cxx
+++ b/vtkm/rendering/testing/UnitTestMapperVolume.cxx
@@ -54,7 +54,7 @@ void Render(const vtkm::cont::DataSet &ds,
 {
     const vtkm::Int32 W = 512, H = 512;
     const vtkm::cont::CoordinateSystem coords = ds.GetCoordinateSystem();
-    vtkm::rendering::MapperVolume<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
+    vtkm::rendering::MapperVolume mapper;
 
     vtkm::rendering::Camera camera;
     Set3DView(camera, coords);
diff --git a/vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx b/vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
index bbd5ac225..09aedc7c3 100644
--- a/vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
+++ b/vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
@@ -49,10 +49,10 @@ void RenderTests()
 {
     std::cout<<"Press any key to cycle through datasets. ESC to quit."<<std::endl;
 
-    typedef vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> M;
-    typedef vtkm::rendering::CanvasGL C;
-    typedef vtkm::rendering::View3D V3;
-    typedef vtkm::rendering::View2D V2;    
+    typedef vtkm::rendering::MapperGL MapperType;
+    typedef vtkm::rendering::CanvasGL CanvasType;
+    typedef vtkm::rendering::View3D View3DType;
+    typedef vtkm::rendering::View2D View2DType;
     
     vtkm::cont::testing::MakeTestDataSet maker;
     vtkm::rendering::ColorTable colorTable("thermal");
@@ -67,16 +67,16 @@ void RenderTests()
        glfwPollEvents();
 
        if (which == 0)
-           vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DRegularDataSet0(),
+           vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DRegularDataSet0(),
                                                     "pointvar", colorTable, "reg3D.pnm");
        else if (which == 1)
-           vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DRectilinearDataSet0(),
+           vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DRectilinearDataSet0(),
                                                     "pointvar", colorTable, "rect3D.pnm");
        else if (which == 2)
-           vtkm::rendering::testing::Render<M,C,V3>(maker.Make3DExplicitDataSet4(),
+           vtkm::rendering::testing::Render<MapperType,CanvasType,View3DType>(maker.Make3DExplicitDataSet4(),
                                                     "pointvar", colorTable, "expl3D.pnm");
        else if (which == 3)
-           vtkm::rendering::testing::Render<M,C,V2>(maker.Make2DRectilinearDataSet0(),
+           vtkm::rendering::testing::Render<MapperType,CanvasType,View2DType>(maker.Make2DRectilinearDataSet0(),
                                                     "pointvar", colorTable, "rect2D.pnm");       
        glfwSwapBuffers(window);