From ab011cfdc6531b844dc38e14ed01c250cd11d262 Mon Sep 17 00:00:00 2001
From: Bradley J Chambers <brad.chambers@gmail.com>
Date: Tue, 3 Feb 2015 16:01:04 -0500
Subject: [PATCH] Plugin framework refactoring

This commit adds a new PluginManager that controls loading of all plugins,
regardless of type (kernel vs. stage, static vs. shared). Subsequently, the
StageFactory and KernelFactory classes are greatly simplified as there was
significant redundant code. Macros are provided to simplify creation of each
type of plugin, but are not explicitly required. Each plugin registers it's
name, description, link, type, and will soon include a version.

Dropped program_options in pdal.cpp and added ability to selectively load
plugin types (or none at all).
---
 apps/pdal.cpp                                 | 299 ++++++++++----
 cmake/compiler_options.cmake                  |   6 +
 doc/tutorial/writing.rst                      |  14 -
 examples/writing/tutorial.cpp                 |   2 +-
 filters/chipper/ChipperFilter.cpp             |   8 +
 filters/chipper/ChipperFilter.hpp             |  19 +-
 filters/colorization/ColorizationFilter.cpp   |  16 +-
 filters/colorization/ColorizationFilter.hpp   |  20 +-
 filters/crop/CropFilter.cpp                   |  10 +
 filters/crop/CropFilter.hpp                   |  15 +-
 filters/decimation/DecimationFilter.cpp       |  13 +-
 filters/decimation/DecimationFilter.hpp       |  12 +-
 filters/ferry/FerryFilter.cpp                 |  15 +-
 filters/ferry/FerryFilter.hpp                 |  18 +-
 filters/merge/CMakeLists.txt                  |  12 +-
 filters/merge/MergeFilter.cpp                 |  50 +++
 filters/merge/MergeFilter.hpp                 |  14 +-
 filters/mortonorder/MortonOrderFilter.cpp     |  12 +-
 filters/mortonorder/MortonOrderFilter.hpp     |  16 +-
 filters/range/RangeFilter.cpp                 |   8 +
 filters/range/RangeFilter.hpp                 |  12 +-
 filters/reprojection/ReprojectionFilter.cpp   |  15 +-
 filters/reprojection/ReprojectionFilter.hpp   |  11 +-
 filters/sort/CMakeLists.txt                   |  12 +-
 filters/sort/SortFilter.cpp                   |  50 +++
 filters/sort/SortFilter.hpp                   |  11 +-
 filters/splitter/SplitterFilter.cpp           |  15 +-
 filters/splitter/SplitterFilter.hpp           |  13 +-
 filters/stats/StatsFilter.cpp                 |  15 +-
 filters/stats/StatsFilter.hpp                 |  13 +-
 .../transformation/TransformationFilter.cpp   |  12 +-
 .../transformation/TransformationFilter.hpp   |  12 +-
 include/pdal/BufferReader.hpp                 |   5 +-
 include/pdal/Drivers.hpp                      |  54 ---
 include/pdal/Filter.hpp                       |   2 -
 include/pdal/Filters.hpp                      |  49 ---
 include/pdal/Kernel.hpp                       |  49 ++-
 include/pdal/KernelFactory.hpp                |  48 +--
 include/pdal/KernelInfo.hpp                   |  99 -----
 include/pdal/KernelSupport.hpp                |   3 +-
 include/pdal/Kernels.hpp                      |  44 ---
 include/pdal/PipelineManager.hpp              |  10 +-
 include/pdal/PipelineReader.hpp               |   6 +-
 include/pdal/PluginManager.hpp                |  58 +++
 include/pdal/Reader.hpp                       |   2 -
 include/pdal/Stage.hpp                        |  24 +-
 include/pdal/StageFactory.hpp                 |  70 +---
 include/pdal/StageInfo.hpp                    | 175 ---------
 include/pdal/Writer.hpp                       |  14 +-
 include/pdal/pdal_macros.hpp                  | 147 +++----
 include/pdal/plugin.h                         |  54 +++
 io/bpf/BpfReader.cpp                          |  16 +-
 io/bpf/BpfReader.hpp                          |  18 +-
 io/bpf/BpfWriter.cpp                          |  18 +-
 io/bpf/BpfWriter.hpp                          |  20 +-
 io/faux/FauxReader.cpp                        |  23 +-
 io/faux/FauxReader.hpp                        |  13 +-
 io/las/LasReader.cpp                          |  19 +-
 io/las/LasReader.hpp                          |  19 +-
 io/las/LasWriter.cpp                          |  11 +
 io/las/LasWriter.hpp                          |  14 +-
 io/qfit/QfitReader.cpp                        |  15 +-
 io/qfit/QfitReader.hpp                        |  13 +-
 io/sbet/SbetReader.cpp                        |   9 +
 io/sbet/SbetReader.hpp                        |  13 +-
 io/sbet/SbetWriter.cpp                        |   9 +
 io/sbet/SbetWriter.hpp                        |  11 +-
 io/terrasolid/TerrasolidReader.cpp            |   9 +
 io/terrasolid/TerrasolidReader.hpp            |  15 +-
 io/text/TextWriter.cpp                        |  16 +-
 io/text/TextWriter.hpp                        |  22 +-
 kernels/delta/DeltaKernel.cpp                 |   9 +-
 kernels/delta/DeltaKernel.hpp                 |  14 +-
 kernels/diff/DiffKernel.cpp                   |  12 +-
 kernels/diff/DiffKernel.hpp                   |  14 +-
 kernels/info/InfoKernel.cpp                   |  11 +-
 kernels/info/InfoKernel.hpp                   |  20 +-
 kernels/pipeline/PipelineKernel.cpp           |  11 +-
 kernels/pipeline/PipelineKernel.hpp           |  13 +-
 kernels/random/RandomKernel.cpp               |  13 +-
 kernels/random/RandomKernel.hpp               |  11 +-
 kernels/sort/SortKernel.cpp                   |  14 +-
 kernels/sort/SortKernel.hpp                   |  11 +-
 kernels/translate/TranslateKernel.cpp         |  21 +-
 kernels/translate/TranslateKernel.hpp         |  11 +-
 pdal_defines.h.in                             |   2 +
 plugins/CMakeLists.txt                        |   7 +-
 plugins/attribute/filters/AttributeFilter.cpp |  10 +-
 plugins/attribute/filters/AttributeFilter.hpp |  13 +-
 plugins/cpd/kernel/Cpd.cpp                    |  16 +-
 plugins/cpd/kernel/Cpd.hpp                    |   8 +-
 plugins/cpd/test/CpdKernelTest.cpp            |  16 +-
 plugins/greyhound/io/GreyhoundReader.cpp      |  11 +-
 plugins/greyhound/io/GreyhoundReader.hpp      |   8 +-
 plugins/hexbin/filters/HexBin.cpp             |   9 +-
 plugins/hexbin/filters/HexBin.hpp             |   8 +-
 plugins/hexbin/test/HexbinFilterTest.cpp      |   4 +-
 plugins/icebridge/io/IcebridgeReader.cpp      |  13 +-
 plugins/icebridge/io/IcebridgeReader.hpp      |  11 +-
 .../icebridge/test/IcebridgeReaderTest.cpp    |   2 +-
 plugins/mrsid/io/MrsidReader.cpp              |  11 +-
 plugins/mrsid/io/MrsidReader.hpp              |  10 +-
 plugins/nitf/io/NitfReader.cpp                |  11 +-
 plugins/nitf/io/NitfReader.hpp                |   8 +-
 plugins/nitf/io/NitfWriter.cpp                |  10 +-
 plugins/nitf/io/NitfWriter.hpp                |   8 +-
 plugins/nitf/test/NitfReaderTest.cpp          |  10 +-
 plugins/nitf/test/NitfWriterTest.cpp          |   4 +-
 plugins/oci/io/OciReader.cpp                  |  11 +-
 plugins/oci/io/OciReader.hpp                  |  10 +-
 plugins/oci/io/OciWriter.cpp                  |  11 +-
 plugins/oci/io/OciWriter.hpp                  |  10 +-
 plugins/oci/test/OCITest.cpp                  |   8 +-
 plugins/p2g/io/P2gWriter.cpp                  |  10 +-
 plugins/p2g/io/P2gWriter.hpp                  |  10 +-
 plugins/pcl/CMakeLists.txt                    |   1 +
 plugins/pcl/filters/GroundFilter.cpp          |  12 +-
 plugins/pcl/filters/GroundFilter.hpp          |   8 +-
 plugins/pcl/filters/PCLBlock.cpp              |  30 +-
 plugins/pcl/filters/PCLBlock.hpp              |  12 +-
 plugins/pcl/io/PCLVisualizer.cpp              |  22 +-
 plugins/pcl/io/PCLVisualizer.hpp              |   8 +-
 plugins/pcl/io/PcdReader.cpp                  |  11 +-
 plugins/pcl/io/PcdReader.hpp                  |   8 +-
 plugins/pcl/io/PcdWriter.cpp                  |  10 +-
 plugins/pcl/io/PcdWriter.hpp                  |  10 +-
 plugins/pcl/kernel/GroundKernel.cpp           |  18 +-
 plugins/pcl/kernel/GroundKernel.hpp           |  12 +-
 plugins/pcl/kernel/PCLKernel.cpp              |  18 +-
 plugins/pcl/kernel/PCLKernel.hpp              |   7 +-
 plugins/pcl/kernel/SmoothKernel.cpp           |  17 +-
 plugins/pcl/kernel/SmoothKernel.hpp           |  11 +-
 plugins/pcl/kernel/ViewKernel.cpp             |  10 +-
 plugins/pcl/kernel/ViewKernel.hpp             |  11 +-
 plugins/pcl/test/PCLBlockFilterTest.cpp       |  18 +-
 plugins/pgpointcloud/io/PgReader.cpp          |  12 +-
 plugins/pgpointcloud/io/PgReader.hpp          |  11 +-
 plugins/pgpointcloud/io/PgWriter.cpp          |  16 +-
 plugins/pgpointcloud/io/PgWriter.hpp          |  11 +-
 .../test/PgpointcloudWriterTest.cpp           |  10 +-
 plugins/python/filters/PredicateFilter.cpp    |  11 +-
 plugins/python/filters/PredicateFilter.hpp    |  10 +-
 plugins/python/filters/ProgrammableFilter.cpp |  11 +-
 plugins/python/filters/ProgrammableFilter.hpp |  10 +-
 plugins/python/test/PredicateFilterTest.cpp   |  22 +-
 .../python/test/ProgrammableFilterTest.cpp    |   8 +-
 plugins/rxp/io/RxpReader.cpp                  |  12 +-
 plugins/rxp/io/RxpReader.hpp                  |  10 +-
 plugins/sqlite/io/SQLiteReader.cpp            |  11 +-
 plugins/sqlite/io/SQLiteReader.hpp            |   9 +-
 plugins/sqlite/io/SQLiteWriter.cpp            |  11 +-
 plugins/sqlite/io/SQLiteWriter.hpp            |   7 +-
 plugins/sqlite/test/SQLiteTest.cpp            |   6 +-
 src/CMakeLists.txt                            |   9 +-
 src/DynamicLibrary.cpp                        |  83 ++++
 src/DynamicLibrary.h                          |  29 ++
 src/Kernel.cpp                                |  58 ++-
 src/KernelFactory.cpp                         | 141 +++----
 src/KernelInfo.cpp                            |  80 ----
 src/KernelSupport.cpp                         |   6 +-
 src/PipelineManager.cpp                       |  19 +-
 src/PipelineReader.cpp                        |  18 +-
 src/PluginManager.cpp                         | 307 +++++++++++++++
 src/Stage.cpp                                 |  13 +-
 src/StageFactory.cpp                          | 366 ++++++------------
 src/StageInfo.cpp                             | 159 --------
 test/unit/LogTest.cpp                         |  18 +-
 test/unit/OptionsTest.cpp                     |  22 +-
 test/unit/PipelineManagerTest.cpp             |  10 +-
 test/unit/filters/CropFilterTest.cpp          |  14 +-
 test/unit/filters/DecimationFilterTest.cpp    |   4 +-
 test/unit/filters/FerryFilterTest.cpp         |   4 +-
 test/unit/filters/RangeFilterTest.cpp         |  32 +-
 test/unit/filters/SplitterTest.cpp            |   4 +-
 test/unit/filters/StatsFilterTest.cpp         |   6 +-
 .../unit/filters/TransformationFilterTest.cpp |   8 +-
 test/unit/io/faux/FauxReaderTest.cpp          |   2 +-
 test/unit/io/qfit/QFITReaderTest.cpp          |   2 +-
 test/unit/io/sbet/SbetWriterTest.cpp          |   2 +-
 179 files changed, 2314 insertions(+), 2005 deletions(-)
 create mode 100644 filters/merge/MergeFilter.cpp
 create mode 100644 filters/sort/SortFilter.cpp
 delete mode 100644 include/pdal/Drivers.hpp
 delete mode 100644 include/pdal/Filters.hpp
 delete mode 100644 include/pdal/KernelInfo.hpp
 delete mode 100644 include/pdal/Kernels.hpp
 create mode 100644 include/pdal/PluginManager.hpp
 delete mode 100644 include/pdal/StageInfo.hpp
 create mode 100644 include/pdal/plugin.h
 create mode 100755 src/DynamicLibrary.cpp
 create mode 100755 src/DynamicLibrary.h
 delete mode 100644 src/KernelInfo.cpp
 create mode 100644 src/PluginManager.cpp
 delete mode 100644 src/StageInfo.cpp

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");
 }