diff --git a/apps/pdal.cpp b/apps/pdal.cpp
index 6a8e802231..4ad0c3165b 100644
--- a/apps/pdal.cpp
+++ b/apps/pdal.cpp
@@ -1,6 +1,6 @@
 /******************************************************************************
 * Copyright (c) 2013, Howard Butler (hobu.inc@gmail.com)
-* Copyright (c) 2014, Bradley J Chambers (brad.chambers@gmail.com)
+* Copyright (c) 2014-2015, Bradley J Chambers (brad.chambers@gmail.com)
 *
 * All rights reserved.
 *
@@ -33,17 +33,32 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-//#include <pdal/Kernels.hpp>
 #include <pdal/KernelFactory.hpp>
+#include <pdal/StageFactory.hpp>
 #include <pdal/pdal_config.hpp>
 
 #include <boost/algorithm/string.hpp>
 
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
 using namespace pdal;
-namespace po = boost::program_options;
 
 std::string headline("------------------------------------------------------------------------------------------");
 
+std::string splitDriverName(std::string const& name)
+{
+    std::vector<std::string> driverVec;
+    boost::algorithm::split(driverVec, name,
+        boost::algorithm::is_any_of("."), boost::algorithm::token_compress_on);
+
+    return driverVec[1];
+}
+
 void outputVersion()
 {
     std::cout << headline << std::endl;
@@ -52,17 +67,23 @@ void outputVersion()
     std::cout << std::endl;
 }
 
-void outputHelp(po::options_description const& options)
+void outputHelp()
 {
-    std::cerr << "Usage: pdal <command> [--debug] [--drivers] [--help] [--options[=<driver name>]] [--version]" << std::endl;
-    std::cerr << options << std::endl;
+    std::cerr << "Usage: pdal <command> [--debug] [--drivers] [--help] [--options[=<driver name>]] [--version]\n";
+    std::cerr << "  --debug                Show debug information\n";
+    std::cerr << "  --drivers              Show drivers\n";
+    std::cerr << "  -h [ --help ]          Print help message\n";
+    std::cerr << "  --options [=arg(=all)] Show driver options\n";
+    std::cerr << "  --version              Show version info\n";
+    std::cerr << "\n";
         
-    std::cerr << "The most commonly used pdal commands are:" << std::endl;
+    std::cerr << "The most commonly used pdal commands are:\n";
 
-    KernelFactory f;
-    std::map<std::string, KernelInfo> const& kernels = f.getKernelInfos();
-    for (auto i = kernels.begin(); i != kernels.end(); ++i)
-        std::cout << "    - " << i->second.getName() << std::endl;
+    KernelFactory f(false);
+    std::vector<std::string> loaded_kernels = f.getKernelNames();
+
+    for (auto name : loaded_kernels)
+        std::cout << "   - " << splitDriverName(name) << std::endl;
 
     std::cout << "See http://pdal.io/apps.html for more detail";
     std::cout << std::endl;
@@ -70,8 +91,8 @@ void outputHelp(po::options_description const& options)
 
 void outputDrivers()
 {
-    StageFactory f;
-    std::map<std::string, StageInfo> const& drivers = f.getStageInfos();
+    StageFactory f(false);
+    std::map<std::string, std::string> sm = f.getStageMap();
 
     std::ostringstream strm;
 
@@ -88,21 +109,21 @@ void outputDrivers()
 
     strm << std::left;
 
-    for (auto i = drivers.begin(); i != drivers.end(); ++i)
+    for (auto s : sm)
     {
         std::vector<std::string> lines;
-        std::string description(i->second.getDescription());
+        std::string description(s.second);
         description = boost::algorithm::erase_all_copy(description, "\n");
 
         Utils::wordWrap(description, lines, description_column-1);
         if (lines.size() == 1)
         {
-            strm << std::setw(name_column) << i->second.getName() << " "
+            strm << std::setw(name_column) << s.first << " "
                  << std::setw(description_column) << description << std::endl;
         }
         else
         {
-            strm << std::setw(name_column) << i->second.getName() << " "
+            strm << std::setw(name_column) << s.first << " "
                  << lines[0] << std::endl;
         }
 
@@ -118,108 +139,226 @@ void outputDrivers()
     std::cout << strm.str() << std::endl;
 }
 
-void outputOptions(std::string const& opt)
+void outputOptions(std::string const& n)
+{
+    StageFactory f(false);
+    std::unique_ptr<Stage> s = f.createStage(n);
+
+    if (!s)
+    {
+        std::cerr << "Unable to create stage " << n << "\n";
+        return;
+    }
+
+    std::vector<Option> options = s->getDefaultOptions().getOptions();
+    if (options.size())
+    {
+        std::ostringstream strm;
+
+        strm << n << std::endl;
+        strm << headline << std::endl;
+
+        std::string tablehead("================================ =============== =========================================");
+        std::string headings ("Name                              Default          Description");
+        
+        strm << std::endl;
+        strm << tablehead << std::endl;
+        strm << headings << std::endl;
+        strm << tablehead << std::endl;
+        
+        uint32_t default_column(15);
+        uint32_t name_column(32);
+        uint32_t description_column(40);
+
+        strm << std::left;
+
+        for (auto const& opt : options)
+        {
+            std::string default_value(opt.getValue<std::string>() );
+            default_value = boost::algorithm::erase_all_copy(default_value, "\n");
+            if (default_value.size() > default_column -1 )
+            {
+                default_value = default_value.substr(0, default_column-3);
+                default_value = default_value + "...";
+            }
+            
+            std::vector<std::string> lines;
+            std::string description(opt.getDescription());
+            description = boost::algorithm::erase_all_copy(description, "\n");
+            
+            Utils::wordWrap(description, lines, description_column-1);
+            if (lines.size() == 1)
+            {
+                
+                strm   << std::setw(name_column) << opt.getName() << " " 
+                       << std::setw(default_column) << default_value << " " 
+                       << std::setw(description_column) << description << std::endl;
+            } else
+                strm   << std::setw(name_column) << opt.getName() << " " 
+                       << std::setw(default_column) << default_value << " " 
+                       << lines[0] << std::endl;
+            
+            std::stringstream blank;
+            size_t blanks(49);
+            for (size_t i = 0; i < blanks; ++i)
+                blank << " ";
+            for (size_t i = 1; i < lines.size(); ++i)
+            {
+                strm << blank.str() <<lines[i] << std::endl;
+            }
+        }
+        strm << tablehead << std::endl;
+        strm << std::endl;
+
+        std::cout << strm.str() << std::endl;
+    }
+    else
+    {
+        std::cerr << n << " has no options\n";
+    }
+}
+
+void outputOptions()
 {
-    StageFactory f;
-    std::cout << opt << std::endl;
-    std::cout << f.toRST(opt) << std::endl;
+    StageFactory f(false);
+    std::vector<std::string> nv = f.getStageNames();
+    for (auto const& n : nv)
+        outputOptions(n);
 }
 
 int main(int argc, char* argv[])
 {
-    KernelFactory f;
-
-    po::options_description options;
-    po::positional_options_description positional;
-    po::variables_map variables;
-    positional.add("command", 1);
-
-    options.add_options()
-        ("command", po::value<std::string>(), "command name")
-        ("debug", po::value<bool>()->zero_tokens()->implicit_value(true), "Show debug information")
-        ("drivers", po::value<bool>()->zero_tokens()->implicit_value(true), "Show drivers")
-        ("help,h", po::value<bool>()->zero_tokens()->implicit_value(true), "Print help message")
-        ("options", po::value<std::string>()->implicit_value("all"), "Show driver options")
-        ("version", po::value<bool>()->zero_tokens()->implicit_value(true), "Show version info")
-            ;
-
+    // No arguments, print basic usage, plugins will be loaded
     if (argc < 2)
     {
-        outputHelp(options);
+        outputHelp(/*false*/);
         return 1;
     }
 
-    try
+    // Discover available kernels without plugins, and test to see if
+    // the positional option 'command' is a valid kernel
+    KernelFactory f(true);
+    std::vector<std::string> loaded_kernels;
+    loaded_kernels = f.getKernelNames();
+
+    bool isValidKernel = false;
+    std::string command(argv[1]);
+    std::string fullname;
+    for (auto name : loaded_kernels)
     {
-        po::store(po::command_line_parser(2, argv).
-            options(options).positional(positional).run(),
-            variables);
+        if (boost::iequals(argv[1], splitDriverName(name)))
+        {
+            fullname = name;
+            isValidKernel = true;
+            break;
+        }
     }
-    catch (boost::program_options::unknown_option& e)
+
+    // If the kernel was not available, then light up the plugins and retry
+    if (!isValidKernel)
     {
-#if BOOST_VERSION >= 104200
+        KernelFactory f(false);
+        loaded_kernels.clear();
+        loaded_kernels = f.getKernelNames();
 
-        std::cerr << "Unknown option '" << e.get_option_name() <<"' not recognized" << std::endl << std::endl;
-#else
-        std::cerr << "Unknown option '" << std::string(e.what()) <<"' not recognized" << std::endl << std::endl;
-#endif
-        outputVersion();
-        return 1;
+        for (auto name : loaded_kernels)
+        {
+            if (boost::iequals(argv[1], splitDriverName(name)))
+            {
+                fullname = name;
+                isValidKernel = true;
+                break;
+            }
+        }
     }
 
-    int count(argc - 1); // remove the 1st argument
-    const char** args = const_cast<const char**>(&argv[1]);
-
-    if (variables.count("version"))
+    // Dispatch execution to the kernel, passing all remaining args
+    if (isValidKernel)
     {
-        outputVersion();
-        return 0;
+        int count(argc - 1); // remove the 1st argument
+        const char** args = const_cast<const char**>(&argv[1]);
+        std::unique_ptr<Kernel> app = f.createKernel(fullname);
+        return app->run(count, args, command);
     }
 
-    if (variables.count("drivers"))
+    // Otherwise, process the remaining args to see if they are supported
+    bool debug = false;
+    bool drivers = false;
+    bool help = false;
+    bool options = false;
+    bool version = false;
+    std::string optString("all");  // --options will default to displaying information on all available stages
+    for (int i = 1; i < argc; ++i)
     {
-        outputDrivers();
-        return 0;
+        if (boost::iequals(argv[i], "--debug"))
+        {
+            debug = true;
+        }
+        else if (boost::iequals(argv[i], "--drivers"))
+        {
+            drivers = true;
+        }
+        else if (boost::iequals(argv[i], "--help") || boost::iequals(argv[i], "-h"))
+        {
+            help = true;
+        }
+        else if (boost::algorithm::istarts_with(argv[i], "--options"))
+        {
+            std::vector<std::string> optionsVec;
+            // we are rather unsophisticated for now, only splitting on '=', no spaces allowed
+            boost::algorithm::split(optionsVec, argv[i],
+                boost::algorithm::is_any_of("="), boost::algorithm::token_compress_on);
+            options = true;
+            if (optionsVec.size() == 2)
+                optString = optionsVec[1];
+        }
+        else if (boost::iequals(argv[i], "--version"))
+        {
+            version = true;
+        }
+        else
+        {
+            if (boost::algorithm::istarts_with(argv[i], "--"))
+                std::cerr << "Unknown option '" << argv[i] <<"' not recognized" << std::endl << std::endl;
+        }
     }
 
-    if (variables.count("options"))
+    if (version)
     {
-        std::string opt = variables["options"].as<std::string>();
-        outputOptions(opt);
+        outputVersion();
         return 0;
     }
 
-    if (variables.count("debug"))
+    if (drivers)
     {
-        std::cerr << getPDALDebugInformation() << std::endl;
+        outputDrivers();
         return 0;
     }
 
-    if (variables.count("help") || !variables.count("command"))
+    if (options)
     {
-        outputHelp(options);
+        if (boost::iequals(optString, "all"))
+            outputOptions();
+        else
+            outputOptions(optString);
         return 0;
     }
 
-    std::string command = variables["command"].as<std::string>();
-
-    bool isValidKernel = false;
-    std::map<std::string, KernelInfo> const& kernels = f.getKernelInfos();
-    for (auto i = kernels.begin(); i != kernels.end(); ++i)
+    if (debug)
     {
-        if (boost::iequals(command, i->second.getName()))
-        {
-            isValidKernel = true;
-        }
+        std::cerr << getPDALDebugInformation() << std::endl;
+        return 0;
     }
 
-    if (isValidKernel)
+    if (help)
     {
-        std::unique_ptr<Kernel> app(f.createKernel(command));
-        return app->run(count, args, command);
+        outputHelp();
+        return 0;
     }
 
-    std::cerr << "Command '" << command <<"' not recognized" << std::endl << std::endl;
-    outputHelp(options);
+    if (!isValidKernel)
+        std::cerr << "Command '" << command <<"' not recognized" << std::endl << std::endl;
+    outputHelp();
     return 1;
 }
+
diff --git a/cmake/compiler_options.cmake b/cmake/compiler_options.cmake
index 1d4c985628..cc1191400e 100644
--- a/cmake/compiler_options.cmake
+++ b/cmake/compiler_options.cmake
@@ -1,5 +1,6 @@
 include_directories(${PDAL_INCLUDE_DIR})
 include_directories(${PDAL_UTIL_DIR})
+include_directories(${PDAL_SRC_DIR})
 include_directories(${PDAL_IO_DIR})
 include_directories(${PDAL_KERNEL_DIR})
 include_directories(${PDAL_FILTER_DIR})
@@ -7,5 +8,10 @@ if (WIN32)
     include (${CMAKE_CURRENT_LIST_DIR}/win32_compiler_options.cmake)
 else()
     include (${CMAKE_CURRENT_LIST_DIR}/unix_compiler_options.cmake)
+    if (APPLE)
+        set (PDAL_PLATFORM_OSX 1)
+    else()
+        set (PDAL_PLATFORM_LINUX 1)
+    endif()
 endif()
 
diff --git a/doc/tutorial/writing.rst b/doc/tutorial/writing.rst
index 7fd12e5332..abcbfd5931 100644
--- a/doc/tutorial/writing.rst
+++ b/doc/tutorial/writing.rst
@@ -39,20 +39,6 @@ main one, `<pdal/pdal.hpp>`, brings in most of the utility and basic classes
 used throughout the PDAL system. Additionally, the following includes are
 available subject to having the required include directories pathed:
 
-* `#include <pdal/Drivers.hpp>`
-* `#include <pdal/Filters.hpp>`
-* `#include <pdal/Kernels.hpp>`
-
-
-.. note::
-
-    Drivers, Filters, and Kernels bring in *all* of the respective sub includes
-    for those sections of the source tree. You are not required to include
-    everything if you don't need it, however, and it is still possible to
-    selectively include the classes you need as shown in the example below.
-
-
-
 .. code-block:: cpp
 
     #include <pdal/pdal.hpp>
diff --git a/examples/writing/tutorial.cpp b/examples/writing/tutorial.cpp
index 1e487282a6..79a2b13aec 100644
--- a/examples/writing/tutorial.cpp
+++ b/examples/writing/tutorial.cpp
@@ -61,7 +61,7 @@ int main(int argc, char* argv[])
     reader.addBuffer(buffer);
 
     pdal::StageFactory f;
-    pdal::WriterPtr writer(f.createWriter("writers.las"));
+    pdal::std::unique_ptr<Stage> writer(f.createStage("writers.las"));
     writer->setInput(&reader);
     writer->setOptions(options);
     writer->prepare(ctx);
diff --git a/filters/chipper/ChipperFilter.cpp b/filters/chipper/ChipperFilter.cpp
index 4614669aa0..fab998cedd 100644
--- a/filters/chipper/ChipperFilter.cpp
+++ b/filters/chipper/ChipperFilter.cpp
@@ -69,6 +69,14 @@ be stored.
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.chipper",
+    "Organize points into spatially contiguous, squarish, and non-overlapping chips.",
+    "http://pdal.io/stages/filters.chipper.html" };
+
+CREATE_STATIC_PLUGIN(ChipperFilter, Filter, s_info)
+
+std::string ChipperFilter::getName() const { return s_info.name; }
 
 void ChipperFilter::processOptions(const Options& options)
 {
diff --git a/filters/chipper/ChipperFilter.hpp b/filters/chipper/ChipperFilter.hpp
index 73ad5b9b73..cadf903615 100644
--- a/filters/chipper/ChipperFilter.hpp
+++ b/filters/chipper/ChipperFilter.hpp
@@ -41,11 +41,15 @@
 
 #pragma once
 
-#include <vector>
-
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 #include <pdal/PointBuffer.hpp>
 
+#include <vector>
+
+extern "C" int32_t ChipperFilter_ExitFunc();
+extern "C" PF_ExitFunc ChipperFilter_InitPlugin();
+
 namespace pdal
 {
 
@@ -132,17 +136,16 @@ class PDAL_DLL ChipRefList
 
 class PDAL_DLL ChipperFilter : public pdal::Filter
 {
-#define CHIPPERDOCS "Organize points into spatially contiguous, squarish, and \n" \
-                    "non-overlapping chips."
 public:
-    SET_STAGE_NAME("filters.chipper", CHIPPERDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.chipper.html")
-
     ChipperFilter() : Filter(),
         m_xvec(DIR_X), m_yvec(DIR_Y), m_spare(DIR_NONE)
     {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     virtual void processOptions(const Options& options);
diff --git a/filters/colorization/ColorizationFilter.cpp b/filters/colorization/ColorizationFilter.cpp
index 321f04a145..8e4835fb72 100644
--- a/filters/colorization/ColorizationFilter.cpp
+++ b/filters/colorization/ColorizationFilter.cpp
@@ -32,20 +32,28 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include <array>
+#include "ColorizationFilter.hpp"
 
-#include <pdal/PointBuffer.hpp>
+#include <pdal/GDALUtils.hpp>
 #include <pdal/GlobalEnvironment.hpp>
+#include <pdal/PointBuffer.hpp>
 
 #include <gdal.h>
 #include <ogr_spatialref.h>
-#include <pdal/GDALUtils.hpp>
 
-#include "ColorizationFilter.hpp"
+#include <array>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.colorization",
+    "Fetch and assign RGB color information from a GDAL-readable datasource.",
+    "http://pdal.io/stages/filters.colorization.html" };
+
+CREATE_STATIC_PLUGIN(ColorizationFilter, Filter, s_info)
+
+std::string ColorizationFilter::getName() const { return s_info.name; }
 
 struct GDALSourceDeleter
 {
diff --git a/filters/colorization/ColorizationFilter.hpp b/filters/colorization/ColorizationFilter.hpp
index 70c17e8f3e..6d4f1f32e5 100644
--- a/filters/colorization/ColorizationFilter.hpp
+++ b/filters/colorization/ColorizationFilter.hpp
@@ -35,8 +35,8 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 
-#include <map>
 #include <boost/array.hpp>
 
 #pragma GCC diagnostic push
@@ -46,6 +46,11 @@
 #include <pdal/GDALUtils.hpp>
 #pragma GCC diagnostic pop
 
+#include <map>
+
+extern "C" int32_t ColorizationFilter_ExitFunc();
+extern "C" PF_ExitFunc ColorizationFilter_InitPlugin();
+
 namespace pdal
 {
 
@@ -72,16 +77,15 @@ struct BandInfo
     double m_scale;
 };
 
-#define COLORIZATIONDOC "Fetch and assign RGB color information from a GDAL-readable " \
-                        "datasource. "
 public:
-    SET_STAGE_NAME("filters.colorization", COLORIZATIONDOC)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.colorization.html")
+    ColorizationFilter()
+    {}
 
-    ColorizationFilter() : Filter()
-        {}
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
-    static Options getDefaultOptions();
+    Options getDefaultOptions();
 
 private:
     virtual void initialize();
diff --git a/filters/crop/CropFilter.cpp b/filters/crop/CropFilter.cpp
index b8b3e77523..09b639f50c 100644
--- a/filters/crop/CropFilter.cpp
+++ b/filters/crop/CropFilter.cpp
@@ -36,12 +36,22 @@
 
 #include <pdal/PointBuffer.hpp>
 #include <pdal/StageFactory.hpp>
+
 #include <sstream>
 #include <cstdarg>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.crop",
+    "Filter points inside or outside a bounding box or a polygon if PDAL was built with GEOS support.",
+    "http://pdal.io/stages/filters.crop.html" };
+
+CREATE_STATIC_PLUGIN(CropFilter, Filter, s_info)
+
+std::string CropFilter::getName() const { return s_info.name; }
+
 #ifdef PDAL_HAVE_GEOS
 namespace geos
 {
diff --git a/filters/crop/CropFilter.hpp b/filters/crop/CropFilter.hpp
index b80bc7034e..2fe81fa9f4 100644
--- a/filters/crop/CropFilter.hpp
+++ b/filters/crop/CropFilter.hpp
@@ -35,28 +35,31 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 
 #ifdef PDAL_HAVE_GEOS
 #include <geos_c.h>
 #endif
 
+extern "C" int32_t CropFilter_ExitFunc();
+extern "C" PF_ExitFunc CropFilter_InitPlugin();
+
 namespace pdal
 {
 class PointBuffer;
 
-#define CROPFILTERDOCS "Filter points inside or outside a bounding box or \n" \
-                       "a polygon if PDAL was built with GEOS support."
 // removes any points outside of the given range
 // updates the header accordingly
 class PDAL_DLL CropFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.crop", CROPFILTERDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.crop.html")
-
     CropFilter();
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
     const BOX3D& getBounds() const;
 
diff --git a/filters/decimation/DecimationFilter.cpp b/filters/decimation/DecimationFilter.cpp
index 1f6ab87aba..7862c67434 100644
--- a/filters/decimation/DecimationFilter.cpp
+++ b/filters/decimation/DecimationFilter.cpp
@@ -32,16 +32,21 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include <pdal/PointBuffer.hpp>
-
 #include "DecimationFilter.hpp"
 
+#include <pdal/PointBuffer.hpp>
+
 namespace pdal
 {
 
-DecimationFilter::DecimationFilter() : pdal::Filter()
-{}
+static PluginInfo const s_info {
+    "filters.decimation",
+    "Rank decimation filter. Keep every Nth point",
+    "http://pdal.io/stages/filters.decimation.html" };
+
+CREATE_STATIC_PLUGIN(DecimationFilter, Filter,  s_info)
 
+std::string DecimationFilter::getName() const { return s_info.name; }
 
 void DecimationFilter::processOptions(const Options& options)
 {
diff --git a/filters/decimation/DecimationFilter.hpp b/filters/decimation/DecimationFilter.hpp
index eb4b4e82d3..45b4b2ca82 100644
--- a/filters/decimation/DecimationFilter.hpp
+++ b/filters/decimation/DecimationFilter.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t DecimationFilter_ExitFunc();
+extern "C" PF_ExitFunc DecimationFilter_InitPlugin();
 
 namespace pdal
 {
@@ -43,10 +47,12 @@ namespace pdal
 class PDAL_DLL DecimationFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.decimation", "Rank decimation filter. Keep every Nth point.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.decimation.html")
+    DecimationFilter()
+        {}
 
-    DecimationFilter();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
 private:
     uint32_t m_step;
diff --git a/filters/ferry/FerryFilter.cpp b/filters/ferry/FerryFilter.cpp
index 534b8aa2d2..e9142f77b6 100644
--- a/filters/ferry/FerryFilter.cpp
+++ b/filters/ferry/FerryFilter.cpp
@@ -34,15 +34,19 @@
 
 #include "FerryFilter.hpp"
 
+#include <pdal/pdal_export.hpp>
+
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.ferry",
+    "Copy date from one dimension to another.",
+    "http://pdal.io/stages/filters.ferry.html" };
 
+CREATE_STATIC_PLUGIN(FerryFilter, Filter, s_info)
 
-void FerryFilter::initialize()
-{
-}
-
+std::string FerryFilter::getName() const { return s_info.name; }
 
 Options FerryFilter::getDefaultOptions()
 {
@@ -119,8 +123,5 @@ void FerryFilter::filter(PointBuffer& buffer)
     }
 }
 
-void FerryFilter::done(PointContext ctx)
-{
-}
 
 } // namespace pdal
diff --git a/filters/ferry/FerryFilter.hpp b/filters/ferry/FerryFilter.hpp
index bb5910e7de..74b45955cd 100644
--- a/filters/ferry/FerryFilter.hpp
+++ b/filters/ferry/FerryFilter.hpp
@@ -35,28 +35,34 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 
 #include <map>
 #include <string>
+
+extern "C" int32_t FerryFilter_ExitFunc();
+extern "C" PF_ExitFunc FerryFilter_InitPlugin();
+
 namespace pdal
 {
 
 class PDAL_DLL FerryFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.ferry", "Copy data from one dimension to another.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.ferry.html")
+    FerryFilter()
+    {}
+
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
-    FerryFilter() : Filter() {};
-    static Options getDefaultOptions();
+    Options getDefaultOptions();
 
 private:
-    virtual void initialize();
     virtual void processOptions(const Options&);
     virtual void addDimensions(PointContextRef ctx);
     virtual void ready(PointContext ctx);
     virtual void filter(PointBuffer& buffer);
-    virtual void done(PointContext ctx);
 
     FerryFilter& operator=(const FerryFilter&); // not implemented
     FerryFilter(const FerryFilter&); // not implemented
diff --git a/filters/merge/CMakeLists.txt b/filters/merge/CMakeLists.txt
index dc6ccdf195..b102c42967 100644
--- a/filters/merge/CMakeLists.txt
+++ b/filters/merge/CMakeLists.txt
@@ -6,13 +6,17 @@
 # Merge Filter
 #
 set(srcs
+    MergeFilter.cpp
 )
 
 set(incs
     MergeFilter.hpp
 )
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
-    DESTINATION "${PDAL_INCLUDE_INSTALL_DIR}"
-    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
-)
+#install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
+#    DESTINATION "${PDAL_INCLUDE_INSTALL_DIR}"
+#    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
+#)
+
+PDAL_ADD_DRIVER(filter merge "${srcs}" "${incs}" objects)
+set(PDAL_TARGET_OBJECTS ${PDAL_TARGET_OBJECTS} ${objects} PARENT_SCOPE)
diff --git a/filters/merge/MergeFilter.cpp b/filters/merge/MergeFilter.cpp
new file mode 100644
index 0000000000..66bfa508bf
--- /dev/null
+++ b/filters/merge/MergeFilter.cpp
@@ -0,0 +1,50 @@
+/******************************************************************************
+ * Copyright (c) 2014, Hobu Inc., hobu.inc@gmail.com
+ * Copyright (c) 2015, Bradley J Chambers, brad.chambers@gmail.com
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following
+ * conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of the Andrew Bell or libLAS nor the names of
+ *       its contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ ****************************************************************************/
+
+#include "MergeFilter.hpp"
+
+namespace pdal
+{
+
+static PluginInfo const s_info {
+    "filters.merge",
+    "Merge data from two different readers into a single stream.",
+    "http://pdal.io/stages/filters.merge.html" };
+
+CREATE_STATIC_PLUGIN(MergeFilter, Filter, s_info)
+
+std::string MergeFilter::getName() const { return s_info.name; }
+
+} // namespace pdal
+
diff --git a/filters/merge/MergeFilter.hpp b/filters/merge/MergeFilter.hpp
index 6cfedeae1c..26bb73b0c7 100644
--- a/filters/merge/MergeFilter.hpp
+++ b/filters/merge/MergeFilter.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t MergeFilter_ExitFunc();
+extern "C" PF_ExitFunc MergeFilter_InitPlugin();
 
 namespace pdal
 {
@@ -42,11 +46,12 @@ namespace pdal
 class PDAL_DLL MergeFilter : public MultiFilter
 {
 public:
-    SET_STAGE_NAME("filters.merge", "Merge data from two different readers into a single stream.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.merge.html")
+    MergeFilter ()
+    {}
 
-    MergeFilter() : MultiFilter()
-        {}
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
 private:
     PointBufferPtr m_buf;
@@ -68,3 +73,4 @@ class PDAL_DLL MergeFilter : public MultiFilter
 };
 
 } // namespace pdal
+
diff --git a/filters/mortonorder/MortonOrderFilter.cpp b/filters/mortonorder/MortonOrderFilter.cpp
index 94304de968..ebdb751b61 100644
--- a/filters/mortonorder/MortonOrderFilter.cpp
+++ b/filters/mortonorder/MortonOrderFilter.cpp
@@ -32,15 +32,23 @@
  * OF SUCH DAMAGE.
  ****************************************************************************/
 
+#include "MortonOrderFilter.hpp"
+
 #include <iostream>
 #include <limits>
 #include <map>
 
-#include "MortonOrderFilter.hpp"
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.morgonorder",
+    "Morton or z-order sorting of points. See http://en.wikipedia.org/wiki/Z-order_curve for more detail.",
+    "http://pdal.io/stages/filters.mortonorder.html" };
+
+CREATE_STATIC_PLUGIN(MortonOrderFilter, Filter, s_info)
+
+std::string MortonOrderFilter::getName() const { return s_info.name; }
 
 Options MortonOrderFilter::getDefaultOptions()
 {
diff --git a/filters/mortonorder/MortonOrderFilter.hpp b/filters/mortonorder/MortonOrderFilter.hpp
index 8583858182..92d8b6a64d 100644
--- a/filters/mortonorder/MortonOrderFilter.hpp
+++ b/filters/mortonorder/MortonOrderFilter.hpp
@@ -35,21 +35,25 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t MortonOrderFilter_ExitFunc();
+extern "C" PF_ExitFunc MortonOrderFilter_InitPlugin();
 
 namespace pdal
 {
 
-#define MORTONDOCS "Morton or z-order sorting of points. See \n" \
-                   "http://en.wikipedia.org/wiki/Z-order_curve for more detail."
 class PDAL_DLL MortonOrderFilter : public pdal::Filter
 {
 public:
-    SET_STAGE_NAME("filters.mortonorder", MORTONDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.morton.html")
+    MortonOrderFilter()
+    {}
 
-    MortonOrderFilter() : Filter() {}
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
-    static Options getDefaultOptions();
+    Options getDefaultOptions();
 
 private:
     virtual void processOptions(const Options& ) {};
diff --git a/filters/range/RangeFilter.cpp b/filters/range/RangeFilter.cpp
index 289445deb2..a1262365c9 100644
--- a/filters/range/RangeFilter.cpp
+++ b/filters/range/RangeFilter.cpp
@@ -44,6 +44,14 @@
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.range",
+    "Pass only points given a dimension/range.",
+    "http://pdal.io/stages/filters.range.html" };
+
+CREATE_STATIC_PLUGIN(RangeFilter, Filter, s_info)
+
+std::string RangeFilter::getName() const { return s_info.name; }
 
 void RangeFilter::processOptions(const Options& options)
 {
diff --git a/filters/range/RangeFilter.hpp b/filters/range/RangeFilter.hpp
index 62d89b6647..06176c9d32 100644
--- a/filters/range/RangeFilter.hpp
+++ b/filters/range/RangeFilter.hpp
@@ -35,11 +35,15 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 
 #include <memory>
 #include <map>
 #include <string>
 
+extern "C" int32_t RangeFilter_ExitFunc();
+extern "C" PF_ExitFunc RangeFilter_InitPlugin();
+
 namespace pdal
 {
 
@@ -56,16 +60,16 @@ struct Range
     double max;
 };
 
-#define RANGEDOCS "Pass only points given a dimension/range."
 class PDAL_DLL RangeFilter : public pdal::Filter
 {
 public:
-    SET_STAGE_NAME("filters.range", RANGEDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.range.html")
-
     RangeFilter() : Filter()
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     std::map<std::string, Range> m_name_map;
     std::map<Dimension::Id::Enum, Range> m_dimensions_map;
diff --git a/filters/reprojection/ReprojectionFilter.cpp b/filters/reprojection/ReprojectionFilter.cpp
index 3c61c5beea..ebcccdfe71 100644
--- a/filters/reprojection/ReprojectionFilter.cpp
+++ b/filters/reprojection/ReprojectionFilter.cpp
@@ -34,18 +34,27 @@
 
 #include "ReprojectionFilter.hpp"
 
-#include <memory>
-
+#include <pdal/GDALUtils.hpp>
 #include <pdal/PointBuffer.hpp>
 
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #include <gdal.h>
 #include <ogr_spatialref.h>
-#include <pdal/GDALUtils.hpp>
+
+#include <memory>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.reprojection",
+    "Reproject data using GDAL from one coordinate system to another.",
+    "http://pdal.io/stages/filters.reprojection.html" };
+
+CREATE_STATIC_PLUGIN(ReprojectionFilter, Filter, s_info)
+
+std::string ReprojectionFilter::getName() const { return s_info.name; }
+
 struct OGRSpatialReferenceDeleter
 {
     template <typename T>
diff --git a/filters/reprojection/ReprojectionFilter.hpp b/filters/reprojection/ReprojectionFilter.hpp
index c51403724d..668d275ebf 100644
--- a/filters/reprojection/ReprojectionFilter.hpp
+++ b/filters/reprojection/ReprojectionFilter.hpp
@@ -35,9 +35,13 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 
 #include <memory>
 
+extern "C" int32_t ReprojectionFilter_ExitFunc();
+extern "C" PF_ExitFunc ReprojectionFilter_InitPlugin();
+
 namespace pdal
 {
 class PointBuffer;
@@ -49,12 +53,13 @@ class Debug;
 class PDAL_DLL ReprojectionFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.reprojection", "Reproject data using GDAL from one coordinate system to another.")
-    SET_STAGE_LINK("http://www.pdal.io/stages/filters.reprojection.html")
-
     ReprojectionFilter() : m_inferInputSRS(true)
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     virtual void processOptions(const Options& options);
     virtual void ready(PointContext ctx);
diff --git a/filters/sort/CMakeLists.txt b/filters/sort/CMakeLists.txt
index e761c324ff..e383eb19c5 100644
--- a/filters/sort/CMakeLists.txt
+++ b/filters/sort/CMakeLists.txt
@@ -6,13 +6,17 @@
 # Sort Filter
 #
 set(srcs
+    SortFilter.cpp
 )
 
 set(incs
     SortFilter.hpp
 )
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
-    DESTINATION "${PDAL_INCLUDE_INSTALL_DIR}"
-    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
-)
+#install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
+#    DESTINATION "${PDAL_INCLUDE_INSTALL_DIR}"
+#    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
+#)
+
+PDAL_ADD_DRIVER(filter sort "${srcs}" "${incs}" objects)
+set(PDAL_TARGET_OBJECTS ${PDAL_TARGET_OBJECTS} ${objects} PARENT_SCOPE)
diff --git a/filters/sort/SortFilter.cpp b/filters/sort/SortFilter.cpp
new file mode 100644
index 0000000000..cee2eebc80
--- /dev/null
+++ b/filters/sort/SortFilter.cpp
@@ -0,0 +1,50 @@
+/******************************************************************************
+ * Copyright (c) 2014, Hobu Inc. (hobu@hobu.co)
+ * Copyright (c) 2015, Bradley J Chambers, brad.chambers@gmail.com
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following
+ * conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of the Andrew Bell or libLAS nor the names of
+ *       its contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ ****************************************************************************/
+
+#include "SortFilter.hpp"
+
+namespace pdal
+{
+
+static PluginInfo const s_info {
+    "filters.sort",
+    "Sort data based on a given dimension.",
+    "http://pdal.io/stages/filters.sort.html" };
+
+CREATE_STATIC_PLUGIN(SortFilter, Filter, s_info)
+
+std::string SortFilter::getName() const { return s_info.name; }
+
+} // namespace pdal
+
diff --git a/filters/sort/SortFilter.hpp b/filters/sort/SortFilter.hpp
index e06e9b732d..b720c8957d 100644
--- a/filters/sort/SortFilter.hpp
+++ b/filters/sort/SortFilter.hpp
@@ -36,6 +36,10 @@
 
 #include <pdal/Filter.hpp>
 #include <pdal/PointBufferIter.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t SortFilter_ExitFunc();
+extern "C" PF_ExitFunc SortFilter_InitPlugin();
 
 namespace pdal
 {
@@ -43,12 +47,13 @@ namespace pdal
 class PDAL_DLL SortFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.sort", "Sort data based on a given dimension.")
-    SET_STAGE_LINK("http://www.pdal.io/stages/filters.sort.html")
-
     SortFilter()
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     // Dimension on which to sort.
     Dimension::Id::Enum m_dim;
diff --git a/filters/splitter/SplitterFilter.cpp b/filters/splitter/SplitterFilter.cpp
index c0d0be06b0..caa49d1f9f 100644
--- a/filters/splitter/SplitterFilter.cpp
+++ b/filters/splitter/SplitterFilter.cpp
@@ -32,14 +32,25 @@
  * OF SUCH DAMAGE.
  ****************************************************************************/
 
+#include "SplitterFilter.hpp"
+
+#include <pdal/pdal_macros.hpp>
+
 #include <iostream>
 #include <limits>
 
-#include "SplitterFilter.hpp"
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.splitter",
+    "Split data based on a X/Y box length.",
+    "http://pdal.io/stages/filters.splitter.html" };
+
+CREATE_STATIC_PLUGIN(SplitterFilter, Filter, s_info)
+
+std::string SplitterFilter::getName() const { return s_info.name; }
+
 void SplitterFilter::processOptions(const Options& options)
 {
     m_length = options.getValueOrDefault<uint32_t>("length", 1000);
diff --git a/filters/splitter/SplitterFilter.hpp b/filters/splitter/SplitterFilter.hpp
index 3e460eca0e..5edbc3dbb6 100644
--- a/filters/splitter/SplitterFilter.hpp
+++ b/filters/splitter/SplitterFilter.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t SplitterFilter_ExitFunc();
+extern "C" PF_ExitFunc SplitterFilter_InitPlugin();
 
 namespace pdal
 {
@@ -42,13 +46,14 @@ namespace pdal
 class PDAL_DLL SplitterFilter : public pdal::Filter
 {
 public:
-    SET_STAGE_NAME("filters.splitter", "Split data based on a X/Y box length.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.splitter.html")
-
     SplitterFilter() : Filter()
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     uint32_t m_length;
diff --git a/filters/stats/StatsFilter.cpp b/filters/stats/StatsFilter.cpp
index 5efc84b25f..35465cd36a 100644
--- a/filters/stats/StatsFilter.cpp
+++ b/filters/stats/StatsFilter.cpp
@@ -32,12 +32,23 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include <pdal/Utils.hpp>
-
 #include "StatsFilter.hpp"
 
+#include <pdal/pdal_export.hpp>
+#include <pdal/Utils.hpp>
+
 namespace pdal
 {
+
+static PluginInfo const s_info {
+    "filters.stats",
+    "Compute statistics about each dimension (mean, min, max, etc.)",
+    "http://pdal.io/stages/filters.stats.html" };
+
+CREATE_STATIC_PLUGIN(StatsFilter, Filter, s_info)
+
+std::string StatsFilter::getName() const { return s_info.name; }
+
 namespace stats
 {
 
diff --git a/filters/stats/StatsFilter.hpp b/filters/stats/StatsFilter.hpp
index a933001989..b1969ffee8 100644
--- a/filters/stats/StatsFilter.hpp
+++ b/filters/stats/StatsFilter.hpp
@@ -35,8 +35,12 @@
 #pragma once
 
 #include <pdal/Filter.hpp>
+#include <pdal/plugin.h>
 #include <pdal/PointBuffer.hpp>
 
+extern "C" int32_t StatsFilter_ExitFunc();
+extern "C" PF_ExitFunc StatsFilter_InitPlugin();
+
 namespace pdal
 {
 namespace stats
@@ -87,17 +91,18 @@ class PDAL_DLL Summary
 
 } // namespace stats
 
-// This is just a pass-thorugh filter, which collects some stats about
+// This is just a pass-through filter, which collects some stats about
 // the points that are fed through it
 class PDAL_DLL StatsFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.stats", "Compute statistics about each dimension (mean, min, max, etc.)")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.stats.html")
-
     StatsFilter() : Filter()
         {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
     const stats::Summary& getStats(Dimension::Id::Enum d) const;
     void reset();
 
diff --git a/filters/transformation/TransformationFilter.cpp b/filters/transformation/TransformationFilter.cpp
index bddb723c89..b14c88333c 100644
--- a/filters/transformation/TransformationFilter.cpp
+++ b/filters/transformation/TransformationFilter.cpp
@@ -34,14 +34,22 @@
 
 #include "TransformationFilter.hpp"
 
-#include <sstream>
-
 #include <pdal/pdal_error.hpp>
+#include <pdal/pdal_export.hpp>
 
+#include <sstream>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.transformation",
+    "Transform each point using a 4x4 transformation matrix",
+    "http://pdal.io/stages/filters.transformation.html" };
+
+CREATE_STATIC_PLUGIN(TransformationFilter, Filter, s_info)
+
+std::string TransformationFilter::getName() const { return s_info.name; }
 
 TransformationMatrix transformationMatrixFromString(const std::string& s)
 {
diff --git a/filters/transformation/TransformationFilter.hpp b/filters/transformation/TransformationFilter.hpp
index 7d653a6188..5207b45fe5 100644
--- a/filters/transformation/TransformationFilter.hpp
+++ b/filters/transformation/TransformationFilter.hpp
@@ -37,9 +37,12 @@
 #include <array>
 #include <string>
 
-#include <pdal/pdal_export.hpp>
 #include <pdal/Filter.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
 
+extern "C" int32_t TransformationFilter_ExitFunc();
+extern "C" PF_ExitFunc TransformationFilter_InitPlugin();
 
 namespace pdal
 {
@@ -55,12 +58,13 @@ TransformationMatrix PDAL_DLL transformationMatrixFromString(const std::string&
 class PDAL_DLL TransformationFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.transformation", "Transform each point using a 4x4 transformation matrix")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.transformation.html")
-
     TransformationFilter() : Filter()
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     TransformationFilter& operator=(const TransformationFilter&); // not implemented
     TransformationFilter(const TransformationFilter&); // not implemented
diff --git a/include/pdal/BufferReader.hpp b/include/pdal/BufferReader.hpp
index 97d8457724..8479578b84 100644
--- a/include/pdal/BufferReader.hpp
+++ b/include/pdal/BufferReader.hpp
@@ -34,6 +34,7 @@
 
 #pragma once
 
+#include <pdal/pdal_export.hpp>
 #include <pdal/PointBuffer.hpp>
 #include <pdal/Reader.hpp>
 
@@ -43,13 +44,11 @@ namespace pdal
 class PDAL_DLL BufferReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.buffer", "PointBuffer Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.buffer.html")
-
     BufferReader() : Reader()
         {}
     void addBuffer(const PointBufferPtr& buffer)
         { m_buffers.insert(buffer); }
+    std::string getName() const { return "readers.buffer"; }
 
 private:
     PointBufferSet m_buffers;
diff --git a/include/pdal/Drivers.hpp b/include/pdal/Drivers.hpp
deleted file mode 100644
index ecbf631a5d..0000000000
--- a/include/pdal/Drivers.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2014, Howard Butler, hobu.inc@gmail.com
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#pragma once
-
-#include <pdal/pdal_config.hpp>
-
-#include <pdal/BufferReader.hpp>
-#include <faux/FauxReader.hpp>
-
-#include <las/LasReader.hpp>
-#include <las/LasWriter.hpp>
-
-#include <bpf/BpfReader.hpp>
-#include <bpf/BpfWriter.hpp>
-
-#include <sbet/SbetReader.hpp>
-#include <sbet/SbetWriter.hpp>
-
-#include <qfit/QfitReader.hpp>
-#include <terrasolid/TerrasolidReader.hpp>
-#include <text/TextWriter.hpp>
-
diff --git a/include/pdal/Filter.hpp b/include/pdal/Filter.hpp
index 8db975f16a..4b407f7b06 100644
--- a/include/pdal/Filter.hpp
+++ b/include/pdal/Filter.hpp
@@ -43,8 +43,6 @@ namespace pdal
 
 class Filter;
 
-typedef std::unique_ptr<Filter> FilterPtr;
-
 //
 // supported options:
 //   <uint32>id
diff --git a/include/pdal/Filters.hpp b/include/pdal/Filters.hpp
deleted file mode 100644
index f4ab5c6a27..0000000000
--- a/include/pdal/Filters.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2014, Howard Butler, hobu.inc@gmail.com
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#pragma once
-
-#include <chipper/ChipperFilter.hpp>
-#include <colorization/ColorizationFilter.hpp>
-#include <crop/CropFilter.hpp>
-#include <decimation/DecimationFilter.hpp>
-#include <ferry/FerryFilter.hpp>
-#include <merge/MergeFilter.hpp>
-#include <mortonorder/MortonOrderFilter.hpp>
-#include <range/RangeFilter.hpp>
-#include <reprojection/ReprojectionFilter.hpp>
-#include <sort/SortFilter.hpp>
-#include <splitter/SplitterFilter.hpp>
-#include <stats/StatsFilter.hpp>
-#include <transformation/TransformationFilter.hpp>
diff --git a/include/pdal/Kernel.hpp b/include/pdal/Kernel.hpp
index 0e2f612d5d..67acc20c4e 100644
--- a/include/pdal/Kernel.hpp
+++ b/include/pdal/Kernel.hpp
@@ -34,12 +34,9 @@
 
 #pragma once
 
-#include <pdal/pdal_internal.hpp>
-#include <pdal/pdal_error.hpp>
-#include <pdal/PDALUtils.hpp>
-#include <cstdarg>
-
 #include <pdal/KernelSupport.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/pdal_error.hpp>
 
 #ifdef PDAL_COMPILER_MSVC
 #  pragma warning(push)
@@ -50,10 +47,23 @@
 #  pragma warning(pop)
 #endif
 
+#include <cstdint>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
 namespace po = boost::program_options;
+
 namespace pdal
 {
 
+class Options;
+class PointBuffer;
+
+typedef std::shared_ptr<PointBuffer> PointBufferPtr;
+
 //
 // The application base class gives us these common options:
 //    --help / -h
@@ -71,7 +81,8 @@ class PDAL_DLL Kernel
     bool isVisualize() const;
     void visualize(PointBufferPtr buffer) const;
     //void visualize(PointBufferPtr input_buffer, PointBufferPtr output_buffer) const;
-    void printError(const std::string&) const;
+
+    virtual ~Kernel() {};
 
 protected:
     // this is protected; your derived class ctor will be the public entry point
@@ -89,7 +100,7 @@ class PDAL_DLL Kernel
     // it will be wrapped in a global catch try/block for you
     virtual int execute() = 0;
 
-    void addSwitchSet(boost::program_options::options_description* options);
+    void addSwitchSet(po::options_description* options);
     void addPositionalSwitch(const char* name, int max_count);
     void setCommonOptions(Options &options);
 
@@ -107,23 +118,6 @@ class PDAL_DLL Kernel
         return m_extra_stage_options;
     }
 
-    virtual std::string getName() const = 0;
-    virtual std::string getDescription() const = 0;
-    static std::string s_getInfoLink()
-    {
-        return std::string();
-    }
-
-#define SET_KERNEL_NAME(name, description)  \
-    static std::string s_getName() { return name; }  \
-    std::string getName() const { return name; }  \
-    static std::string s_getDescription() { return description; }  \
-    std::string getDescription() const { return description; }
-
-#define SET_KERNEL_LINK(infolink) \
-    static std::string s_getInfoLink() { return infolink; }  \
-    std::string getInfoLink() const { return infolink; }
-
 protected:
     bool m_usestdin;
 
@@ -156,9 +150,9 @@ class PDAL_DLL Kernel
     std::string m_offsets;
     bool m_visualize;
 
-    std::vector<boost::program_options::options_description*> m_options;
-    boost::program_options::positional_options_description m_positionalOptions;
-    boost::program_options::variables_map m_variablesMap;
+    std::vector<po::options_description*> m_options;
+    po::positional_options_description m_positionalOptions;
+    po::variables_map m_variablesMap;
     std::vector<std::string> m_extra_options;
     std::map<std::string, Options> m_extra_stage_options;
 
@@ -169,3 +163,4 @@ class PDAL_DLL Kernel
 PDAL_DLL std::ostream& operator<<(std::ostream& ostr, const Kernel&);
 
 } // namespace pdal
+
diff --git a/include/pdal/KernelFactory.hpp b/include/pdal/KernelFactory.hpp
index 9133ce7232..5bfd347cc1 100644
--- a/include/pdal/KernelFactory.hpp
+++ b/include/pdal/KernelFactory.hpp
@@ -34,13 +34,8 @@
 
 #pragma once
 
-#include <pdal/pdal_internal.hpp>
 #include <pdal/Kernel.hpp>
-#include <pdal/KernelInfo.hpp>
-
-#include <vector>
-#include <map>
-#include <string>
+#include <pdal/pdal_export.hpp>
 
 
 namespace pdal
@@ -62,47 +57,16 @@ namespace pdal
 class PDAL_DLL KernelFactory
 {
 public:
-    typedef Kernel* KernelCreator();
-
-    typedef std::map<std::string, KernelCreator*> KernelCreatorList;
-
-public:
-    KernelFactory();
-
-    std::unique_ptr<Kernel> createKernel(const std::string& type);
-
-    void registerKernel(const std::string& type, KernelCreator* f);
-
-    void loadPlugins();
-    void registerPlugin(std::string const& filename);
+    KernelFactory(bool no_plugins=true);
+    virtual ~KernelFactory() {};
 
-    std::map<std::string, pdal::KernelInfo> const& getKernelInfos() const;
-    template<class T> void registerKernelDriverInfo();
-
-    // callers take ownership of returned kernels
-    KernelCreator* getKernelCreator(const std::string& type) const;
+    static std::unique_ptr<Kernel> createKernel(std::string const& kernel_name);
+    static std::vector<std::string> getKernelNames();
 
 private:
-    void registerKnownKernels();
-
-    // these are the "registries" of the factory creator functions
-    KernelCreatorList m_kernelCreators;
-
-    // driver name + driver description
-    std::map<std::string, pdal::KernelInfo> m_driver_info;
+    void loadPlugins();  // BJC - deprecated, just keeping it around for some notes on how we used to do stuff, esp. handling symlinks
     KernelFactory& operator=(const KernelFactory&); // not implemented
     KernelFactory(const KernelFactory&); // not implemented
 };
 
-template <class T>
-inline void KernelFactory::registerKernelDriverInfo()
-{
-
-    pdal::KernelInfo info(T::s_getName(), T::s_getDescription());
-    info.setInfoLink(T::s_getInfoLink());
-
-    m_driver_info.insert(
-        std::pair<std::string, pdal::KernelInfo>(T::s_getName(), info));
-}
-
 } // namespace pdal
diff --git a/include/pdal/KernelInfo.hpp b/include/pdal/KernelInfo.hpp
deleted file mode 100644
index 97da139bad..0000000000
--- a/include/pdal/KernelInfo.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2014, Bradley J Chambers (brad.chambers@gmail.com)
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include <iosfwd>
-
-#include <pdal/pdal_internal.hpp>
-
-namespace pdal
-{
-
-class Kernel;
-
-class PDAL_DLL KernelInfo
-{
-    friend class KernelBase;
-public:
-
-    /// Constructor.
-    ///
-    KernelInfo(std::string const& kernelName, std::string const& kernelDescription="");
-
-    KernelInfo& operator=(const KernelInfo& rhs);
-    KernelInfo(const KernelInfo&);
-
-    /// Destructor.
-    virtual ~KernelInfo() {};
-
-    inline std::string const& getName() const
-    {
-        return m_name;
-    }
-
-    inline std::string const& getDescription() const
-    {
-        return m_description;
-    }
-
-    inline void setInfoLink(std::string const& link)
-    {
-        m_link = link;
-    }
-
-    inline std::string const& getInfoLink() const
-    {
-        return m_link;
-    }
-
-private:
-    std::string m_name;
-    std::string m_description;
-    std::string m_link;
-};
-
-/// Output operator for serialization
-///
-/// @param ostr    The output stream to write to
-/// @param src     The KernelInfo to be serialized out
-///
-/// @return The output stream
-
-PDAL_DLL std::ostream& operator<<(std::ostream& ostr, const KernelInfo& src);
-
-} // namespace pdal
-
diff --git a/include/pdal/KernelSupport.hpp b/include/pdal/KernelSupport.hpp
index f2d6010531..2cdc8c1db1 100644
--- a/include/pdal/KernelSupport.hpp
+++ b/include/pdal/KernelSupport.hpp
@@ -38,7 +38,6 @@
 
 #include <pdal/Options.hpp>
 #include <pdal/Stage.hpp>
-#include <pdal/Writer.hpp>
 #include <pdal/UserCallback.hpp>
 #include <pdal/PipelineManager.hpp>
 
@@ -72,7 +71,7 @@ class PDAL_DLL KernelSupport
 
     // makes a writer, from just the filename and some other
     // options (and the input stage)
-    static Writer* makeWriter(const std::string& filename, Stage *stage);
+    static Stage* makeWriter(const std::string& filename, Stage *stage);
     static PipelineManager* makePipeline(const std::string& filename);
 
 private:
diff --git a/include/pdal/Kernels.hpp b/include/pdal/Kernels.hpp
deleted file mode 100644
index a83e281e3d..0000000000
--- a/include/pdal/Kernels.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2013, Howard Butler (hobu.inc@gmail.com)
-* Copyright (c) 2014, Bradley J Chambers (brad.chambers@gmail.com)
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#pragma once
-
-#include <delta/DeltaKernel.hpp>
-#include <diff/DiffKernel.hpp>
-#include <info/InfoKernel.hpp>
-#include <pipeline/PipelineKernel.hpp>
-#include <random/RandomKernel.hpp>
-#include <sort/SortKernel.hpp>
-#include <translate/TranslateKernel.hpp>
diff --git a/include/pdal/PipelineManager.hpp b/include/pdal/PipelineManager.hpp
index c05d4e5985..d2224c6f95 100644
--- a/include/pdal/PipelineManager.hpp
+++ b/include/pdal/PipelineManager.hpp
@@ -54,15 +54,15 @@ class PDAL_DLL PipelineManager
     ~PipelineManager();
 
     // Use these to manually add stages into the pipeline manager.
-    Reader* addReader(const std::string& type);
-    Filter* addFilter(const std::string& type, Stage *prevStage);
-    Filter* addFilter(const std::string& type,
+    Stage* addReader(const std::string& type);
+    Stage* addFilter(const std::string& type, Stage *prevStage);
+    Stage* addFilter(const std::string& type,
         const std::vector<Stage *>& prevStages);
-    Writer* addWriter(const std::string& type, Stage *prevStage);
+    Stage* addWriter(const std::string& type, Stage *prevStage);
 
     // returns true if the pipeline endpoint is a writer
     bool isWriterPipeline() const
-        { return (bool)dynamic_cast<Writer *>(getStage()); }
+        { return (bool)getStage(); }
 
     // return the pipeline reader endpoint (or NULL, if not a reader pipeline)
     Stage* getStage() const
diff --git a/include/pdal/PipelineReader.hpp b/include/pdal/PipelineReader.hpp
index a375c7c1ef..f34bb581bf 100644
--- a/include/pdal/PipelineReader.hpp
+++ b/include/pdal/PipelineReader.hpp
@@ -70,9 +70,9 @@ class PDAL_DLL PipelineReader
     bool parseElement_Pipeline(const boost::property_tree::ptree&);
     Stage* parseElement_anystage(const std::string& name,
         const boost::property_tree::ptree& subtree);
-    Reader* parseElement_Reader(const boost::property_tree::ptree& tree);
-    Filter* parseElement_Filter(const boost::property_tree::ptree& tree);
-    Writer* parseElement_Writer(const boost::property_tree::ptree& tree);
+    Stage* parseElement_Reader(const boost::property_tree::ptree& tree);
+    Stage* parseElement_Filter(const boost::property_tree::ptree& tree);
+    Stage* parseElement_Writer(const boost::property_tree::ptree& tree);
     Option parseElement_Option(const boost::property_tree::ptree& tree);
     void collect_attributes(map_t& attrs,
         const boost::property_tree::ptree& tree);
diff --git a/include/pdal/PluginManager.hpp b/include/pdal/PluginManager.hpp
new file mode 100644
index 0000000000..79785867e8
--- /dev/null
+++ b/include/pdal/PluginManager.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <pdal/plugin.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace pdal
+{
+
+class DynamicLibrary;
+
+/*
+ * I think PluginManager can eventually be a private header, only accessible
+ * through the factories, but we'll leave it as public for now.
+ */
+class PluginManager
+{
+    typedef std::map<std::string, std::shared_ptr<DynamicLibrary> > DynamicLibraryMap;
+    typedef std::vector<PF_ExitFunc> ExitFuncVec;
+    typedef std::vector<PF_RegisterParams> RegistrationVec;
+
+public:
+    typedef std::map<std::string, PF_RegisterParams> RegistrationMap;
+
+    static PluginManager & getInstance();
+    static int32_t initializePlugin(PF_InitFunc initFunc);
+    int32_t loadAll(PF_PluginType type);
+    int32_t loadAll(const std::string & pluginDirectory, PF_PluginType type);
+    int32_t guessLoadByPath(const std::string & driverName);
+    int32_t loadByPath(const std::string & path, PF_PluginType type);
+
+    void * createObject(const std::string & objectType);
+
+    int32_t shutdown();
+    static int32_t registerObject(const std::string & objectType, const PF_RegisterParams * params);
+    const RegistrationMap & getRegistrationMap();
+
+private:
+    ~PluginManager();
+    PluginManager();
+    PluginManager(const PluginManager &);
+
+    DynamicLibrary * loadLibrary(const std::string & path, std::string & errorString);
+
+    bool inInitializePlugin_;
+    DynamicLibraryMap dynamicLibraryMap_;
+    ExitFuncVec exitFuncVec_;
+
+    RegistrationMap tempExactMatchMap_;
+
+    RegistrationMap exactMatchMap_;
+};
+
+} // namespace pdal
+
diff --git a/include/pdal/Reader.hpp b/include/pdal/Reader.hpp
index c8fe7a9b49..ddb3b9552b 100644
--- a/include/pdal/Reader.hpp
+++ b/include/pdal/Reader.hpp
@@ -42,8 +42,6 @@ namespace pdal
 
 class Reader;
 
-typedef std::unique_ptr<Reader> ReaderPtr;
-
 class PDAL_DLL Reader : public Stage
 {
 public:
diff --git a/include/pdal/Stage.hpp b/include/pdal/Stage.hpp
index 9a7b537f73..1b45418d8c 100644
--- a/include/pdal/Stage.hpp
+++ b/include/pdal/Stage.hpp
@@ -43,6 +43,7 @@
 #include <pdal/PointBuffer.hpp>
 #include <pdal/QuickInfo.hpp>
 #include <pdal/SpatialReference.hpp>
+#include <pdal/UserCallback.hpp>
 
 #include <boost/property_tree/ptree.hpp>
 
@@ -99,11 +100,11 @@ class PDAL_DLL Stage
             return m_options.getValueOrDefault<uint32_t>("verbose", 0);
         }
     virtual std::string getName() const = 0;
-    virtual std::string getDescription() const = 0;
+    //virtual std::string getDescription() const = 0;
     const std::vector<Stage *>& getInputs() const
         { return m_inputs; }
     std::vector<Stage*> findStage(std::string name);
-    static Options getDefaultOptions()
+    virtual Options getDefaultOptions()
         { return Options(); }
     static Dimension::IdList getDefaultDimensions()
         { return Dimension::IdList(); }
@@ -114,26 +115,17 @@ class PDAL_DLL Stage
     virtual boost::property_tree::ptree toPTree(PointContextRef ctx) const
         { return boost::property_tree::ptree(); }
 
-#define SET_STAGE_NAME(name, description)  \
-    static std::string s_getName() { return name; }  \
-    std::string getName() const { return name; }  \
-    static std::string s_getDescription() { return description; }  \
-    std::string getDescription() const { return description; }
-
-#define SET_STAGE_LINK(infolink) \
-    static std::string s_getInfoLink() { return infolink; }  \
-    std::string getInfoLink() const { return infolink; }
-
-#define SET_PLUGIN_VERSION(version) \
-    static std::string s_getPluginVersion() { return version; } \
-    std::string getPluginVersion() { return version; }
-
     virtual StageSequentialIterator* createSequentialIterator() const
         { return NULL; }
     inline MetadataNode getMetadata() const
         { return m_metadata; }
 
+    /// Sets the UserCallback to manage progress/cancel operations
+    void setUserCallback(UserCallback* userCallback)
+        { m_callback.reset(userCallback); }
+
 protected:
+    std::unique_ptr<UserCallback> m_callback;
     Options m_options;
     MetadataNode m_metadata;
 
diff --git a/include/pdal/StageFactory.hpp b/include/pdal/StageFactory.hpp
index 4ade1553cb..b3ca05a2cb 100644
--- a/include/pdal/StageFactory.hpp
+++ b/include/pdal/StageFactory.hpp
@@ -34,16 +34,12 @@
 
 #pragma once
 
-#include <pdal/pdal_internal.hpp>
+#include <pdal/pdal_export.hpp>
 #include <pdal/Stage.hpp>
-#include <pdal/Reader.hpp>
-#include <pdal/Filter.hpp>
-#include <pdal/Writer.hpp>
-#include <pdal/StageInfo.hpp>
 
-#include <vector>
 #include <map>
 #include <string>
+#include <vector>
 
 
 namespace pdal
@@ -68,16 +64,8 @@ class Options;
 class PDAL_DLL StageFactory
 {
 public:
-    typedef Reader* ReaderCreator();
-    typedef Filter* FilterCreator();
-    typedef Writer* WriterCreator();
-
-    typedef std::map<std::string, ReaderCreator*> ReaderCreatorList;
-    typedef std::map<std::string, FilterCreator*> FilterCreatorList;
-    typedef std::map<std::string, WriterCreator*> WriterCreatorList;
-
-public:
-    StageFactory();
+    StageFactory(bool no_plugins=true);
+    virtual ~StageFactory() {};
 
     // infer the driver to use based on filename extension
     // returns "" if no driver found
@@ -91,58 +79,18 @@ class PDAL_DLL StageFactory
     // e.g. output files ending in .laz should be compressed
     static pdal::Options inferWriterOptionsChanges(const std::string& filename);
 
-    Reader* createReader(const std::string& type);
-    Filter* createFilter(const std::string& type);
-    Writer* createWriter(const std::string& type);
-
-    void registerReader(const std::string& type, ReaderCreator* f);
-    void registerFilter(const std::string& type, FilterCreator* f);
-    void registerWriter(const std::string& type, WriterCreator* f);
-
-    void loadPlugins();
-    void registerPlugin(std::string const& filename);
+    static std::unique_ptr<Stage> createStage(const std::string& type);
+    static Stage* createStage2(const std::string& type);
 
-    std::map<std::string, pdal::StageInfo> const& getStageInfos() const;
-    template<class T> void registerDriverInfo();
-
-    std::string toRST(std::string driverName="") const;
-
-    // callers take ownership of returned stages
-    ReaderCreator* getReaderCreator(const std::string& type) const;
-    FilterCreator* getFilterCreator(const std::string& type) const;
-    WriterCreator* getWriterCreator(const std::string& type) const;
+    std::vector<std::string> getStageNames();
+    std::map<std::string, std::string> getStageMap();
 
 private:
-    void registerKnownReaders();
-    void registerKnownFilters();
-    void registerKnownWriters();
-
-    // these are the "registries" of the factory creator functions
-    ReaderCreatorList m_readerCreators;
-    FilterCreatorList m_filterCreators;
-    WriterCreatorList m_writerCreators;
+    void loadPlugins();  // BJC - deprecated, just keeping it around for some notes on how we used to do stuff, esp. handling symlinks
 
-    // driver name + driver description
-    std::map<std::string, pdal::StageInfo> m_driver_info;
     StageFactory& operator=(const StageFactory&); // not implemented
     StageFactory(const StageFactory&); // not implemented
 };
 
-template <class T>
-inline void StageFactory::registerDriverInfo()
-{
-
-    pdal::StageInfo info(T::s_getName(), T::s_getDescription());
-    info.setInfoLink(T::s_getInfoLink());
-    info.addProvidedDimensions(T::getDefaultDimensions());
-    info.setPluginVersion(T::s_getPluginVersion());
-
-    std::vector<Option> options = T::getDefaultOptions().getOptions();
-    for (auto i = options.begin(); i != options.end(); ++i)
-        info.addProvidedOption(*i);
-    m_driver_info.insert(
-        std::pair<std::string, pdal::StageInfo>(T::s_getName(), info));
-}
-
 } // namespace pdal
 
diff --git a/include/pdal/StageInfo.hpp b/include/pdal/StageInfo.hpp
deleted file mode 100644
index 2c0a3db6e8..0000000000
--- a/include/pdal/StageInfo.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2013, Howard Butler (hobu.inc@gmail.com)
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include <iosfwd>
-
-#include <pdal/Dimension.hpp>
-#include <pdal/Options.hpp>
-#include <pdal/Metadata.hpp>
-
-namespace pdal
-{
-
-class Stage;
-
-class PDAL_DLL StageInfo
-{
-    friend class StageBase;
-public:
-
-    /// Constructor.
-    ///
-    StageInfo(std::string const& stageName, std::string const& stageDescription="");
-
-    StageInfo& operator=(const StageInfo& rhs); 
-    StageInfo(const StageInfo&); 
-
-    /// Destructor.
-    virtual ~StageInfo() {};
-
-    /// Gets the available Options for the Stage.
-    ///
-    /// @return The options.
-
-
-    /// Gets the dimensions that a give stage produces
-/**
-    inline std::vector<Dimension> const& getProvidedDimensions() const
-    {
-        return m_dimensions;
-    }
-**/    
-    
-    void addProvidedDimensions(const Dimension::IdList& dims)
-    {
-        std::copy(dims.begin(), dims.end(), std::back_inserter(m_dimensions));
-    }
-
-    inline std::vector<Option> const& getProvidedOptions() const
-    {
-        return m_options;
-    }
-    
-    inline void addProvidedOption(Option const& opt)
-    {
-        m_options.push_back(opt);
-    }
-    
-    inline std::string const& getName() const
-    {
-        return m_name;
-    }
-    
-    inline std::string const& getDescription() const
-    {
-        return m_description;
-    }
-    
-    inline void setInfoLink(std::string const& link)
-    {
-        m_link = link;
-    }
-    
-    inline std::string const& getInfoLink() const
-    {
-        return m_link;
-    }
-
-    inline void setPluginVersion(std::string const& version)
-    {
-        m_plugin_version = version;
-    }
- 
-    inline std::string const& getPluginVersion() const
-    {
-        return m_plugin_version;
-    }
-        
-    std::string optionsToRST() const;
-    
-    inline std::string toRST() const
-    {
-        std::ostringstream strm;
-        std::string link(getInfoLink());
-        bool bDoLink = link.size() > 0;
-         
-        // strm << headline << std::endl;
-        if (bDoLink)
-            strm << "`";
-        strm << getName();
-        if (bDoLink)
-            strm << "`_ ";
-        strm << std::endl;
-        std::string headline("------------------------------------------------------------------------------------------");
-
-        strm << headline << std::endl;
-    
-        strm << getDescription() << std::endl;
-
-        std::string version(getPluginVersion());
-        if (version.size())
-            strm << "Plugin version: " << getPluginVersion() << std::endl;
-        
-        if (bDoLink)
-        {
-            strm << std::endl;
-            strm << ".. _`" << getName() << "`: " << getInfoLink() << std::endl;
-        }
-        return strm.str();    
-    }
-
-private:
-    std::string m_name;
-    std::string m_description;
-    Dimension::IdList m_dimensions;
-    std::vector<Option> m_options;
-    std::string m_link;
-    std::string m_plugin_version;
-};
-
-/// Output operator for serialization
-///
-/// @param ostr    The output stream to write to
-/// @param src     The StageInfo to be serialized out
-///
-/// @return The output stream
-
-PDAL_DLL std::ostream& operator<<(std::ostream& ostr, const StageInfo& src);
-
-} // namespace pdal
-
diff --git a/include/pdal/Writer.hpp b/include/pdal/Writer.hpp
index b1d5aa45a4..1e33a520cf 100644
--- a/include/pdal/Writer.hpp
+++ b/include/pdal/Writer.hpp
@@ -36,7 +36,7 @@
 
 #include <pdal/pdal_internal.hpp>
 #include <pdal/Options.hpp>
-#include <pdal/UserCallback.hpp>
+//#include <pdal/UserCallback.hpp>
 #include <pdal/Stage.hpp>
 
 #include <string>
@@ -46,8 +46,6 @@ namespace pdal
 
 class Writer;
 
-typedef std::unique_ptr<Writer> WriterPtr;
-
 class PointBuffer;
 class UserCallback;
 
@@ -58,7 +56,7 @@ class PDAL_DLL Writer : public Stage
 
 public:
     /// Constructs an end-stage consumer of a pipeline of data -- a writer
-    Writer() : m_callback(new UserCallback)
+    Writer() //: m_callback(new UserCallback)
         {}
 
     /// Serialize the pipeline to a boost::property_tree::ptree
@@ -66,11 +64,11 @@ class PDAL_DLL Writer : public Stage
     virtual boost::property_tree::ptree serializePipeline() const;
 
     /// Sets the UserCallback to manage progress/cancel operations
-    void setUserCallback(UserCallback* userCallback)
-        { m_callback.reset(userCallback); }
+//    void setUserCallback(UserCallback* userCallback)
+//        { m_callback.reset(userCallback); }
 
 protected:
-    std::unique_ptr<UserCallback> m_callback;
+//    std::unique_ptr<UserCallback> m_callback;
     std::string m_filename;
     XForm m_xXform;
     XForm m_yXform;
@@ -89,7 +87,7 @@ class PDAL_DLL Writer : public Stage
     }
     virtual void writerProcessOptions(const Options& options);
     virtual void write(const PointBuffer& /*buffer*/)
-        { std::cerr << "Can't write with stage = " << getName() << "!\n"; }
+        { /*std::cerr << "Can't write with stage = " << getName() << "!\n";*/ }
 
     Writer& operator=(const Writer&); // not implemented
     Writer(const Writer&); // not implemented
diff --git a/include/pdal/pdal_macros.hpp b/include/pdal/pdal_macros.hpp
index ecdddcbafb..7ab7b046da 100644
--- a/include/pdal/pdal_macros.hpp
+++ b/include/pdal/pdal_macros.hpp
@@ -34,102 +34,73 @@
 
 #pragma once
 
-#include <pdal/pdal_internal.hpp>
-//
-// macros for creating the various stage types
-//
-#define MAKE_READER_CREATOR(T, FullT) \
-    pdal::Reader* create_##T() \
-        { pdal::Reader *r = new FullT(); return r; }
-#define MAKE_FILTER_CREATOR(T, FullT) \
-    pdal::Filter* create_##T() \
-        { pdal::Filter *f = new FullT(); return f; }
-#define MAKE_WRITER_CREATOR(T, FullT) \
-    pdal::Writer* create_##T() \
-        { pdal::Writer *w = new FullT(); return w; }
-#define MAKE_KERNEL_CREATOR(T, FullT) \
-    pdal::Kernel* create_##T() \
-        { pdal::Kernel *k = new FullT(); return k; }
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
+#include <pdal/PluginManager.hpp>
 
-//
-// macros to register the stage creators
-//
-#define REGISTER_WRITER(T, FullT) \
-    registerDriverInfo<FullT>(); \
-    registerWriter(FullT::s_getName(), create_##T)
-#define REGISTER_READER(T, FullT) \
-    registerDriverInfo<FullT>(); \
-    registerReader(FullT::s_getName(), create_##T)
-#define REGISTER_FILTER(T, FullT) \
-    registerDriverInfo<FullT>(); \
-    registerFilter(FullT::s_getName(), create_##T)
-#define REGISTER_KERNEL(T, FullT) \
-    registerKernelDriverInfo<FullT>(); \
-    registerKernel(FullT::s_getName(), create_##T)
+namespace {
 
-//
-// macros to create the various plugins types
-//
-#define CREATE_READER_PLUGIN(T, FullT) \
-    MAKE_READER_CREATOR(T, FullT) \
-    PDAL_C_START PDAL_DLL void PDALRegister_reader_##T(void* factory) \
+typedef struct PluginInfo {
+    std::string name;
+    std::string description;
+    std::string link;
+} PluginInfo;
+
+}
+
+#define CREATE_SHARED_PLUGIN(T, type, info) \
+    extern "C" PDAL_DLL int32_t ExitFunc() \
+    { return 0; } \
+    extern "C" PDAL_DLL PF_ExitFunc PF_initPlugin() \
     { \
-        pdal::StageFactory& f = *(pdal::StageFactory*) factory; \
-        f.registerDriverInfo< FullT>(); \
-        f.registerReader(FullT::s_getName(), create_##T); \
+        int res = 0; \
+        PF_RegisterParams rp; \
+        rp.createFunc = pdal::T::create; \
+        rp.destroyFunc = pdal::T::destroy; \
+        strcpy(rp.description, info.description.c_str()); \
+        strcpy(rp.link, info.link.c_str()); \
+        rp.pluginType = PF_PluginType_ ## type; \
+        pdal::PluginManager & pm = pdal::PluginManager::getInstance(); \
+        res = pm.registerObject(info.name.c_str(), &rp); \
+        if (res < 0) \
+            return NULL; \
+        return ExitFunc; \
     } \
-    PDAL_C_END \
-    SET_READER_PLUGIN_VERSION(T)
-#define CREATE_FILTER_PLUGIN(T, FullT) \
-    MAKE_FILTER_CREATOR(T, FullT) \
-    PDAL_C_START PDAL_DLL void PDALRegister_filter_##T(void* factory) \
+    void * pdal::T::create() { return new pdal::T(); } \
+    int32_t pdal::T::destroy(void *p) \
     { \
-        pdal::StageFactory& f = *(pdal::StageFactory*) factory; \
-        f.registerDriverInfo< FullT>(); \
-        f.registerFilter(FullT::s_getName(), create_##T); \
-    } \
-    PDAL_C_END \
-    SET_FILTER_PLUGIN_VERSION(T)
-#define CREATE_WRITER_PLUGIN(T, FullT) \
-    MAKE_WRITER_CREATOR(T, FullT) \
-    PDAL_C_START PDAL_DLL void PDALRegister_writer_##T(void* factory) \
+        if (!p) \
+            return -1; \
+        delete (pdal::T *)p; \
+        return 0; \
+    }
+
+#define CREATE_STATIC_PLUGIN(T, type, info) \
+    extern "C" PDAL_DLL int32_t T ## _ExitFunc() \
+    { return 0; } \
+    extern "C" PDAL_DLL PF_ExitFunc T ## _InitPlugin() \
     { \
-        pdal::StageFactory& f = *(pdal::StageFactory*) factory; \
-        f.registerDriverInfo< FullT>(); \
-        f.registerWriter(FullT::s_getName(), create_##T); \
+        int res = 0; \
+        PF_RegisterParams rp; \
+        rp.createFunc = pdal::T::create; \
+        rp.destroyFunc = pdal::T::destroy; \
+        strcpy(rp.description, info.description.c_str()); \
+        strcpy(rp.link, info.link.c_str()); \
+        rp.pluginType = PF_PluginType_ ## type; \
+        pdal::PluginManager & pm = pdal::PluginManager::getInstance(); \
+        res = pm.registerObject(info.name.c_str(), &rp); \
+        if (res < 0) \
+            return NULL; \
+        return T ## _ExitFunc; \
     } \
-    PDAL_C_END \
-    SET_WRITER_PLUGIN_VERSION(T)
-#define CREATE_KERNEL_PLUGIN(T, FullT) \
-    MAKE_KERNEL_CREATOR(T, FullT) \
-    PDAL_C_START PDAL_DLL void PDALRegister_kernel_##T(void* factory) \
+    void * pdal::T::create() { return new pdal::T(); } \
+    int32_t pdal::T::destroy(void *p) \
     { \
-        pdal::KernelFactory& f = *(pdal::KernelFactory*) factory; \
-        f.registerKernelDriverInfo< FullT>(); \
-        f.registerKernel(FullT::s_getName(), create_##T); \
-    } \
-    PDAL_C_END \
-    SET_KERNEL_PLUGIN_VERSION(T)
-
-//
-// macro to register the version of PDAL the plugin was linked against
-//
-#define SET_READER_PLUGIN_VERSION(T) \
-    PDAL_C_START PDAL_DLL int PDALRegister_version_reader_##T() \
-        { return PDAL_PLUGIN_VERSION; } \
-    PDAL_C_END
-#define SET_FILTER_PLUGIN_VERSION(T) \
-    PDAL_C_START PDAL_DLL int PDALRegister_version_filter_##T() \
-        { return PDAL_PLUGIN_VERSION; } \
-    PDAL_C_END
-#define SET_WRITER_PLUGIN_VERSION(T) \
-    PDAL_C_START PDAL_DLL int PDALRegister_version_writer_##T() \
-        { return PDAL_PLUGIN_VERSION; } \
-    PDAL_C_END
-#define SET_KERNEL_PLUGIN_VERSION(T) \
-    PDAL_C_START PDAL_DLL int PDALRegister_version_kernel_##T() \
-        { return PDAL_PLUGIN_VERSION; } \
-    PDAL_C_END
+        if (!p) \
+            return -1; \
+        delete (pdal::T *)p; \
+        return 0; \
+    }
 
 #ifdef _WIN32
 inline long lround(double d)
diff --git a/include/pdal/plugin.h b/include/pdal/plugin.h
new file mode 100644
index 0000000000..4cd579a185
--- /dev/null
+++ b/include/pdal/plugin.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <pdal/pdal_export.hpp>
+
+#include <cstdint>
+
+#define PF_MAX_DESCRIPTION_LEN 128
+#define PF_MAX_LINK_LEN 128
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum PF_PluginType
+{
+    PF_PluginType_Kernel,
+    PF_PluginType_Reader,
+    PF_PluginType_Filter,
+    PF_PluginType_Writer
+} PF_PluginType;
+
+typedef void * (*PF_CreateFunc)();
+typedef int32_t (*PF_DestroyFunc)(void *);
+
+typedef struct PF_RegisterParams
+{
+    PF_CreateFunc createFunc;
+    PF_DestroyFunc destroyFunc;
+    char description[PF_MAX_DESCRIPTION_LEN + 1];
+    char link[PF_MAX_LINK_LEN + 1];
+    PF_PluginType pluginType;
+} PF_RegisterParams;
+
+typedef int32_t (*PF_ExitFunc)();
+typedef PF_ExitFunc (*PF_InitFunc)();
+
+#ifndef PDAL_DLL
+  #ifdef WIN32
+    #define PDAL_DLL __declspec(dllimport)
+  #else
+    #define PDAL_DLL
+  #endif
+#endif
+
+extern
+#ifdef __cplusplus
+"C"
+#endif
+PDAL_DLL PF_ExitFunc PF_initPlugin();
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/io/bpf/BpfReader.cpp b/io/bpf/BpfReader.cpp
index 9ffa1c64d8..e2bd4eea65 100644
--- a/io/bpf/BpfReader.cpp
+++ b/io/bpf/BpfReader.cpp
@@ -32,17 +32,27 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include <pdal/pdal_internal.hpp>
+#include "BpfReader.hpp"
 
 #include <zlib.h>
 
 #include <pdal/Options.hpp>
-
-#include "BpfReader.hpp"
+#include <pdal/pdal_export.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.bpf",
+    "\"Binary Point Format\" (BPF) reader support. BPF is a simple \n" \
+        "DoD and research format that is used by some sensor and \n" \
+        "processing chains.",
+    "http://pdal.io/stages/readers.bpf.html" };
+
+CREATE_STATIC_PLUGIN(BpfReader, Reader, s_info)
+
+std::string BpfReader::getName() const { return s_info.name; }
+
 void BpfReader::processOptions(const Options&)
 {
     if (m_filename.empty())
diff --git a/io/bpf/BpfReader.hpp b/io/bpf/BpfReader.hpp
index 4caaec5f0a..e57f3f0c8e 100644
--- a/io/bpf/BpfReader.hpp
+++ b/io/bpf/BpfReader.hpp
@@ -34,26 +34,28 @@
 
 #pragma once
 
-#include <vector>
-
 #include <pdal/Charbuf.hpp>
 #include <pdal/IStream.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
 #include <pdal/Reader.hpp>
 
 #include "BpfHeader.hpp"
 
+#include <vector>
+
+extern "C" int32_t BpfReader_ExitFunc();
+extern "C" PF_ExitFunc BpfReader_InitPlugin();
+
 namespace pdal
 {
 
-#define BPFREADERDOC "\"Binary Point Format\" (BPF) reader support. BPF is a simple \n" \
-                     "DoD and research format that is used by some sensor and \n" \
-                     "processing chains."
-
 class PDAL_DLL BpfReader : public Reader
 {
 public:
-    SET_STAGE_NAME("readers.bpf", BPFREADERDOC)
-    SET_STAGE_LINK("http://pdal.io/stages/readers.bpf.html")
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
     virtual point_count_t numPoints() const
         {  return (point_count_t)m_header.m_numPts; }
diff --git a/io/bpf/BpfWriter.cpp b/io/bpf/BpfWriter.cpp
index 215cec2c8a..291b27bcd5 100644
--- a/io/bpf/BpfWriter.cpp
+++ b/io/bpf/BpfWriter.cpp
@@ -34,18 +34,28 @@
 
 #include "BpfWriter.hpp"
 
-#include <pdal/pdal_internal.hpp>
-
-#include <zlib.h>
-
 #include <pdal/Charbuf.hpp>
 #include <pdal/Options.hpp>
+#include <pdal/pdal_export.hpp>
+
+#include <zlib.h>
 
 #include "BpfCompressor.hpp"
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.bpf",
+    "\"Binary Point Format\" (BPF) writer support. BPF is a simple \n" \
+        "DoD and research format that is used by some sensor and \n" \
+        "processing chains.",
+    "http://pdal.io/stages/writers.bpf.html" };
+
+CREATE_STATIC_PLUGIN(BpfWriter, Writer, s_info)
+
+std::string BpfWriter::getName() const { return s_info.name; }
+
 Options BpfWriter::getDefaultOptions()
 {
     Options ops;
diff --git a/io/bpf/BpfWriter.hpp b/io/bpf/BpfWriter.hpp
index 15886643bb..33c2abd559 100644
--- a/io/bpf/BpfWriter.hpp
+++ b/io/bpf/BpfWriter.hpp
@@ -34,12 +34,17 @@
 
 #pragma once
 
-#include <vector>
+#include "BpfHeader.hpp"
 
 #include <pdal/OStream.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
 #include <pdal/Writer.hpp>
 
-#include "BpfHeader.hpp"
+#include <vector>
+
+extern "C" int32_t BpfWriter_ExitFunc();
+extern "C" PF_ExitFunc BpfWriter_InitPlugin();
 
 namespace pdal
 {
@@ -47,14 +52,11 @@ namespace pdal
 class PDAL_DLL BpfWriter : public Writer
 {
 public:
-    SET_STAGE_NAME("writers.bpf",
-        "\"Binary Point Format\" (BPF) writer support. "
-        "BPF is a simple \n"
-        "DoD and research format that is used by some sensor and \n"
-        "processing chains.");
-    SET_STAGE_LINK("http://pdal.io/stages/writers.bpf.html")
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
-    static Options getDefaultOptions();
+    Options getDefaultOptions();
 
 private:
     OLeStream m_stream;
diff --git a/io/faux/FauxReader.cpp b/io/faux/FauxReader.cpp
index f88fac6956..63566a8175 100644
--- a/io/faux/FauxReader.cpp
+++ b/io/faux/FauxReader.cpp
@@ -32,17 +32,27 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include <ctime>
+#include "FauxReader.hpp"
 
+#include <pdal/Options.hpp>
 #include <pdal/PointBuffer.hpp>
 
 #include <boost/algorithm/string.hpp>
 
-#include "FauxReader.hpp"
+#include <ctime>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.faux",
+    "Faux Reader",
+    "http://pdal.io/stages/readers.faux.html" };
+
+CREATE_STATIC_PLUGIN(FauxReader, Reader, s_info)
+
+std::string FauxReader::getName() const { return s_info.name; }
+
 static Mode string2mode(const std::string& str)
 {
     if (boost::iequals(str, "constant")) return Constant;
@@ -60,7 +70,6 @@ FauxReader::FauxReader()
     m_count = 0;
 }
 
-
 void FauxReader::processOptions(const Options& options)
 {
     BOX3D bounds = options.getValueOrDefault<BOX3D>("bounds",
@@ -88,6 +97,14 @@ void FauxReader::processOptions(const Options& options)
         throw pdal_error("faux: number_of_returns option must be 10 or less.");
 }
 
+Options FauxReader::getDefaultOptions()
+{
+    Options options;
+    Option count("num_points", 10, "Number of points");
+    options.add(count);
+    return options;
+}
+
 
 void FauxReader::addDimensions(PointContextRef ctx)
 {
diff --git a/io/faux/FauxReader.hpp b/io/faux/FauxReader.hpp
index 6ce717907b..1c6c419bf7 100644
--- a/io/faux/FauxReader.hpp
+++ b/io/faux/FauxReader.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Reader.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t FauxReader_ExitFunc();
+extern "C" PF_ExitFunc FauxReader_InitPlugin();
 
 namespace pdal
 {
@@ -77,14 +81,17 @@ enum Mode
 // activated by passing a numeric value as "number_of_returns" to the
 // reader constructor.
 //
-class PDAL_DLL FauxReader : public pdal::Reader
+class PDAL_DLL FauxReader : public Reader
 {
 public:
-    SET_STAGE_NAME("readers.faux", "Faux Reader")
-
     FauxReader();
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
     static Dimension::IdList getDefaultDimensions();
+    Options getDefaultOptions();
 
 private:
     Mode m_mode;
diff --git a/io/las/LasReader.cpp b/io/las/LasReader.cpp
index e117fb3159..0bd253e1e5 100644
--- a/io/las/LasReader.cpp
+++ b/io/las/LasReader.cpp
@@ -38,20 +38,31 @@
 #include <string.h>
 
 #include <pdal/Extractor.hpp>
-#include <pdal/util/FileUtils.hpp>
 #include <pdal/IStream.hpp>
-#include <pdal/QuickInfo.hpp>
-#include <pdal/PointBuffer.hpp>
 #include <pdal/Metadata.hpp>
+#include <pdal/PointBuffer.hpp>
+#include <pdal/QuickInfo.hpp>
+#include <pdal/util/FileUtils.hpp>
 
+#include "GeotiffSupport.hpp"
 #include "LasHeader.hpp"
 #include "VariableLengthRecord.hpp"
 #include "ZipPoint.hpp"
-#include "GeotiffSupport.hpp"
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.las",
+    "ASPRS LAS 1.0 - 1.4 read support. LASzip support is also \n" \
+        "enabled through this driver if LASzip was found diring \n" \
+        "compilation.",
+    "http://pdal.io/stages/readers.las.html" };
+
+CREATE_STATIC_PLUGIN(LasReader, Reader, s_info)
+
+std::string LasReader::getName() const { return s_info.name; }
+
 QuickInfo LasReader::inspect()
 {
     QuickInfo qi;
diff --git a/io/las/LasReader.hpp b/io/las/LasReader.hpp
index 6a96e8f75e..9011ef21ee 100644
--- a/io/las/LasReader.hpp
+++ b/io/las/LasReader.hpp
@@ -34,13 +34,18 @@
 
 #pragma once
 
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
 #include <pdal/Reader.hpp>
-
 #include <pdal/StreamFactory.hpp>
+
 #include "LasError.hpp"
 #include "LasHeader.hpp"
 #include "ZipPoint.hpp"
 
+extern "C" int32_t LasReader_ExitFunc();
+extern "C" PF_ExitFunc LasReader_InitPlugin();
+
 namespace pdal
 {
 
@@ -48,21 +53,19 @@ class NitfReader;
 class LasHeader;
 class PointDimensions;
 
-#define LASREADERDOCS "ASPRS LAS 1.0 - 1.4 read support. LASzip support is also \n" \
-                      "enabled through this driver if LASzip was found diring \n" \
-                      "compilation."
 class PDAL_DLL LasReader : public pdal::Reader
 {
     friend class NitfReader;
 public:
-    SET_STAGE_NAME("readers.las", LASREADERDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/readers.las.html")
-
     LasReader() : pdal::Reader(), m_index(0),
             m_istream(NULL)
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
     const LasHeader& header() const
         { return m_lasHeader; }
diff --git a/io/las/LasWriter.cpp b/io/las/LasWriter.cpp
index aa4ce35a74..ae9b254ec3 100644
--- a/io/las/LasWriter.cpp
+++ b/io/las/LasWriter.cpp
@@ -48,6 +48,17 @@
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.las",
+    "ASPRS LAS 1.0 - 1.4 writer. LASzip support is also \n" \
+        "available if enabled at compile-time. Note that LAZ \n" \
+        "does not provide LAS 1.4 support at this time.",
+    "http://pdal.io/stages/writers.las.html" };
+
+CREATE_STATIC_PLUGIN(LasWriter, Writer, s_info)
+
+std::string LasWriter::getName() const { return s_info.name; }
+
 void LasWriter::construct()
 {
     m_xXform.m_scale = .01;
diff --git a/io/las/LasWriter.hpp b/io/las/LasWriter.hpp
index 6f2090221d..f5e36f00a9 100644
--- a/io/las/LasWriter.hpp
+++ b/io/las/LasWriter.hpp
@@ -34,6 +34,7 @@
 
 #pragma once
 
+#include <pdal/plugin.h>
 #include <pdal/Writer.hpp>
 
 #include "LasError.hpp"
@@ -41,6 +42,9 @@
 #include "SummaryData.hpp"
 #include "ZipPoint.hpp"
 
+extern "C" int32_t LasWriter_ExitFunc();
+extern "C" PF_ExitFunc LasWriter_InitPlugin();
+
 namespace pdal
 {
 class LasTester;
@@ -56,23 +60,21 @@ struct VlrOptionInfo
     std::string m_description;
 };
 
-#define LASWRITERDOC "ASPRS LAS 1.0 - 1.4 writer. LASzip support is also \n" \
-                     "available if enabled at compile-time. Note that LAZ \n" \
-                     "does not provide LAS 1.4 support at this time."
 class PDAL_DLL LasWriter : public pdal::Writer
 {
     friend class LasTester;
     friend class NitfWriter;
 public:
-    SET_STAGE_NAME("writers.las", LASWRITERDOC)
-    SET_STAGE_LINK("http://pdal.io/stages/writers.las.html")
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
     LasWriter() : m_ostream(NULL)
          { construct(); }
     LasWriter(std::ostream *stream) : m_ostream(stream)
         { construct(); }
 
-    static Options getDefaultOptions();
+    Options getDefaultOptions();
 
     void flush();
 
diff --git a/io/qfit/QfitReader.cpp b/io/qfit/QfitReader.cpp
index 6d83391457..be4b67f618 100644
--- a/io/qfit/QfitReader.cpp
+++ b/io/qfit/QfitReader.cpp
@@ -166,14 +166,14 @@ Word #       Content
 
 */
 
-#include <algorithm>
-#include <map>
+#include "QfitReader.hpp"
 
 #include <pdal/PointBuffer.hpp>
 #include <pdal/util/FileUtils.hpp>
 #include <pdal/Utils.hpp>
 
-#include "QfitReader.hpp"
+#include <algorithm>
+#include <map>
 
 #ifdef PDAL_COMPILER_MSVC
 #  pragma warning(disable: 4127)  // conditional expression is constant
@@ -182,6 +182,15 @@ Word #       Content
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.qfit",
+    "QFIT Reader",
+    "http://pdal.io/stages/readers.qfit.html" };
+
+CREATE_STATIC_PLUGIN(QfitReader, Reader, s_info)
+
+std::string QfitReader::getName() const { return s_info.name; }
+
 QfitReader::QfitReader() : pdal::Reader(),
     m_format(QFIT_Format_Unknown), m_size(0), m_littleEndian(false)
 {}
diff --git a/io/qfit/QfitReader.hpp b/io/qfit/QfitReader.hpp
index 5dbf8a120c..e5e62deeae 100644
--- a/io/qfit/QfitReader.hpp
+++ b/io/qfit/QfitReader.hpp
@@ -38,6 +38,7 @@
 
 #include <boost/detail/endian.hpp>
 
+#include <pdal/plugin.h>
 #include <pdal/Reader.hpp>
 #include <pdal/Options.hpp>
 
@@ -63,6 +64,9 @@
         }} while(false)
 #endif
 
+extern "C" int32_t QfitReader_ExitFunc();
+extern "C" PF_ExitFunc QfitReader_InitPlugin();
+
 namespace pdal
 {
 
@@ -86,12 +90,13 @@ class qfit_error : public pdal_error
 class PDAL_DLL QfitReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.qfit", "QFIT Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.qfit.html")
-
     QfitReader();
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     static Dimension::IdList getDefaultDimensions();
 
     std::string getFileName() const;
diff --git a/io/sbet/SbetReader.cpp b/io/sbet/SbetReader.cpp
index 4a91555135..9700000f8b 100644
--- a/io/sbet/SbetReader.cpp
+++ b/io/sbet/SbetReader.cpp
@@ -37,6 +37,15 @@
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.sbet",
+    "SBET Reader",
+    "http://pdal.io/stages/readers.sbet.html" };
+
+CREATE_STATIC_PLUGIN(SbetReader, Reader, s_info)
+
+std::string SbetReader::getName() const { return s_info.name; }
+
 Options SbetReader::getDefaultOptions()
 {
     Options options;
diff --git a/io/sbet/SbetReader.hpp b/io/sbet/SbetReader.hpp
index 788d4c3a58..9fa4603661 100644
--- a/io/sbet/SbetReader.hpp
+++ b/io/sbet/SbetReader.hpp
@@ -35,24 +35,29 @@
 #pragma once
 
 #include <pdal/IStream.hpp>
+#include <pdal/plugin.h>
 #include <pdal/PointBuffer.hpp>
 #include <pdal/Reader.hpp>
 
 #include "SbetCommon.hpp"
 
+extern "C" int32_t SbetReader_ExitFunc();
+extern "C" PF_ExitFunc SbetReader_InitPlugin();
+
 namespace pdal
 {
 
 class PDAL_DLL SbetReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.sbet", "SBET Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.sbet.html")
-
     SbetReader() : Reader()
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     static Dimension::IdList getDefaultDimensions()
         { return fileDimensions(); }
 
diff --git a/io/sbet/SbetWriter.cpp b/io/sbet/SbetWriter.cpp
index 2c8072cebb..2811d3b3a4 100644
--- a/io/sbet/SbetWriter.cpp
+++ b/io/sbet/SbetWriter.cpp
@@ -39,6 +39,15 @@
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.sbet",
+    "SBET Writer",
+    "http://pdal.io/stages/writers.sbet.html" };
+
+CREATE_STATIC_PLUGIN(SbetWriter, Writer, s_info)
+
+std::string SbetWriter::getName() const { return s_info.name; }
+
 void SbetWriter::processOptions(const Options& options)
 {
     m_filename = options.getOption("filename").getValue<std::string>();
diff --git a/io/sbet/SbetWriter.hpp b/io/sbet/SbetWriter.hpp
index 51be614f15..a7c2154bce 100644
--- a/io/sbet/SbetWriter.hpp
+++ b/io/sbet/SbetWriter.hpp
@@ -35,22 +35,27 @@
 #pragma once
 
 #include <pdal/OStream.hpp>
+#include <pdal/plugin.h>
 #include <pdal/Writer.hpp>
 
 #include "SbetCommon.hpp"
 
+extern "C" int32_t SbetWriter_ExitFunc();
+extern "C" PF_ExitFunc SbetWriter_InitPlugin();
+
 namespace pdal
 {
 
 class PDAL_DLL SbetWriter : public pdal::Writer
 {
 public:
-    SET_STAGE_NAME("writers.sbet", "SBET Writer")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.sbet.html")
-
     SbetWriter() : pdal::Writer()
         {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
     static Dimension::IdList getDefaultDimensions()
         { return fileDimensions(); }
 
diff --git a/io/terrasolid/TerrasolidReader.cpp b/io/terrasolid/TerrasolidReader.cpp
index f53e9e7a22..0325003a37 100644
--- a/io/terrasolid/TerrasolidReader.cpp
+++ b/io/terrasolid/TerrasolidReader.cpp
@@ -42,6 +42,15 @@
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.terrasolid",
+    "TerraSolid Reader",
+    "http://pdal.io/stages/readers.terrasolid.html" };
+
+CREATE_STATIC_PLUGIN(TerrasolidReader, Reader, s_info)
+
+std::string TerrasolidReader::getName() const { return s_info.name; }
+
 void TerrasolidReader::initialize()
 {
     std::istream* stream = FileUtils::openFile(m_filename);
diff --git a/io/terrasolid/TerrasolidReader.hpp b/io/terrasolid/TerrasolidReader.hpp
index a31bc5c0ce..bd4364331a 100644
--- a/io/terrasolid/TerrasolidReader.hpp
+++ b/io/terrasolid/TerrasolidReader.hpp
@@ -34,14 +34,17 @@
 
 #pragma once
 
-#include <pdal/Reader.hpp>
 #include <pdal/Options.hpp>
+#include <pdal/plugin.h>
+#include <pdal/Reader.hpp>
+
+#include <boost/detail/endian.hpp>
 
 #include <memory>
 #include <vector>
 
-#include <boost/detail/endian.hpp>
-
+extern "C" int32_t TerrasolidReader_ExitFunc();
+extern "C" PF_ExitFunc TerrasolidReader_InitPlugin();
 
 namespace pdal
 {
@@ -95,12 +98,14 @@ class terrasolid_error : public pdal_error
 class PDAL_DLL TerrasolidReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.terrasolid", "TerraSolid Reader")
-
     TerrasolidReader() : pdal::Reader(),
         m_format(TERRASOLID_Format_Unknown)
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
     static Dimension::IdList getDefaultDimensions();
 
     point_count_t getNumPoints() const
diff --git a/io/text/TextWriter.cpp b/io/text/TextWriter.cpp
index e8fe324060..fb863858cc 100644
--- a/io/text/TextWriter.cpp
+++ b/io/text/TextWriter.cpp
@@ -34,22 +34,30 @@
 
 #include "TextWriter.hpp"
 
-#include <pdal/util/Algorithm.hpp>
+#include <pdal/pdal_export.hpp>
 #include <pdal/PointBuffer.hpp>
-#include <pdal/pdal_internal.hpp>
+#include <pdal/util/Algorithm.hpp>
 
-#include <iostream>
 #include <algorithm>
+#include <iostream>
 #include <map>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/erase.hpp>
 #include <boost/tokenizer.hpp>
 
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.text",
+    "Text Writer",
+    "http://pdal.io/stages/writers.text.html" };
+
+CREATE_STATIC_PLUGIN(TextWriter, Writer, s_info)
+
+std::string TextWriter::getName() const { return s_info.name; }
+
 struct FileStreamDeleter
 {
 
diff --git a/io/text/TextWriter.hpp b/io/text/TextWriter.hpp
index 7a27c3eeb5..86f28b1f74 100644
--- a/io/text/TextWriter.hpp
+++ b/io/text/TextWriter.hpp
@@ -34,29 +34,35 @@
 
 #pragma once
 
-#include <pdal/Writer.hpp>
-#include <pdal/util/FileUtils.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/plugin.h>
 #include <pdal/StageFactory.hpp>
+#include <pdal/util/FileUtils.hpp>
+#include <pdal/Writer.hpp>
 
 #include <memory>
 #include <vector>
 #include <string>
 
+extern "C" int32_t TextWriter_ExitFunc();
+extern "C" PF_ExitFunc TextWriter_InitPlugin();
+
 namespace pdal
 {
 
 typedef std::shared_ptr<std::ostream> FileStreamPtr;
 
-class PDAL_DLL TextWriter : public pdal::Writer
+class PDAL_DLL TextWriter : public Writer
 {
 public:
-    SET_STAGE_NAME("writers.text", "Text Writer")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.text.html")
-
-    TextWriter() : pdal::Writer()
+    TextWriter()
     {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     virtual void processOptions(const Options&);
diff --git a/kernels/delta/DeltaKernel.cpp b/kernels/delta/DeltaKernel.cpp
index f9b184365b..2769e21918 100644
--- a/kernels/delta/DeltaKernel.cpp
+++ b/kernels/delta/DeltaKernel.cpp
@@ -35,13 +35,20 @@
 #include "DeltaKernel.hpp"
 
 #include <boost/format.hpp>
-
+#include <boost/program_options.hpp>
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.delta",
+    "Delta Kernel",
+    "http://pdal.io/kernels/kernels.delta.html" };
+
+CREATE_STATIC_PLUGIN(DeltaKernel, Kernel, s_info)
+
 DeltaKernel::DeltaKernel()
     : Kernel()
     , m_outputStream(0)
diff --git a/kernels/delta/DeltaKernel.hpp b/kernels/delta/DeltaKernel.hpp
index 4e5207c55e..8e7a4a859e 100644
--- a/kernels/delta/DeltaKernel.hpp
+++ b/kernels/delta/DeltaKernel.hpp
@@ -37,6 +37,7 @@
 #include <pdal/KDIndex.hpp>
 #include <pdal/Kernel.hpp>
 #include <pdal/PointBuffer.hpp>
+#include <pdal/plugin.h>
 #include <pdal/Stage.hpp>
 #include <pdal/util/FileUtils.hpp>
 
@@ -51,6 +52,9 @@
 #include <boost/accumulators/statistics/count.hpp>
 //#include <boost/accumulators/statistics/density.hpp>
 
+extern "C" int32_t DeltaKernel_ExitFunc();
+extern "C" PF_ExitFunc DeltaKernel_InitPlugin();
+
 namespace pdal
 {
     
@@ -99,13 +103,12 @@ class PDAL_DLL Point
 class PDAL_DLL DeltaKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("delta", "Delta Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.delta.html")
- 
-    DeltaKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute(); // overrride
     
 private:
+    DeltaKernel();
     void addSwitches(); // overrride
     
     std::string m_sourceFile;
@@ -134,4 +137,5 @@ class PDAL_DLL DeltaKernel : public Kernel
 
 };
 
-} // pdal
+} // namespace pdal
+
diff --git a/kernels/diff/DiffKernel.cpp b/kernels/diff/DiffKernel.cpp
index 5393a7e80a..c42776dc85 100644
--- a/kernels/diff/DiffKernel.cpp
+++ b/kernels/diff/DiffKernel.cpp
@@ -38,12 +38,21 @@
 
 #include <pdal/PDALUtils.hpp>
 
+#include <boost/program_options.hpp>
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 
 using boost::property_tree::ptree;
 
-namespace pdal {
+namespace pdal
+{
+
+static PluginInfo const s_info {
+    "kernels.diff",
+    "Diff Kernel",
+    "http://pdal.io/kernels/kernels.diff.html" };
+
+CREATE_STATIC_PLUGIN(DiffKernel, Kernel, s_info)
 
 DiffKernel::DiffKernel()
     : Kernel()
@@ -226,3 +235,4 @@ int DiffKernel::execute()
 }
 
 } // namespace pdal
+
diff --git a/kernels/diff/DiffKernel.hpp b/kernels/diff/DiffKernel.hpp
index bf1db0312e..ab86e31cf2 100644
--- a/kernels/diff/DiffKernel.hpp
+++ b/kernels/diff/DiffKernel.hpp
@@ -37,10 +37,14 @@
 #include <pdal/Kernel.hpp>
 #include <pdal/Stage.hpp>
 #include <pdal/util/FileUtils.hpp>
+#include <pdal/plugin.h>
 #include <pdal/PointBuffer.hpp>
 
 #include <boost/property_tree/ptree.hpp>
 
+extern "C" int32_t DiffKernel_ExitFunc();
+extern "C" PF_ExitFunc DiffKernel_InitPlugin();
+
 namespace pdal
 {
     
@@ -48,14 +52,13 @@ namespace pdal
 class PDAL_DLL DiffKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("diff", "Diff Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.diff.html")
- 
-    DiffKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute(); // overrride
     
     
 private:
+    DiffKernel();
     void addSwitches(); // overrride
     void validateSwitches(); // overrride
     
@@ -68,4 +71,5 @@ class PDAL_DLL DiffKernel : public Kernel
     bool m_useJSON;
 };
 
-} // pdal
+} // namespace pdal
+
diff --git a/kernels/info/InfoKernel.cpp b/kernels/info/InfoKernel.cpp
index 7688ee125a..a26a2559bd 100644
--- a/kernels/info/InfoKernel.cpp
+++ b/kernels/info/InfoKernel.cpp
@@ -41,9 +41,18 @@
 #include <pdal/PDALUtils.hpp>
 #include <pdal/pdal_config.hpp>
 
+#include <boost/program_options.hpp>
+
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.info",
+    "Info Kernel",
+    "http://pdal.io/kernels/kernels.info.html" };
+
+CREATE_STATIC_PLUGIN(InfoKernel, Kernel, s_info)
+
 InfoKernel::InfoKernel()
     : m_showStats(false)
     , m_showSchema(false)
@@ -346,7 +355,7 @@ int InfoKernel::execute()
 
     m_manager = std::unique_ptr<PipelineManager>(
         KernelSupport::makePipeline(filename));
-    m_reader = static_cast<Reader *>(m_manager->getStage());
+    m_reader = m_manager->getStage();
     Stage *stage = m_reader;
 
     if (m_Dimensions.size())
diff --git a/kernels/info/InfoKernel.hpp b/kernels/info/InfoKernel.hpp
index e7ed476102..5d89bca93b 100644
--- a/kernels/info/InfoKernel.hpp
+++ b/kernels/info/InfoKernel.hpp
@@ -35,11 +35,11 @@
 #pragma once
 
 #include <pdal/Kernel.hpp>
-
+#include <pdal/KernelSupport.hpp>
+#include <pdal/plugin.h>
+#include <pdal/PointBuffer.hpp>
 #include <pdal/Stage.hpp>
 #include <pdal/util/FileUtils.hpp>
-#include <pdal/PointBuffer.hpp>
-
 
 #ifdef __clang__
 #pragma GCC diagnostic ignored "-Wtautological-constant-out-of-range-compare"
@@ -48,23 +48,23 @@
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/tokenizer.hpp>
 
-#include <pdal/KernelSupport.hpp>
-
 typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
 
+extern "C" int32_t InfoKernel_ExitFunc();
+extern "C" PF_ExitFunc InfoKernel_InitPlugin();
+
 namespace pdal
 {
 
 class PDAL_DLL InfoKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("info", "Info Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.info.html")
-
-    InfoKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute(); // overrride
 
 private:
+    InfoKernel();
     void addSwitches(); // overrride
     void validateSwitches(); // overrride
 
@@ -93,7 +93,7 @@ class PDAL_DLL InfoKernel : public Kernel
 
     Stage *m_statsStage;
     Stage *m_hexbinStage;
-    Reader *m_reader;
+    Stage *m_reader;
 
     MetadataNode m_tree;
     std::unique_ptr<PipelineManager> m_manager;
diff --git a/kernels/pipeline/PipelineKernel.cpp b/kernels/pipeline/PipelineKernel.cpp
index a14228a324..ee59fac6e4 100644
--- a/kernels/pipeline/PipelineKernel.cpp
+++ b/kernels/pipeline/PipelineKernel.cpp
@@ -34,9 +34,18 @@
 
 #include "PipelineKernel.hpp"
 
+#include <boost/program_options.hpp>
+
 namespace pdal
 {
-    
+
+static PluginInfo const s_info {
+    "kernels.pipeline",
+    "Pipeline Kernel",
+    "http://pdal.io/kernels/kernels.pipeline.html" };
+
+CREATE_STATIC_PLUGIN(PipelineKernel, Kernel, s_info)
+
 PipelineKernel::PipelineKernel() : m_validate(false)
 {}
 
diff --git a/kernels/pipeline/PipelineKernel.hpp b/kernels/pipeline/PipelineKernel.hpp
index da9dd10ebb..06261800de 100644
--- a/kernels/pipeline/PipelineKernel.hpp
+++ b/kernels/pipeline/PipelineKernel.hpp
@@ -38,8 +38,12 @@
 #include <pdal/PipelineReader.hpp>
 #include <pdal/PipelineManager.hpp>
 #include <pdal/PipelineWriter.hpp>
-#include <pdal/util/FileUtils.hpp>
+#include <pdal/plugin.h>
 #include <pdal/PointBuffer.hpp>
+#include <pdal/util/FileUtils.hpp>
+
+extern "C" int32_t PipelineKernel_ExitFunc();
+extern "C" PF_ExitFunc PipelineKernel_InitPlugin();
 
 namespace pdal
 {
@@ -47,13 +51,12 @@ namespace pdal
 class PDAL_DLL PipelineKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("pipeline", "Pipeline Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.pipeline.html")
-
-    PipelineKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    PipelineKernel();
     void addSwitches();
     void validateSwitches();
     
diff --git a/kernels/random/RandomKernel.cpp b/kernels/random/RandomKernel.cpp
index 2c75c02689..8e078259c7 100644
--- a/kernels/random/RandomKernel.cpp
+++ b/kernels/random/RandomKernel.cpp
@@ -34,9 +34,18 @@
 
 #include "RandomKernel.hpp"
 
+#include <boost/program_options.hpp>
+
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.random",
+    "Random Kernel",
+    "http://pdal.io/kernels/kernels.random.html" };
+
+CREATE_STATIC_PLUGIN(RandomKernel, Kernel, s_info)
+
 RandomKernel::RandomKernel()
     : Kernel()
     , m_outputFile("")
@@ -90,7 +99,7 @@ Stage* RandomKernel::makeReader(Options readerOptions)
     }
 
     StageFactory factory;
-    ReaderPtr reader_stage(factory.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader_stage(factory.createStage("readers.faux"));
     reader_stage->setOptions(readerOptions);
 
     return reader_stage.get();
@@ -158,7 +167,7 @@ int RandomKernel::execute()
 
     Stage* final_stage = makeReader(readerOptions);
 
-    Writer* writer = KernelSupport::makeWriter(m_outputFile, final_stage);
+    Stage* writer = KernelSupport::makeWriter(m_outputFile, final_stage);
     writer->setOptions(writerOptions);
     PointContext ctx;
 
diff --git a/kernels/random/RandomKernel.hpp b/kernels/random/RandomKernel.hpp
index 091f99d654..bbbabd82b6 100644
--- a/kernels/random/RandomKernel.hpp
+++ b/kernels/random/RandomKernel.hpp
@@ -35,6 +35,7 @@
 #pragma once
 
 #include <pdal/Kernel.hpp>
+#include <pdal/plugin.h>
 #include <pdal/util/FileUtils.hpp>
 
 
@@ -43,19 +44,21 @@
 #include <boost/tokenizer.hpp>
 typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
 
+extern "C" int32_t RandomKernel_ExitFunc();
+extern "C" PF_ExitFunc RandomKernel_InitPlugin();
+
 namespace pdal
 {
 
 class PDAL_DLL RandomKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("random", "Random Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.random.html")
-
-    RandomKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    RandomKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/kernels/sort/SortKernel.cpp b/kernels/sort/SortKernel.cpp
index 237a43346f..c9a7326d9d 100644
--- a/kernels/sort/SortKernel.cpp
+++ b/kernels/sort/SortKernel.cpp
@@ -34,14 +34,22 @@
 
 #include "SortKernel.hpp"
 
+#include <pdal/BufferReader.hpp>
 #include <pdal/KernelSupport.hpp>
 #include <pdal/StageFactory.hpp>
 
-#include <pdal/BufferReader.hpp>
+#include <boost/program_options.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.sort",
+    "Sort Kernel",
+    "http://pdal.io/kernels/kernels.sort.html" };
+
+CREATE_STATIC_PLUGIN(SortKernel, Kernel, s_info)
+
 SortKernel::SortKernel() :
     Kernel(), m_bCompress(false), m_bForwardMetadata(false)
 {}
@@ -129,7 +137,7 @@ int SortKernel::execute()
     sortOptions.add<uint32_t>("verbose", getVerboseLevel());
 
     StageFactory f;
-    Filter* sortStage = f.createFilter("filters.mortonorder");
+    Stage* sortStage = f.createStage2("filters.mortonorder");
     sortStage->setInput(&bufferReader);
     sortStage->setOptions(sortOptions);
 
@@ -147,7 +155,7 @@ int SortKernel::execute()
         cmd.size() ? (UserCallback *)new ShellScriptCallback(cmd) :
         (UserCallback *)new HeartbeatCallback();
 
-    WriterPtr writer(KernelSupport::makeWriter(m_outputFile, sortStage));
+    std::unique_ptr<Stage> writer(KernelSupport::makeWriter(m_outputFile, sortStage));
 
     // Some options are inferred by makeWriter based on filename
     // (compression, driver type, etc).
diff --git a/kernels/sort/SortKernel.hpp b/kernels/sort/SortKernel.hpp
index 32bf48ed75..b44c6beae6 100644
--- a/kernels/sort/SortKernel.hpp
+++ b/kernels/sort/SortKernel.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Kernel.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t SortKernel_ExitFunc();
+extern "C" PF_ExitFunc SortKernel_InitPlugin();
 
 namespace pdal
 {
@@ -42,13 +46,12 @@ namespace pdal
 class PDAL_DLL SortKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("sort", "Sort Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.sort.html")
- 
-    SortKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    SortKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/kernels/translate/TranslateKernel.cpp b/kernels/translate/TranslateKernel.cpp
index 0eefad842b..6c6f903980 100644
--- a/kernels/translate/TranslateKernel.cpp
+++ b/kernels/translate/TranslateKernel.cpp
@@ -33,15 +33,24 @@
 ****************************************************************************/
 
 #include "TranslateKernel.hpp"
-#include <pdal/KernelSupport.hpp>
 
 #include <pdal/BufferReader.hpp>
+#include <pdal/KernelSupport.hpp>
 #include <pdal/StageFactory.hpp>
 #include <reprojection/ReprojectionFilter.hpp>
 
+#include <boost/program_options.hpp>
+
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.translate",
+    "Translate Kernel",
+    "http://pdal.io/kernels/kernels.translate.html" };
+
+CREATE_STATIC_PLUGIN(TranslateKernel, Kernel, s_info)
+
 TranslateKernel::TranslateKernel() :
     Kernel(), m_bCompress(false),
     m_input_srs(pdal::SpatialReference()),
@@ -198,8 +207,8 @@ Stage* TranslateKernel::makeTranslate(Options translateOptions, Stage* reader_st
     if (!m_bounds.empty() || !m_wkt.empty() || !m_output_srs.empty() || extra_opts.size() > 0)
     {
         Stage* next_stage = reader_stage;
-        Stage* crop_stage = f.createFilter("filters.crop");
-        Stage* reprojection_stage = f.createFilter("filters.reprojection");
+        Stage* crop_stage = f.createStage2("filters.crop");
+        Stage* reprojection_stage = f.createStage2("filters.reprojection");
 
 
         bool bHaveReprojection = extra_opts.find("filters.reprojection") != extra_opts.end();
@@ -262,7 +271,7 @@ Stage* TranslateKernel::makeTranslate(Options translateOptions, Stage* reader_st
 
     if (boost::iequals(m_decimation_method, "VoxelGrid"))
     {
-        Stage* decimation_stage(f.createFilter("filters.pclblock"));
+        Stage* decimation_stage(f.createStage2("filters.pclblock"));
 
         Options decimationOptions;
         std::ostringstream ss;
@@ -294,7 +303,7 @@ Stage* TranslateKernel::makeTranslate(Options translateOptions, Stage* reader_st
         decimationOptions.add("step", m_decimation_step);
         decimationOptions.add("offset", m_decimation_offset);
         decimationOptions.add("limit", m_decimation_limit);
-        Stage* decimation_stage(f.createFilter("filters.decimation"));
+        Stage* decimation_stage(f.createStage2("filters.decimation"));
         decimation_stage->setInput(final_stage);
         decimation_stage->setOptions(decimationOptions);
         final_stage = decimation_stage;
@@ -349,7 +358,7 @@ int TranslateKernel::execute()
         cmd.size() ? (UserCallback *)new ShellScriptCallback(cmd) :
         (UserCallback *)new HeartbeatCallback();
 
-    WriterPtr writer( KernelSupport::makeWriter(m_outputFile, finalStage));
+    std::unique_ptr<Stage> writer( KernelSupport::makeWriter(m_outputFile, finalStage));
     if (!m_output_srs.empty())
         writer->setSpatialReference(m_output_srs);
 
diff --git a/kernels/translate/TranslateKernel.hpp b/kernels/translate/TranslateKernel.hpp
index b32f80d082..c006521adb 100644
--- a/kernels/translate/TranslateKernel.hpp
+++ b/kernels/translate/TranslateKernel.hpp
@@ -35,6 +35,10 @@
 #pragma once
 
 #include <pdal/Kernel.hpp>
+#include <pdal/plugin.h>
+
+extern "C" int32_t TranslateKernel_ExitFunc();
+extern "C" PF_ExitFunc TranslateKernel_InitPlugin();
 
 namespace pdal
 {
@@ -42,13 +46,12 @@ namespace pdal
 class PDAL_DLL TranslateKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME ("translate", "Translate Kernel")
-    SET_KERNEL_LINK ("http://pdal.io/kernels/kernels.translate.html")
- 
-    TranslateKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    TranslateKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/pdal_defines.h.in b/pdal_defines.h.in
index b94ccc703c..4482ab6b20 100644
--- a/pdal_defines.h.in
+++ b/pdal_defines.h.in
@@ -55,6 +55,8 @@
  * platform OS
  */
 #cmakedefine PDAL_PLATFORM_WIN32
+#cmakedefine PDAL_PLATFORM_OSX
+#cmakedefine PDAL_PLATFORM_LINUX
 
 /*
  * platform compiler
diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 1c270c1b42..37efdc7d85 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -50,10 +50,11 @@ if(BUILD_PLUGIN_PYTHON)
     add_subdirectory(python)
 endif()
 
+if(BUILD_PLUGIN_RIVLIB)
+    add_subdirectory(rxp)
+endif(BUILD_PLUGIN_RIVLIB)
+
 if(BUILD_PLUGIN_SQLITE)
     add_subdirectory(sqlite)
 endif()
 
-if(BUILD_PLUGIN_RIVLIB)
-    add_subdirectory(rxp)
-endif(BUILD_PLUGIN_RIVLIB)
diff --git a/plugins/attribute/filters/AttributeFilter.cpp b/plugins/attribute/filters/AttributeFilter.cpp
index e9fc2aeffc..28fffe9f26 100644
--- a/plugins/attribute/filters/AttributeFilter.cpp
+++ b/plugins/attribute/filters/AttributeFilter.cpp
@@ -45,11 +45,17 @@
 #include <ogr_geometry.h>
 #include <geos_c.h>
 
-CREATE_FILTER_PLUGIN(attribute, pdal::AttributeFilter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.attribute",
+    "Assign values for a dimension using a specified value, \n" \
+        "an OGR-readable data source, or an OGR SQL query.",
+    "http://pdal.io/stages/filters.attribute.html" };
+
+CREATE_SHARED_PLUGIN(AttributeFilter, Filter, s_info)
+
 struct OGRDataSourceDeleter
 {
     template <typename T>
diff --git a/plugins/attribute/filters/AttributeFilter.hpp b/plugins/attribute/filters/AttributeFilter.hpp
index 54e4eb8f43..7f0a0c1252 100644
--- a/plugins/attribute/filters/AttributeFilter.hpp
+++ b/plugins/attribute/filters/AttributeFilter.hpp
@@ -110,15 +110,14 @@ typedef std::map< std::string, AttributeInfo> AttributeInfoMap;
 
 class PDAL_DLL AttributeFilter : public Filter
 {
-#define ATTRIBUTEDOCS "Assign values for a dimension using a specified value, \n" \
-                      "an OGR-readable data source, or an OGR SQL query."
 public:
-    SET_STAGE_NAME("filters.attribute", ATTRIBUTEDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/filters.attribute.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     AttributeFilter() : Filter(), m_geosEnvironment(0) {};
-    static Options getDefaultOptions();
+
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const { return "filters.attribute"; }
+
+    Options getDefaultOptions();
 
 private:
     virtual void initialize();
diff --git a/plugins/cpd/kernel/Cpd.cpp b/plugins/cpd/kernel/Cpd.cpp
index a3a9e3e45a..ada192a2ee 100644
--- a/plugins/cpd/kernel/Cpd.cpp
+++ b/plugins/cpd/kernel/Cpd.cpp
@@ -40,17 +40,15 @@
 #include "chipper/ChipperFilter.hpp"
 #include "crop/CropFilter.hpp"
 
-
-CREATE_KERNEL_PLUGIN(cpd, pdal::CpdKernel)
-
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.cpd",
+    "CPD Kernel",
+    "http://pdal.io/kernels/kernels.cpd.html" };
 
-CpdKernel::CpdKernel()
-    : Kernel()
-{}
+CREATE_SHARED_PLUGIN(CpdKernel, Kernel, s_info)
 
 
 void CpdKernel::validateSwitches()
@@ -135,7 +133,7 @@ PointBufferPtr CpdKernel::readFile(const std::string& filename, PointContext& ct
         Options boundsOptions;
         boundsOptions.add("bounds", m_bounds);
         StageFactory f;
-        std::shared_ptr<Stage> crop(f.createFilter("filters.crop"));
+        std::shared_ptr<Stage> crop(f.createStage("filters.crop"));
         crop->setInput(source.get());
         crop->setOptions(boundsOptions);
         source = crop;
@@ -249,7 +247,7 @@ int CpdKernel::execute()
     writerOpts.add<bool>("keep_unspecified", false);
     setCommonOptions(writerOpts);
 
-    std::unique_ptr<Writer> writer(KernelSupport::makeWriter(m_output, &reader));
+    std::unique_ptr<Stage> writer(KernelSupport::makeWriter(m_output, &reader));
     writer->setOptions(writerOpts + writer->getOptions());
     writer->prepare(ctxout);
     writer->execute(ctxout);
diff --git a/plugins/cpd/kernel/Cpd.hpp b/plugins/cpd/kernel/Cpd.hpp
index fc88a15eeb..6802a19db0 100644
--- a/plugins/cpd/kernel/Cpd.hpp
+++ b/plugins/cpd/kernel/Cpd.hpp
@@ -37,6 +37,7 @@
 #include <cpd/nonrigid_lowrank.hpp>
 
 #include <pdal/Kernel.hpp>
+#include <pdal/pdal_export.hpp>
 
 
 namespace pdal
@@ -46,13 +47,12 @@ namespace pdal
 class PDAL_DLL CpdKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME("cpd", "CPD Kernel")
-    SET_KERNEL_LINK("http://pdal.io/kernels/kernels.cpd.html")
-
-    CpdKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    CpdKernel() {};
     void addSwitches();
     void validateSwitches();
     PointBufferPtr readFile(const std::string& filename, PointContext& ctx, arma::mat& mat);
diff --git a/plugins/cpd/test/CpdKernelTest.cpp b/plugins/cpd/test/CpdKernelTest.cpp
index 1d3527e6dd..6039741bfe 100644
--- a/plugins/cpd/test/CpdKernelTest.cpp
+++ b/plugins/cpd/test/CpdKernelTest.cpp
@@ -65,17 +65,17 @@ class CpdKernelTest : public ::testing::Test
 
         Options readerOptions;
         readerOptions.add("filename", m_x);
-        Reader * reader = mrManager.addReader("readers.las");
+        Stage * reader = mrManager.addReader("readers.las");
         reader->setOptions(readerOptions);
 
         Options transformationOptions;
         transformationOptions.add("matrix", "0.36 0.48 -0.8 1\n-0.8 0.6 0.0 2\n0.48 0.64 0.60 3\n0 0 0 1");
-        Filter * filter = mrManager.addFilter("filters.transformation", reader);
+        Stage* filter = mrManager.addFilter("filters.transformation", reader);
         filter->setOptions(transformationOptions);
 
         Options writerOptions;
         writerOptions.add("filename", m_y);
-        Writer * writer = mrManager.addWriter("writers.las", reader);
+        Stage * writer = mrManager.addWriter("writers.las", reader);
         writer->setOptions(writerOptions);
 
         point_count_t np = mrManager.execute();
@@ -94,13 +94,13 @@ class CpdKernelTest : public ::testing::Test
 };
 
 
-}
+} // namespace
 
 
 TEST_F(CpdKernelTest, Execution)
 {
-    KernelFactory kernelFactory;
-    std::unique_ptr<Kernel> cpdKernel = kernelFactory.createKernel("cpd");
+    KernelFactory f;
+    std::unique_ptr<Kernel> cpdKernel = f.createKernel("kernels.cpd");
 
     int argc = 7;
     const char * argv[7] = {
@@ -112,9 +112,11 @@ TEST_F(CpdKernelTest, Execution)
         "-o",
         m_outfile.c_str()
     };
+
     int retval = cpdKernel->run(argc, argv, "cpd");
     EXPECT_EQ(0, retval);
 }
 
 
-}
+} // namespace pdal
+
diff --git a/plugins/greyhound/io/GreyhoundReader.cpp b/plugins/greyhound/io/GreyhoundReader.cpp
index 954ff3c212..979612c740 100644
--- a/plugins/greyhound/io/GreyhoundReader.cpp
+++ b/plugins/greyhound/io/GreyhoundReader.cpp
@@ -36,11 +36,18 @@
 
 #include "Exchanges.hpp"
 
-CREATE_READER_PLUGIN(greyhound, pdal::GreyhoundReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.greyhound",
+    "Greyhound Reader",
+    "http://pdal.io/stages/readers.greyhound.html" };
+
+CREATE_SHARED_PLUGIN(GreyhoundReader, Reader, s_info)
+
+std::string GreyhoundReader::getName() const { return s_info.name; }
+
 GreyhoundReader::GreyhoundReader()
     : Reader()
     , m_url()
diff --git a/plugins/greyhound/io/GreyhoundReader.hpp b/plugins/greyhound/io/GreyhoundReader.hpp
index 61bae11a43..145d779b0d 100644
--- a/plugins/greyhound/io/GreyhoundReader.hpp
+++ b/plugins/greyhound/io/GreyhoundReader.hpp
@@ -45,13 +45,13 @@ namespace pdal
 class PDAL_DLL GreyhoundReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.greyhound", "Greyhound Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.greyhound.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     GreyhoundReader();
     ~GreyhoundReader();
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     std::string m_url;
     std::string m_pipelineId;
diff --git a/plugins/hexbin/filters/HexBin.cpp b/plugins/hexbin/filters/HexBin.cpp
index b271ce4921..9ace051726 100644
--- a/plugins/hexbin/filters/HexBin.cpp
+++ b/plugins/hexbin/filters/HexBin.cpp
@@ -39,11 +39,16 @@
 
 using namespace hexer;
 
-CREATE_FILTER_PLUGIN(hexbin, pdal::HexBin)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.hexbin",
+    "Tessellate the point's X/Y domain and determine point density and/or point boundary.",
+    "http://pdal.io/stages/filters.hexbin.html" };
+
+CREATE_SHARED_PLUGIN(HexBin, Filter, s_info)
+
 void HexBin::processOptions(const Options& options)
 {
     m_sampleSize = options.getValueOrDefault<uint32_t>("sample_size", 5000);
diff --git a/plugins/hexbin/filters/HexBin.hpp b/plugins/hexbin/filters/HexBin.hpp
index 65569f38ae..8f2ac7f23b 100644
--- a/plugins/hexbin/filters/HexBin.hpp
+++ b/plugins/hexbin/filters/HexBin.hpp
@@ -46,13 +46,13 @@ namespace pdal
 class PDAL_DLL HexBin : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.hexbin", "Tessellate the point's X/Y domain and determine point density and/or point boundary.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.hexbin.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     HexBin() : Filter()
         {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const { return "filters.hexbin"; }
+
 private:
 
     std::unique_ptr<hexer::HexGrid> m_grid;
diff --git a/plugins/hexbin/test/HexbinFilterTest.cpp b/plugins/hexbin/test/HexbinFilterTest.cpp
index cadf8ff91b..c5ea7f6f1e 100644
--- a/plugins/hexbin/test/HexbinFilterTest.cpp
+++ b/plugins/hexbin/test/HexbinFilterTest.cpp
@@ -70,11 +70,11 @@ TEST(HexbinFilterTest, HexbinFilterTest_test_1)
         "use in situations where you do not want to estimate based on "
         "a sample");
 
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(options);
 
-    FilterPtr hexbin(f.createFilter("filters.hexbin"));
+    std::unique_ptr<Stage> hexbin(f.createStage("filters.hexbin"));
     EXPECT_TRUE(hexbin.get());
     hexbin->setOptions(options);
     hexbin->setInput(reader.get());
diff --git a/plugins/icebridge/io/IcebridgeReader.cpp b/plugins/icebridge/io/IcebridgeReader.cpp
index ed34090b00..5366f16d87 100644
--- a/plugins/icebridge/io/IcebridgeReader.cpp
+++ b/plugins/icebridge/io/IcebridgeReader.cpp
@@ -38,8 +38,6 @@
 
 #include <map>
 
-CREATE_READER_PLUGIN(icebridge, pdal::IcebridgeReader)
-
 namespace
 {
     const std::vector<pdal::hdf5::Hdf5ColumnData> hdf5Columns =
@@ -62,6 +60,17 @@ namespace
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.icebridge",
+    "NASA HDF5-based IceBridge ATM reader. \n" \
+        "See http://nsidc.org/data/docs/daac/icebridge/ilatm1b/index.html \n" \
+        "for more information.",
+    "http://pdal.io/stages/readers.icebridge.html" };
+
+CREATE_SHARED_PLUGIN(IcebridgeReader, Reader, s_info)
+
+std::string IcebridgeReader::getName() const { return s_info.name; }
+
 Options IcebridgeReader::getDefaultOptions()
 {
     Options options;
diff --git a/plugins/icebridge/io/IcebridgeReader.hpp b/plugins/icebridge/io/IcebridgeReader.hpp
index 7d68276c7b..55ad73edc0 100644
--- a/plugins/icebridge/io/IcebridgeReader.hpp
+++ b/plugins/icebridge/io/IcebridgeReader.hpp
@@ -52,18 +52,17 @@ class icebridge_error : public pdal_error
     { }
 };
 
-#define ICEBRIDGEDOCS "NASA HDF5-based IceBridge ATM reader. \nSee http://nsidc.org/data/docs/daac/icebridge/ilatm1b/index.html for more information."
 class PDAL_DLL IcebridgeReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.icebridge", ICEBRIDGEDOCS)
-    SET_STAGE_LINK("http://pdal.io/stages/readers.icebridge.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     IcebridgeReader() : pdal::Reader()
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     static Dimension::IdList getDefaultDimensions();
 
 private:
diff --git a/plugins/icebridge/test/IcebridgeReaderTest.cpp b/plugins/icebridge/test/IcebridgeReaderTest.cpp
index a0199b8fa9..b8e72c3775 100644
--- a/plugins/icebridge/test/IcebridgeReaderTest.cpp
+++ b/plugins/icebridge/test/IcebridgeReaderTest.cpp
@@ -92,7 +92,7 @@ std::string getFilePath()
 TEST(IcebridgeReaderTest, testRead)
 {
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.icebridge"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.icebridge"));
     EXPECT_TRUE(reader.get());
 
     Option filename("filename", getFilePath(), "");
diff --git a/plugins/mrsid/io/MrsidReader.cpp b/plugins/mrsid/io/MrsidReader.cpp
index 1986ea68c6..0560becbae 100644
--- a/plugins/mrsid/io/MrsidReader.cpp
+++ b/plugins/mrsid/io/MrsidReader.cpp
@@ -38,12 +38,17 @@
 
 #include <boost/algorithm/string.hpp>
 
-
-CREATE_READER_PLUGIN(mrsid, pdal::MrsidReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.mrsid",
+    "MrSID Reader",
+    "http://www.pdal.io/stages/readers.mrsid.html" };
+
+CREATE_SHARED_PLUGIN(MrsidReader, Reader, s_info)
+
+std::string MrsidReader::getName() const { return s_info.name; }
 
 MrsidReader::MrsidReader(LizardTech::PointSource *ps)
     : pdal::Reader()
diff --git a/plugins/mrsid/io/MrsidReader.hpp b/plugins/mrsid/io/MrsidReader.hpp
index ca473c11a0..bed6e6b9fc 100644
--- a/plugins/mrsid/io/MrsidReader.hpp
+++ b/plugins/mrsid/io/MrsidReader.hpp
@@ -60,15 +60,15 @@ class PDAL_DLL MrsidReader : public pdal::Reader
 {
 
 public:
-    SET_STAGE_NAME("readers.mrsid", "MrSID Reader")
-    SET_STAGE_LINK("http://www.pdal.io/stages/readers.mrsid.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     virtual ~MrsidReader();
     MrsidReader() : Writer() {};
     MrsidReader(LizardTech::PointSource *ps);
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     static std::vector<Dimension> getDefaultDimensions();
     pdal::StageSequentialIterator*
         createSequentialIterator(PointBuffer& buffer) const;
diff --git a/plugins/nitf/io/NitfReader.cpp b/plugins/nitf/io/NitfReader.cpp
index f7636ed28c..dd0c731372 100644
--- a/plugins/nitf/io/NitfReader.cpp
+++ b/plugins/nitf/io/NitfReader.cpp
@@ -35,11 +35,18 @@
 #include "NitfFile.hpp"
 #include "NitfReader.hpp"
 
-CREATE_READER_PLUGIN(nitf, pdal::NitfReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.nitf",
+    "NITF Reader",
+    "http://pdal.io/stages/readers.nitf.html" };
+
+CREATE_SHARED_PLUGIN(NitfReader, Reader, s_info)
+
+std::string NitfReader::getName() const { return s_info.name; }
+
 //
 // References:
 //   - NITF 2.1 standard: MIL-STD-2500C (01 May 2006)
diff --git a/plugins/nitf/io/NitfReader.hpp b/plugins/nitf/io/NitfReader.hpp
index 992d9e96f6..2937f2d3d8 100644
--- a/plugins/nitf/io/NitfReader.hpp
+++ b/plugins/nitf/io/NitfReader.hpp
@@ -45,13 +45,13 @@ namespace pdal
 class PDAL_DLL NitfReader : public LasReader
 {
 public:
-    SET_STAGE_NAME("readers.nitf", "NITF Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.nitf.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     NitfReader() : LasReader()
         {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     uint64_t m_offset;
     uint64_t m_length;
diff --git a/plugins/nitf/io/NitfWriter.cpp b/plugins/nitf/io/NitfWriter.cpp
index c8ef512828..2fd6634295 100644
--- a/plugins/nitf/io/NitfWriter.cpp
+++ b/plugins/nitf/io/NitfWriter.cpp
@@ -77,11 +77,17 @@
 // syntactically, how do we name all the LAS writer options that we will pass to the las writer?
 //
 
-CREATE_WRITER_PLUGIN(nitf, pdal::NitfWriter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.nitf",
+    "NITF Writer",
+    "http://pdal.io/stages/writers.nitf.html" };
+
+CREATE_SHARED_PLUGIN(NitfWriter, Writer, s_info)
+
+std::string NitfWriter::getName() const { return s_info.name; }
 
 BOX3D reprojectBoxToDD(const SpatialReference& reference, const BOX3D& box)
 {
diff --git a/plugins/nitf/io/NitfWriter.hpp b/plugins/nitf/io/NitfWriter.hpp
index 2ea88f5525..2daaf86850 100644
--- a/plugins/nitf/io/NitfWriter.hpp
+++ b/plugins/nitf/io/NitfWriter.hpp
@@ -44,11 +44,11 @@ namespace pdal
 class PDAL_DLL NitfWriter : public LasWriter
 {
 public:
-    SET_STAGE_NAME("writers.nitf", "NITF Writer")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.nitf.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
+    NitfWriter();
 
-    NitfWriter() ;
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
 
 private:
     virtual void processOptions(const Options& options);
diff --git a/plugins/nitf/test/NitfReaderTest.cpp b/plugins/nitf/test/NitfReaderTest.cpp
index c512843e8b..87dfbae5e9 100644
--- a/plugins/nitf/test/NitfReaderTest.cpp
+++ b/plugins/nitf/test/NitfReaderTest.cpp
@@ -63,12 +63,12 @@ TEST(NitfReaderTest, test_one)
 
     PointContext ctx;
 
-    ReaderPtr nitf_reader(f.createReader("readers.nitf"));
+    std::unique_ptr<Stage> nitf_reader(f.createStage("readers.nitf"));
     EXPECT_TRUE(nitf_reader.get());
     nitf_reader->setOptions(nitf_opts);
     nitf_reader->prepare(ctx);
     PointBufferSet pbSet = nitf_reader->execute(ctx);
-    EXPECT_EQ(nitf_reader->getDescription(), "NITF Reader");
+    //EXPECT_EQ(nitf_reader->getDescription(), "NITF Reader");
     EXPECT_EQ(pbSet.size(), 1u);
     PointBufferPtr buf = *pbSet.begin();
 
@@ -91,7 +91,7 @@ TEST(NitfReaderTest, test_one)
 
     PointContext ctx2;
 
-    ReaderPtr las_reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> las_reader(f.createStage("readers.las"));
     EXPECT_TRUE(las_reader.get());
     las_reader->setOptions(las_opts);
     las_reader->prepare(ctx2);
@@ -156,14 +156,14 @@ TEST(NitfReaderTest, optionSrs)
 
     PointContext ctx;
 
-    ReaderPtr nitfReader(f.createReader("readers.nitf"));
+    std::unique_ptr<Stage> nitfReader(f.createStage("readers.nitf"));
     EXPECT_TRUE(nitfReader.get());
     nitfReader->setOptions(nitfOpts);
 
     Options lasOpts;
     lasOpts.add("filename", "/dev/null");
 
-    WriterPtr lasWriter(f.createWriter("writers.las"));
+    std::unique_ptr<Stage> lasWriter(f.createStage("writers.las"));
     EXPECT_TRUE(lasWriter.get());
     lasWriter->setInput(nitfReader.get());
     lasWriter->setOptions(lasOpts);;
diff --git a/plugins/nitf/test/NitfWriterTest.cpp b/plugins/nitf/test/NitfWriterTest.cpp
index 3077f18c51..181871c38c 100644
--- a/plugins/nitf/test/NitfWriterTest.cpp
+++ b/plugins/nitf/test/NitfWriterTest.cpp
@@ -147,11 +147,11 @@ TEST(NitfWriterTest, test1)
         // writer_opts.add(verbose);
         writer_opts.add(writer_opt1);
 
-        ReaderPtr reader(f.createReader("readers.las"));
+        std::unique_ptr<Stage> reader(f.createStage("readers.las"));
         EXPECT_TRUE(reader.get());
         reader->setOptions(reader_opts);
 
-        WriterPtr writer(f.createWriter("writers.nitf"));
+        std::unique_ptr<Stage> writer(f.createStage("writers.nitf"));
         EXPECT_TRUE(writer.get());
         writer->setOptions(writer_opts);
         writer->setInput(reader.get());
diff --git a/plugins/oci/io/OciReader.cpp b/plugins/oci/io/OciReader.cpp
index d8a83b61ad..2c1fcdf5a7 100644
--- a/plugins/oci/io/OciReader.cpp
+++ b/plugins/oci/io/OciReader.cpp
@@ -38,11 +38,18 @@
 #include <pdal/GlobalEnvironment.hpp>
 #include "OciReader.hpp"
 
-CREATE_READER_PLUGIN(oci, pdal::OciReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.oci",
+    "Read point cloud data from Oracle SDO_POINTCLOUD.",
+    "http://pdal.io/stages/readers.oci.html" };
+
+CREATE_SHARED_PLUGIN(OciReader, Reader, s_info)
+
+std::string OciReader::getName() const { return s_info.name; }
+
 void OciReader::processOptions(const Options& options)
 {
     m_schemaFile = options.getValueOrDefault<std::string>(
diff --git a/plugins/oci/io/OciReader.hpp b/plugins/oci/io/OciReader.hpp
index 6902e62708..b13cd84f22 100644
--- a/plugins/oci/io/OciReader.hpp
+++ b/plugins/oci/io/OciReader.hpp
@@ -47,14 +47,14 @@ namespace pdal
 class PDAL_DLL OciReader : public DbReader
 {
 public:
-    SET_STAGE_NAME("readers.oci", "Read point cloud data from Oracle SDO_POINTCLOUD.")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.oci.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     OciReader()
     {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     virtual void initialize();
diff --git a/plugins/oci/io/OciWriter.cpp b/plugins/oci/io/OciWriter.cpp
index c7b5bf3a08..67924a008d 100644
--- a/plugins/oci/io/OciWriter.cpp
+++ b/plugins/oci/io/OciWriter.cpp
@@ -46,11 +46,18 @@
 
 #include <ogr_api.h>
 
-CREATE_WRITER_PLUGIN(oci, pdal::OciWriter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.oci",
+    "Write data using SDO_PC objects to Oracle.",
+    "http://pdal.io/stages/writers.oci.html" };
+
+CREATE_SHARED_PLUGIN(OciWriter, Writer, s_info)
+
+std::string OciWriter::getName() const { return s_info.name; }
+
 OciWriter::OciWriter()
     : m_createIndex(false)
     , m_bDidCreateBlockTable(false)
diff --git a/plugins/oci/io/OciWriter.hpp b/plugins/oci/io/OciWriter.hpp
index 989ae6254d..7fa8fa7dba 100644
--- a/plugins/oci/io/OciWriter.hpp
+++ b/plugins/oci/io/OciWriter.hpp
@@ -47,13 +47,13 @@ namespace pdal
 class PDAL_DLL OciWriter : public DbWriter
 {
 public:
-    SET_STAGE_NAME("writers.oci", "Write data using SDO_PC objects to Oracle.")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.oci.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     OciWriter();
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     template<typename T>
diff --git a/plugins/oci/test/OCITest.cpp b/plugins/oci/test/OCITest.cpp
index 77775908e6..5c189fef6e 100644
--- a/plugins/oci/test/OCITest.cpp
+++ b/plugins/oci/test/OCITest.cpp
@@ -222,12 +222,12 @@ bool WriteUnprojectedData()
     PointContext ctx;
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(options);
     // filters::Chipper chipper(options);
     // chipper.setInput(&reader);
-    WriterPtr writer(f.createWriter("writers.oci"));
+    std::unique_ptr<Stage> writer(f.createStage("writers.oci"));
     EXPECT_TRUE(writer.get());
     writer->setOptions(options);
     writer->setInput(reader.get());
@@ -280,7 +280,7 @@ void compareAgainstSourceBuffer(PointBuffer const& candidate,
 
     PointContext tc;
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(options);
 
@@ -358,7 +358,7 @@ TEST_F(OCITest, read_unprojected_data)
     verbose.setValue<std::string>( "7");
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.oci"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.oci"));
     EXPECT_TRUE(reader.get());
 
     reader->setOptions(options);
diff --git a/plugins/p2g/io/P2gWriter.cpp b/plugins/p2g/io/P2gWriter.cpp
index f2b6574c27..a6dd0c8a76 100644
--- a/plugins/p2g/io/P2gWriter.cpp
+++ b/plugins/p2g/io/P2gWriter.cpp
@@ -41,11 +41,17 @@
 #include <boost/algorithm/string.hpp>
 #include <points2grid/Interpolation.hpp>
 
-CREATE_WRITER_PLUGIN(p2g, pdal::P2gWriter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.p2g",
+    "Points2Grid Writer",
+    "http://pdal.io/stages/writers.p2g.html" };
+
+CREATE_SHARED_PLUGIN(P2gWriter, Writer, s_info)
+
+std::string P2gWriter::getName() const { return s_info.name; }
 
 void P2gWriter::processOptions(const Options& options)
 {
diff --git a/plugins/p2g/io/P2gWriter.hpp b/plugins/p2g/io/P2gWriter.hpp
index d15852c971..223aad18a8 100644
--- a/plugins/p2g/io/P2gWriter.hpp
+++ b/plugins/p2g/io/P2gWriter.hpp
@@ -65,14 +65,14 @@ class CoreInterp;
 class PDAL_DLL P2gWriter : public pdal::Writer
 {
 public:
-    SET_STAGE_NAME("writers.p2g", "Points2Grid Writer")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.p2g.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     P2gWriter() : Writer(), m_outputTypes(0), m_outputFormat(OUTPUT_FORMAT_ARC_ASCII) {};
     ~P2gWriter() {};
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     P2gWriter& operator=(const P2gWriter&); // not implemented
diff --git a/plugins/pcl/CMakeLists.txt b/plugins/pcl/CMakeLists.txt
index a0df443c24..1bac766667 100644
--- a/plugins/pcl/CMakeLists.txt
+++ b/plugins/pcl/CMakeLists.txt
@@ -30,6 +30,7 @@ set_package_properties(PCL PROPERTIES DESCRIPTION "Point Cloud Library"
 include_directories(${PCL_INCLUDE_DIRS})
 include_directories(${CMAKE_CURRENT_LIST_DIR})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/filters)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/pipeline)
 link_directories(${PCL_LIBRARY_DIRS})
 add_definitions(${PCL_DEFINITIONS})
 if (NOT WIN32)
diff --git a/plugins/pcl/filters/GroundFilter.cpp b/plugins/pcl/filters/GroundFilter.cpp
index 90be5e7f6f..2345c2ec10 100644
--- a/plugins/pcl/filters/GroundFilter.cpp
+++ b/plugins/pcl/filters/GroundFilter.cpp
@@ -37,7 +37,6 @@
 #include "PCLConversions.hpp"
 
 #include <pdal/Options.hpp>
-#include <pdal/pdal_macros.hpp>
 #include <pdal/PointBuffer.hpp>
 #include <pdal/PointContext.hpp>
 #include <pdal/StageFactory.hpp>
@@ -48,11 +47,18 @@
 #include <pcl/io/pcd_io.h>
 #include <pcl/segmentation/progressive_morphological_filter.h>
 
-CREATE_FILTER_PLUGIN(ground, pdal::GroundFilter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.ground",
+    "Progressive morphological filter",
+    "http://pdal.io/stages/filters.ground.html" };
+
+CREATE_SHARED_PLUGIN(GroundFilter, Filter, s_info)
+
+std::string GroundFilter::getName() const { return s_info.name; }
+
 void GroundFilter::processOptions(const Options& options)
 {
     m_maxWindowSize = options.getValueOrDefault<double>("maxWindowSize", 33);
diff --git a/plugins/pcl/filters/GroundFilter.hpp b/plugins/pcl/filters/GroundFilter.hpp
index 1d81bbe3e2..fe28d8489e 100644
--- a/plugins/pcl/filters/GroundFilter.hpp
+++ b/plugins/pcl/filters/GroundFilter.hpp
@@ -52,13 +52,13 @@ typedef PointContext PointContextRef;
 class PDAL_DLL GroundFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.ground", "Progressive Morphological Filter")
-    SET_STAGE_LINK("http://www.pdal.io/stages/filters.ground.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     GroundFilter() : Filter()
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     double m_maxWindowSize;
     double m_slope;
diff --git a/plugins/pcl/filters/PCLBlock.cpp b/plugins/pcl/filters/PCLBlock.cpp
index 13f7dd5bdf..197738168d 100644
--- a/plugins/pcl/filters/PCLBlock.cpp
+++ b/plugins/pcl/filters/PCLBlock.cpp
@@ -32,21 +32,26 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
-#include "../PCLConversions.hpp"
 #include "PCLBlock.hpp"
 
+#include "PCLConversions.hpp"
+#include "PCLPipeline.h"
+
 #include <pcl/console/print.h>
 #include <pcl/point_types.h>
 #include <pcl/io/pcd_io.h>
 
-#include "../pipeline/PCLPipeline.h"
-
-CREATE_FILTER_PLUGIN(pclblock, pdal::filters::PCLBlock)
-
 namespace pdal
 {
-namespace filters
-{
+
+static PluginInfo const s_info {
+    "filters.pclblock",
+    "PCL Block implementation",
+    "http://pdal.io/stages/filters.pclblock.html" };
+
+CREATE_SHARED_PLUGIN(PCLBlock, Filter, s_info)
+
+std::string PCLBlock::getName() const { return s_info.name; }
 
 /** \brief This method processes the PointBuffer through the given pipeline. */
 
@@ -56,13 +61,6 @@ void PCLBlock::processOptions(const Options& options)
     m_json = options.getValueOrDefault<std::string>("json", "");
 }
 
-
-void PCLBlock::ready(PointContext ctx)
-{
-
-}
-
-
 PointBufferSet PCLBlock::run(PointBufferPtr input)
 {
     PointBufferPtr output = input->makeNew();
@@ -145,5 +143,5 @@ PointBufferSet PCLBlock::run(PointBufferPtr input)
     return pbSet;
 }
 
-} // filters
-} // pdal
+} // namespace pdal
+
diff --git a/plugins/pcl/filters/PCLBlock.hpp b/plugins/pcl/filters/PCLBlock.hpp
index 470e43f441..de8c335b8d 100644
--- a/plugins/pcl/filters/PCLBlock.hpp
+++ b/plugins/pcl/filters/PCLBlock.hpp
@@ -39,31 +39,27 @@
 
 namespace pdal
 {
-namespace filters
-{
 
 class PDAL_DLL PCLBlock : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.pclblock", "PCL Block implementation")
-    SET_STAGE_LINK("http://www.pdal.io/stages/filters.pclblock.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PCLBlock() : Filter()
     {}
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     std::string m_filename;
     std::string m_json;
 
     virtual void processOptions(const Options& options);
-    virtual void ready(PointContext ctx);
     virtual PointBufferSet run(PointBufferPtr buf);
 
     PCLBlock& operator=(const PCLBlock&); // not implemented
     PCLBlock(const PCLBlock&); // not implemented
 };
 
-} // namespace filters
 } // namespace pdal
 
diff --git a/plugins/pcl/io/PCLVisualizer.cpp b/plugins/pcl/io/PCLVisualizer.cpp
index bbbafe4c5e..a2b2185442 100644
--- a/plugins/pcl/io/PCLVisualizer.cpp
+++ b/plugins/pcl/io/PCLVisualizer.cpp
@@ -34,14 +34,9 @@
 
 #include "PCLVisualizer.hpp"
 
-#include <chrono>
-#include <memory>
-#include <thread>
-
 #include <pcl/conversions.h>
 #include <pcl/io/pcd_io.h>
 
-
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 
@@ -51,12 +46,15 @@
 #include <pcl/visualization/impl/point_cloud_handlers.hpp>
 #pragma GCC diagnostic pop
 
-#include "PCLConversions.hpp"
-#include "point_types.hpp"
 #include <pdal/PointBuffer.hpp>
 #include <pdal/StageFactory.hpp>
 
-CREATE_WRITER_PLUGIN(pclvisualizer, pdal::PclVisualizer)
+#include "PCLConversions.hpp"
+#include "point_types.hpp"
+
+#include <chrono>
+#include <memory>
+#include <thread>
 
 bool
 isValidFieldName(const std::string &field)
@@ -137,6 +135,14 @@ class PointCloudColorHandlerIntensity : public PointCloudColorHandler<PointT>
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.pclvisualizer",
+    "PCL Visualizer",
+    "http://pdal.io/stages/writers.pclvisualizer.html" };
+
+CREATE_SHARED_PLUGIN(PclVisualizer, Writer, s_info)
+
+std::string PclVisualizer::getName() const { return s_info.name; }
 
 void PclVisualizer::write(const PointBuffer& data)
 {
diff --git a/plugins/pcl/io/PCLVisualizer.hpp b/plugins/pcl/io/PCLVisualizer.hpp
index 43836b8e1e..82ae3ebe68 100644
--- a/plugins/pcl/io/PCLVisualizer.hpp
+++ b/plugins/pcl/io/PCLVisualizer.hpp
@@ -44,12 +44,12 @@ namespace pdal
 class PDAL_DLL PclVisualizer : public pdal::Writer
 {
 public:
-    SET_STAGE_NAME("writers.pclvisualizer", "PCD Writer")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.pclvisualizer.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PclVisualizer() : pdal::Writer() {};
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
     virtual void processOptions(const Options&) {};
     virtual void ready(PointContextRef ctx) {};
diff --git a/plugins/pcl/io/PcdReader.cpp b/plugins/pcl/io/PcdReader.cpp
index ace7600ded..c034d759be 100644
--- a/plugins/pcl/io/PcdReader.cpp
+++ b/plugins/pcl/io/PcdReader.cpp
@@ -43,11 +43,18 @@
 #include <pdal/PointBuffer.hpp>
 #include "PCLConversions.hpp"
 
-CREATE_READER_PLUGIN(pcd, pdal::PcdReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.pcd",
+    "Read data in the Point Cloud Library (PCL) format.",
+    "http://pdal.io/stages/readers.pclvisualizer.html" };
+
+CREATE_SHARED_PLUGIN(PcdReader, Reader, s_info)
+
+std::string PcdReader::getName() const { return s_info.name; }
+
 void PcdReader::ready(PointContextRef ctx)
 {
     pcl::PCLPointCloud2 cloud;
diff --git a/plugins/pcl/io/PcdReader.hpp b/plugins/pcl/io/PcdReader.hpp
index 6ccfa5a624..b7b3258506 100644
--- a/plugins/pcl/io/PcdReader.hpp
+++ b/plugins/pcl/io/PcdReader.hpp
@@ -46,12 +46,12 @@ namespace pdal
 class PDAL_DLL PcdReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.pcd", "Read data from Point Cloud Library (PCL).")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.pcd.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PcdReader() : Reader() {};
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
     static Dimension::IdList getDefaultDimensions()
     {
         return fileDimensions();
diff --git a/plugins/pcl/io/PcdWriter.cpp b/plugins/pcl/io/PcdWriter.cpp
index dfb948442b..3a5083bbd1 100644
--- a/plugins/pcl/io/PcdWriter.cpp
+++ b/plugins/pcl/io/PcdWriter.cpp
@@ -49,11 +49,17 @@
 #include <pdal/PointBuffer.hpp>
 #include <pdal/pdal_macros.hpp>
 
-CREATE_WRITER_PLUGIN(pcd, pdal::PcdWriter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.pcd",
+    "Write data in the Point Cloud Library (PCL) format.",
+    "http://pdal.io/stages/writers.pclvisualizer.html" };
+
+CREATE_SHARED_PLUGIN(PcdWriter, Writer, s_info)
+
+std::string PcdWriter::getName() const { return s_info.name; }
 
 void PcdWriter::processOptions(const Options& ops)
 {
diff --git a/plugins/pcl/io/PcdWriter.hpp b/plugins/pcl/io/PcdWriter.hpp
index 04405f6282..63fa53f3e1 100644
--- a/plugins/pcl/io/PcdWriter.hpp
+++ b/plugins/pcl/io/PcdWriter.hpp
@@ -47,13 +47,13 @@ namespace pdal
 class PDAL_DLL PcdWriter : public pdal::Writer
 {
 public:
-    SET_STAGE_NAME("writers.pcd", "Write data in Point Cloud Library (PCL) format.")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.pcd.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PcdWriter() : pdal::Writer() {};
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     virtual void processOptions(const Options&);
diff --git a/plugins/pcl/kernel/GroundKernel.cpp b/plugins/pcl/kernel/GroundKernel.cpp
index 480e8f5c56..535d24c181 100644
--- a/plugins/pcl/kernel/GroundKernel.cpp
+++ b/plugins/pcl/kernel/GroundKernel.cpp
@@ -35,6 +35,8 @@
 
 #include "GroundKernel.hpp"
 
+#include <pdal/KernelFactory.hpp>
+#include <pdal/KernelSupport.hpp>
 #include <pdal/Options.hpp>
 #include <pdal/pdal_macros.hpp>
 #include <pdal/PointBuffer.hpp>
@@ -42,18 +44,20 @@
 #include <pdal/Stage.hpp>
 #include <pdal/StageFactory.hpp>
 
-#include <pdal/KernelFactory.hpp>
-#include <pdal/KernelSupport.hpp>
-
 #include <memory>
 #include <string>
 #include <vector>
 
-CREATE_KERNEL_PLUGIN(ground, pdal::GroundKernel)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.ground",
+    "Ground Kernel",
+    "http://pdal.io/kernels/kernels.ground.html" };
+
+CREATE_SHARED_PLUGIN(GroundKernel, Kernel, s_info)
+
 GroundKernel::GroundKernel()
     : Kernel()
     , m_inputFile("")
@@ -143,7 +147,7 @@ int GroundKernel::execute()
     groundOptions.add<bool>("extract", m_extract);
 
     StageFactory f;
-    std::unique_ptr<Filter> groundStage(f.createFilter("filters.ground"));
+    std::unique_ptr<Stage> groundStage(f.createStage("filters.ground"));
     groundStage->setOptions(groundOptions);
     groundStage->setInput(readerStage.get());
 
@@ -152,7 +156,7 @@ int GroundKernel::execute()
     writerOptions.add<std::string>("filename", m_outputFile);
     setCommonOptions(writerOptions);
 
-    WriterPtr writer(KernelSupport::makeWriter(m_outputFile, groundStage.get()));
+    std::unique_ptr<Stage> writer(KernelSupport::makeWriter(m_outputFile, groundStage.get()));
     writer->setOptions(writerOptions);
 
     std::vector<std::string> cmd = getProgressShellCommand();
diff --git a/plugins/pcl/kernel/GroundKernel.hpp b/plugins/pcl/kernel/GroundKernel.hpp
index 35417716a0..0ddf30338e 100644
--- a/plugins/pcl/kernel/GroundKernel.hpp
+++ b/plugins/pcl/kernel/GroundKernel.hpp
@@ -35,10 +35,9 @@
 
 #pragma once
 
-#include <pdal/util/FileUtils.hpp>
-#include <pdal/pdal_export.hpp>
-
 #include <pdal/Kernel.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/util/FileUtils.hpp>
 
 #include <memory>
 #include <string>
@@ -52,13 +51,12 @@ class Stage;
 class PDAL_DLL GroundKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME("ground", "Ground Kernel")
-    SET_KERNEL_LINK("http://pdal.io/kernels/kernels.ground.html")
-
-    GroundKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    GroundKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/plugins/pcl/kernel/PCLKernel.cpp b/plugins/pcl/kernel/PCLKernel.cpp
index 0b9271d617..817c1d300f 100644
--- a/plugins/pcl/kernel/PCLKernel.cpp
+++ b/plugins/pcl/kernel/PCLKernel.cpp
@@ -33,16 +33,22 @@
  ****************************************************************************/
 
 #include "PCLKernel.hpp"
-#include "../filters/PCLBlock.hpp"
-#include <pdal/KernelFactory.hpp>
 
-#include <pdal/BufferReader.hpp>
+#include "PCLBlock.hpp"
 
-CREATE_KERNEL_PLUGIN(pcl, pdal::PCLKernel)
+#include <pdal/BufferReader.hpp>
+#include <pdal/KernelFactory.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.pcl",
+    "PCL Kernel",
+    "http://pdal.io/kernels/kernels.pcl.html" };
+
+CREATE_SHARED_PLUGIN(PCLKernel, Kernel, s_info)
+
 PCLKernel::PCLKernel()
     : Kernel()
     , m_bCompress(false)
@@ -137,7 +143,7 @@ int PCLKernel::execute()
     pclOptions.add<bool>("debug", isDebug());
     pclOptions.add<uint32_t>("verbose", getVerboseLevel());
 
-    std::unique_ptr<Stage> pclStage(new filters::PCLBlock());
+    std::unique_ptr<Stage> pclStage(new PCLBlock());
     pclStage->setInput(&bufferReader);
     pclStage->setOptions(pclOptions);
 
@@ -158,7 +164,7 @@ int PCLKernel::execute()
         cmd.size() ? (UserCallback *)new ShellScriptCallback(cmd) :
         (UserCallback *)new HeartbeatCallback();
 
-    WriterPtr
+    std::unique_ptr<Stage>
         writer(KernelSupport::makeWriter(m_outputFile, pclStage.get()));
 
     // Some options are inferred by makeWriter based on filename
diff --git a/plugins/pcl/kernel/PCLKernel.hpp b/plugins/pcl/kernel/PCLKernel.hpp
index 4603c402e0..4b3d02223d 100644
--- a/plugins/pcl/kernel/PCLKernel.hpp
+++ b/plugins/pcl/kernel/PCLKernel.hpp
@@ -42,13 +42,12 @@ namespace pdal
 class PDAL_DLL PCLKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME("pcl", "PCL Kernel")
-    SET_KERNEL_LINK("http://pdal.io/kernels/kernels.pcl.html")
-
-    PCLKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    PCLKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/plugins/pcl/kernel/SmoothKernel.cpp b/plugins/pcl/kernel/SmoothKernel.cpp
index e41ba37450..62d8a1d474 100644
--- a/plugins/pcl/kernel/SmoothKernel.cpp
+++ b/plugins/pcl/kernel/SmoothKernel.cpp
@@ -34,16 +34,21 @@
 ****************************************************************************/
 
 #include "SmoothKernel.hpp"
-#include "../filters/PCLBlock.hpp"
-#include <pdal/KernelFactory.hpp>
 
-#include <pdal/BufferReader.hpp>
+#include "PCLBlock.hpp"
 
-CREATE_KERNEL_PLUGIN(smooth, pdal::SmoothKernel)
+#include <pdal/BufferReader.hpp>
+#include <pdal/KernelFactory.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.smooth",
+    "Smooth Kernel",
+    "http://pdal.io/kernels/kernels.smooth.html" };
+
+CREATE_SHARED_PLUGIN(SmoothKernel, Kernel, s_info)
 
 void SmoothKernel::validateSwitches()
 {
@@ -136,7 +141,7 @@ int SmoothKernel::execute()
     smoothOptions.add("debug", isDebug());
     smoothOptions.add("verbose", getVerboseLevel());
 
-    std::unique_ptr<Stage> smoothStage(new filters::PCLBlock());
+    std::unique_ptr<Stage> smoothStage(new PCLBlock());
     smoothStage->setOptions(smoothOptions);
     smoothStage->setInput(&bufferReader);
 
@@ -144,7 +149,7 @@ int SmoothKernel::execute()
     writerOptions.add("filename", m_outputFile);
     setCommonOptions(writerOptions);
 
-    WriterPtr writer(KernelSupport::makeWriter(m_outputFile, smoothStage.get()));
+    std::unique_ptr<Stage> writer(KernelSupport::makeWriter(m_outputFile, smoothStage.get()));
     writer->setOptions(writerOptions);
 
     std::vector<std::string> cmd = getProgressShellCommand();
diff --git a/plugins/pcl/kernel/SmoothKernel.hpp b/plugins/pcl/kernel/SmoothKernel.hpp
index 241c524c21..7804b57661 100644
--- a/plugins/pcl/kernel/SmoothKernel.hpp
+++ b/plugins/pcl/kernel/SmoothKernel.hpp
@@ -35,9 +35,9 @@
 
 #pragma once
 
-#include <pdal/util/FileUtils.hpp>
-
 #include <pdal/Kernel.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/util/FileUtils.hpp>
 
 namespace pdal
 {
@@ -45,13 +45,12 @@ namespace pdal
 class PDAL_DLL SmoothKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME("smooth", "Smooth Kernel")
-    SET_KERNEL_LINK("http://pdal.io/kernels/kernels.smooth.html")
-
-    SmoothKernel() {};
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    SmoothKernel() {};
     void addSwitches();
     void validateSwitches();
 
diff --git a/plugins/pcl/kernel/ViewKernel.cpp b/plugins/pcl/kernel/ViewKernel.cpp
index 3eb51074ab..8fa25362e0 100644
--- a/plugins/pcl/kernel/ViewKernel.cpp
+++ b/plugins/pcl/kernel/ViewKernel.cpp
@@ -33,13 +33,19 @@
 ****************************************************************************/
 
 #include "ViewKernel.hpp"
-#include <pdal/KernelFactory.hpp>
 
-CREATE_KERNEL_PLUGIN(view, pdal::ViewKernel)
+#include <pdal/KernelFactory.hpp>
 
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "kernels.view",
+    "View Kernel",
+    "http://pdal.io/kernels/kernels.view.html" };
+
+CREATE_SHARED_PLUGIN(ViewKernel, Kernel, s_info)
+
 // Support for parsing point numbers.  Points can be specified singly or as
 // dash-separated ranges.  i.e. 6-7,8,19-20
 namespace {
diff --git a/plugins/pcl/kernel/ViewKernel.hpp b/plugins/pcl/kernel/ViewKernel.hpp
index e69eb8ed99..0bece45363 100644
--- a/plugins/pcl/kernel/ViewKernel.hpp
+++ b/plugins/pcl/kernel/ViewKernel.hpp
@@ -35,9 +35,9 @@
 
 #pragma once
 
-#include <pdal/util/FileUtils.hpp>
-
 #include <pdal/Kernel.hpp>
+#include <pdal/pdal_export.hpp>
+#include <pdal/util/FileUtils.hpp>
 
 namespace pdal
 {
@@ -45,13 +45,12 @@ namespace pdal
 class PDAL_DLL ViewKernel : public Kernel
 {
 public:
-    SET_KERNEL_NAME("view", "View Kernel")
-    SET_KERNEL_LINK("http://pdal.io/kernels/kernels.view.html")
-
-    ViewKernel();
+    static void * create();
+    static int32_t destroy(void *);
     int execute();
 
 private:
+    ViewKernel();
     void addSwitches();
     void validateSwitches();
 
diff --git a/plugins/pcl/test/PCLBlockFilterTest.cpp b/plugins/pcl/test/PCLBlockFilterTest.cpp
index 235596969b..8a29d0d9a2 100644
--- a/plugins/pcl/test/PCLBlockFilterTest.cpp
+++ b/plugins/pcl/test/PCLBlockFilterTest.cpp
@@ -36,6 +36,7 @@
 
 #include <pdal/PipelineManager.hpp>
 #include <pdal/PipelineReader.hpp>
+#include <pdal/PluginManager.hpp>
 #include <pdal/StageFactory.hpp>
 
 #include "Support.hpp"
@@ -47,7 +48,18 @@ using namespace pdal;
 TEST(PCLBlockFilterTest, PCLBlockFilterTest_example_passthrough_xml)
 {
     StageFactory f;
-    FilterPtr filter(f.createFilter("filters.pclblock"));
+    //std::vector<std::string> nv = f.getStageNames();
+    //std::cerr << nv.size() << std::endl;
+    //for (auto name : nv)
+    //    std::cout << name << std::endl;
+    std::unique_ptr<Stage> filter(f.createStage("filters.pclblock"));
+
+    //std::unique_ptr<Stage> filter(f.createStage("filters.pclblock"));
+    //PluginManager & pm = PluginManager::getInstance();
+
+    //void * stage = pm.createObject("filters.pclblock");
+    //EXPECT_TRUE(stage);
+    //Filter * filter = (Filter*)stage;
     EXPECT_TRUE(filter.get());
 
     PipelineManager pipeline;
@@ -83,7 +95,7 @@ static void test_filter(const std::string& jsonFile,
     options.add(debug);
     options.add(verbose);
 
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(options);
 
@@ -91,7 +103,7 @@ static void test_filter(const std::string& jsonFile,
     Options filter_options;
     filter_options.add(fname);
 
-    FilterPtr pcl_block(f.createFilter("filters.pclblock"));
+    std::unique_ptr<Stage> pcl_block(f.createStage("filters.pclblock"));
     EXPECT_TRUE(pcl_block.get());
     pcl_block->setOptions(filter_options);
     pcl_block->setInput(reader.get());
diff --git a/plugins/pgpointcloud/io/PgReader.cpp b/plugins/pgpointcloud/io/PgReader.cpp
index a3b893142b..ec4c8738cb 100644
--- a/plugins/pgpointcloud/io/PgReader.cpp
+++ b/plugins/pgpointcloud/io/PgReader.cpp
@@ -39,11 +39,19 @@
 
 #include <iostream>
 
-CREATE_READER_PLUGIN(pgpointcloud, pdal::PgReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.pgpointcloud",
+    "Read data from pgpointcloud format. \"query\" option needs to be a \n" \
+        "SQL statment selecting the data.",
+    "http://pdal.io/stages/readers.pgpointcloud.html" };
+
+CREATE_SHARED_PLUGIN(PgReader, Reader, s_info)
+
+std::string PgReader::getName() const { return s_info.name; }
+
 PgReader::PgReader() : m_session(NULL), m_pcid(0), m_cached_point_count(0),
     m_cached_max_points(0)
 {}
diff --git a/plugins/pgpointcloud/io/PgReader.hpp b/plugins/pgpointcloud/io/PgReader.hpp
index a30f4c34ab..84048875dc 100644
--- a/plugins/pgpointcloud/io/PgReader.hpp
+++ b/plugins/pgpointcloud/io/PgReader.hpp
@@ -82,15 +82,14 @@ class PDAL_DLL PgReader : public DbReader
     };
 
 public:
-    SET_STAGE_NAME("readers.pgpointcloud",
-        "Read data from pgpointcloud format. \"query\" option needs to be a SQL statment selecting the data.")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.pgpointcloud.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PgReader();
     ~PgReader();
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     virtual point_count_t getNumPoints() const;
     point_count_t getMaxPoints() const;
     std::string getDataQuery() const;
diff --git a/plugins/pgpointcloud/io/PgWriter.cpp b/plugins/pgpointcloud/io/PgWriter.cpp
index 91a6f7a40a..fff9b4a164 100644
--- a/plugins/pgpointcloud/io/PgWriter.cpp
+++ b/plugins/pgpointcloud/io/PgWriter.cpp
@@ -43,7 +43,17 @@
 #include <pdal/util/Endian.hpp>
 #include <pdal/XMLSchema.hpp>
 
-CREATE_WRITER_PLUGIN(pgpointcloud, pdal::PgWriter)
+namespace pdal
+{
+
+static PluginInfo const s_info {
+    "writers.pgpointcloud",
+    "Write points to PostgreSQL pgpointcloud output",
+    "http://pdal.io/stages/writers.pgpointcloud.html" };
+
+CREATE_SHARED_PLUGIN(PgWriter, Writer, s_info)
+
+std::string PgWriter::getName() const { return s_info.name; }
 
 // TO DO:
 // - change INSERT into COPY
@@ -57,10 +67,6 @@ CREATE_WRITER_PLUGIN(pgpointcloud, pdal::PgWriter)
 // table information about each load? If so, how to distinguish
 // between loads? Leave to pre/post SQL?
 
-
-namespace pdal
-{
-
 PgWriter::PgWriter()
     : m_session(0)
     , m_patch_compression_type(CompressionType::None)
diff --git a/plugins/pgpointcloud/io/PgWriter.hpp b/plugins/pgpointcloud/io/PgWriter.hpp
index af512fd5cc..bcd0423679 100644
--- a/plugins/pgpointcloud/io/PgWriter.hpp
+++ b/plugins/pgpointcloud/io/PgWriter.hpp
@@ -45,15 +45,14 @@ namespace pdal
 class PDAL_DLL PgWriter : public DbWriter
 {
 public:
-    SET_STAGE_NAME("writers.pgpointcloud",
-        "Write points to PostgreSQL pgpointcloud output")
-    SET_STAGE_LINK("http://pdal.io/stages/writers.pgpointcloud.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PgWriter();
     ~PgWriter();
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     PgWriter& operator=(const PgWriter&); // not implemented
diff --git a/plugins/pgpointcloud/test/PgpointcloudWriterTest.cpp b/plugins/pgpointcloud/test/PgpointcloudWriterTest.cpp
index ea5389a46d..f5f3a344d6 100644
--- a/plugins/pgpointcloud/test/PgpointcloudWriterTest.cpp
+++ b/plugins/pgpointcloud/test/PgpointcloudWriterTest.cpp
@@ -162,8 +162,8 @@ namespace
 void optionsWrite(const Options& writerOps)
 {
     StageFactory f;
-    WriterPtr writer(f.createWriter("writers.pgpointcloud"));
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> writer(f.createStage("writers.pgpointcloud"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
 
     EXPECT_TRUE(writer.get());
     EXPECT_TRUE(reader.get());
@@ -214,7 +214,7 @@ TEST_F(PgpointcloudWriterTest, writeXYZ)
     optionsWrite(ops);
 
     PointContext ctx;
-    ReaderPtr reader(StageFactory().createReader("readers.pgpointcloud"));
+    std::unique_ptr<Stage> reader(StageFactory().createStage("readers.pgpointcloud"));
     reader->setOptions(getDbOptions());
 
     reader->prepare(ctx);
@@ -228,7 +228,7 @@ TEST_F(PgpointcloudWriterTest, writeXYZ)
 TEST_F(PgpointcloudWriterTest, writetNoPointcloudExtension)
 {
     StageFactory f;
-    WriterPtr writer(f.createWriter("writers.pgpointcloud"));
+    std::unique_ptr<Stage> writer(f.createStage("writers.pgpointcloud"));
     EXPECT_TRUE(writer.get());
 
     executeOnTestDb("DROP EXTENSION pointcloud");
@@ -237,7 +237,7 @@ TEST_F(PgpointcloudWriterTest, writetNoPointcloudExtension)
 
     const Option opt_filename("filename", file);
 
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     Options options;
     options.add(opt_filename);
diff --git a/plugins/python/filters/PredicateFilter.cpp b/plugins/python/filters/PredicateFilter.cpp
index bc4c15d876..f597f868e8 100644
--- a/plugins/python/filters/PredicateFilter.cpp
+++ b/plugins/python/filters/PredicateFilter.cpp
@@ -38,11 +38,18 @@
 #include <pdal/PointBuffer.hpp>
 #include <pdal/StageFactory.hpp>
 
-CREATE_FILTER_PLUGIN(predicate, pdal::PredicateFilter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.predicate",
+    "Filter data using inline Python expressions.",
+    "http://pdal.io/stages/filters.predicate.html" };
+
+CREATE_SHARED_PLUGIN(PredicateFilter, Filter, s_info)
+
+std::string PredicateFilter::getName() const { return s_info.name; }
+
 void PredicateFilter::processOptions(const Options& options)
 {
     m_source = options.getValueOrDefault<std::string>("source", "");
diff --git a/plugins/python/filters/PredicateFilter.hpp b/plugins/python/filters/PredicateFilter.hpp
index f418db7329..49fa666b24 100644
--- a/plugins/python/filters/PredicateFilter.hpp
+++ b/plugins/python/filters/PredicateFilter.hpp
@@ -44,14 +44,14 @@ namespace pdal
 class PDAL_DLL PredicateFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.predicate", "Filter data using inline Python expressions.")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.predicate.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     PredicateFilter() : Filter(), m_script(NULL)
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     plang::BufferedInvocation* m_pythonMethod;
diff --git a/plugins/python/filters/ProgrammableFilter.cpp b/plugins/python/filters/ProgrammableFilter.cpp
index 2234a55014..ac636405f0 100644
--- a/plugins/python/filters/ProgrammableFilter.cpp
+++ b/plugins/python/filters/ProgrammableFilter.cpp
@@ -38,11 +38,18 @@
 #include <pdal/PointBuffer.hpp>
 #include <pdal/StageFactory.hpp>
 
-CREATE_FILTER_PLUGIN(programmable, pdal::ProgrammableFilter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "filters.programmable",
+    "Manipulate data using inline Python",
+    "http://pdal.io/stages/filters.programmable.html" };
+
+CREATE_SHARED_PLUGIN(ProgrammableFilter, Filter, s_info)
+
+std::string ProgrammableFilter::getName() const { return s_info.name; }
+
 Options ProgrammableFilter::getDefaultOptions()
 {
     Options options;
diff --git a/plugins/python/filters/ProgrammableFilter.hpp b/plugins/python/filters/ProgrammableFilter.hpp
index a9bbb1403f..74fd3c37d2 100644
--- a/plugins/python/filters/ProgrammableFilter.hpp
+++ b/plugins/python/filters/ProgrammableFilter.hpp
@@ -46,14 +46,14 @@ class ProgrammableFilterSequentialIterator;
 class PDAL_DLL ProgrammableFilter : public Filter
 {
 public:
-    SET_STAGE_NAME("filters.programmable", "Manipulate data using inline Python")
-    SET_STAGE_LINK("http://pdal.io/stages/filters.programmable.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     ProgrammableFilter() : Filter(), m_script(NULL)
         {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
 
 private:
     plang::Script* m_script;
diff --git a/plugins/python/test/PredicateFilterTest.cpp b/plugins/python/test/PredicateFilterTest.cpp
index a7c3db88c3..b568365789 100644
--- a/plugins/python/test/PredicateFilterTest.cpp
+++ b/plugins/python/test/PredicateFilterTest.cpp
@@ -54,7 +54,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test1)
     readerOps.add("num_points", 1000);
     readerOps.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(readerOps);
 
     // keep all points where x less than 1.0
@@ -76,7 +76,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test1)
     opts.add(module);
     opts.add(function);
 
-    FilterPtr filter(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.predicate"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
@@ -114,7 +114,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test2)
     readerOps.add("num_points", 1000);
     readerOps.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(readerOps);
 
     Option source("source",
@@ -134,7 +134,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test2)
     opts.add(module);
     opts.add(function);
 
-    FilterPtr filter(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.predicate"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
@@ -172,7 +172,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test3)
     readerOpts.add("num_points", 1000);
     readerOpts.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(readerOpts);
 
     // keep all points where x less than 1.0
@@ -194,7 +194,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test3)
     opts1.add(module1);
     opts1.add(function1);
 
-    FilterPtr filter1(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter1(f.createStage("filters.predicate"));
     filter1->setOptions(opts1);
     filter1->setInput(reader.get());
 
@@ -217,7 +217,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test3)
     opts2.add(module2);
     opts2.add(function2);
 
-    FilterPtr filter2(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter2(f.createStage("filters.predicate"));
     filter2->setOptions(opts2);
     filter2->setInput(filter1.get());
 
@@ -253,7 +253,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test4)
     readerOpts.add("num_points", 1000);
     readerOpts.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(readerOpts);
 
     const Option source("source",
@@ -273,7 +273,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test4)
     opts.add(module);
     opts.add(function);
 
-    FilterPtr filter(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.predicate"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
@@ -308,7 +308,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test5)
     readerOpts.add("num_points", 1000);
     readerOpts.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(readerOpts);
 
     const Option source("source",
@@ -328,7 +328,7 @@ TEST(PredicateFilterTest, PredicateFilterTest_test5)
     opts.add(module);
     opts.add(function);
 
-    FilterPtr filter(f.createFilter("filters.predicate"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.predicate"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
diff --git a/plugins/python/test/ProgrammableFilterTest.cpp b/plugins/python/test/ProgrammableFilterTest.cpp
index 89f3684b66..07f6985a7e 100644
--- a/plugins/python/test/ProgrammableFilterTest.cpp
+++ b/plugins/python/test/ProgrammableFilterTest.cpp
@@ -54,7 +54,7 @@ TEST(ProgrammableFilterTest, ProgrammableFilterTest_test1)
     ops.add("num_points", 10);
     ops.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Option source("source", "import numpy as np\n"
@@ -79,7 +79,7 @@ TEST(ProgrammableFilterTest, ProgrammableFilterTest_test1)
     opts.add(module);
     opts.add(function);
 
-    FilterPtr filter(f.createFilter("filters.programmable"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.programmable"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
@@ -137,7 +137,7 @@ TEST(ProgrammableFilterTest, add_dimension)
     ops.add("num_points", 10);
     ops.add("mode", "ramp");
 
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Option source("source", "import numpy\n"
@@ -157,7 +157,7 @@ TEST(ProgrammableFilterTest, add_dimension)
     opts.add(intensity);
     opts.add(scanDirection);
 
-    FilterPtr filter(f.createFilter("filters.programmable"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.programmable"));
     filter->setOptions(opts);
     filter->setInput(reader.get());
 
diff --git a/plugins/rxp/io/RxpReader.cpp b/plugins/rxp/io/RxpReader.cpp
index b0c5c5839f..bcb9ab6a09 100644
--- a/plugins/rxp/io/RxpReader.cpp
+++ b/plugins/rxp/io/RxpReader.cpp
@@ -42,13 +42,17 @@
 
 #include <pdal/StageFactory.hpp>
 
-
-CREATE_READER_PLUGIN(rxp, pdal::RxpReader)
-
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.rxp",
+    "RXP Reader",
+    "http://pdal.io/stages/readers.rxp.html" };
+
+CREATE_SHARED_PLUGIN(RxpReader, Reader, s_info)
+
+std::string RxpReader::getName() const { return s_info.name; }
 
 std::string extractRivlibURI(const Options& options)
 {
diff --git a/plugins/rxp/io/RxpReader.hpp b/plugins/rxp/io/RxpReader.hpp
index 541ce5144b..628836d988 100644
--- a/plugins/rxp/io/RxpReader.hpp
+++ b/plugins/rxp/io/RxpReader.hpp
@@ -141,10 +141,6 @@ class PDAL_DLL RxpInclFixPointcloud : public RxpPointcloud
 class PDAL_DLL RxpReader : public pdal::Reader
 {
 public:
-    SET_STAGE_NAME("readers.rxp", "RXP Reader")
-    SET_STAGE_LINK("http://pdal.io/stages/readers.rxp.html")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     RxpReader()
         : pdal::Reader()
         , m_uri("")
@@ -154,7 +150,11 @@ class PDAL_DLL RxpReader : public pdal::Reader
         , m_pointcloud(NULL)
     {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     static Dimension::IdList getDefaultDimensions()
     {
         return getRxpDimensions(DEFAULT_SYNC_TO_PPS, DEFAULT_MINIMAL);
diff --git a/plugins/sqlite/io/SQLiteReader.cpp b/plugins/sqlite/io/SQLiteReader.cpp
index fce03b8745..6fc8a5c33d 100644
--- a/plugins/sqlite/io/SQLiteReader.cpp
+++ b/plugins/sqlite/io/SQLiteReader.cpp
@@ -35,11 +35,18 @@
 #include "SQLiteReader.hpp"
 #include <pdal/PointBuffer.hpp>
 
-CREATE_READER_PLUGIN(sqlite, pdal::SQLiteReader)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "readers.sqlite",
+    "Read data from SQLite3 database files.",
+    ""};
+
+CREATE_SHARED_PLUGIN(SQLiteReader, Reader, s_info)
+
+std::string SQLiteReader::getName() const { return s_info.name; }
+
 void SQLiteReader::initialize()
 {
     try
diff --git a/plugins/sqlite/io/SQLiteReader.hpp b/plugins/sqlite/io/SQLiteReader.hpp
index c68a21cedc..b66f7f9d4b 100644
--- a/plugins/sqlite/io/SQLiteReader.hpp
+++ b/plugins/sqlite/io/SQLiteReader.hpp
@@ -48,13 +48,14 @@ namespace pdal
 class PDAL_DLL SQLiteReader : public DbReader
 {
 public:
-    SET_STAGE_NAME("readers.sqlite", "Read data from SQLite3 database files.")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     SQLiteReader()
     {}
 
-    static Options getDefaultOptions();
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
+    Options getDefaultOptions();
     SpatialReference fetchSpatialReference(std::string const& query) const;
     SQLite& getSession()
         { return *m_session.get(); }
diff --git a/plugins/sqlite/io/SQLiteWriter.cpp b/plugins/sqlite/io/SQLiteWriter.cpp
index d79a580079..15445002ab 100644
--- a/plugins/sqlite/io/SQLiteWriter.cpp
+++ b/plugins/sqlite/io/SQLiteWriter.cpp
@@ -46,11 +46,18 @@
 #include <gdal.h>
 #include <ogr_api.h>
 
-CREATE_WRITER_PLUGIN(sqlite, pdal::SQLiteWriter)
-
 namespace pdal
 {
 
+static PluginInfo const s_info {
+    "writers.sqlite",
+    "Write data to SQLite3 database files.",
+    "" };
+
+CREATE_SHARED_PLUGIN(SQLiteWriter, Writer, s_info)
+
+std::string SQLiteWriter::getName() const { return s_info.name; }
+
 SQLiteWriter::SQLiteWriter() : 
     m_doCreateIndex(false)
     , m_sdo_pc_is_initialized(false)
diff --git a/plugins/sqlite/io/SQLiteWriter.hpp b/plugins/sqlite/io/SQLiteWriter.hpp
index bc593a35d6..4b9db51cf8 100644
--- a/plugins/sqlite/io/SQLiteWriter.hpp
+++ b/plugins/sqlite/io/SQLiteWriter.hpp
@@ -45,11 +45,12 @@ namespace pdal
 class PDAL_DLL SQLiteWriter : public DbWriter
 {
 public:
-    SET_STAGE_NAME("writers.sqlite", "Write data to SQLite3 database files.")
-    SET_PLUGIN_VERSION("1.0.0b1")
-
     SQLiteWriter();
 
+    static void * create();
+    static int32_t destroy(void *);
+    std::string getName() const;
+
 private:
 
     SQLiteWriter& operator=(const SQLiteWriter&); // not implemented
diff --git a/plugins/sqlite/test/SQLiteTest.cpp b/plugins/sqlite/test/SQLiteTest.cpp
index c8793d1e22..8a5e858d39 100644
--- a/plugins/sqlite/test/SQLiteTest.cpp
+++ b/plugins/sqlite/test/SQLiteTest.cpp
@@ -109,10 +109,10 @@ void testReadWrite(bool compression, bool scaling)
     lasReadOpts.add("filename", Support::datapath("las/1.2-with-color.las"));
     lasReadOpts.add("count", 11);
 
-    ReaderPtr lasReader(lasRc());
+    std::unique_ptr<Stage> lasReader(lasRc());
     lasReader->setOptions(lasReadOpts);
 
-    WriterPtr sqliteWriter(sqliteWc());
+    std::unique_ptr<Stage> sqliteWriter(sqliteWc());
     sqliteWriter->setOptions(sqliteOptions);
     sqliteWriter->setInput(lasReader.get());
 
@@ -121,7 +121,7 @@ void testReadWrite(bool compression, bool scaling)
     sqliteWriter->execute(ctx);
 
     // Done - now read back.
-    ReaderPtr sqliteReader(sqliteRc());
+    std::unique_ptr<Stage> sqliteReader(sqliteRc());
     sqliteReader->setOptions(sqliteOptions);
 
     PointContext ctx2;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2fc1f188ac..a74823b45f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -42,16 +42,13 @@ set(PDAL_BASE_HPP
   "${PDAL_HEADERS_DIR}/Charbuf.hpp"
   "${PDAL_HEADERS_DIR}/Compression.hpp"
   "${PDAL_HEADERS_DIR}/Dimension.hpp"
-  "${PDAL_HEADERS_DIR}/Drivers.hpp"
   "${PDAL_HEADERS_DIR}/Filter.hpp"
-  "${PDAL_HEADERS_DIR}/Filters.hpp"
   "${PDAL_HEADERS_DIR}/GDALUtils.hpp"
   "${PDAL_HEADERS_DIR}/GlobalEnvironment.hpp"
   "${PDAL_HEADERS_DIR}/gitsha.h"
   "${PDAL_HEADERS_DIR}/IStream.hpp"
   "${PDAL_HEADERS_DIR}/KDIndex.hpp"
   "${PDAL_HEADERS_DIR}/KernelFactory.hpp"
-  "${PDAL_HEADERS_DIR}/KernelInfo.hpp"
   "${PDAL_HEADERS_DIR}/Kernel.hpp"
   "${PDAL_HEADERS_DIR}/KernelSupport.hpp"
   "${PDAL_HEADERS_DIR}/Log.hpp"
@@ -70,19 +67,18 @@ set(PDAL_BASE_HPP
   "${PDAL_HEADERS_DIR}/SpatialReference.hpp"
   "${PDAL_HEADERS_DIR}/Stage.hpp"
   "${PDAL_HEADERS_DIR}/StageFactory.hpp"
-  "${PDAL_HEADERS_DIR}/StageInfo.hpp"
   "${PDAL_HEADERS_DIR}/StageRunner.hpp"
   "${PDAL_HEADERS_DIR}/StreamFactory.hpp"
   "${PDAL_HEADERS_DIR}/UserCallback.hpp"
   "${PDAL_HEADERS_DIR}/Utils.hpp"
   "${PDAL_HEADERS_DIR}/Writer.hpp"
-  "${PDAL_HEADERS_DIR}/Kernels.hpp"
     ${PDAL_XML_HEADER}
     ${DB_DRIVER_HEADERS}
 )
 
 set(PDAL_BASE_CPP
   Charbuf.cpp
+  DynamicLibrary.cpp
   Filter.cpp
   gitsha.cpp
   GDALUtils.cpp
@@ -90,7 +86,6 @@ set(PDAL_BASE_CPP
   KDIndex.cpp
   Kernel.cpp
   KernelFactory.cpp
-  KernelInfo.cpp
   KernelSupport.cpp
   Log.cpp
   Options.cpp
@@ -98,13 +93,13 @@ set(PDAL_BASE_CPP
   PipelineManager.cpp
   PipelineReader.cpp
   PipelineWriter.cpp
+  PluginManager.cpp
   PointBuffer.cpp
   QuadIndex.cpp
   Reader.cpp
   SpatialReference.cpp
   Stage.cpp
   StageFactory.cpp
-  StageInfo.cpp
   StreamFactory.cpp
   Utils.cpp
   Writer.cpp
diff --git a/src/DynamicLibrary.cpp b/src/DynamicLibrary.cpp
new file mode 100755
index 0000000000..4f737f7626
--- /dev/null
+++ b/src/DynamicLibrary.cpp
@@ -0,0 +1,83 @@
+#ifdef WIN32
+  #include <Windows.h>
+#else
+  #include <dlfcn.h>
+#endif
+
+#include "DynamicLibrary.h"
+#include <sstream>
+#include <iostream>
+
+namespace pdal
+{
+
+DynamicLibrary::DynamicLibrary(void * handle) : handle_(handle)
+{
+}
+
+DynamicLibrary::~DynamicLibrary()
+{
+  if (handle_)
+  {
+  #ifndef WIN32
+    ::dlclose(handle_);
+  #else
+    ::FreeLibrary((HMODULE)handle_);
+  #endif
+  }
+}
+
+DynamicLibrary * DynamicLibrary::load(const std::string & name, 
+                                      std::string & errorString)
+{
+  if (name.empty()) 
+  {
+    errorString = "Empty path.";
+    return NULL;
+  }
+  
+  void * handle = NULL;
+
+  #ifdef WIN32
+    handle = ::LoadLibraryA(name.c_str());
+    if (handle == NULL)
+    {
+      DWORD errorCode = ::GetLastError();
+      std::stringstream ss;
+      ss << std::string("LoadLibrary(") << name 
+         << std::string(") Failed. errorCode: ") 
+         << errorCode; 
+      errorString = ss.str();
+    }
+  #else
+    handle = ::dlopen(name.c_str(), RTLD_NOW);
+    if (!handle) 
+    {
+      std::string dlErrorString;
+      const char *zErrorString = ::dlerror();
+      if (zErrorString)
+        dlErrorString = zErrorString;
+      errorString += "Failed to load \"" + name + '"';
+      if(dlErrorString.size())
+        errorString += ": " + dlErrorString;
+      return NULL;
+    }
+
+  #endif
+  return new DynamicLibrary(handle);
+}
+
+void * DynamicLibrary::getSymbol(const std::string & symbol)
+{
+  if (!handle_)
+    return NULL;
+  
+  #ifdef WIN32
+    return ::GetProcAddress((HMODULE)handle_, symbol.c_str());
+  #else
+    return ::dlsym(handle_, symbol.c_str());
+  #endif
+}
+
+} // namespace pdal
+
diff --git a/src/DynamicLibrary.h b/src/DynamicLibrary.h
new file mode 100755
index 0000000000..0a4455b5ed
--- /dev/null
+++ b/src/DynamicLibrary.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+
+namespace pdal
+{
+
+class DynamicLibrary
+{
+public:
+
+  static DynamicLibrary * load(const std::string & path, 
+                               std::string &errorString);
+  ~DynamicLibrary();
+  
+  void * getSymbol(const std::string & name);
+
+private:
+  DynamicLibrary();
+  
+  DynamicLibrary(void * handle);
+  DynamicLibrary(const DynamicLibrary &);
+  
+private:
+  void * handle_;  
+};
+
+} // namespace pdal
+
diff --git a/src/Kernel.cpp b/src/Kernel.cpp
index b239f6dd5f..83863790e0 100644
--- a/src/Kernel.cpp
+++ b/src/Kernel.cpp
@@ -56,6 +56,16 @@ namespace po = boost::program_options;
 namespace pdal
 {
 
+namespace
+{
+
+static void printError(const std::string& err)
+{
+    std::cout << err << std::endl;
+    std::cout << std::endl;
+}
+
+}
 
 Kernel::Kernel()
     : m_usestdin(false)
@@ -74,7 +84,7 @@ Kernel::Kernel()
 
 std::ostream& operator<<(std::ostream& ostr, const Kernel& kernel)
 {
-    ostr << "  Name: " << kernel.getName() << std::endl;
+    //ostr << "  Name: " << kernel.getName() << std::endl;
 
     return ostr;
 }
@@ -241,8 +251,8 @@ void Kernel::collectExtraOptions()
         // boost::erase_all(o, " "); // Wipe off spaces
         tokenizer option_tokens(o, equal);
         std::vector<std::string> option_split;
-        for (auto ti = option_tokens.begin(); ti != option_tokens.end(); ++ti)
-            option_split.push_back(boost::lexical_cast<std::string>(*ti));
+        for (auto const& ti : option_tokens)
+            option_split.push_back(boost::lexical_cast<std::string>(ti));
         if (!(option_split.size() == 2))
         {
             std::ostringstream oss;
@@ -256,10 +266,8 @@ void Kernel::collectExtraOptions()
 
         tokenizer name_tokens(stage_value, dot);
         std::vector<std::string> stage_values;
-        for (auto ti = name_tokens.begin(); ti != name_tokens.end(); ++ti)
-        {
-            stage_values.push_back(*ti);
-        }
+        for (auto const& ti : name_tokens)
+            stage_values.push_back(ti);
 
         std::string option_name = *stage_values.rbegin();
         std::ostringstream stage_name_ostr;
@@ -303,8 +311,8 @@ int Kernel::innerRun()
 
     if (!m_showOptions.empty())
     {
-        pdal::StageFactory factory;
-        std::cout << factory.toRST(m_showOptions) << std::endl;
+        //pdal::StageFactory factory;
+        //std::cout << factory.toRST(m_showOptions) << std::endl;
         return 0;
     }
     try
@@ -325,13 +333,6 @@ int Kernel::innerRun()
 }
 
 
-void Kernel::printError(const std::string& err) const
-{
-    std::cout << err << std::endl;
-    std::cout << std::endl;
-}
-
-
 bool Kernel::isDebug() const
 {
     return m_isDebug;
@@ -356,7 +357,7 @@ void Kernel::visualize(PointBufferPtr buffer) const
     bufferReader.addBuffer(buffer);
 
     StageFactory f;
-    WriterPtr writer(f.createWriter("writers.pclvisualizer"));
+    std::unique_ptr<Stage> writer(f.createStage("writers.pclvisualizer"));
     writer->setInput(&bufferReader);
 
     PointContext ctx;
@@ -427,8 +428,8 @@ void Kernel::setCommonOptions(Options &options)
     {
         std::vector<double> scales;
         tokenizer scale_tokens(m_scales, sep);
-        for (auto t = scale_tokens.begin(); t != scale_tokens.end(); ++t)
-            scales.push_back(boost::lexical_cast<double>(*t));
+        for (auto const& t : scale_tokens)
+            scales.push_back(boost::lexical_cast<double>(t));
         if (scales.size())
         {
             if (scales.size() <= 1)
@@ -453,8 +454,8 @@ void Kernel::setCommonOptions(Options &options)
     {
         std::vector<double> offsets;
         tokenizer offset_tokens(m_offsets, sep);
-        for (auto t = offset_tokens.begin(); t != offset_tokens.end(); ++t)
-            offsets.push_back(boost::lexical_cast<double>(*t));
+        for (auto const& t : offset_tokens)
+            offsets.push_back(boost::lexical_cast<double>(t));
         if (offsets.size())
         {
             if (offsets.size() <= 1)
@@ -486,11 +487,9 @@ void Kernel::outputHelp()
 {
     outputVersion();
 
-
-    for (auto iter = m_options.begin(); iter != m_options.end(); ++iter)
+    for (auto const& iter : m_options)
     {
-        const po::options_description* options = *iter;
-        std::cout << *options;
+        std::cout << *iter;
         std::cout << std::endl;
     }
 
@@ -552,13 +551,8 @@ void Kernel::parseSwitches()
 {
     po::options_description options;
 
-    for (auto iter = m_options.begin();
-            iter != m_options.end();
-            ++iter)
-    {
-        po::options_description* sub_options = *iter;
-        options.add(*sub_options);
-    }
+    for (auto const& iter : m_options)
+        options.add(*iter);
 
     try
     {
diff --git a/src/KernelFactory.cpp b/src/KernelFactory.cpp
index 98de821d05..c6ae5310c0 100644
--- a/src/KernelFactory.cpp
+++ b/src/KernelFactory.cpp
@@ -34,88 +34,29 @@
 
 #include <pdal/KernelFactory.hpp>
 #include <pdal/Kernel.hpp>
-#include <pdal/Kernels.hpp>
-
+#include <pdal/PluginManager.hpp>
 #include <pdal/Utils.hpp>
 
+#include <delta/DeltaKernel.hpp>
+#include <diff/DiffKernel.hpp>
+#include <info/InfoKernel.hpp>
+#include <pipeline/PipelineKernel.hpp>
+#include <random/RandomKernel.hpp>
+#include <sort/SortKernel.hpp>
+#include <translate/TranslateKernel.hpp>
+
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/tokenizer.hpp>
 
 #include <sstream>
 #include <stdio.h> // for funcptr
+#include <string>
+#include <vector>
 
 namespace pdal
 {
 
-//
-// define the functions to create the kernels
-//
-MAKE_KERNEL_CREATOR(delta, pdal::DeltaKernel)
-MAKE_KERNEL_CREATOR(diff, pdal::DiffKernel)
-MAKE_KERNEL_CREATOR(info, pdal::InfoKernel)
-MAKE_KERNEL_CREATOR(pipeline, pdal::PipelineKernel)
-MAKE_KERNEL_CREATOR(random, pdal::RandomKernel)
-MAKE_KERNEL_CREATOR(sort, pdal::SortKernel)
-MAKE_KERNEL_CREATOR(translate, pdal::TranslateKernel)
-
-KernelFactory::KernelFactory()
-{
-    registerKnownKernels();
-
-    loadPlugins();
-    return;
-}
-
-
-std::unique_ptr<Kernel> KernelFactory::createKernel(const std::string& type)
-{
-    KernelCreator* f = getKernelCreator(type);
-    if (!f)
-    {
-        std::ostringstream oss;
-        oss << "Unable to create kernel for type '" << type << "'. Does a driver with this type name exist?";
-        throw pdal_error(oss.str());
-    }
-    std::unique_ptr<Kernel> kernel(f());
-    return kernel;
-}
-
-
-template<typename T>
-static T* findFirst(const std::string& type, std::map<std::string, T*> list)
-{
-    typename std::map<std::string, T*>::const_iterator iter = list.find(type);
-    if (iter == list.end())
-        return NULL;
-    return (*iter).second;
-}
-
-
-KernelFactory::KernelCreator* KernelFactory::getKernelCreator(const std::string& type) const
-{
-    return findFirst<KernelCreator>(type, m_kernelCreators);
-}
-
-
-void KernelFactory::registerKernel(const std::string& type, KernelCreator* f)
-{
-    std::pair<std::string, KernelCreator*> p(type, f);
-    m_kernelCreators.insert(p);
-}
-
-
-void KernelFactory::registerKnownKernels()
-{
-    REGISTER_KERNEL(delta, pdal::DeltaKernel);
-    REGISTER_KERNEL(diff, pdal::DiffKernel);
-    REGISTER_KERNEL(info, pdal::InfoKernel);
-    REGISTER_KERNEL(pipeline, pdal::PipelineKernel);
-    REGISTER_KERNEL(random, pdal::RandomKernel);
-    REGISTER_KERNEL(sort, pdal::SortKernel);
-    REGISTER_KERNEL(translate, pdal::TranslateKernel);
-}
-
 
 void KernelFactory::loadPlugins()
 {
@@ -215,7 +156,7 @@ void KernelFactory::loadPlugins()
             path basename = t->first;
             path filename = t->second;
 
-            registerPlugin(filename.string());
+            //registerPlugin(filename.string());
             // std::string methodName = "PDALRegister_" + boost::algorithm::ireplace_first_copy(basename.string(), "libpdal_plugin_", "");
             // Utils::registerPlugin((void*)this, filename.string(), methodName);
 
@@ -223,40 +164,46 @@ void KernelFactory::loadPlugins()
     }
 }
 
-
-void KernelFactory::registerPlugin(std::string const& filename)
+KernelFactory::KernelFactory(bool no_plugins)
 {
-    using namespace boost::filesystem;
-    path basename;
-
-    path t = path(filename);
-    for (; !t.extension().empty(); t = t.stem())
-    {
-        if (t.stem().extension().empty())
-        {
-            basename = t.stem().string();
-        }
-    }
+    PluginManager & pm = PluginManager::getInstance();
+    if (!no_plugins) { pm.loadAll(PF_PluginType_Kernel); }
+    PluginManager::initializePlugin(DeltaKernel_InitPlugin);
+    PluginManager::initializePlugin(DiffKernel_InitPlugin);
+    PluginManager::initializePlugin(InfoKernel_InitPlugin);
+    PluginManager::initializePlugin(PipelineKernel_InitPlugin);
+    PluginManager::initializePlugin(RandomKernel_InitPlugin);
+    PluginManager::initializePlugin(SortKernel_InitPlugin);
+    PluginManager::initializePlugin(TranslateKernel_InitPlugin);
+}
 
-    std::string base = basename.string();
+std::unique_ptr<Kernel> KernelFactory::createKernel(std::string const& kernel_name)
+{
+    PluginManager & pm = PluginManager::getInstance();
 
-    std::string pluginName = boost::algorithm::ireplace_first_copy(base, "libpdal_plugin_", "");
-    std::string pluginType = pluginName.substr(0, pluginName.find_last_of("_"));
-    if (boost::iequals(pluginType, "kernel"))
+    void * kernel = pm.createObject(kernel_name);
+    if (!kernel)
     {
-        std::string registerMethodName = "PDALRegister_" + pluginName;
-
-        std::string versionMethodName = "PDALRegister_version_" + pluginName;
-
-        Utils::registerPlugin((void*)this, filename, registerMethodName, versionMethodName);
+        int32_t res = pm.guessLoadByPath(kernel_name);
+        if (res == 0)
+            kernel = pm.createObject(kernel_name);
     }
+    Kernel *k = (Kernel*)kernel;
+    std::unique_ptr<Kernel> retKernel(k);
+    return retKernel;
 }
 
-
-std::map<std::string, pdal::KernelInfo> const& KernelFactory::getKernelInfos() const
+std::vector<std::string> KernelFactory::getKernelNames()
 {
-    return m_driver_info;
+    PluginManager & pm = PluginManager::getInstance();
+    PluginManager::RegistrationMap rm = pm.getRegistrationMap();
+    std::vector<std::string> nv;
+    for (auto r : rm)
+    {
+        if (r.second.pluginType == PF_PluginType_Kernel)
+            nv.push_back(r.first);
+    }
+    return nv;
 }
 
-
 } // namespace pdal
diff --git a/src/KernelInfo.cpp b/src/KernelInfo.cpp
deleted file mode 100644
index 7942ac63e7..0000000000
--- a/src/KernelInfo.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2014, Bradley J Chambers (brad.chambers@gmail.com)
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#include <iomanip>
-
-#include <boost/algorithm/string.hpp>
-
-#include <pdal/KernelInfo.hpp>
-
-namespace pdal
-{
-
-
-std::ostream& operator<<(std::ostream& ostr, const KernelInfo& info)
-{
-    // boost::property_tree::ptree tree = kernel.toPTree();
-    //
-    // boost::property_tree::write_json(ostr, tree);
-
-    return ostr;
-}
-
-KernelInfo::KernelInfo(std::string const& name, std::string const& description)
-    : m_name(name), m_description(description) {}
-
-/// copy constructor
-KernelInfo::KernelInfo(KernelInfo const& other)
-    : m_name(other.m_name)
-    , m_description(other.m_description)
-    , m_link(other.m_link)
-{
-    return;
-}
-
-/// assignment operator
-KernelInfo& KernelInfo::operator=(KernelInfo const& rhs)
-{
-    if (&rhs != this)
-    {
-        m_name = rhs.m_name;
-        m_description = rhs.m_description;
-        m_link = rhs.m_link;
-    }
-
-    return *this;
-}
-
-
-} // namespace pdal
diff --git a/src/KernelSupport.cpp b/src/KernelSupport.cpp
index 4f29fbee27..f4933824d8 100644
--- a/src/KernelSupport.cpp
+++ b/src/KernelSupport.cpp
@@ -87,14 +87,14 @@ Stage *KernelSupport::makeReader(const std::string& inputFile)
         throw app_runtime_error("Cannot determine input file type of " +
             inputFile);
 
-    Stage* stage = factory.createReader(driver);
+    Stage* stage = factory.createStage2(driver);
     if (!stage)
         throw app_runtime_error("reader creation failed");
     return stage;
 }
 
 
-Writer* KernelSupport::makeWriter(const std::string& outputFile, Stage *stage)
+Stage* KernelSupport::makeWriter(const std::string& outputFile, Stage *stage)
 {
     pdal::StageFactory factory;
     std::string driver = factory.inferWriterDriver(outputFile);
@@ -103,7 +103,7 @@ Writer* KernelSupport::makeWriter(const std::string& outputFile, Stage *stage)
             outputFile);
     Options options = factory.inferWriterOptionsChanges(outputFile);
 
-    pdal::Writer* writer = factory.createWriter(driver);
+    Stage* writer = factory.createStage2(driver);
     if (!writer)
         throw app_runtime_error("writer creation failed");
     writer->setInput(stage);
diff --git a/src/PipelineManager.cpp b/src/PipelineManager.cpp
index ca1ae56be3..0e6606fc0f 100644
--- a/src/PipelineManager.cpp
+++ b/src/PipelineManager.cpp
@@ -34,9 +34,6 @@
 
 #include <pdal/PipelineManager.hpp>
 
-#include <pdal/Filter.hpp>
-#include <pdal/Reader.hpp>
-#include <pdal/Writer.hpp>
 #include <pdal/Utils.hpp>
 
 //#include <boost/optional.hpp>
@@ -55,36 +52,36 @@ PipelineManager::~PipelineManager()
 }
 
 
-Reader* PipelineManager::addReader(const std::string& type)
+Stage* PipelineManager::addReader(const std::string& type)
 {
-    Reader *r = m_factory.createReader(type);
+    Stage *r = m_factory.createStage2(type);
     m_stages.push_back(r);
     return r;
 }
 
 
-Filter* PipelineManager::addFilter(const std::string& type,
+Stage* PipelineManager::addFilter(const std::string& type,
     const std::vector<Stage *>& prevStages)
 {
-    Filter* stage = m_factory.createFilter(type);
+    Stage* stage = m_factory.createStage2(type);
     stage->setInput(prevStages);
     m_stages.push_back(stage);
     return stage;
 }
 
 
-Filter* PipelineManager::addFilter(const std::string& type, Stage *prevStage)
+Stage* PipelineManager::addFilter(const std::string& type, Stage *prevStage)
 {
-    Filter* stage = m_factory.createFilter(type);
+    Stage* stage = m_factory.createStage2(type);
     stage->setInput(prevStage);
     m_stages.push_back(stage);
     return stage;
 }
 
 
-Writer* PipelineManager::addWriter(const std::string& type, Stage *prevStage)
+Stage* PipelineManager::addWriter(const std::string& type, Stage *prevStage)
 {
-    Writer* writer = m_factory.createWriter(type);
+    Stage* writer = m_factory.createStage2(type);
     writer->setInput(prevStage);
     m_stages.push_back(writer);
     return writer;
diff --git a/src/PipelineReader.cpp b/src/PipelineReader.cpp
index 3585ddb5a5..60bf2207d1 100644
--- a/src/PipelineReader.cpp
+++ b/src/PipelineReader.cpp
@@ -34,10 +34,8 @@
 
 #include <pdal/PipelineReader.hpp>
 
-#include <pdal/PipelineManager.hpp>
 #include <pdal/Filter.hpp>
-#include <pdal/Reader.hpp>
-#include <pdal/Writer.hpp>
+#include <pdal/PipelineManager.hpp>
 #include <pdal/Options.hpp>
 #include <pdal/util/FileUtils.hpp>
 
@@ -240,7 +238,7 @@ Stage* PipelineReader::parseElement_anystage(const std::string& name,
 }
 
 
-Reader* PipelineReader::parseElement_Reader(const ptree& tree)
+Stage* PipelineReader::parseElement_Reader(const ptree& tree)
 {
     Options options(m_baseOptions);
 
@@ -302,13 +300,13 @@ Reader* PipelineReader::parseElement_Reader(const ptree& tree)
 
     context.validate();
 
-    Reader* reader =m_manager.addReader(type);
+    Stage* reader = m_manager.addReader(type);
     reader->setOptions(options);
     return reader;
 }
 
 
-Filter* PipelineReader::parseElement_Filter(const ptree& tree)
+Stage* PipelineReader::parseElement_Filter(const ptree& tree)
 {
     Options options(m_baseOptions);
 //    Stage* prevStage = NULL;
@@ -355,7 +353,7 @@ Filter* PipelineReader::parseElement_Filter(const ptree& tree)
         context.addType();
     }
 
-    Filter* ptr = m_manager.addFilter(type, prevStages);
+    Stage* ptr = m_manager.addFilter(type, prevStages);
     ptr->setOptions(options);
     if (dynamic_cast<MultiFilter *>(ptr))
         context.setCardinality(StageParserContext::Many);
@@ -387,7 +385,7 @@ void PipelineReader::collect_attributes(map_t& attrs, const ptree& tree)
 }
 
 
-Writer* PipelineReader::parseElement_Writer(const ptree& tree)
+Stage* PipelineReader::parseElement_Writer(const ptree& tree)
 {
     Options options(m_baseOptions);
     Stage* prevStage = NULL;
@@ -433,7 +431,7 @@ Writer* PipelineReader::parseElement_Writer(const ptree& tree)
     }
 
     context.validate();
-    Writer* writer = m_manager.addWriter(type, prevStage);
+    Stage* writer = m_manager.addWriter(type, prevStage);
     writer->setOptions(options);
     return writer;
 }
@@ -442,7 +440,7 @@ Writer* PipelineReader::parseElement_Writer(const ptree& tree)
 bool PipelineReader::parseElement_Pipeline(const ptree& tree)
 {
     Stage* stage = NULL;
-    Writer* writer = NULL;
+    Stage* writer = NULL;
 
     map_t attrs;
     collect_attributes(attrs, tree);
diff --git a/src/PluginManager.cpp b/src/PluginManager.cpp
new file mode 100644
index 0000000000..207463b684
--- /dev/null
+++ b/src/PluginManager.cpp
@@ -0,0 +1,307 @@
+#include <pdal/PluginManager.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/tokenizer.hpp>
+
+#include <pdal/pdal_defines.h>
+#include <pdal/util/FileUtils.hpp>
+#include <pdal/Utils.hpp>
+
+#include "DynamicLibrary.h"
+
+#include <iostream> //temp
+#include <memory>
+#include <sstream>
+#include <string>
+
+namespace pdal
+{
+
+#if defined(PDAL_PLATFORM_OSX)
+    static std::string dynamicLibraryExtension(".dylib");
+#elif defined(PDAL_PLATFORM_LINUX)
+    static std::string dynamicLibraryExtension(".so");
+#elif defined(PDAL_PLATFORM_WIN32)
+    static std::string dynamicLibraryExtension(".dll");
+#endif
+
+static bool isValid(const PF_RegisterParams * params)
+{
+    if (!params || !params->createFunc || !params->destroyFunc)
+        return false;
+
+    return true;
+}
+
+int32_t PluginManager::registerObject(const std::string & objectType, const PF_RegisterParams * params)
+{
+    if (!isValid(params))
+        return -1;
+
+    PluginManager & pm = PluginManager::getInstance();
+
+    // skipped version check for now
+
+    if (pm.exactMatchMap_.find(objectType) != pm.exactMatchMap_.end())
+        return -1;
+
+    pm.exactMatchMap_[objectType] = *params;
+    return 0;
+}
+
+PluginManager & PluginManager::getInstance()
+{
+    static PluginManager instance;
+    return instance;
+}
+
+int32_t PluginManager::loadAll(PF_PluginType type)
+{
+    std::string driver_path("PDAL_DRIVER_PATH");
+    std::string pluginDir = Utils::getenv(driver_path);
+
+    // If we don't have a driver path, we'll default to /usr/local/lib and lib
+
+    if (pluginDir.size() == 0)
+    {
+        std::ostringstream oss;
+        oss << PDAL_PLUGIN_INSTALL_PATH << ":/usr/local/lib:./lib:../lib:../bin";
+        pluginDir = oss.str();
+    }
+
+    std::vector<std::string> pluginPathVec;
+    boost::algorithm::split(pluginPathVec, pluginDir,
+        boost::algorithm::is_any_of(":"), boost::algorithm::token_compress_on);
+
+    for (const auto& pluginPath : pluginPathVec)
+    {
+        loadAll(pluginPath, type);
+    }
+
+    return 0;
+}
+
+int32_t PluginManager::loadAll(const std::string & pluginDirectory, PF_PluginType type)
+{
+    if (pluginDirectory.empty())
+        return -1;
+
+    if (!boost::filesystem::exists(pluginDirectory) || !boost::filesystem::is_directory(pluginDirectory))
+        return -1;
+
+    boost::filesystem::directory_iterator dir(pluginDirectory);
+    for (auto const& it : dir)
+    {
+        boost::filesystem::path full_path = it.path();
+
+        if (boost::filesystem::is_directory(full_path))
+            continue;
+
+        std::string ext = full_path.extension().string();
+        if (ext != dynamicLibraryExtension)
+            continue;
+
+        loadByPath(full_path.string(), type);
+    }
+
+    return 0;
+}
+
+int32_t PluginManager::initializePlugin(PF_InitFunc initFunc)
+{
+    PluginManager & pm = PluginManager::getInstance();
+
+    PF_ExitFunc exitFunc = initFunc();
+    if (!exitFunc)
+        return -1;
+
+    pm.exitFuncVec_.push_back(exitFunc);
+    return 0;
+}
+
+PluginManager::PluginManager() : inInitializePlugin_(false)
+{}
+
+PluginManager::~PluginManager()
+{
+    shutdown();
+}
+
+int32_t PluginManager::shutdown()
+{
+    int32_t result = 0;
+    for (auto const& func : exitFuncVec_)
+    {
+        try
+        {
+            result = (*func)();
+        }
+        catch (...)
+        {
+            result = 01;
+        }
+    }
+
+    dynamicLibraryMap_.clear();
+    exactMatchMap_.clear();
+    exitFuncVec_.clear();
+
+    return result;
+}
+
+int32_t PluginManager::guessLoadByPath(const std::string& driverName)
+{
+    // parse the driver name into an expected pluginName, e.g., writers.las => libpdal_plugin_writer_las
+    std::vector<std::string> driverNameVec;
+    boost::algorithm::split(driverNameVec, driverName,
+        boost::algorithm::is_any_of("."), boost::algorithm::token_compress_on);
+
+    std::string pluginName = "libpdal_plugin_" + driverNameVec[0] + "_" + driverNameVec[1];
+
+    std::string driver_path("PDAL_DRIVER_PATH");
+    std::string pluginDir = Utils::getenv(driver_path);
+
+    // If we don't have a driver path, we'll default to /usr/local/lib and lib
+
+    if (pluginDir.size() == 0)
+    {
+        std::ostringstream oss;
+        oss << PDAL_PLUGIN_INSTALL_PATH << ":/usr/local/lib:./lib:../lib:../bin";
+        pluginDir = oss.str();
+    }
+
+    std::vector<std::string> pluginPathVec;
+    boost::algorithm::split(pluginPathVec, pluginDir,
+        boost::algorithm::is_any_of(":"), boost::algorithm::token_compress_on);
+
+    for (const auto& pluginPath : pluginPathVec)
+    {
+        boost::filesystem::path path(pluginPath);
+
+        if (path.empty())
+            continue;
+
+        if (!boost::filesystem::exists(path) || !boost::filesystem::is_directory(path))
+            continue;
+
+        boost::filesystem::directory_iterator dir(path);
+        for (auto const& it : dir)
+        {
+            boost::filesystem::path full_path = it.path();
+            
+            if (boost::filesystem::is_directory(full_path))
+                continue;
+
+            std::string ext = full_path.extension().string();
+            if (ext != dynamicLibraryExtension)
+                continue;
+
+            PF_PluginType type;
+            if (driverNameVec[0] == "readers")
+                type = PF_PluginType_Reader;
+            else if (driverNameVec[0] == "kernels")
+                type = PF_PluginType_Kernel;
+            else if (driverNameVec[0] == "filters")
+                type = PF_PluginType_Filter;
+            else if (driverNameVec[0] == "writers")
+                type = PF_PluginType_Writer;
+
+            loadByPath(full_path.string(), type);
+        }
+   }
+
+    return 0;
+}
+
+int32_t PluginManager::loadByPath(const std::string& pluginPath, PF_PluginType type)
+{
+    boost::filesystem::path path(pluginPath);
+
+    bool isValid = false;
+    if (boost::algorithm::istarts_with(path.filename().string(), "libpdal_plugin_kernel"))
+    {
+        if (type == PF_PluginType_Kernel) { isValid = true; }
+    }
+    else if (boost::algorithm::istarts_with(path.filename().string(), "libpdal_plugin_filter"))
+    {
+        if (type == PF_PluginType_Filter) { isValid = true; }
+    }
+    else if (boost::algorithm::istarts_with(path.filename().string(), "libpdal_plugin_reader"))
+    {
+        if (type == PF_PluginType_Reader) { isValid = true; }
+    }
+    else if (boost::algorithm::istarts_with(path.filename().string(), "libpdal_plugin_writer"))
+    {
+        if (type == PF_PluginType_Writer) { isValid = true; }
+    }
+
+    if (!isValid)
+        return -1;
+
+/*  // I'm punting on the possibility of symlinks for now...
+    #ifndef WIN32
+    if (path.isSymbolicLink())
+    {
+        char buff[APR_PATH_MAX+1];
+        int length = ::readlink(path, buff, APR_PATH_MAX);
+        if (length < 0)
+            return -1;
+
+        path = std::string(buff, length);
+    }
+    #endif
+*/
+    if (dynamicLibraryMap_.find(path.string()) != dynamicLibraryMap_.end())
+        return -1;
+
+    //path.makeAbsolute();
+
+    std::string errorString;
+    DynamicLibrary * d = loadLibrary(boost::filesystem::complete(path).string(), errorString);
+    if (!d)
+        return -1;
+
+    PF_InitFunc initFunc = (PF_InitFunc)(d->getSymbol("PF_initPlugin"));
+    if (!initFunc)
+        return -1;
+
+    int32_t res = initializePlugin(initFunc);
+    if (res < 0)
+        return res;
+
+    return 0;
+}
+
+void * PluginManager::createObject(const std::string & objectType)
+{
+    if (exactMatchMap_.find(objectType) != exactMatchMap_.end())
+    {
+        PF_RegisterParams & rp = exactMatchMap_[objectType];
+        void * object = rp.createFunc();
+        if (object)
+        {
+            return object;
+        }
+    }
+
+    return NULL;
+}
+
+DynamicLibrary * PluginManager::loadLibrary(const std::string & path, std::string & errorString)
+{
+    DynamicLibrary * d = DynamicLibrary::load(path, errorString);
+    if (!d)
+        return NULL;
+
+    dynamicLibraryMap_[boost::filesystem::complete(path).string()] = std::shared_ptr<DynamicLibrary>(d);
+    return d;
+}
+
+const PluginManager::RegistrationMap & PluginManager::getRegistrationMap()
+{
+    return exactMatchMap_;
+}
+
+} // namespace pdal
+
diff --git a/src/Stage.cpp b/src/Stage.cpp
index a6125ad8b1..94c2e80a4f 100644
--- a/src/Stage.cpp
+++ b/src/Stage.cpp
@@ -36,6 +36,7 @@
 #include <pdal/Stage.hpp>
 #include <pdal/SpatialReference.hpp>
 #include <pdal/StageRunner.hpp>
+#include <pdal/UserCallback.hpp>
 
 #include <memory>
 
@@ -44,6 +45,7 @@ namespace pdal
 
 
 Stage::Stage()
+  : m_callback(new UserCallback)
 {
     Construct();
 }
@@ -93,15 +95,15 @@ PointBufferSet Stage::execute(PointContextRef ctx)
     std::vector<StageRunnerPtr> runners;
 
     ready(ctx);
-    for (auto it = buffers.begin(); it != buffers.end(); ++it)
+    for (auto const& it : buffers)
     {
-        StageRunnerPtr runner(new StageRunner(this, *it));
+        StageRunnerPtr runner(new StageRunner(this, it));
         runners.push_back(runner);
         runner->run();
     }
-    for (auto it = runners.begin(); it != runners.end(); ++it)
+    for (auto const& it : runners)
     {
-        StageRunnerPtr runner(*it);
+        StageRunnerPtr runner(it);
         PointBufferSet temp = runner->wait();
         outBuffers.insert(temp.begin(), temp.end());
     }
@@ -209,9 +211,8 @@ std::vector<Stage*> Stage::findStage(std::string name)
     if (boost::iequals(getName(), name))
         output.push_back(this);
 
-    for (auto s = m_inputs.begin(); s != m_inputs.end(); ++s)
+    for (auto const& stage : m_inputs)
     {
-        Stage* stage = (*s);
         if (boost::iequals(stage->getName(), name))
             output.push_back(stage);
         if (stage->getInputs().size())
diff --git a/src/StageFactory.cpp b/src/StageFactory.cpp
index 626a2129a0..9f0b249e28 100644
--- a/src/StageFactory.cpp
+++ b/src/StageFactory.cpp
@@ -34,16 +34,34 @@
 
 #include <pdal/StageFactory.hpp>
 
-#include <pdal/Filter.hpp>
-#include <pdal/Reader.hpp>
-#include <pdal/Writer.hpp>
-
-
-#include <pdal/Drivers.hpp>
-#include <pdal/Filters.hpp>
-
 #include <pdal/Utils.hpp>
-
+#include <pdal/PluginManager.hpp>
+
+#include <chipper/ChipperFilter.hpp>
+#include <colorization/ColorizationFilter.hpp>
+#include <crop/CropFilter.hpp>
+#include <decimation/DecimationFilter.hpp>
+#include <ferry/FerryFilter.hpp>
+#include <merge/MergeFilter.hpp>
+#include <mortonorder/MortonOrderFilter.hpp>
+#include <range/RangeFilter.hpp>
+#include <reprojection/ReprojectionFilter.hpp>
+#include <sort/SortFilter.hpp>
+#include <splitter/SplitterFilter.hpp>
+#include <stats/StatsFilter.hpp>
+#include <transformation/TransformationFilter.hpp>
+
+#include <pdal/BufferReader.hpp>
+#include <faux/FauxReader.hpp>
+#include <las/LasReader.hpp>
+#include <las/LasWriter.hpp>
+#include <bpf/BpfReader.hpp>
+#include <bpf/BpfWriter.hpp>
+#include <sbet/SbetReader.hpp>
+#include <sbet/SbetWriter.hpp>
+#include <qfit/QfitReader.hpp>
+#include <terrasolid/TerrasolidReader.hpp>
+#include <text/TextWriter.hpp>
 
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
@@ -58,60 +76,13 @@
 namespace pdal
 {
 
-//
-// define the functions to create the readers
-//
-MAKE_READER_CREATOR(FauxReader, pdal::FauxReader)
-MAKE_READER_CREATOR(LasReader, pdal::LasReader)
-MAKE_READER_CREATOR(BpfReader, pdal::BpfReader)
-MAKE_READER_CREATOR(BufferReader, pdal::BufferReader)
-MAKE_READER_CREATOR(QfitReader, pdal::QfitReader)
-MAKE_READER_CREATOR(SbetReader, pdal::SbetReader)
-MAKE_READER_CREATOR(TerrasolidReader, pdal::TerrasolidReader)
-
-//
-// define the functions to create the filters
-//
-MAKE_FILTER_CREATOR(Chipper, pdal::ChipperFilter)
-MAKE_FILTER_CREATOR(Colorization, pdal::ColorizationFilter)
-MAKE_FILTER_CREATOR(Crop, pdal::CropFilter)
-MAKE_FILTER_CREATOR(Decimation, pdal::DecimationFilter)
-MAKE_FILTER_CREATOR(Ferry, pdal::FerryFilter)
-MAKE_FILTER_CREATOR(Merge, pdal::MergeFilter)
-MAKE_FILTER_CREATOR(MortonOrder, pdal::MortonOrderFilter)
-MAKE_FILTER_CREATOR(Range, pdal::RangeFilter)
-MAKE_FILTER_CREATOR(Reprojection, pdal::ReprojectionFilter)
-MAKE_FILTER_CREATOR(Sort, pdal::SortFilter)
-MAKE_FILTER_CREATOR(Splitter, pdal::SplitterFilter)
-MAKE_FILTER_CREATOR(Stats, pdal::StatsFilter)
-MAKE_FILTER_CREATOR(Transformation, pdal::TransformationFilter)
-
-//
-// define the functions to create the writers
-//
-MAKE_WRITER_CREATOR(BpfWriter, pdal::BpfWriter)
-MAKE_WRITER_CREATOR(LasWriter, pdal::LasWriter)
-MAKE_WRITER_CREATOR(SbetWriter, pdal::SbetWriter)
-MAKE_WRITER_CREATOR(TextWriter, pdal::TextWriter)
-
-StageFactory::StageFactory()
-{
-    registerKnownReaders();
-    registerKnownFilters();
-    registerKnownWriters();
-
-    loadPlugins();
-    return;
-}
-
-
 std::string StageFactory::inferReaderDriver(const std::string& filename)
 {
-    StageFactory f;
+    PluginManager & pm = PluginManager::getInstance();
 
     // filename may actually be a greyhound uri + pipelineId
     std::string http = filename.substr(0, 4);
-    if (boost::iequals(http, "http") && f.getReaderCreator("readers.greyhound"))
+    if (boost::iequals(http, "http") && pm.createObject("readers.greyhound"))
         return "readers.greyhound";
 
     std::string ext = boost::filesystem::extension(filename);
@@ -119,10 +90,10 @@ std::string StageFactory::inferReaderDriver(const std::string& filename)
     drivers["las"] = "readers.las";
     drivers["laz"] = "readers.las";
     drivers["bin"] = "readers.terrasolid";
-    if (f.getReaderCreator("readers.greyhound"))
+    if (pm.createObject("readers.greyhound"))
         drivers["greyhound"] = "readers.greyhound";
     drivers["qi"] = "readers.qfit";
-    if (f.getReaderCreator("readers.nitf"))
+    if (pm.createObject("readers.nitf"))
     {
         drivers["nitf"] = "readers.nitf";
         drivers["ntf"] = "readers.nitf";
@@ -133,10 +104,10 @@ std::string StageFactory::inferReaderDriver(const std::string& filename)
     drivers["icebridge"] = "readers.icebridge";
     drivers["sqlite"] = "readers.sqlite";
 
-    if (f.getReaderCreator("readers.rxp"))
+    if (pm.createObject("readers.rxp"))
         drivers["rxp"] = "readers.rxp";
 
-    if (f.getReaderCreator("readers.pcd"))
+    if (pm.createObject("readers.pcd"))
         drivers["pcd"] = "readers.pcd";
 
     if (ext == "") return "";
@@ -151,6 +122,8 @@ std::string StageFactory::inferReaderDriver(const std::string& filename)
 
 std::string StageFactory::inferWriterDriver(const std::string& filename)
 {
+    PluginManager & pm = PluginManager::getInstance();
+
     std::string ext = boost::filesystem::extension(filename);
 
     boost::to_lower(ext);
@@ -159,17 +132,16 @@ std::string StageFactory::inferWriterDriver(const std::string& filename)
     drivers["bpf"] = "writers.bpf";
     drivers["las"] = "writers.las";
     drivers["laz"] = "writers.las";
-    StageFactory f;
-    if (f.getWriterCreator("writers.pcd"))
+    if (pm.createObject("writers.pcd"))
         drivers["pcd"] = "writers.pcd";
-    if (f.getWriterCreator("writers.pclvisualizer"))
+    if (pm.createObject("writers.pclvisualizer"))
         drivers["pclviz"] = "writers.pclvisualizer";
     drivers["sbet"] = "writers.sbet";
     drivers["csv"] = "writers.text";
     drivers["json"] = "writers.text";
     drivers["xyz"] = "writers.text";
     drivers["txt"] = "writers.text";
-    if (f.getWriterCreator("writers.nitf"))
+    if (pm.createObject("writers.nitf"))
         drivers["ntf"] = "writers.nitf";
     drivers["sqlite"] = "writers.sqlite";
 
@@ -199,8 +171,8 @@ pdal::Options StageFactory::inferWriterOptionsChanges(const std::string& filenam
         options.add("compression", true);
     }
 
-    StageFactory f;
-    if (boost::algorithm::iequals(ext,".pcd") && f.getWriterCreator("writers.pcd"))
+    PluginManager & pm = PluginManager::getInstance();
+    if (boost::algorithm::iequals(ext,".pcd") && pm.createObject("writers.pcd"))
     {
         options.add("format","PCD");
     }
@@ -209,138 +181,6 @@ pdal::Options StageFactory::inferWriterOptionsChanges(const std::string& filenam
     return options;
 }
 
-
-Reader* StageFactory::createReader(const std::string& type)
-{
-    ReaderCreator* f = getReaderCreator(type);
-    if (!f)
-    {
-        std::ostringstream oss;
-        oss << "Unable to create reader for type '" << type << "'. Does a driver with this type name exist?";
-        throw pdal_error(oss.str());
-    }
-    Reader* stage = f();
-    return stage;
-}
-
-
-Filter* StageFactory::createFilter(const std::string& type)
-{
-    FilterCreator* f = getFilterCreator(type);
-    if (!f)
-    {
-        std::ostringstream oss;
-        oss << "Unable to create filter for type '" << type << "'. Does a driver with this type name exist?";
-        throw pdal_error(oss.str());
-    }
-
-    return f();
-}
-
-
-Writer* StageFactory::createWriter(const std::string& type)
-{
-    WriterCreator* f = getWriterCreator(type);
-    if (!f)
-    {
-        std::ostringstream oss;
-        oss << "Unable to create writer for type '" << type <<
-            "'. Does a driver with this type name exist?";
-        throw pdal_error(oss.str());
-    }
-
-    return f();
-}
-
-
-template<typename T>
-static T* findFirst(const std::string& type, std::map<std::string, T*> list)
-{
-    typename std::map<std::string, T*>::const_iterator iter = list.find(type);
-    if (iter == list.end())
-        return NULL;
-    return (*iter).second;
-}
-
-
-StageFactory::ReaderCreator* StageFactory::getReaderCreator(const std::string& type) const
-{
-    return findFirst<ReaderCreator>(type, m_readerCreators);
-}
-
-
-StageFactory::FilterCreator* StageFactory::getFilterCreator(const std::string& type) const
-{
-    return findFirst<FilterCreator>(type, m_filterCreators);
-}
-
-
-StageFactory::WriterCreator* StageFactory::getWriterCreator(const std::string& type) const
-{
-    return findFirst<WriterCreator>(type, m_writerCreators);
-}
-
-
-void StageFactory::registerReader(const std::string& type, ReaderCreator* f)
-{
-    std::pair<std::string, ReaderCreator*> p(type, f);
-    m_readerCreators.insert(p);
-}
-
-
-void StageFactory::registerFilter(const std::string& type, FilterCreator* f)
-{
-    std::pair<std::string, FilterCreator*> p(type, f);
-    m_filterCreators.insert(p);
-}
-
-
-void StageFactory::registerWriter(const std::string& type, WriterCreator* f)
-{
-    std::pair<std::string, WriterCreator*> p(type, f);
-    m_writerCreators.insert(p);
-}
-
-
-void StageFactory::registerKnownReaders()
-{
-    REGISTER_READER(FauxReader, pdal::FauxReader);
-    REGISTER_READER(BufferReader, pdal::BufferReader);
-    REGISTER_READER(LasReader, pdal::LasReader);
-
-    REGISTER_READER(QfitReader, pdal::QfitReader);
-    REGISTER_READER(TerrasolidReader, pdal::TerrasolidReader);
-    REGISTER_READER(BpfReader, pdal::BpfReader);
-    REGISTER_READER(SbetReader, pdal::SbetReader);
-}
-
-
-void StageFactory::registerKnownFilters()
-{
-    REGISTER_FILTER(Chipper, pdal::ChipperFilter);
-    REGISTER_FILTER(Colorization, pdal::ColorizationFilter);
-    REGISTER_FILTER(Crop, pdal::CropFilter);
-    REGISTER_FILTER(Decimation, pdal::DecimationFilter);
-    REGISTER_FILTER(Ferry, pdal::FerryFilter);
-    REGISTER_FILTER(Merge, pdal::MergeFilter);
-    REGISTER_FILTER(MortonOrder, pdal::MortonOrderFilter);
-    REGISTER_FILTER(Range, pdal::RangeFilter);
-    REGISTER_FILTER(Reprojection, pdal::ReprojectionFilter);
-    REGISTER_FILTER(Sort, pdal::SortFilter);
-    REGISTER_FILTER(Splitter, pdal::SplitterFilter);
-    REGISTER_FILTER(Stats, pdal::StatsFilter);
-    REGISTER_FILTER(Transformation, pdal::TransformationFilter);
-}
-
-
-void StageFactory::registerKnownWriters()
-{
-    REGISTER_WRITER(BpfWriter, pdal::BpfWriter);
-    REGISTER_WRITER(LasWriter, pdal::LasWriter);
-    REGISTER_WRITER(SbetWriter, pdal::SbetWriter);
-    REGISTER_WRITER(TextWriter, pdal::TextWriter);
-}
-
 void StageFactory::loadPlugins()
 {
     using namespace boost::filesystem;
@@ -443,7 +283,7 @@ void StageFactory::loadPlugins()
             path basename = t->first;
             path filename = t->second;
 
-            registerPlugin(filename.string());
+            //registerPlugin(filename.string());
             // std::string methodName = "PDALRegister_" + boost::algorithm::ireplace_first_copy(basename.string(), "libpdal_plugin_", "");
             // Utils::registerPlugin((void*)this, filename.string(), methodName);
 
@@ -451,65 +291,103 @@ void StageFactory::loadPlugins()
     }
 }
 
-void StageFactory::registerPlugin(std::string const& filename)
+StageFactory::StageFactory(bool no_plugins)
 {
-    using namespace boost::filesystem;
-    path basename;
-
-    path t = path(filename);
-    for (; !t.extension().empty(); t = t.stem())
+    PluginManager & pm = PluginManager::getInstance();
+    if (!no_plugins)
     {
-        if (t.stem().extension().empty())
-        {
-            basename = t.stem().string();
-        }
+        pm.loadAll(PF_PluginType_Filter);
+        pm.loadAll(PF_PluginType_Reader);
+        pm.loadAll(PF_PluginType_Writer);
     }
+    PluginManager::initializePlugin(FauxReader_InitPlugin);
+    PluginManager::initializePlugin(LasReader_InitPlugin);
+    PluginManager::initializePlugin(BpfReader_InitPlugin);
+    PluginManager::initializePlugin(QfitReader_InitPlugin);
+    PluginManager::initializePlugin(SbetReader_InitPlugin);
+    PluginManager::initializePlugin(TerrasolidReader_InitPlugin);
+    PluginManager::initializePlugin(ChipperFilter_InitPlugin);
+    PluginManager::initializePlugin(ColorizationFilter_InitPlugin);
+    PluginManager::initializePlugin(CropFilter_InitPlugin);
+    PluginManager::initializePlugin(DecimationFilter_InitPlugin);
+    PluginManager::initializePlugin(FerryFilter_InitPlugin);
+    PluginManager::initializePlugin(MergeFilter_InitPlugin);
+    PluginManager::initializePlugin(MortonOrderFilter_InitPlugin);
+    PluginManager::initializePlugin(RangeFilter_InitPlugin);
+    PluginManager::initializePlugin(ReprojectionFilter_InitPlugin);
+    PluginManager::initializePlugin(SortFilter_InitPlugin);
+    PluginManager::initializePlugin(SplitterFilter_InitPlugin);
+    PluginManager::initializePlugin(StatsFilter_InitPlugin);
+    PluginManager::initializePlugin(TransformationFilter_InitPlugin);
+    PluginManager::initializePlugin(BpfWriter_InitPlugin);
+    PluginManager::initializePlugin(LasWriter_InitPlugin);
+    PluginManager::initializePlugin(SbetWriter_InitPlugin);
+    PluginManager::initializePlugin(TextWriter_InitPlugin);
+}
 
-    std::string base = basename.string();
-    std::string pluginName = boost::algorithm::ireplace_first_copy(base, "libpdal_plugin_", "");
-
-    std::string registerMethodName = "PDALRegister_" + pluginName;
-
-    std::string versionMethodName = "PDALRegister_version_" + pluginName;
+Stage* StageFactory::createStage2(std::string const& stage_name)
+{
+    PluginManager & pm = PluginManager::getInstance();
 
-    Utils::registerPlugin((void*)this, filename, registerMethodName, versionMethodName);
+    void * stage = pm.createObject(stage_name);
+    if (!stage)
+    {
+        int32_t res = pm.guessLoadByPath(stage_name);
+        if (res == 0)
+            stage = pm.createObject(stage_name);
+    }
 
+    return (Stage*)stage;
 }
 
+std::unique_ptr<Stage> StageFactory::createStage(std::string const& stage_name)
+{/*
+    PluginManager & pm = PluginManager::getInstance();
 
-std::map<std::string, pdal::StageInfo> const& StageFactory::getStageInfos() const
-{
-    return m_driver_info;
+    void * stage = pm.createObject(stage_name);
+    if (!stage)
+    {
+        int32_t res = pm.guessLoadByPath(stage_name);
+        if (res == 0)
+            stage = pm.createObject(stage_name);
+    }
+
+    Stage *s = (Stage*)stage;
+  */
+    std::unique_ptr<Stage> retStage(createStage2(stage_name));
+    return retStage;
 }
 
-std::string StageFactory::toRST(std::string driverName) const
+std::vector<std::string> StageFactory::getStageNames()
 {
-    std::ostringstream os;
-
-    std::map<std::string, pdal::StageInfo> const& drivers = getStageInfos();
-    typedef std::map<std::string, pdal::StageInfo>::const_iterator Iterator;
-
-    Iterator i = drivers.find(driverName);
-    std::string headline("------------------------------------------------------------------------------------------");
-
-    os << headline << std::endl;
-    os << "PDAL Options" << " (" << pdal::GetFullVersionString() << ")" <<std::endl;
-    os << headline << std::endl << std::endl;
-
-    // If we were given an explicit driver name, only display that.
-    // Otherwise, display output for all of the registered drivers.
-    if ( i != drivers.end())
+    PluginManager & pm = PluginManager::getInstance();
+    PluginManager::RegistrationMap rm = pm.getRegistrationMap();
+    std::vector<std::string> nv;
+    for (auto r : rm)
     {
-        os << i->second.optionsToRST() << std::endl;
+        if (r.second.pluginType == PF_PluginType_Filter ||
+            r.second.pluginType == PF_PluginType_Reader ||
+            r.second.pluginType == PF_PluginType_Writer)
+            nv.push_back(r.first);
     }
-    else
+    return nv;
+}
+
+std::map<std::string, std::string> StageFactory::getStageMap()
+{
+    PluginManager & pm = PluginManager::getInstance();
+    PluginManager::RegistrationMap rm = pm.getRegistrationMap();
+    std::map<std::string, std::string> sm;
+    for (auto r : rm)
     {
-        for (i = drivers.begin(); i != drivers.end(); ++i)
-        {
-            os << i->second.optionsToRST() << std::endl;
-        }
+        if (r.second.pluginType == PF_PluginType_Filter ||
+            r.second.pluginType == PF_PluginType_Reader ||
+            r.second.pluginType == PF_PluginType_Writer)
+            sm.insert(std::make_pair(r.first, r.second.description));
     }
-    return os.str();
+    return sm;
 }
 
+
 } // namespace pdal
+
diff --git a/src/StageInfo.cpp b/src/StageInfo.cpp
deleted file mode 100644
index 401b4bc557..0000000000
--- a/src/StageInfo.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-/******************************************************************************
-* Copyright (c) 2013, Howard Butler (hobu.inc@gmail.com)
-*
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following
-* conditions are met:
-*
-*     * Redistributions of source code must retain the above copyright
-*       notice, this list of conditions and the following disclaimer.
-*     * Redistributions in binary form must reproduce the above copyright
-*       notice, this list of conditions and the following disclaimer in
-*       the documentation and/or other materials provided
-*       with the distribution.
-*     * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
-*       names of its contributors may be used to endorse or promote
-*       products derived from this software without specific prior
-*       written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
-* OF SUCH DAMAGE.
-****************************************************************************/
-
-#include <iomanip>
-
-#include <boost/algorithm/string.hpp>
-
-#include <pdal/StageInfo.hpp>
-
-namespace pdal
-{
-
-
-std::ostream& operator<<(std::ostream& ostr, const StageInfo& info)
-{
-    // boost::property_tree::ptree tree = stage.toPTree();
-    //
-    // boost::property_tree::write_json(ostr, tree);
-
-    return ostr;
-}
-
-StageInfo::StageInfo(std::string const& name, std::string const& description)
-    : m_name(name), m_description(description) {}
-
-/// copy constructor
-StageInfo::StageInfo(StageInfo const& other)
-    : m_name(other.m_name)
-    , m_description(other.m_description)
-    , m_dimensions(other.m_dimensions)
-    , m_options(other.m_options)
-    , m_link(other.m_link)
-    , m_plugin_version(other.m_plugin_version)
-{
-    return;
-}
-
-/// assignment operator
-StageInfo& StageInfo::operator=(StageInfo const& rhs)
-{
-    if (&rhs != this)
-    {
-        m_name = rhs.m_name;
-        m_description = rhs.m_description;
-        m_dimensions = rhs.m_dimensions;
-        m_options = rhs.m_options;
-        m_link = rhs.m_link;
-        m_plugin_version = rhs.m_plugin_version;
-    }
-
-    return *this;
-}
-
-std::string StageInfo::optionsToRST() const
-{
-    std::ostringstream strm;
-
-    std::vector<Option> options = getProvidedOptions();
-
-    strm << toRST() << std::endl;
-
-    if (!options.size())
-    {
-        strm << "No options documented" << std::endl << std::endl;
-        return strm.str();
-    } 
- 
-    std::string tablehead("================================ =============== =========================================");
-    std::string headings ("Name                              Default          Description");
-    
-    strm << std::endl;
-    strm << tablehead << std::endl;
-    strm << headings << std::endl;
-    strm << tablehead << std::endl;
-    
-    uint32_t default_column(15);
-    uint32_t name_column(32);
-    uint32_t description_column(40);
-
-    strm << std::left;
-
-    for (std::vector<Option>::const_iterator it = options.begin();
-        it != options.end();
-        ++it)
-    {
-        pdal::Option const& opt = *it;
-        std::string default_value(opt.getValue<std::string>() );
-        default_value = boost::algorithm::erase_all_copy(default_value, "\n");
-        if (default_value.size() > default_column -1 )
-        {
-            default_value = default_value.substr(0, default_column-3);
-            default_value = default_value + "...";
-        }
-        
-        std::vector<std::string> lines;
-        std::string description(opt.getDescription());
-        description = boost::algorithm::erase_all_copy(description, "\n");
-        
-        Utils::wordWrap(description, lines, description_column-1);
-        if (lines.size() == 1)
-        {
-            
-            strm   << std::setw(name_column) << opt.getName() << " " 
-                   << std::setw(default_column) << default_value << " " 
-                   << std::setw(description_column) << description << std::endl;
-        } else
-            strm   << std::setw(name_column) << opt.getName() << " " 
-                   << std::setw(default_column) << default_value << " " 
-                   << lines[0] << std::endl;
-        
-        std::stringstream blank;
-        size_t blanks(49);
-        for (size_t i = 0; i < blanks; ++i)
-            blank << " ";
-        for (size_t i = 1; i < lines.size(); ++i)
-        {
-            strm << blank.str() <<lines[i] << std::endl;
-        }
-
-    }
-
-    strm << tablehead << std::endl;
-    strm << std::endl;
-    return strm.str();    
-}
-
-
-} // namespace pdal
diff --git a/test/unit/LogTest.cpp b/test/unit/LogTest.cpp
index b7aa07a61d..25ce800f71 100644
--- a/test/unit/LogTest.cpp
+++ b/test/unit/LogTest.cpp
@@ -60,7 +60,7 @@ TEST(LogTest, test_one)
     {
         PointContext ctx;
 
-        ReaderPtr reader(f.createReader("readers.faux"));
+        std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
         reader->setOptions(opts);
         reader->prepare(ctx);
 
@@ -140,14 +140,14 @@ TEST(LogTest, test_two_a)
     }
 
     {
-        ReaderPtr reader(f.createReader("readers.faux"));
+        std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
         reader->setOptions(reader_opts);
 
-        FilterPtr xfilter(f.createFilter("filters.programmable"));
+        std::unique_ptr<Stage> xfilter(f.createStage("filters.programmable"));
         xfilter->setOptions(xfilter_opts);
         xfilter->setInput(reader.get());
 
-        FilterPtr yfilter(f.createFilter("filters.programmable"));
+        std::unique_ptr<Stage> yfilter(f.createStage("filters.programmable"));
         yfilter->setOptions(yfilter_opts);
         yfilter->setInput(xfilter.get());
 
@@ -239,14 +239,14 @@ TEST(LogTest, test_two_b)
     }
 
     {
-        ReaderPtr reader(f.createReader("readers.faux"));
+        std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
         reader->setOptions(reader_opts);
 
-        FilterPtr xfilter(f.createFilter("filters.programmable"));
+        std::unique_ptr<Stage> xfilter(f.createStage("filters.programmable"));
         xfilter->setOptions(xfilter_opts);
         xfilter->setInput(reader.get());
 
-        FilterPtr yfilter(f.createFilter("filters.programmable"));
+        std::unique_ptr<Stage> yfilter(f.createStage("filters.programmable"));
         yfilter->setOptions(yfilter_opts);
         yfilter->setInput(xfilter.get());
 
@@ -328,10 +328,10 @@ TEST(LogTest, test_three)
     }
 
     {
-        ReaderPtr reader(f.createReader("readers.faux"));
+        std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
         reader->setOptions(reader_opts);
 
-        FilterPtr xfilter(f.createFilter("filters.programmable"));
+        std::unique_ptr<Stage> xfilter(f.createStage("filters.programmable"));
         xfilter->setOptions(xfilter_opts);
         xfilter->setInput(reader.get());
 
diff --git a/test/unit/OptionsTest.cpp b/test/unit/OptionsTest.cpp
index aaecd73280..a357cf6103 100644
--- a/test/unit/OptionsTest.cpp
+++ b/test/unit/OptionsTest.cpp
@@ -65,25 +65,19 @@ TEST(OptionsTest, test_static_options)
     Options ops;
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops);
-    FilterPtr crop(f.createFilter("filters.crop"));
+    std::unique_ptr<Stage> crop(f.createStage("filters.crop"));
     EXPECT_TRUE(crop.get());
     crop->setOptions(ops);
     crop->setInput(reader.get());
-    std::map<std::string, pdal::StageInfo> const& drivers = f.getStageInfos();
-    typedef std::map<std::string, pdal::StageInfo>::const_iterator Iterator;
-    Iterator i = drivers.find("filters.crop");
-    if (i != drivers.end())
-    {
-      const std::vector<Option> opts = i->second.getProvidedOptions();
-      EXPECT_EQ(opts.size(), 3u);
-      EXPECT_TRUE(hasOption(opts, "bounds"));
-      EXPECT_TRUE(hasOption(opts, "inside"));
-      EXPECT_TRUE(hasOption(opts, "polygon"));
-      EXPECT_FALSE(hasOption(opts, "metes"));
-    }
+    auto opts = crop->getDefaultOptions();
+    EXPECT_EQ(opts.getOptions().size(), 3u);
+    EXPECT_TRUE(opts.hasOption("bounds"));
+    EXPECT_TRUE(opts.hasOption("inside"));
+    EXPECT_TRUE(opts.hasOption("polygon"));
+    EXPECT_FALSE(opts.hasOption("metes"));
 }
 
 TEST(OptionsTest, test_option_writing)
diff --git a/test/unit/PipelineManagerTest.cpp b/test/unit/PipelineManagerTest.cpp
index 62ee4231db..17940415f4 100644
--- a/test/unit/PipelineManagerTest.cpp
+++ b/test/unit/PipelineManagerTest.cpp
@@ -50,12 +50,12 @@ TEST(PipelineManagerTest, basic)
 
     Options optsR;
     optsR.add("filename", Support::datapath("las/1.2-with-color.las"));
-    Reader* reader = mgr.addReader("readers.las");
+    Stage* reader = mgr.addReader("readers.las");
     reader->setOptions(optsR);
 
     Options optsW;
     optsW.add("filename", outfile, "file to write to");
-    Writer* writer = mgr.addWriter("writers.las", reader);
+    Stage* writer = mgr.addWriter("writers.las", reader);
     writer->setOptions(optsW);
 
     point_count_t np = mgr.execute();
@@ -77,11 +77,11 @@ TEST(PipelineManagerTest, PipelineManagerTest_test2)
 
         Options optsR1;
         optsR1.add("filename", Support::datapath("1.2-with-color.las"));
-        Reader* reader1 = mgr.addReader("readers.las", optsR1);
+        Stage* reader1 = mgr.addReader("readers.las", optsR1);
 
         Options optsR2;
         optsR2.add("filename", Support::datapath("1.2-with-color.las"));
-        Reader* reader2 = mgr.addReader("readers.las", optsR2);
+        Stage* reader2 = mgr.addReader("readers.las", optsR2);
 
         Options optsMF;
         std::vector<Stage*> vec;
@@ -95,7 +95,7 @@ TEST(PipelineManagerTest, PipelineManagerTest_test2)
 
         Options optsW;
         optsW.add("filename", "temp.las", "file to write to");
-        Writer* writer = mgr.addWriter("writers.las", *filter, optsW);
+        Stage* writer = mgr.addWriter("writers.las", *filter, optsW);
         point_count_t np = mgr.execute();
 
         EXPECT_TRUE(np == 1065 * 2);
diff --git a/test/unit/filters/CropFilterTest.cpp b/test/unit/filters/CropFilterTest.cpp
index 1405fb8a28..8d25a37685 100644
--- a/test/unit/filters/CropFilterTest.cpp
+++ b/test/unit/filters/CropFilterTest.cpp
@@ -51,7 +51,7 @@ TEST(CropFilterTest, test_crop)
     opts.add("bounds", srcBounds);
     opts.add("num_points", 1000);
     opts.add("mode", "ramp");
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(opts);
 
@@ -60,7 +60,7 @@ TEST(CropFilterTest, test_crop)
     Options cropOpts;
     cropOpts.add("bounds", dstBounds);
 
-    FilterPtr filter(f.createFilter("filters.crop"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.crop"));
     EXPECT_TRUE(filter.get());
     filter->setOptions(cropOpts);
     filter->setInput(reader.get());
@@ -115,7 +115,7 @@ TEST(CropFilterTest, test_crop_polygon)
 
     Options ops1;
     ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops1);
 
@@ -136,7 +136,7 @@ TEST(CropFilterTest, test_crop_polygon)
     Option polygon("polygon", wkt, "");
     options.add(polygon);
 
-    FilterPtr crop(f.createFilter("filters.crop"));
+    std::unique_ptr<Stage> crop(f.createStage("filters.crop"));
     EXPECT_TRUE(crop.get());
     crop->setInput(reader.get());
     crop->setOptions(options);
@@ -196,16 +196,16 @@ TEST(CropFilterTest, test_crop_polygon_reprojection)
     Option polygon("polygon", wkt, "");
     options.add(polygon);
 
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(options);
 
-    FilterPtr reprojection(f.createFilter("filters.reprojection"));
+    std::unique_ptr<Stage> reprojection(f.createStage("filters.reprojection"));
     EXPECT_TRUE(reprojection.get());
     reprojection->setOptions(options);
     reprojection->setInput(reader.get());
 
-    FilterPtr crop(f.createFilter("filters.crop"));
+    std::unique_ptr<Stage> crop(f.createStage("filters.crop"));
     EXPECT_TRUE(crop.get());
     crop->setOptions(options);
     crop->setInput(reprojection.get());
diff --git a/test/unit/filters/DecimationFilterTest.cpp b/test/unit/filters/DecimationFilterTest.cpp
index 4a4a2a6b4d..2bfc182684 100644
--- a/test/unit/filters/DecimationFilterTest.cpp
+++ b/test/unit/filters/DecimationFilterTest.cpp
@@ -49,14 +49,14 @@ TEST(DecimationFilterTest, DecimationFilterTest_test1)
     ops.add("mode", "random");
     ops.add("num_points", 30);
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops);
 
     Options decimationOps;
     decimationOps.add("step", 10);
     
-    FilterPtr filter(f.createFilter("filters.decimation"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.decimation"));
     EXPECT_TRUE(filter.get());
     filter->setOptions(decimationOps);
     filter->setInput(reader.get());
diff --git a/test/unit/filters/FerryFilterTest.cpp b/test/unit/filters/FerryFilterTest.cpp
index bcd9ca8d2f..6ed49eb3a7 100644
--- a/test/unit/filters/FerryFilterTest.cpp
+++ b/test/unit/filters/FerryFilterTest.cpp
@@ -78,7 +78,7 @@ TEST(FerryFilterTest, test_ferry_invalid)
     Options ops1;
     ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.las"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.las"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops1);
 
@@ -91,7 +91,7 @@ TEST(FerryFilterTest, test_ferry_invalid)
     x.setOptions(xO);
     options.add(x);
 
-    FilterPtr ferry(f.createFilter("filters.ferry"));
+    std::unique_ptr<Stage> ferry(f.createStage("filters.ferry"));
     EXPECT_TRUE(ferry.get());
     ferry->setInput(reader.get());
     ferry->setOptions(options);
diff --git a/test/unit/filters/RangeFilterTest.cpp b/test/unit/filters/RangeFilterTest.cpp
index 05dcf07ee6..2687167dbb 100644
--- a/test/unit/filters/RangeFilterTest.cpp
+++ b/test/unit/filters/RangeFilterTest.cpp
@@ -40,17 +40,17 @@
 
 using namespace pdal;
 
-TEST(RangeFilterTest, createFilter)
+TEST(RangeFilterTest, createStage)
 {
     StageFactory f;
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     EXPECT_TRUE(filter.get());
 }
 
 TEST(RangeFilterTest, noDimension)
 {
     StageFactory f;
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
 
     PointContext ctx;
     EXPECT_THROW(filter->prepare(ctx), pdal_error);
@@ -62,7 +62,7 @@ TEST(RangeFilterTest, noRange)
     rangeOps.add("dimension", "Z");
     
     StageFactory f;
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
 
     PointContext ctx;
@@ -79,7 +79,7 @@ TEST(RangeFilterTest, singleDimension)
     ops.add("num_points", 10);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options range;
@@ -92,7 +92,7 @@ TEST(RangeFilterTest, singleDimension)
     Options rangeOps;
     rangeOps.add(dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
@@ -118,7 +118,7 @@ TEST(RangeFilterTest, multipleDimensions)
     ops.add("num_points", 10);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options y_range;
@@ -139,7 +139,7 @@ TEST(RangeFilterTest, multipleDimensions)
     rangeOps.add(y_dim);
     rangeOps.add(z_dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
@@ -168,7 +168,7 @@ TEST(RangeFilterTest, onlyMin)
     ops.add("num_points", 10);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options range;
@@ -180,7 +180,7 @@ TEST(RangeFilterTest, onlyMin)
     Options rangeOps;
     rangeOps.add(dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
@@ -208,7 +208,7 @@ TEST(RangeFilterTest, onlyMax)
     ops.add("num_points", 10);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options range;
@@ -220,7 +220,7 @@ TEST(RangeFilterTest, onlyMax)
     Options rangeOps;
     rangeOps.add(dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
@@ -248,7 +248,7 @@ TEST(RangeFilterTest, equals)
     ops.add("num_points", 10);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options range;
@@ -260,7 +260,7 @@ TEST(RangeFilterTest, equals)
     Options rangeOps;
     rangeOps.add(dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
@@ -284,7 +284,7 @@ TEST(RangeFilterTest, negativeValues)
     ops.add("num_points", 21);
 
     StageFactory f;
-    std::unique_ptr<Reader> reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     reader->setOptions(ops);
 
     Options range;
@@ -297,7 +297,7 @@ TEST(RangeFilterTest, negativeValues)
     Options rangeOps;
     rangeOps.add(dim);
     
-    std::unique_ptr<Filter> filter(f.createFilter("filters.range"));
+    std::unique_ptr<Stage> filter(f.createStage("filters.range"));
     filter->setOptions(rangeOps);
     filter->setInput(reader.get());
 
diff --git a/test/unit/filters/SplitterTest.cpp b/test/unit/filters/SplitterTest.cpp
index 18f225b748..f0c84bd647 100644
--- a/test/unit/filters/SplitterTest.cpp
+++ b/test/unit/filters/SplitterTest.cpp
@@ -47,7 +47,7 @@ TEST(SplitterTest, test_tile_filter)
     // create the reader
     Options ops1;
     ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
-    ReaderPtr r(f.createReader("readers.las"));
+    std::unique_ptr<Stage> r(f.createStage("readers.las"));
     EXPECT_TRUE(r.get());
     r->setOptions(ops1);
 
@@ -56,7 +56,7 @@ TEST(SplitterTest, test_tile_filter)
     o.add(length);
 
     // create the tile filter and prepare
-    FilterPtr s(f.createFilter("filters.splitter"));
+    std::unique_ptr<Stage> s(f.createStage("filters.splitter"));
     EXPECT_TRUE(s.get());
     s->setOptions(o);
     s->setInput(r.get());
diff --git a/test/unit/filters/StatsFilterTest.cpp b/test/unit/filters/StatsFilterTest.cpp
index e4cd1e6bdf..11f23c46b6 100644
--- a/test/unit/filters/StatsFilterTest.cpp
+++ b/test/unit/filters/StatsFilterTest.cpp
@@ -50,7 +50,7 @@ TEST(StatsFilterTest, simple)
     ops.add("mode", "constant");
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops);
 
@@ -92,7 +92,7 @@ TEST(StatsFilterTest, dimset)
     ops.add("mode", "constant");
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops);
 
@@ -134,7 +134,7 @@ TEST(StatsFilterTest, metadata)
     ops.add("mode", "constant");
 
     StageFactory f;
-    ReaderPtr reader(f.createReader("readers.faux"));
+    std::unique_ptr<Stage> reader(f.createStage("readers.faux"));
     EXPECT_TRUE(reader.get());
     reader->setOptions(ops);
 
diff --git a/test/unit/filters/TransformationFilterTest.cpp b/test/unit/filters/TransformationFilterTest.cpp
index e82d903549..378785d691 100644
--- a/test/unit/filters/TransformationFilterTest.cpp
+++ b/test/unit/filters/TransformationFilterTest.cpp
@@ -48,8 +48,8 @@ class TransformationFilterTest : public ::testing::Test
 
     TransformationFilterTest()
         : factory()
-        , reader(factory.createReader("readers.faux"))
-        , filter(factory.createFilter("filters.transformation"))
+        , reader(factory.createStage("readers.faux"))
+        , filter(factory.createStage("filters.transformation"))
     {}
 
     virtual void SetUp()
@@ -67,8 +67,8 @@ class TransformationFilterTest : public ::testing::Test
     }
 
     StageFactory factory;
-    ReaderPtr reader;
-    FilterPtr filter;
+    std::unique_ptr<Stage> reader;
+    std::unique_ptr<Stage> filter;
 
 };
 
diff --git a/test/unit/io/faux/FauxReaderTest.cpp b/test/unit/io/faux/FauxReaderTest.cpp
index 56c53624d6..7a37d46a49 100644
--- a/test/unit/io/faux/FauxReaderTest.cpp
+++ b/test/unit/io/faux/FauxReaderTest.cpp
@@ -51,7 +51,7 @@ TEST(FauxReaderTest, test_constant_mode_sequential_iter)
 
     PointContext ctx;
     reader.prepare(ctx);
-    EXPECT_EQ(reader.getDescription(), "Faux Reader");
+    //EXPECT_EQ(reader.getDescription(), "Faux Reader");
     PointBufferSet pbSet = reader.execute(ctx);
     EXPECT_EQ(pbSet.size(), 1u);
     PointBufferPtr buf = *pbSet.begin();
diff --git a/test/unit/io/qfit/QFITReaderTest.cpp b/test/unit/io/qfit/QFITReaderTest.cpp
index 0fb8178a31..27c6d78958 100644
--- a/test/unit/io/qfit/QFITReaderTest.cpp
+++ b/test/unit/io/qfit/QFITReaderTest.cpp
@@ -76,7 +76,7 @@ TEST(QFITReaderTest, test_10_word)
 
     QfitReader reader;
     reader.setOptions(options);
-    EXPECT_TRUE(reader.getDescription() == "QFIT Reader");
+    //EXPECT_TRUE(reader.getDescription() == "QFIT Reader");
     EXPECT_EQ(reader.getName(), "readers.qfit");
 
     PointContext ctx;
diff --git a/test/unit/io/sbet/SbetWriterTest.cpp b/test/unit/io/sbet/SbetWriterTest.cpp
index e2f1e2f0f9..4ce426d555 100644
--- a/test/unit/io/sbet/SbetWriterTest.cpp
+++ b/test/unit/io/sbet/SbetWriterTest.cpp
@@ -66,7 +66,7 @@ TEST(SbetWriterTest, testConstructor)
     writer.setOptions(makeWriterOptions());
     writer.setInput(&reader);
 
-    EXPECT_TRUE(writer.getDescription() == "SBET Writer");
+    //EXPECT_TRUE(writer.getDescription() == "SBET Writer");
     EXPECT_EQ(writer.getName(), "writers.sbet");
 }