diff --git a/CMakeLists.txt b/CMakeLists.txt
index 912c081..55c2e50 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,17 +18,35 @@ if(NOT SC_PATH)
   message(FATAL_ERROR "SuperCollider source path is not set")
 endif()
 
-set(FLUID_PATH "" CACHE PATH "Optional path to the flucoma-core repo")
+set(FLUID_PATH "" CACHE PATH "Optional path to the Fluid Decomposition repo")
 
 if (APPLE)
-	set(CMAKE_OSX_ARCHITECTURES x86_64)
   set(CMAKE_XCODE_GENERATE_SCHEME ON)
-  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.8)
+	set(CMAKE_OSX_ARCHITECTURES "x86_64" CACHE STRING "")
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "10.8" CACHE STRING "")
+  #A consequence of targetting 10.8. Needs to be set globally from 10.15 onwards in order for the test program to compile successfully during configure 
+  string(APPEND CMAKE_CXX_FLAGS " -stdlib=libc++")
 endif()
 
 ################################################################################
 # Main project
 project (flucoma-sc LANGUAGES CXX)
+
+if(NOT MSVC)
+  add_compile_options(-fdiagnostics-color=always)
+endif() 
+
+#set correct std lib linking for Windows (in CMake 3.15 this has a native function)
+if(MSVC) #needs to be after project()
+  foreach(flag_var
+      CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+      CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    if(${flag_var} MATCHES "/MD")
+      string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+    endif()
+  endforeach()
+endif()
+
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 set(CMAKE_XCODE_GENERATE_TOP_LEVEL_PROJECT_ONLY ON)
 
@@ -74,6 +92,8 @@ set_if_toplevel(VAR CMAKE_LIBRARY_OUTPUT_DIRECTORY
 
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_TEST "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
 set(CMAKE_SHARED_MODULE_PREFIX "")
 
 if(APPLE OR WIN32)
@@ -83,7 +103,36 @@ endif()
 #needed for complaint-free static linking with GCC
 if(CMAKE_COMPILER_IS_GNUCXX)
   target_compile_options( HISSTools_FFT PUBLIC -fPIC )
-ENDIF()
+endif()
+
+#sandbox regrettable dependency on SC internals for SendReply()
+add_library(FLUID_SC_COPYREPLYADDR STATIC
+  "${CMAKE_SOURCE_DIR}/include/wrapper/CopyReplyAddress.cpp"
+  "${SC_PATH}/common/SC_Reply.cpp"
+  "${SC_PATH}/external_libraries/boost/libs/system/src/error_code.cpp"
+)
+
+target_include_directories(FLUID_SC_COPYREPLYADDR SYSTEM PRIVATE 
+  "${SC_PATH}/include/plugin_interface"
+  "${SC_PATH}/include/common"
+  "${SC_PATH}/common"
+  "${SC_PATH}/external_libraries/boost"
+)
+set_target_properties(FLUID_SC_COPYREPLYADDR PROPERTIES
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS NO
+)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+  target_compile_options(FLUID_SC_COPYREPLYADDR PUBLIC -fPIC )
+endif()
+
+if(APPLE)
+  target_compile_options(FLUID_SC_COPYREPLYADDR PRIVATE -stdlib=libc++)
+endif()
+
+target_compile_definitions(FLUID_SC_COPYREPLYADDR PRIVATE BOOST_ALL_NO_LIB  BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
 
 add_library(FLUID_SC_WRAPPER INTERFACE)
 target_include_directories(FLUID_SC_WRAPPER 
@@ -97,6 +146,8 @@ target_sources(FLUID_SC_WRAPPER
   "${CMAKE_CURRENT_SOURCE_DIR}/include/SCBufferAdaptor.hpp"
 )
 
+target_link_libraries(FLUID_SC_WRAPPER INTERFACE FLUID_SC_COPYREPLYADDR)
+
 SUBDIRLIST(PROJECT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
 foreach (project_dir ${PROJECT_DIRS})
 	if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/${project_dir}/CMakeLists.txt")
@@ -105,6 +156,8 @@ foreach (project_dir ${PROJECT_DIRS})
 	endif ()
 endforeach ()
 
+
+
 #install bits. 
 
 set(SC_INSTALL_PREFIX "." CACHE PATH "Prefix for assembling SC packages")
diff --git a/include/FluidSCWrapper.hpp b/include/FluidSCWrapper.hpp
index 0df8bc3..226bddb 100644
--- a/include/FluidSCWrapper.hpp
+++ b/include/FluidSCWrapper.hpp
@@ -11,541 +11,42 @@ under the European Union’s Horizon 2020 research and innovation programme
 #pragma once
 
 #include "SCBufferAdaptor.hpp"
-#include <clients/common/FluidBaseClient.hpp>
-#include <clients/common/Result.hpp>
-#include <data/FluidTensor.hpp>
-#include <data/TensorTypes.hpp>
+#include "wrapper/DeriveBaseClass.hpp"
+#include "wrapper/NonRealtime.hpp"
+#include "wrapper/Realtime.hpp"
 #include <FluidVersion.hpp>
-#include <SC_PlugIn.hpp>
-#include <algorithm>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
 
 namespace fluid {
 namespace client {
 
-template <typename Client>
-class FluidSCWrapper;
-
-namespace impl {
-
-// Iterate over kr/ir inputs via callbacks from params object
-struct FloatControlsIter
-{
-  FloatControlsIter(float** vals, index N) : mValues(vals), mSize(N) {}
-
-  float next() { return mCount >= mSize ? 0 : *mValues[mCount++]; }
-
-  void reset(float** vals)
-  {
-    mValues = vals;
-    mCount = 0;
-  }
-
-  index size() const noexcept { return mSize; }
-
-private:
-  float** mValues;
-  index   mSize;
-  index   mCount{0};
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Real Time Processor
-
-template <typename Client, class Wrapper>
-class RealTime : public SCUnit
-{
-  using HostVector = FluidTensorView<float, 1>;
-  using ParamSetType = typename Client::ParamSetType;
-
-public:
-  static void setup(InterfaceTable* ft, const char* name)
-  {
-    registerUnit<Wrapper>(ft, name);
-    ft->fDefineUnitCmd(name, "latency", doLatency);
-  }
-
-  static void doLatency(Unit* unit, sc_msg_iter*)
-  {
-    float l[]{
-        static_cast<float>(static_cast<Wrapper*>(unit)->mClient.latency())};
-    auto ft = Wrapper::getInterfaceTable();
-
-    std::stringstream ss;
-    ss << '/' << Wrapper::getName() << "_latency";
-    std::cout << ss.str() << std::endl;
-    ft->fSendNodeReply(&unit->mParent->mNode, -1, ss.str().c_str(), 1, l);
-  }
-
-  RealTime()
-      : mControlsIterator{mInBuf + mSpecialIndex + 1,
-                          static_cast<index>(mNumInputs) - mSpecialIndex - 1},
-        mParams{Wrapper::Client::getParameterDescriptors()},
-        mClient{Wrapper::setParams(mParams, mWorld->mVerbosity > 0, mWorld,
-                                   mControlsIterator, true)}
-  {}
-
-  void init()
-  {
-    assert(
-        !(mClient.audioChannelsOut() > 0 && mClient.controlChannelsOut() > 0) &&
-        "Client can't have both audio and control outputs");
-
-    // If we don't the number of arguments we expect, the language side code is
-    // probably the wrong version set plugin to no-op, squawk, and bail;
-    if (mControlsIterator.size() != Client::getParameterDescriptors().count())
-    {
-      mCalcFunc = Wrapper::getInterfaceTable()->fClearUnitOutputs;
-      std::cout
-          << "ERROR: " << Wrapper::getName()
-          << " wrong number of arguments. Expected "
-          << Client::getParameterDescriptors().count() << ", got "
-          << mControlsIterator.size()
-          << ". Your .sc file and binary plugin might be different versions."
-          << std::endl;
-      return;
-    }
-
-    mClient.sampleRate(fullSampleRate());
-    mInputConnections.reserve(asUnsigned(mClient.audioChannelsIn()));
-    mOutputConnections.reserve(asUnsigned(mClient.audioChannelsOut()));
-    mAudioInputs.reserve(asUnsigned(mClient.audioChannelsIn()));
-    mOutputs.reserve(asUnsigned(
-        std::max(mClient.audioChannelsOut(), mClient.controlChannelsOut())));
-
-    for (index i = 0; i < mClient.audioChannelsIn(); ++i)
-    {
-      mInputConnections.emplace_back(isAudioRateIn(static_cast<int>(i)));
-      mAudioInputs.emplace_back(nullptr, 0, 0);
-    }
-
-    for (index i = 0; i < mClient.audioChannelsOut(); ++i)
-    {
-      mOutputConnections.emplace_back(true);
-      mOutputs.emplace_back(nullptr, 0, 0);
-    }
-
-    for (index i = 0; i < mClient.controlChannelsOut(); ++i)
-    { mOutputs.emplace_back(nullptr, 0, 0); }
-
-    mCalcFunc = make_calc_function<RealTime, &RealTime::next>();
-    Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
-  }
-
-  void next(int)
-  {
-    mControlsIterator.reset(mInBuf + 1); // mClient.audioChannelsIn());
-    Wrapper::setParams(
-        mParams, mWorld->mVerbosity > 0, mWorld,
-        mControlsIterator); // forward on inputs N + audio inputs as params
-    mParams.constrainParameterValues();
-    const Unit* unit = this;
-    for (index i = 0; i < mClient.audioChannelsIn(); ++i)
-    {
-      if (mInputConnections[asUnsigned(i)])
-      { mAudioInputs[asUnsigned(i)].reset(IN(i), 0, fullBufferSize()); }
-    }
-    for (index i = 0; i < mClient.audioChannelsOut(); ++i)
-    {
-      assert(i <= std::numeric_limits<int>::max());
-      if (mOutputConnections[asUnsigned(i)])
-        mOutputs[asUnsigned(i)].reset(out(static_cast<int>(i)), 0,
-                                      fullBufferSize());
-    }
-    for (index i = 0; i < mClient.controlChannelsOut(); ++i)
-    {
-      assert(i <= std::numeric_limits<int>::max());
-      mOutputs[asUnsigned(i)].reset(out(static_cast<int>(i)), 0, 1);
-    }
-    mClient.process(mAudioInputs, mOutputs, mContext);
-  }
-
-private:
-  std::vector<bool>       mInputConnections;
-  std::vector<bool>       mOutputConnections;
-  std::vector<HostVector> mAudioInputs;
-  std::vector<HostVector> mOutputs;
-  FloatControlsIter       mControlsIterator;
-  FluidContext            mContext;
-
-protected:
-  ParamSetType mParams;
-  Client       mClient;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Non Real Time Processor
-/// This is also a UGen, but the main action is delegated off to a worker
-/// thread, via the NRT thread. The RT bit is there to allow us (a) to poll our
-/// thread and (b) emit a kr progress update
-template <typename Client, typename Wrapper>
-class NonRealTime : public SCUnit
-{
-  using ParamSetType = typename Client::ParamSetType;
-
-public:
-  static void setup(InterfaceTable* ft, const char* name)
-  {
-    registerUnit<Wrapper>(ft, name);
-    ft->fDefineUnitCmd(name, "cancel", doCancel);
-    ft->fDefineUnitCmd(
-        name, "queue_enabled", [](struct Unit* unit, struct sc_msg_iter* args) {
-          auto w = static_cast<Wrapper*>(unit);
-          w->mQueueEnabled = args->geti(0);
-          w->mFifoMsg.Set(
-              w->mWorld,
-              [](FifoMsg* f) {
-                auto w = static_cast<Wrapper*>(f->mData);
-                w->mClient.setQueueEnabled(w->mQueueEnabled);
-              },
-              nullptr, w);
-          Wrapper::getInterfaceTable()->fSendMsgFromRT(w->mWorld, w->mFifoMsg);
-        });
-    ft->fDefineUnitCmd(
-        name, "synchronous", [](struct Unit* unit, struct sc_msg_iter* args) {
-          auto w = static_cast<Wrapper*>(unit);
-          w->mSynchronous = args->geti(0);
-          w->mFifoMsg.Set(
-              w->mWorld,
-              [](FifoMsg* f) {
-                auto w = static_cast<Wrapper*>(f->mData);
-                w->mClient.setSynchronous(w->mSynchronous);
-              },
-              nullptr, w);
-          Wrapper::getInterfaceTable()->fSendMsgFromRT(w->mWorld, w->mFifoMsg);
-        });
-  }
-
-  /// Penultimate input is the doneAction, final is blocking mode. Neither are
-  /// params, so we skip them in the controlsIterator
-  NonRealTime()
-      : mControlsIterator{mInBuf, index(mNumInputs) - mSpecialIndex - 2},
-        mParams{Wrapper::Client::getParameterDescriptors()},
-        mClient{Wrapper::setParams(mParams, mWorld->mVerbosity > 0, mWorld,
-                                   mControlsIterator, true)},
-        mSynchronous{mNumInputs > 2 ? (in0(int(mNumInputs) - 1) > 0) : false}
-  {}
-
-  ~NonRealTime()
-  {
-    if (mClient.state() == ProcessState::kProcessing)
-    {
-      std::cout << Wrapper::getName() << ": Processing cancelled" << std::endl;
-      Wrapper::getInterfaceTable()->fSendNodeReply(&mParent->mNode, 1, "/done",
-                                                   0, nullptr);
-    }
-    // processing will be cancelled in ~NRTThreadAdaptor()
-  }
-
-
-  /// No option of not using a worker thread for now
-  /// init() sets up the NRT process via the SC NRT thread, and then sets our
-  /// UGen calc function going
-  void init()
-  {
-    mFifoMsg.Set(mWorld, initNRTJob, nullptr, this);
-    mWorld->ft->fSendMsgFromRT(mWorld, mFifoMsg);
-    // we want to poll thread roughly every 20ms
-    checkThreadInterval = static_cast<index>(0.02 / controlDur());
-    set_calc_function<NonRealTime, &NonRealTime::poll>();
-  };
-
-  /// The calc function. Checks to see if we've cancelled, spits out progress,
-  /// launches tidy up when complete
-  void poll(int)
-  {
-    out0(0) = mDone ? 1.0f : static_cast<float>(mClient.progress());
-
-    if (0 == pollCounter++ && !mCheckingForDone)
-    {
-      mCheckingForDone = true;
-      mWorld->ft->fDoAsynchronousCommand(mWorld, nullptr, Wrapper::getName(),
-                                         this, postProcess, exchangeBuffers,
-                                         tidyUp, destroy, 0, nullptr);
-    }
-    pollCounter %= checkThreadInterval;
-  }
-
-
-  /// To be called on NRT thread. Validate parameters and commence processing in
-  /// new thread
-  static void initNRTJob(FifoMsg* f)
-  {
-    auto w = static_cast<Wrapper*>(f->mData);
-    w->mDone = false;
-    w->mCancelled = false;
-
-    Result result = validateParameters(w);
-
-    if (!result.ok())
-    {
-      std::cout << "ERROR: " << Wrapper::getName() << ": "
-                << result.message().c_str() << std::endl;
-      return;
-    }
-    w->mClient.setSynchronous(w->mSynchronous);
-    w->mClient.enqueue(w->mParams);
-    w->mResult = w->mClient.process();
-  }
-
-  /// Check result and report if bad
-  static bool postProcess(World*, void* data)
-  {
-    auto         w = static_cast<Wrapper*>(data);
-    Result       r;
-    ProcessState s = w->mClient.checkProgress(r);
-
-    if(w->mSynchronous) r = w->mResult;
-
-    if ((s == ProcessState::kDone || s == ProcessState::kDoneStillProcessing) ||
-        (w->mSynchronous &&
-         s == ProcessState::kNoProcess)) // I think this hinges on the fact that
-                                         // when mSynchrous = true, this call
-                                         // will always be behind process() on
-                                         // the command FIFO, so we can assume
-                                         // that if the state is kNoProcess, it
-                                         // has run (vs never having run)
-    {
-      // Given that cancellation from the language now always happens by freeing
-      // the synth, this block isn't reached normally. HOwever, if someone
-      // cancels using u_cmd, this is what will fire
-      if (r.status() == Result::Status::kCancelled)
-      {
-        std::cout << Wrapper::getName() << ": Processing cancelled" << std::endl;
-        w->mCancelled = true;
-        return false;
-      }
-
-      if (!r.ok())
-      {
-        std::cout << "ERROR: " << Wrapper::getName() << ": "
-                  << r.message().c_str() << std::endl;
-        return false;
-      }
-
-      w->mDone = true;
-      return true;
-    }
-    return false;
-  }
-
-  /// swap NRT buffers back to RT-land
-  static bool exchangeBuffers(World* world, void* data)
-  {
-    return static_cast<Wrapper*>(data)->exchangeBuffers(world);
-  }
-  /// Tidy up any temporary buffers
-  static bool tidyUp(World* world, void* data)
-  {
-    return static_cast<Wrapper*>(data)->tidyUp(world);
-  }
-
-  /// Now we're actually properly done, call the UGen's done action (possibly
-  /// destroying this instance)
-  static void destroy(World* world, void* data)
-  {
-    auto w = static_cast<Wrapper*>(data);
-    if (w->mDone &&
-        w->mNumInputs >
-            2) // don't check for doneAction if UGen has no ins (there should be
-               // 3 minimum -> sig, doneAction, blocking mode)
-    {
-      int doneAction = static_cast<int>(
-          w->in0(int(w->mNumInputs) -
-                 2)); // doneAction is penultimate input; THIS IS THE LAW
-      world->ft->fDoneAction(doneAction, w);
-      return;
-    }
-    w->mCheckingForDone = false;
-  }
-
-  static void doCancel(Unit* unit, sc_msg_iter*)
-  {
-    static_cast<Wrapper*>(unit)->mClient.cancel();
-  }
-
-private:
-  static Result validateParameters(NonRealTime* w)
-  {
-    auto results = w->mParams.constrainParameterValues();
-    for (auto& r : results)
-    {
-      if (!r.ok()) return r;
-    }
-    return {};
-  }
-
-  bool exchangeBuffers(World* world) // RT thread
-  {
-    mParams.template forEachParamType<BufferT, AssignBuffer>(world);
-    // At this point, we can see if we're finished and let the language know (or
-    // it can wait for the doneAction, but that takes extra time) use replyID to
-    // convey status (0 = normal completion, 1 = cancelled)
-    if (mDone)
-      world->ft->fSendNodeReply(&mParent->mNode, 0, "/done", 0, nullptr);
-    if (mCancelled)
-      world->ft->fSendNodeReply(&mParent->mNode, 1, "/done", 0, nullptr);
-    return true;
-  }
-
-  bool tidyUp(World*) // NRT thread
-  {
-    mParams.template forEachParamType<BufferT, CleanUpBuffer>();
-    return true;
-  }
-
-  template <size_t N, typename T>
-  struct AssignBuffer
-  {
-    void operator()(const typename BufferT::type& p, World* w)
-    {
-      if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->assignToRT(w);
-    }
-  };
-
-  template <size_t N, typename T>
-  struct CleanUpBuffer
-  {
-    void operator()(const typename BufferT::type& p)
-    {
-      if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->cleanUp();
-    }
-  };
-
-  FloatControlsIter mControlsIterator;
-  FifoMsg           mFifoMsg;
-  char*             mCompletionMessage = nullptr;
-  void*             mReplyAddr = nullptr;
-  const char*       mName = nullptr;
-  index             checkThreadInterval;
-  index             pollCounter{0};
-
-protected:
-  ParamSetType mParams;
-  Client       mClient;
-  bool         mSynchronous{true};
-  bool         mQueueEnabled{false};
-  bool mCheckingForDone{false}; // only write to this from RT thread kthx
-  bool mCancelled{false};
-  Result mResult; 
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// An impossible monstrosty
-template <typename Client, typename Wrapper>
-class NonRealTimeAndRealTime : public RealTime<Client, Wrapper>,
-                               public NonRealTime<Client, Wrapper>
-{
-  static void setup(InterfaceTable* ft, const char* name)
-  {
-    RealTime<Client, Wrapper>::setup(ft, name);
-    NonRealTime<Client, Wrapper>::setup(ft, name);
-  }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Template Specialisations for NRT/RT
-
-template <typename Client, typename Wrapper, typename NRT, typename RT>
-class FluidSCWrapperImpl;
-
-template <typename Client, typename Wrapper>
-class FluidSCWrapperImpl<Client, Wrapper, std::true_type, std::false_type>
-    : public NonRealTime<Client, Wrapper>
-{};
-
-template <typename Client, typename Wrapper>
-class FluidSCWrapperImpl<Client, Wrapper, std::false_type, std::true_type>
-    : public RealTime<Client, Wrapper>
-{};
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Make base class(es), full of CRTP mixin goodness
-template <typename Client>
-using FluidSCWrapperBase =
-    FluidSCWrapperImpl<Client, FluidSCWrapper<Client>, isNonRealTime<Client>,
-                       isRealTime<Client>>;
-
-} // namespace impl
-
-////////////////////////////////////////////////////////////////////////////////
-
 /// The main wrapper
 template <typename C>
 class FluidSCWrapper : public impl::FluidSCWrapperBase<C>
 {
-
   using FloatControlsIter = impl::FloatControlsIter;
-
-  // Iterate over arguments via callbacks from params object
-  template <typename ArgType, size_t N, typename T>
-  struct Setter
-  {
-    static constexpr index argSize =
-        C::getParameterDescriptors().template get<N>().fixedSize;
-
-    auto fromArgs(World*, FloatControlsIter& args, LongT::type, int)
-    {
-      return args.next();
-    }
-    auto fromArgs(World*, FloatControlsIter& args, FloatT::type, int)
-    {
-      return args.next();
-    }
-
-    auto fromArgs(World* w, ArgType args, BufferT::type, int)
-    {
-      typename LongT::type bufnum =
-          static_cast<LongT::type>(fromArgs(w, args, LongT::type(), -1));
-      return BufferT::type(bufnum >= 0 ? new SCBufferAdaptor(bufnum, w)
-                                       : nullptr);
-    }
-
-    auto fromArgs(World* w, ArgType args, InputBufferT::type, int)
-    {
-      typename LongT::type bufnum =
-          static_cast<LongT::type>(fromArgs(w, args, LongT::type(), -1));
-      return InputBufferT::type(bufnum >= 0 ? new SCBufferAdaptor(bufnum, w)
-                                            : nullptr);
-    }
-
-    typename T::type operator()(World* w, ArgType args)
-    {
-      ParamLiteralConvertor<T, argSize> a;
-      using LiteralType =
-          typename ParamLiteralConvertor<T, argSize>::LiteralType;
-
-      for (index i = 0; i < argSize; i++)
-        a[i] = static_cast<LiteralType>(fromArgs(w, args, a[0], 0));
-
-      return a.value();
-    }
-  };
-
-  template <size_t N, typename T>
-  using ControlSetter = Setter<FloatControlsIter&, N, T>;
+  
+  //I would like to template these to something more scaleable, but baby steps
+  friend class impl::RealTime<C,FluidSCWrapper>;
+  friend class impl::NonRealTime<C,FluidSCWrapper>;
 
   static void doVersion(Unit*, sc_msg_iter*)
   {
-    std::cout << "Fluid Corpus Manipualtion Toolkit version " << fluidVersion()
+    std::cout << "Fluid Corpus Manipulation Toolkit: version " << fluidVersion()
               << std::endl;
   }
 
+  bool mInit{false};
 
 public:
-  using Client = C;
-  using ParameterSetType = typename C::ParamSetType;
 
-  FluidSCWrapper() { impl::FluidSCWrapperBase<Client>::init(); }
+  template <size_t N, typename T>
+  using ArgumentSetter = typename ClientParams<FluidSCWrapper>::template Setter<sc_msg_iter, N, T>;
+
+  template <size_t N, typename T>
+  using ControlSetter = typename ClientParams<FluidSCWrapper>::template Setter<FloatControlsIter, N, T>;
+
+  using Client = C;
+  using ParamSetType = typename C::ParamSetType;
 
   static const char* getName(const char* setName = nullptr)
   {
@@ -565,33 +66,79 @@ public:
     getInterfaceTable(ft);
     impl::FluidSCWrapperBase<Client>::setup(ft, name);
     ft->fDefineUnitCmd(name, "version", doVersion);
+    
+    std::string commandName("/");
+    commandName += getName();
+    commandName += "/version";
+    ft->fDefinePlugInCmd(commandName.c_str(),
+      [](World*, void*, sc_msg_iter*, void*){ doVersion(nullptr,nullptr); },
+    nullptr);
+    
+  }
+
+  static auto& setParams(Unit* x, ParamSetType& p,
+                         FloatControlsIter& inputs, bool constrain = false, bool initialized = true)
+  {
+    bool verbose = x->mWorld->mVerbosity > 0;
+    
+    using Reportage = decltype(static_cast<FluidSCWrapper*>(x)->mReportage);
+    
+    Reportage* reportage = initialized ? &(static_cast<FluidSCWrapper*>(x)->mReportage) : new Reportage();
+          
+    p.template setParameterValuesRT<ControlSetter>(verbose ? reportage: nullptr , x, inputs);
+    if (constrain) p.constrainParameterValuesRT(verbose ? reportage : nullptr);
+    if(verbose)
+    {
+      for(auto& r:*reportage)
+      {
+        if(!r.ok()) printResult(x->mParent->mNode.mWorld, r);
+      }
+    }
+    if(!initialized) delete reportage;
+    return p;
   }
 
-  static auto& setParams(ParameterSetType& p, bool verbose, World* world,
-                         FloatControlsIter& inputs, bool constrain = false)
+//  static void printResult(SharedState<C>& x, Result& r)
+//  {
+//    if (!x.get() || !x->mNodeAlive) return;
+//    FluidSCWrapper::printResult(x->mNode->mWorld, r);
+//  }
+  
+  static void printResult(World* w,Result& r)
   {
-    // We won't even try and set params if the arguments don't match
-    if (inputs.size() == C::getParameterDescriptors().count())
-    {
-      p.template setParameterValues<ControlSetter>(verbose, world, inputs);
-      if (constrain) p.constrainParameterValues();
-    }
-    else
+  
+    switch (r.status())
     {
-      std::cout << "ERROR: " << getName()
-                << ": parameter count mismatch. Perhaps your binary plugins "
-                   "and SC sources are different versions"
-                << std::endl;
-      // TODO: work out how to bring any further work to a halt
-    }
-    return p;
+      case Result::Status::kWarning: 
+      {
+        if (!w || w->mVerbosity > 0)
+          std::cout << "WARNING: " << getName() << " - " << r.message().c_str() << '\n';
+        break;
+      }
+      case Result::Status::kError: 
+      {
+        std::cout << "ERROR: " << getName() << " - " << r.message().c_str() << '\n';
+        break;
+      }
+      case Result::Status::kCancelled: 
+      {
+        std::cout << getName() << ": Task cancelled\n" << '\n';
+        break;
+      }
+      default: 
+      {
+      }
+    }  
   }
+  
+private:
+  std::array<Result, Client::getParameterDescriptors().size()> mReportage;
 };
 
-template <template <typename T> class Client>
+template <typename Client>
 void makeSCWrapper(const char* name, InterfaceTable* ft)
 {
-  FluidSCWrapper<Client<float>>::setup(ft, name);
+  FluidSCWrapper<Client>::setup(ft, name);
 }
 
 } // namespace client
diff --git a/include/SCBufferAdaptor.hpp b/include/SCBufferAdaptor.hpp
index 523faec..f3b2a24 100644
--- a/include/SCBufferAdaptor.hpp
+++ b/include/SCBufferAdaptor.hpp
@@ -25,29 +25,7 @@ under the European Union’s Horizon 2020 research and innovation programme
 
 namespace fluid {
 namespace client {
-/**
- A descendent of SndBuf that will populate itself
- from the NRT mirror buffers given a world and a bufnum
- **/
-struct NRTBuf
-{
-  NRTBuf(SndBuf* b) : mBuffer(b) {}
-  NRTBuf(World* world, index bufnum, bool rt = false)
-      : NRTBuf(rt ? World_GetBuf(world, static_cast<uint32>(bufnum))
-                  : World_GetNRTBuf(world, static_cast<uint32>(bufnum)))
-  {
-    if (mBuffer && !static_cast<bool>(mBuffer->samplerate))
-      mBuffer->samplerate = world->mFullRate.mSampleRate;
-  }
-
-protected:
-  SndBuf* mBuffer;
-};
-
-/**
- A combination of SndBuf and client::BufferAdaptor (which, in turn, exposes
- FluidTensorView<float,2>), for simple transfer of data
-
+/* 
  Given a World* and a buffer number, this will populate its SndBuf stuff
  from the NRT mirror buffers, and create a FluidTensorView wrapper of
  appropriate dimensions.
@@ -60,25 +38,35 @@ protected:
  nSamps = rows
  nChans = columns
  **/
-class SCBufferAdaptor : public NRTBuf, public client::BufferAdaptor
+class SCBufferAdaptor; 
+std::ostream& operator<<(std::ostream& os, SCBufferAdaptor& b);
+ 
+class SCBufferAdaptor :public client::BufferAdaptor
 {
 public:
-  //  SCBufferAdaptor()               = delete;
+    
   SCBufferAdaptor(const SCBufferAdaptor&) = delete;
   SCBufferAdaptor& operator=(const SCBufferAdaptor&) = delete;
 
   SCBufferAdaptor(SCBufferAdaptor&&) = default;
   
-
-
-  SCBufferAdaptor(index bufnum, World* world, bool rt = false)
-      : NRTBuf(world, bufnum, rt), mBufnum(bufnum), mWorld(world)
+  SCBufferAdaptor(SndBuf* buf, World* world, bool local)
+      : mBuffer{buf}, mWorld{world}, mLocal{local}
   {}
 
-  ~SCBufferAdaptor() { cleanUp(); }
+  SCBufferAdaptor(index bufnum, World* world)
+      : mBuffer{World_GetNRTBuf(world, static_cast<uint32>(bufnum))}, mBufnum(bufnum), mWorld(world)
+  {  
+      if (mBuffer && !static_cast<bool>(mBuffer->samplerate))
+        mBuffer->samplerate = world->mFullRate.mSampleRate;
+  }
+
+//  ~SCBufferAdaptor() { cleanUp(); }
 
   void assignToRT(World* rtWorld)
   {
+    if(mLocal) return;
+    
     SndBuf* rtBuf = World_GetBuf(rtWorld, static_cast<uint32>(mBufnum));
     *rtBuf = *mBuffer;
     rtWorld->mSndBufUpdates[mBufnum].writes++;
@@ -86,11 +74,8 @@ public:
 
   void cleanUp()
   {
-    if (mOldData)
-    {
-      boost::alignment::aligned_free(mOldData);
-      mOldData = nullptr;
-    }
+    boost::alignment::aligned_free(mOldData);
+    mOldData = nullptr;
   }
 
   // No locks in (vanilla) SC, so no-ops for these
@@ -101,11 +86,26 @@ public:
   // knows about
   bool valid() const override
   {
-    return (mBuffer && mBufnum >= 0 && mBufnum < asSigned(mWorld->mNumSndBufs));
+    return (mLocal ? true : mBufnum >= 0 && mBufnum < asSigned(mWorld->mNumSndBufs));
   }
 
   bool exists() const override { return true; }
 
+  FluidTensorView<float, 2> allFrames() override
+  {
+  
+    FluidTensorView<float, 2> v{mBuffer->data, 0, mBuffer->frames,
+                                mBuffer->channels};
+    return v.transpose();
+  }
+
+  FluidTensorView<const float, 2> allFrames() const override
+  {
+    FluidTensorView<const float, 2> v{mBuffer->data, 0, mBuffer->frames,
+                                mBuffer->channels};
+    return v.transpose();
+  }
+
   FluidTensorView<float, 1> samps(index channel) override
   {
     FluidTensorView<float, 2> v{mBuffer->data, 0, mBuffer->frames,
@@ -159,19 +159,30 @@ public:
   std::string asString() const override { return std::to_string(bufnum()); }
 
   const Result resize(index frames, index channels, double sampleRate) override
-  {
-    SndBuf* thisThing = mBuffer;
-    mOldData = thisThing->data;
+  {    
+    if(mLocal) // don't try and resize
+    {
+      if(frames > mBuffer->frames || channels > mBuffer->channels)
+      {
+        return {Result::Status::kError, "Local buffer must be presized adequetly, need ",
+                                                        frames, " frames, ", channels, " channels." };
+      }
+      else return {};
+    }
+    
+    mOldData = mBuffer->data;
     int allocResult =
         mWorld->ft->fBufAlloc(mBuffer, static_cast<int>(channels),
                               static_cast<int>(frames), sampleRate);
-
+    
+    if(mBuffer->data == mOldData) mOldData = nullptr;
+    
     Result r;
 
     if (allocResult != kSCErr_None)
     {
       r.set(Result::Status::kError);
-      r.addMessage("Resize on buffer ", bufnum(), " failed.");
+      r.addMessage("Resize on buffer ", bufnum(), " failed. (Requested ", frames, " frames, ", channels, "channels)");
     }
     return r;
   }
@@ -180,10 +191,12 @@ public:
   void  realTime(bool rt) { mRealTime = rt; }
 
 protected:
+  SndBuf* mBuffer;
   bool   mRealTime{false};
-  float* mOldData{0};
+  float* mOldData{nullptr};
   index  mBufnum;
   World* mWorld;
+  bool   mLocal{false};
 };
 
 std::ostream& operator<<(std::ostream& os, SCBufferAdaptor& b)
diff --git a/include/clients/rt/FluidDataSetWr.hpp b/include/clients/rt/FluidDataSetWr.hpp
new file mode 100644
index 0000000..028fcd4
--- /dev/null
+++ b/include/clients/rt/FluidDataSetWr.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <algorithms/KDTree.hpp>
+#include <clients/common/FluidBaseClient.hpp>
+#include <clients/common/FluidNRTClientWrapper.hpp>
+#include <clients/common/MessageSet.hpp>
+#include <clients/common/OfflineClient.hpp>
+#include <clients/common/ParameterSet.hpp>
+#include <clients/common/ParameterTypes.hpp>
+#include <clients/common/Result.hpp>
+#include <clients/common/SharedClientUtils.hpp>
+#include <clients/nrt/CommonResults.hpp>
+#include <clients/nrt/DataSetClient.hpp>
+#include <data/FluidDataSet.hpp>
+#include <data/FluidIndex.hpp>
+#include <data/FluidTensor.hpp>
+#include <data/TensorTypes.hpp>
+#include <string>
+
+namespace fluid {
+namespace client {
+namespace datasetwr {
+
+enum { kDataSet, kIDPrefix, kIDNumber, kBuffer };
+
+constexpr std::initializer_list<index> idNumberDefaults{0, 0};
+
+constexpr auto DataSetWrParams = defineParameters(
+    DataSetClientRef::makeParam("dataSet", "DataSet ID"),
+    StringParam("idPrefix", "ID Prefix"),
+    LongArrayParam("idNumber", "ID Counter Offset", idNumberDefaults),
+    BufferParam("buf", "Data Buffer"));
+
+class DataSetWriterClient : public FluidBaseClient, OfflineIn, OfflineOut {
+
+public:
+  using ParamDescType = decltype(DataSetWrParams);
+
+  using ParamSetViewType = ParameterSetView<ParamDescType>;
+  std::reference_wrapper<ParamSetViewType> mParams;
+
+  void setParams(ParamSetViewType &p) { mParams = p; }
+
+  template <size_t N> auto &get() const {
+    return mParams.get().template get<N>();
+  }
+
+  static constexpr auto &getParameterDescriptors() { return DataSetWrParams; }
+
+  DataSetWriterClient(ParamSetViewType &p) : mParams(p) {}
+
+  template <typename T> Result process(FluidContext &) {
+    auto dataset = get<kDataSet>().get();
+    if (auto datasetPtr = dataset.lock()) {
+      std::string &idPrefix = get<kIDPrefix>();
+      auto &idNumberArr = get<kIDNumber>();
+      if (idNumberArr.size() != 2)
+        return {Result::Status::kError, "ID number malformed"};
+      if (idPrefix.size() == 0 && idNumberArr[0] == 0)
+        return {Result::Status::kError, "No ID supplied"};
+
+      std::string id = idPrefix;
+
+      if (idNumberArr[0] > 0)
+        id += std::to_string(idNumberArr[1]);
+
+      auto buf = get<kBuffer>();
+      return datasetPtr->setPoint(id, buf);
+    } else
+      return {Result::Status::kError, "No DataSet"};
+  }
+};
+} // namespace datasetwr
+
+using NRTThreadedDataSetWriter =
+    NRTThreadingAdaptor<ClientWrapper<datasetwr::DataSetWriterClient>>;
+} // namespace client
+} // namespace fluid
diff --git a/include/wrapper/ArgsFromClient.hpp b/include/wrapper/ArgsFromClient.hpp
new file mode 100644
index 0000000..88ae458
--- /dev/null
+++ b/include/wrapper/ArgsFromClient.hpp
@@ -0,0 +1,337 @@
+#pragma once 
+
+#include "Meta.hpp"
+
+namespace fluid {
+namespace client {
+
+namespace impl {  
+  // Iterate over kr/ir inputs via callbacks from params object
+  struct FloatControlsIter
+  {
+    FloatControlsIter(float** vals, index N) : mValues(vals), mSize(N) {}
+
+    float next() { return mCount >= mSize ? 0 : *mValues[mCount++]; }
+
+    void reset(float** vals)
+    {
+      mValues = vals;
+      mCount = 0;
+    }
+
+    index size() const noexcept { return mSize; }
+    index remain() { return mSize - mCount; }
+    
+  private:
+    float** mValues;
+    index   mSize;
+    index   mCount{0};
+  };  
+} //impl
+
+//Specializations of param reader for RT and NRT cases (data encoded differently, buffer semantics differ cause of local bufs)
+template <typename ArgType> struct ParamReader;
+
+// RT case: we're decoding data from float**, there will be a Unit, we can have LocalBufs
+// TODO: All the allocations should be using SC RT allocator, but this won't work reliably until it propagates down through the param set
+template<>
+struct ParamReader<impl::FloatControlsIter>
+{
+
+  using Controls = impl::FloatControlsIter;
+
+  static auto fromArgs(Unit* /*x*/, Controls& args, std::string, int)
+  {
+    // first is string size, then chars
+    index size = static_cast<index>(args.next());
+    std::string res;
+    res.resize(asUnsigned(size));
+    for (index i = 0; i < size; ++i)
+      res[asUnsigned(i)] = static_cast<char>(args.next());
+    return res;
+  }
+  
+  static auto fromArgs(Unit*, Controls& args,typename LongArrayT::type&, int)
+  {
+      //first is array size, then items
+      using Container = typename LongArrayT::type;
+      using Value = typename Container::type;
+      index size = static_cast<index>(args.next());
+      Container res(size);
+      for (index i = 0; i < size; ++i)
+        res[i] = static_cast<Value>(args.next());
+      return res;
+  }
+  
+  template <typename T>
+  static std::enable_if_t<std::is_integral<T>::value, T>
+  fromArgs(Unit*, Controls& args, T, int)
+  {
+    return static_cast<index>(args.next());
+  }
+
+  template <typename T>
+  static std::enable_if_t<std::is_floating_point<T>::value, T>
+  fromArgs(Unit*, Controls& args, T, int)
+  {
+    return args.next();
+  }
+  
+  static SCBufferAdaptor* fetchBuffer(Unit* x, index bufnum)
+  {
+    if(bufnum >= x->mWorld->mNumSndBufs)
+    {
+      index localBufNum = bufnum - x->mWorld->mNumSndBufs;
+      
+      Graph* parent = x->mParent;
+      
+      return localBufNum <= parent->localMaxBufNum ?
+                                new SCBufferAdaptor(parent->mLocalSndBufs + localBufNum,x->mWorld,true)
+                                : nullptr;
+    }
+    else
+      return bufnum >= 0 ? new SCBufferAdaptor(bufnum, x->mWorld) : nullptr;
+  }
+
+  static auto fromArgs(Unit* x, Controls& args, BufferT::type&, int)
+  {
+    typename LongT::type bufnum = static_cast<typename LongT::type>(
+        ParamReader::fromArgs(x, args, typename LongT::type(), -1));
+    return BufferT::type(fetchBuffer(x, bufnum));
+  }
+
+  static auto fromArgs(Unit* x, Controls& args, InputBufferT::type&, int)
+  {
+    typename LongT::type bufnum =
+        static_cast<LongT::type>(fromArgs(x, args, LongT::type(), -1));
+    return InputBufferT::type(fetchBuffer(x, bufnum));
+  }
+
+  template <typename P>
+  static std::enable_if_t<IsSharedClient<P>::value, P>
+  fromArgs(Unit* x, Controls& args, P&, int)
+  {
+    auto id = fromArgs(x, args, index{}, 0);
+    return  {id >= 0 ? std::to_string(id).c_str() : "" };
+  }
+};
+
+// NRT case: we're decoding data from sc_msg_iter*, there will be a World*, we can't have LocalBufs
+// TODO: All the allocations should be using SC RT allocator (I guess: this will probably always run on the RT thread), but this won't work reliably until it propagates down through the param set
+template<>
+struct ParamReader<sc_msg_iter>
+{
+  static const char* oscTagToString(char tag)
+  {
+    switch (tag)
+    {
+      case 'i': return "integer"; break;
+      case 'f': return "float"; break;
+      case 'd': return "double"; break;
+      case 's': return "string"; break;
+      case 'b': return "blob"; break;
+      case 't': return "time tag"; break;
+      default: return "unknown type";
+    }
+  }
+  
+  static const char* argTypeToString(std::string&)
+  {
+    return "string";
+  }
+  
+  template <typename T>
+  static std::enable_if_t<std::is_integral<T>::value, const char*>
+  argTypeToString(T&)
+  {
+    return "integer";
+  }
+
+  template <typename T>
+  static std::enable_if_t<std::is_floating_point<T>::value, const char*>
+  argTypeToString(T&)
+  {
+    return "float";
+  }
+
+  static const char* argTypeToString(BufferT::type&)
+  {
+    return "buffer";
+  }
+  
+  static const char* argTypeToString(InputBufferT::type&)
+  {
+    return "buffer";
+  }
+  
+  template <typename P>
+  static std::enable_if_t<IsSharedClient<P>::value,const char*>
+  argTypeToString(P&)
+  {
+    return "shared_object"; //not ideal
+  }
+
+  static bool argTypeOK(std::string&, char tag)
+  {
+    return tag == 's';
+  }
+  
+  template <typename T>
+  static std::enable_if_t<std::is_integral<T>::value
+                          || std::is_floating_point<T>::value, bool>
+  argTypeOK(T&, char tag)
+  {
+    return tag == 'i' || tag == 'f' || tag == 'd';
+  }
+
+  static bool argTypeOK(BufferT::type&, char tag)
+  {
+    return tag == 'i';
+  }
+  
+  static bool argTypeOK(InputBufferT::type&, char tag)
+  {
+    return tag == 'i';
+  }
+  
+  template <typename P>
+  static std::enable_if_t<IsSharedClient<P>::value,bool>
+  argTypeOK(P&, char tag)
+  {
+    return tag == 'i';
+  }
+  
+  static auto fromArgs(World*, sc_msg_iter& args, std::string, int)
+  {
+    const char* recv = args.gets("");
+
+    return std::string(recv ? recv : "");
+  }
+  
+  template <typename T>
+  static std::enable_if_t<std::is_integral<T>::value, T>
+  fromArgs(World*, sc_msg_iter& args, T, int defVal)
+  {
+    return args.geti(defVal);
+  }
+
+  template <typename T>
+  static std::enable_if_t<std::is_floating_point<T>::value, T>
+  fromArgs(World*, sc_msg_iter& args, T, int)
+  {
+    return args.getf();
+  }
+  
+  static SCBufferAdaptor* fetchBuffer(World* x, index bufnum)
+  {
+    if(bufnum >= x->mNumSndBufs)
+    {
+      std::cout << "ERROR: bufnum " << bufnum << " is invalid for global buffers\n";
+      return nullptr;
+    }
+    else
+      return bufnum >= 0 ? new SCBufferAdaptor(bufnum, x) : nullptr;
+  }
+
+  static auto fromArgs(World* x, sc_msg_iter& args, BufferT::type&, int)
+  {
+    typename LongT::type bufnum = static_cast<typename LongT::type>(
+        ParamReader::fromArgs(x, args, typename LongT::type(), -1));
+    return BufferT::type(fetchBuffer(x, bufnum));
+  }
+
+  static auto fromArgs(World* x, sc_msg_iter& args, InputBufferT::type&, int)
+  {
+    typename LongT::type bufnum =
+        static_cast<LongT::type>(fromArgs(x, args, LongT::type(), -1));
+    return InputBufferT::type(fetchBuffer(x, bufnum));
+  }
+
+  template <typename P>
+  static std::enable_if_t<IsSharedClient<P>::value, P>
+  fromArgs(World* x, sc_msg_iter& args, P&, int)
+  {
+    auto id = fromArgs(x, args, index{}, 0); 
+    return {id >= 0 ? std::to_string(id).c_str() : ""};
+  }
+  
+  static auto fromArgs(World*, sc_msg_iter& args,typename LongArrayT::type&, int)
+  {
+      //first is array size, then items
+      using Container = typename LongArrayT::type;
+      using Value = typename Container::type;
+      index size = static_cast<index>(args.geti());
+      Container res(size);
+      for (index i = 0; i < size; ++i)
+        res[i] = static_cast<Value>(args.geti());
+      return res;
+  }
+};
+
+
+template <typename Wrapper>
+struct ClientParams{
+// Iterate over arguments via callbacks from params object
+  template <typename ArgType, size_t N, typename T>
+  struct Setter
+  {
+    static constexpr index argSize =
+        Wrapper::Client::getParameterDescriptors().template get<N>().fixedSize;
+
+    
+    /// Grizzly enable_if hackage coming up. Need to brute force an int from incoming data into a string param for FluidDataSet / FluidLabelSet. 
+    /// This will go away one day    
+
+    template<typename Context, typename Client = typename Wrapper::Client, size_t Number = N>
+    std::enable_if_t<!impl::IsNamedShared_v<Client> || Number!=0, typename T::type>
+    operator()(Context* x, ArgType& args)
+    {
+      // Just return default if there's nothing left to grab
+      if (args.remain() == 0)
+      {
+        std::cout << "WARNING: " << Wrapper::getName()
+                  << " received fewer parameters than expected\n";
+        return Wrapper::Client::getParameterDescriptors().template makeValue<N>();
+      }
+
+      ParamLiteralConvertor<T, argSize> a;
+      using LiteralType =
+          typename ParamLiteralConvertor<T, argSize>::LiteralType;
+
+      for (index i = 0; i < argSize; i++)
+        a[i] = static_cast<LiteralType>(
+            ParamReader<ArgType>::fromArgs(x, args, a[0], 0));
+
+      return a.value();
+    }
+    
+    template<typename Context, typename Client = typename Wrapper::Client, size_t Number = N>
+    std::enable_if_t<impl::IsNamedShared_v<Client> && Number==0, typename T::type>
+    operator()(Context* x, ArgType& args)
+    {
+      // Just return default if there's nothing left to grab
+      if (args.remain() == 0)
+      {
+        std::cout << "WARNING: " << Wrapper::getName()
+                  << " received fewer parameters than expected\n";
+        return Wrapper::Client::getParameterDescriptors().template makeValue<N>();
+      }
+      
+      index id = ParamReader<ArgType>::fromArgs(x,args,index{},0);
+      return std::to_string(id); 
+    }
+  };
+  
+  template <typename ArgType, size_t N, typename T>
+  struct Getter
+  {
+    static constexpr index argSize =
+        Wrapper::Client::getParameterDescriptors().template get<N>().fixedSize;
+
+  };
+  
+  
+}; 
+
+}
+}
diff --git a/include/wrapper/ArgsToClient.hpp b/include/wrapper/ArgsToClient.hpp
new file mode 100644
index 0000000..c9bb1c4
--- /dev/null
+++ b/include/wrapper/ArgsToClient.hpp
@@ -0,0 +1,200 @@
+#pragma once 
+
+namespace fluid {
+namespace client {
+
+  struct ToFloatArray
+  {
+    static index allocSize(typename BufferT::type) { return 1; }
+
+    template <typename T>
+    static std::enable_if_t<
+        std::is_integral<T>::value || std::is_floating_point<T>::value, index>
+        allocSize(T)
+    {
+      return 1;
+    }
+
+    static index allocSize(std::string s)
+    {
+      return asSigned(s.size()) + 1;
+    } // put null char at end when we send
+
+    static index allocSize(FluidTensor<std::string, 1> s)
+    {
+      index count = 0;
+      for (auto& str : s) count += (str.size() + 1);
+      return count;
+    }
+
+    template <typename T>
+    static index allocSize(FluidTensor<T, 1> s)
+    {
+      return s.size();
+    }
+
+    template <typename... Ts>
+    static std::tuple<std::array<index, sizeof...(Ts)>, index>
+    allocSize(std::tuple<Ts...>&& t)
+    {
+      return allocSizeImpl(std::forward<decltype(t)>(t),
+                           std::index_sequence_for<Ts...>());
+    }
+
+    template <typename... Ts, size_t... Is>
+    static std::tuple<std::array<index, sizeof...(Ts)>, index>
+    allocSizeImpl(std::tuple<Ts...>&& t, std::index_sequence<Is...>)
+    {
+      index                            size{0};
+      std::array<index, sizeof...(Ts)> res;
+      (void) std::initializer_list<int>{
+          (res[Is] = size, size += ToFloatArray::allocSize(std::get<Is>(t)),
+           0)...};
+      return std::make_tuple(res,
+                             size); // array of offsets into allocated buffer &
+                                    // total number of floats to alloc
+    }
+
+    static void convert(float* f, typename BufferT::type buf)
+    {
+      f[0] = static_cast<float>(static_cast<SCBufferAdaptor*>(buf.get())->bufnum());
+    }
+
+    template <typename T>
+    static std::enable_if_t<std::is_integral<T>::value ||
+                            std::is_floating_point<T>::value>
+    convert(float* f, T x)
+    {
+      f[0] = static_cast<float>(x);
+    }
+
+    static void convert(float* f, std::string s)
+    {
+      std::copy(s.begin(), s.end(), f);
+      f[s.size()] = 0; // terminate
+    }
+    static void convert(float* f, FluidTensor<std::string, 1> s)
+    {
+      for (auto& str : s)
+      {
+        std::copy(str.begin(), str.end(), f);
+        f += str.size();
+        *f++ = 0;
+      }
+    }
+    template <typename T>
+    static void convert(float* f, FluidTensor<T, 1> s)
+    {
+      static_assert(std::is_convertible<T, float>::value,
+                    "Can't convert this to float output");
+      std::copy(s.begin(), s.end(), f);
+    }
+
+    template <typename... Ts, size_t... Is>
+    static void convert(float* f, std::tuple<Ts...>&& t,
+                        std::array<index, sizeof...(Ts)> offsets,
+                        std::index_sequence<Is...>)
+    {
+      (void) std::initializer_list<int>{
+          (convert(f + offsets[Is], std::get<Is>(t)), 0)...};
+    }
+  };
+  
+  template<typename Packet>
+  struct ToOSCTypes
+  {
+  
+    static index numTags(typename BufferT::type) { return 1; }
+
+    template <typename T>
+    static std::enable_if_t<
+        std::is_integral<T>::value || std::is_floating_point<T>::value, index>
+        numTags(T)
+    {
+      return 1;
+    }
+
+    static index numTags(std::string)
+    {
+      return 1;;
+    }
+
+    template <typename T>
+    static index numTags(FluidTensor<T, 1> s)
+    {
+      return s.size();
+    }
+
+    template <typename... Ts>
+    static index numTags(std::tuple<Ts...>&&)
+    {
+      return std::tuple_size<std::tuple<Ts...>>::value;
+    }
+  
+    static void getTag(Packet& p, typename BufferT::type) { p.addtag('i'); }
+        
+    template <typename T>
+    static std::enable_if_t<std::is_integral<std::decay_t<T>>::value>
+    getTag(Packet& p, T&&) { p.addtag('i'); }
+
+    template <typename T>
+    static std::enable_if_t<std::is_floating_point<std::decay_t<T>>::value>
+    getTag(Packet& p, T&&) { p.addtag('f'); }
+
+    static void getTag (Packet& p, std::string) { p.addtag('s'); }
+
+    template <typename T>
+    static void getTag(Packet& p, FluidTensor<T, 1> x)
+    {
+      T dummy{};
+      for (int i = 0; i < x.rows(); i++)
+        getTag(p, dummy);
+   }
+
+    template <typename... Ts>
+    static void getTag(Packet& p, std::tuple<Ts...>&& t)
+    {
+        ForEach(t,[&p](auto&  x){getTag(p,x);});
+    }
+
+
+    static void convert(Packet& p, typename BufferT::type buf)
+    {
+      p.addi(static_cast<int>(static_cast<SCBufferAdaptor*>(buf.get())->bufnum()));
+    }
+
+    template <typename T>
+    static std::enable_if_t<std::is_integral<T>::value>
+    convert(Packet& p, T x)
+    {
+      p.addi(static_cast<int>(x));
+    }
+
+    template <typename T>
+    static std::enable_if_t<std::is_floating_point<T>::value>
+    convert(Packet& p, T x)
+    {
+      p.addf(static_cast<float>(x));
+    }
+
+    static void convert(Packet& p, std::string s)
+    {
+      p.adds(s.c_str());
+    }
+    
+    template <typename T>
+    static void convert(Packet& p, FluidTensor<T, 1> s)
+    {
+      for(auto& x: s) convert(p,x);
+    }
+
+    template <typename... Ts>
+    static void convert(Packet& p, std::tuple<Ts...>&& t)
+    {
+       ForEach(t,[&p](auto& x){ convert(p,x);});
+    }
+  };
+  
+  
+}
+}
diff --git a/include/wrapper/BufferFuncs.hpp b/include/wrapper/BufferFuncs.hpp
new file mode 100644
index 0000000..303e96f
--- /dev/null
+++ b/include/wrapper/BufferFuncs.hpp
@@ -0,0 +1,29 @@
+#pragma once 
+
+#include "SCBufferAdaptor.hpp"
+
+namespace fluid {
+namespace client {
+namespace impl {
+  
+  template <size_t N, typename T>
+  struct AssignBuffer
+  {
+    void operator()(const typename BufferT::type& p, World* w)
+    {
+      if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->assignToRT(w);
+    }
+  };
+  
+  template <size_t N, typename T>
+  struct CleanUpBuffer
+  {
+    void operator()(const typename BufferT::type& p)
+    {
+      if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->cleanUp();
+    }
+  };  
+  
+}
+}
+}
diff --git a/include/wrapper/CopyReplyAddress.cpp b/include/wrapper/CopyReplyAddress.cpp
new file mode 100644
index 0000000..0346b23
--- /dev/null
+++ b/include/wrapper/CopyReplyAddress.cpp
@@ -0,0 +1,51 @@
+
+#include "CopyReplyAddress.hpp"
+#include <SC_Win32Utils.h>
+#include <SC_ReplyImpl.hpp>
+
+namespace fluid{
+namespace client{
+    
+void* copyReplyAddress(InterfaceTable* ft, World* inWorld, void* inreply)
+{
+  
+  if(! inreply) return nullptr; 
+  
+  ReplyAddress* reply = (ReplyAddress*)ft->fRTAlloc(inWorld, sizeof(ReplyAddress)); 
+  
+  *reply = *(static_cast<ReplyAddress*>(inreply));
+  
+  return reply;   
+}
+
+void deleteReplyAddress(InterfaceTable* ft, World* inWorld, void* inreply)
+{
+  if(! inreply) return;
+  ft->fRTFree(inWorld,(ReplyAddress*)inreply);
+}
+
+void* copyReplyAddress(void* inreply)
+{
+  
+  if(! inreply) return nullptr; 
+  
+  ReplyAddress* reply = new ReplyAddress(); 
+  
+  *reply = *(static_cast<ReplyAddress*>(inreply));
+  
+  return reply;   
+}
+
+void deleteReplyAddress(void* inreply)
+{
+  if(! inreply) return;
+  delete (ReplyAddress*)inreply;
+}
+
+void SendReply(void* inReplyAddr, char* inBuf, int inSize) {    
+     SendReply(static_cast<ReplyAddress*>(inReplyAddr),inBuf,inSize); 
+}
+
+
+}  
+}
diff --git a/include/wrapper/CopyReplyAddress.hpp b/include/wrapper/CopyReplyAddress.hpp
new file mode 100644
index 0000000..fcc6ba8
--- /dev/null
+++ b/include/wrapper/CopyReplyAddress.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <SC_PlugIn.h>
+
+namespace fluid{
+namespace client{
+    
+void* copyReplyAddress(InterfaceTable* ft, World* inWorld, void* inreply);
+void deleteReplyAddress(InterfaceTable* ft, World* inWorld, void* inreply);
+void* copyReplyAddress(void* inreply);
+void deleteReplyAddress(void* inreply);
+void SendReply(void* inReplyAddr, char* inBuf, int inSize);
+
+
+}  
+}
diff --git a/include/wrapper/DeriveBaseClass.hpp b/include/wrapper/DeriveBaseClass.hpp
new file mode 100644
index 0000000..e0f3e94
--- /dev/null
+++ b/include/wrapper/DeriveBaseClass.hpp
@@ -0,0 +1,49 @@
+#pragma once 
+
+#include "NonRealtime.hpp"
+#include "Realtime.hpp"
+
+namespace fluid {
+namespace client {
+  
+template <typename Client> class FluidSCWrapper;  
+  
+namespace impl { 
+
+template<bool UseRealTime> struct ChooseRTOrNRT;
+
+template<>
+struct ChooseRTOrNRT<false>
+{
+   template<typename Client, typename Wrapper>
+   using type = NonRealTime<Client,Wrapper>;
+};
+
+template<>
+struct ChooseRTOrNRT<true>
+{
+   template<typename Client, typename Wrapper>
+   using type = RealTime<Client,Wrapper>;
+};
+
+
+template <typename Client,typename Wrapper>   
+struct BaseChooser
+{
+  using RT = typename Client::isRealTime;
+  
+  static constexpr bool UseRealTime = RT::value && !IsModel_t<Client>::value;
+  
+  using type = typename ChooseRTOrNRT<UseRealTime>::template type<Client,Wrapper>;
+}; 
+
+
+template <typename Client,typename Wrapper>
+using BaseChooser_t = typename BaseChooser<Client,Wrapper>::type;
+
+
+template <typename Client>
+using FluidSCWrapperBase = BaseChooser_t<Client,FluidSCWrapper<Client>>;
+} 
+}
+}
diff --git a/include/wrapper/Messaging.hpp b/include/wrapper/Messaging.hpp
new file mode 100644
index 0000000..cf7b4c3
--- /dev/null
+++ b/include/wrapper/Messaging.hpp
@@ -0,0 +1,273 @@
+#pragma once 
+
+#include "ArgsFromClient.hpp"
+#include "ArgsToClient.hpp"
+#include "CopyReplyAddress.hpp"
+#include <scsynthsend.h>
+
+namespace fluid {
+namespace client {
+
+template<typename FluidSCWrapper, typename Client>
+struct FluidSCMessaging{
+   
+  static auto getInterfaceTable(){ return FluidSCWrapper::getInterfaceTable(); }
+  static auto getName(){ return FluidSCWrapper::getName(); }
+
+
+  template <size_t N>
+  struct MessageDispatchCmd
+  {
+    using Descriptor = typename Client::MessageSetType::template MessageDescriptorAt<N>;
+    using ArgTuple   = typename Descriptor::ArgumentTypes;
+    using ReturnType = typename Descriptor::ReturnType;
+    using IndexList  = typename Descriptor::IndexList;
+  
+    static constexpr size_t Message = N;
+    index                   id;
+    ArgTuple                args;
+    ReturnType              result;
+    std::string             name;
+    IndexList               argIndices;
+    void*                   replyAddr{nullptr};
+  };
+  
+
+  template <size_t N, typename T>
+  struct SetupMessageCmd
+  {
+  
+    void operator()(const T& message)
+    {
+      static std::string messageName = std::string{getName()} + '/' + message.name;
+      auto ft = getInterfaceTable();      
+      ft->fDefinePlugInCmd(messageName.c_str(), doMessage<N>,(void*)messageName.c_str());
+    }
+  };
+  
+
+  template <typename Message>
+  static bool validateMessageArgs(Message* msg, sc_msg_iter* inArgs)
+  {
+    using ArgTuple = decltype(msg->args);
+    
+    std::string tags(inArgs->tags + inArgs->count);//evidently this needs commenting: construct string at pointer offset by tag count, to pick up args
+    bool willContinue = true;
+    bool typesMatch = true;
+    
+    auto& args = msg->args;
+    
+    constexpr size_t expectedArgCount = std::tuple_size<ArgTuple>::value;
+    
+    /// TODO this squawks if we have a completion message, so maybe we can check if extra arg is a 'b' and squawk if not?
+//    if(tags.size() > expectedArgCount)
+//    {
+//      std::cout << "WARNING: " << msg->name << " received more arguments than expected (got "
+//                << tags.size() << ", expect " << expectedArgCount << ")\n";
+//    }
+    
+    if(tags.size() < expectedArgCount)
+    {
+      std::cout << "ERROR: " << msg->name << " received fewer arguments than expected (got "
+                << tags.size() << ", expect " << expectedArgCount << ")\n";
+      willContinue = false;
+    }
+
+    auto tagsIter = tags.begin();
+    auto tagsEnd  = tags.end();
+    ForEach(args,[&typesMatch,&tagsIter,&tagsEnd](auto& arg){
+       if(tagsIter == tagsEnd)
+       {
+          typesMatch = false;
+          return;
+       }
+       char t = *(tagsIter++);
+       typesMatch = typesMatch && ParamReader<sc_msg_iter>::argTypeOK(arg,t);
+    });
+    
+   willContinue = willContinue && typesMatch;
+   
+   if(!typesMatch)
+   {
+      auto& report = std::cout;
+      report << "ERROR: " << msg->name << " type signature incorrect.\nExpect: (";
+      size_t i{0};
+      ForEach(args, [&i](auto& x){
+        std::cout << ParamReader<sc_msg_iter>::argTypeToString(x);
+        if(i < (std::tuple_size<ArgTuple>::value - 1 ) )
+        {
+          std::cout << " ,";
+        }
+        i++;
+      });
+      report << ")\nReceived: (";
+      i = 0;
+      for(auto t: tags)
+      {
+        report << ParamReader<sc_msg_iter>::oscTagToString(t);
+        if( i < ( tags.size() - 1 ) )
+        {
+          report << ", ";
+        }
+        i++;
+      }
+      report << ")\n";
+   }
+   
+   return willContinue;
+  }
+
+
+  template<size_t N>
+  static void doMessage(World* inWorld, void* inUserData, struct sc_msg_iter* args, void* replyAddr)
+  {
+    using MessageData = MessageDispatchCmd<N>;
+    
+    auto msg = new MessageData();
+    
+    msg->id = args->geti();
+    msg->replyAddr = copyReplyAddress(replyAddr);
+    ///TODO make this step contingent on verbosity or something, in the name of effieciency
+    bool willContinue = validateMessageArgs(msg, args);
+    
+    if(!willContinue)
+    {
+      delete msg;
+      return;
+    }
+
+
+    msg->name = std::string{'/'} +  (const char*)(inUserData);
+    
+    ForEach(msg-> args,[inWorld,&args](auto& thisarg)
+    {
+      thisarg = ParamReader<sc_msg_iter>::fromArgs(inWorld, *args,thisarg,0);
+    });
+     
+    size_t completionMsgSize{args ? args->getbsize() : 0};
+    assert(completionMsgSize <= std::numeric_limits<int>::max());
+    char* completionMsgData = nullptr;
+    
+    if (completionMsgSize) {
+      completionMsgData = (char*)getInterfaceTable()->fRTAlloc(inWorld, completionMsgSize);
+      args->getb(completionMsgData, completionMsgSize);
+    }
+    
+    auto ft = getInterfaceTable();
+    
+    ft->fDoAsynchronousCommand(inWorld, replyAddr, getName(), msg,
+        [](World* world, void* data) // NRT thread: invocation
+        {
+          MessageData* m = static_cast<MessageData*>(data);
+          using ReturnType = typename MessageData::ReturnType;
+          
+          if(auto  ptr = FluidSCWrapper::get(m->id).lock())
+          {
+            m->result =
+                ReturnType{invokeImpl<N>(ptr->mClient, m->args,m->argIndices)};
+
+            if (!m->result.ok())
+              FluidSCWrapper::printResult(world, m->result);
+          } else FluidSCWrapper::printNotFound(m->id);
+
+          return true;
+        },
+        [](World* world, void* data) // RT thread:  buffer swap (and possible completion messages)
+        {
+          MessageData* m = static_cast<MessageData*>(data);
+          MessageData::Descriptor::template forEachArg<typename BufferT::type,
+                                                 impl::AssignBuffer>(m->args,
+                                                                     world);
+          return true;
+        },
+        [](World*, void* data) // NRT Thread: Send reply
+        {
+          MessageData* m = static_cast<MessageData*>(data);
+          if(m->result.status() != Result::Status::kError)
+            messageOutput(m->name, m->id, m->result, m->replyAddr);
+          return false;
+        },
+        [](World*, void* data) // RT thread: clean up
+        {
+          MessageData* m = static_cast<MessageData*>(data);
+          delete m;
+        },
+        static_cast<int>(completionMsgSize), completionMsgData);
+        
+        if(completionMsgSize) ft->fRTFree(inWorld, completionMsgData);
+        
+  }
+  
+  template <size_t N, typename ArgsTuple, size_t... Is> // Call from NRT
+  static decltype(auto) invokeImpl(Client& x, ArgsTuple& args,
+                                   std::index_sequence<Is...>)
+  {
+    return x.template invoke<N>(x, std::get<Is>(args)...);
+  }
+  
+  template <typename T> // call from RT
+  static void messageOutput(const std::string& s, index id, MessageResult<T>& result, void* replyAddr)
+  {
+    index  numTags = ToOSCTypes<small_scpacket>::numTags(static_cast<T>(result));
+    if(numTags > 2048)
+    {
+      std::cout << "ERROR: Message response too big to send (" << asUnsigned(numTags) * sizeof(float) << " bytes)." << std::endl;
+      return;
+    }
+
+    small_scpacket packet;
+    packet.adds(s.c_str());
+    packet.maketags(static_cast<int>(numTags) + 2);
+    packet.addtag(',');
+    packet.addtag('i');
+    ToOSCTypes<small_scpacket>::getTag(packet, static_cast<T>(result));
+    
+    packet.addi(static_cast<int>(id));
+    ToOSCTypes<small_scpacket>::convert(packet, static_cast<T>(result));
+    
+    if(replyAddr)
+      SendReply(replyAddr,packet.data(),static_cast<int>(packet.size()));
+  }
+
+  static void messageOutput(const std::string& s,index id, MessageResult<void>&, void* replyAddr)
+  {
+    small_scpacket packet;
+    packet.adds(s.c_str());
+    packet.maketags(2);
+    packet.addtag(',');
+    packet.addtag('i');
+    packet.addi(static_cast<int>(id));
+    
+    if(replyAddr)
+      SendReply(replyAddr,packet.data(),static_cast<int>(packet.size()));
+  }
+
+  template <typename... Ts>
+  static void messageOutput(const std::string& s, index id, MessageResult<std::tuple<Ts...>>& result, void* replyAddr)
+  {
+    using T = std::tuple<Ts...>;
+    
+    index  numTags = ToOSCTypes<small_scpacket>::numTags(static_cast<T>(result));
+    if(numTags > 2048)
+    {
+      std::cout << "ERROR: Message response too big to send (" << asUnsigned(numTags) * sizeof(float) << " bytes)." << std::endl;
+      return;
+    }
+    
+    small_scpacket packet;
+    packet.adds(s.c_str());
+    packet.maketags(static_cast<int>(numTags + 3));
+    packet.addtag(',');
+    packet.addtag('i');
+    ToOSCTypes<small_scpacket>::getTag(packet,static_cast<T>(result));
+    
+    packet.addi(static_cast<int>(id));
+    ToOSCTypes<small_scpacket>::convert(packet, static_cast<T>(result));
+    
+    if(replyAddr)
+      SendReply(replyAddr,packet.data(),static_cast<int>(packet.size()));
+
+  }
+};
+}
+}
diff --git a/include/wrapper/Meta.hpp b/include/wrapper/Meta.hpp
new file mode 100644
index 0000000..8b375cf
--- /dev/null
+++ b/include/wrapper/Meta.hpp
@@ -0,0 +1,59 @@
+#pragma once 
+
+#include <clients/nrt/FluidSharedInstanceAdaptor.hpp>
+#include <clients/common/FluidNRTClientWrapper.hpp>
+#include <clients/common/SharedClientUtils.hpp>
+
+namespace fluid {
+namespace client {
+namespace impl {  
+  /// Named, shared clients already have a lookup table in their adaptor class
+  template <typename T>
+  struct IsNamedShared
+  {
+    using type = std::false_type;
+  };
+
+  //TODO: make less tied to current implementation
+  template <typename T>
+  struct IsNamedShared<NRTThreadingAdaptor<NRTSharedInstanceAdaptor<T>>>
+  {
+    using type = std::true_type;
+  };
+
+  template<typename T>
+  using IsNamedShared_t = typename IsNamedShared<T>::type;
+
+  template<typename T>
+  constexpr bool IsNamedShared_v = IsNamedShared_t<T>::value;
+
+  /// Models don't, but still need to survive CMD-.
+  template<typename T>
+  struct IsModel
+  {
+    using type = std::false_type;
+  };
+
+  template<typename T>
+  struct IsModel<NRTThreadingAdaptor<ClientWrapper<T>>>
+  {
+    using type = typename ClientWrapper<T>::isModelObject;
+  };
+
+  template<typename T>
+  struct IsModel<ClientWrapper<T>>
+  {
+    using type = typename ClientWrapper<T>::isModelObject;
+  };
+
+  template<typename T>
+  using IsModel_t = typename IsModel<T>::type;
+  
+  template<typename T>
+  constexpr bool IsModel_v = IsModel_t<T>::value;
+  
+  
+  
+}
+}
+}
diff --git a/include/wrapper/NonRealtime.hpp b/include/wrapper/NonRealtime.hpp
new file mode 100644
index 0000000..9983c5a
--- /dev/null
+++ b/include/wrapper/NonRealtime.hpp
@@ -0,0 +1,993 @@
+#pragma once 
+
+#include "BufferFuncs.hpp"
+#include "CopyReplyAddress.hpp"
+#include "Messaging.hpp"
+#include "Meta.hpp"
+#include "RealTimeBase.hpp"
+#include "SCBufferAdaptor.hpp"
+#include <clients/common/FluidBaseClient.hpp>
+#include <data/FluidMeta.hpp>
+#include <SC_PlugIn.hpp>
+#include <scsynthsend.h>
+#include <unordered_map>
+
+namespace fluid {
+namespace client {
+namespace impl { 
+  
+  /// Non Real Time Processor
+  
+  template <typename Client, typename Wrapper>
+  class NonRealTime : public SCUnit
+  {
+    using Params =  typename Client::ParamSetType;
+    
+    template<typename T,typename...Args>
+    static T* rtalloc(World* world,Args&&...args)
+    {
+      void* space = getInterfaceTable()->fRTAlloc(world, sizeof(T));
+      return new (space) T{std::forward<Args>(args)...};
+    }
+    
+    /// Instance cache
+    struct CacheEntry
+    {
+      
+      CacheEntry(const Params& p):mParams{p},mClient{mParams}
+      {}
+      
+      Params mParams;
+      Client mClient;
+      bool mDone{false};
+    };
+    
+    using CacheEntryPointer = std::shared_ptr<CacheEntry>; 
+    using WeakCacheEntryPointer = std::weak_ptr<CacheEntry>; //could use weak_type in 17
+
+   public:
+    using Cache = std::unordered_map<index,CacheEntryPointer>; 
+    static Cache mCache;
+   private:
+    static bool isNull(WeakCacheEntryPointer const& weak) {
+      return !weak.owner_before(WeakCacheEntryPointer{}) && !WeakCacheEntryPointer{}.owner_before(weak);
+    }
+    
+
+  
+  public:
+    static WeakCacheEntryPointer get(index id)
+    {
+      auto   lookup  = mCache.find(id);
+      return lookup == mCache.end() ? WeakCacheEntryPointer() : lookup->second;
+    }
+    
+    static WeakCacheEntryPointer add(index id, const Params& params)
+    {
+      if(isNull(get(id)))
+      {
+        auto result =  mCache.emplace(id,
+                               std::make_shared<CacheEntry>(params));
+                               
+        return result.second ? (result.first)->second : WeakCacheEntryPointer(); //sob
+      }
+      else //client has screwed up
+      {
+          std::cout << "ERROR: " <<  Wrapper::getName() << " ID " << id << " already in use\n";
+          return {};
+      }
+    }
+    
+    static void remove(index id)
+    {
+      mCache.erase(id);
+    }
+    
+    static void printNotFound(index id)
+    {
+      std::cout << "ERROR: " << Wrapper::getName() << " no instance with ID " << id << std::endl;
+    }
+    
+  private:
+    static InterfaceTable* getInterfaceTable() { return Wrapper::getInterfaceTable() ;}
+    
+    template <size_t N, typename T>
+    using ParamsFromOSC = typename ClientParams<Wrapper>::template Setter<sc_msg_iter, N, T>;
+
+    template <size_t N, typename T>
+    using ParamsFromSynth = typename ClientParams<Wrapper>::template Setter<impl::FloatControlsIter, N, T>;
+
+
+    struct NRTCommand
+    {
+      NRTCommand(World*, sc_msg_iter* args, void* replyAddr, bool consumeID = true)
+      {
+        auto count = args->count;
+        auto pos = args->rdpos;
+        
+        mID = args->geti();
+        
+        if(!consumeID)
+        {
+          args->count = count;
+          args->rdpos = pos;
+        }
+        
+        if(replyAddr)
+         mReplyAddress =  copyReplyAddress(replyAddr);
+      }
+      
+      ~NRTCommand()
+      {
+        if(mReplyAddress) deleteReplyAddress(mReplyAddress);
+      }
+      
+      NRTCommand(){}
+      
+      explicit NRTCommand(index id):mID{id}{}
+      
+      bool stage2(World*) { return true; } //nrt
+      bool stage3(World*) { return true; } //rt
+      bool stage4(World*) { return false; } //nrt
+      void cleanup(World*) {} //rt
+                    
+      void sendReply(const char* name,bool success)
+      {
+        if(mReplyAddress)
+        {
+          std::string slash{"/"};
+          small_scpacket packet;
+          packet.adds((slash+name).c_str());
+          packet.maketags(3);
+          packet.addtag(',');
+          packet.addtag('i');
+          packet.addtag('i');
+          packet.addi(success);
+          packet.addi(static_cast<int>(mID));
+          
+          SendReply(mReplyAddress,packet.data(), static_cast<int>(packet.size()));
+        }
+      }
+//      protected:
+      index mID;
+      void* mReplyAddress{nullptr};
+    };
+    
+    struct CommandNew : public NRTCommand
+    {
+      CommandNew(World* world, sc_msg_iter* args,void* replyAddr)
+        : NRTCommand{world,args, replyAddr, !IsNamedShared_v<Client>},
+          mParams{Client::getParameterDescriptors()}
+      {
+        mParams.template setParameterValuesRT<ParamsFromOSC>(nullptr, world, *args);
+      }
+
+      CommandNew(index id, World*, FloatControlsIter& args, Unit* x)
+        :NRTCommand{id},
+         mParams{Client::getParameterDescriptors()}
+      {
+        mParams.template setParameterValuesRT<ParamsFromSynth>(nullptr, x, args);
+      }
+
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/new";
+        return cmd.c_str();
+      }
+
+      bool stage2(World* w)
+      {
+//        auto entry = ;
+
+
+        Result constraintsRes =  validateParameters(mParams);
+
+        if(!constraintsRes.ok()) Wrapper::printResult(w,constraintsRes);
+
+        mResult = (!isNull(add(NRTCommand::mID, mParams)));
+                
+        //Sigh. The cache entry above has both the client instance and main params instance.
+        // The client is linked to the params by reference; I've not got the in-place constrction
+        // working properly so that params are in their final resting place by the time we make the client
+        // so (for) now we need to manually repoint the client to the correct place. Or badness.
+        if(mResult)
+        {
+           auto ptr = get(NRTCommand::mID).lock();
+           ptr->mClient.setParams(ptr->mParams);
+        }
+        
+        NRTCommand::sendReply(name(),mResult);
+        
+        return mResult;
+      }
+      
+    private:
+      bool mResult;
+      Params mParams;
+    };
+    
+    struct CommandFree: public NRTCommand
+    {
+      using NRTCommand::NRTCommand;
+      
+      void cancelCheck(std::false_type, index id)
+      {
+        if(auto ptr = get(id).lock())
+        {
+          auto& client = ptr->mClient;
+          if(!client.synchronous() && client.state() == ProcessState::kProcessing)
+            std::cout << Wrapper::getName()
+            << ": Processing cancelled"
+            << std::endl;
+        }
+      }
+      
+      void cancelCheck(std::true_type, index){}
+      
+            
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/free";
+        return cmd.c_str();
+      }
+      
+      bool stage2(World*)
+      {
+        cancelCheck(IsRTQueryModel_t(),NRTCommand::mID);
+        remove(NRTCommand::mID);
+        NRTCommand::sendReply(name(), true);
+        return true;
+      }
+
+    };
+    
+    
+    /// Not registered as a PlugInCmd. Triggered by  worker thread callback
+    struct CommandAsyncComplete: public NRTCommand
+    {
+      CommandAsyncComplete(World*, index id, void* replyAddress)
+      {
+        NRTCommand::mID = id;
+        NRTCommand::mReplyAddress = replyAddress;
+      }
+      
+      static const char* name() { return CommandProcess::name(); }
+      
+      bool stage2(World* world)
+      {
+        
+        // std::cout << "In Async completion\n";
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          Result       r;
+          auto& client = ptr->mClient;
+          ProcessState s = client.checkProgress(r);
+          if (s == ProcessState::kDone || s == ProcessState::kDoneStillProcessing)
+          {
+            if (r.status() == Result::Status::kCancelled)
+            {
+              std::cout << Wrapper::getName()
+                        << ": Processing cancelled"
+                        << std::endl;
+              ptr->mDone = true;
+              return false;
+            }
+            
+            client.checkProgress(r);
+            mSuccess = !(r.status() == Result::Status::kError);
+            if (!r.ok())
+            {
+              Wrapper::printResult(world,r);              
+              if(r.status() == Result::Status::kError)
+              {
+                ptr->mDone = true;
+                return false;
+              }
+            }
+            
+            return true;
+          }
+        }
+        return false;
+      }
+      
+      bool stage3(World* world)
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          auto& params = ptr->mParams;
+          params.template forEachParamType<BufferT, AssignBuffer>(world);
+          return true;
+        }
+        return false;
+      }
+      
+      bool stage4(World*) //nrt
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          ptr->mParams.template forEachParamType<BufferT, impl::CleanUpBuffer>();
+          
+          if(NRTCommand::mID >= 0 && NRTCommand::mReplyAddress)
+          {
+            NRTCommand::sendReply(name(),mSuccess);
+          }
+          ptr->mDone = true;
+          return true;
+        }
+        return false;
+      }
+      
+      bool mSuccess;
+    };
+    
+        
+    static void doProcessCallback(World* world, index id,size_t completionMsgSize,char* completionMessage,void* replyAddress)
+    {
+      auto ft = getInterfaceTable();
+      struct Context{
+        World* mWorld;
+        index  mID;
+        size_t    mCompletionMsgSize;
+        char*  mCompletionMessage;
+        void*  mReplyAddress;
+      };
+      
+      Context* c = new Context{world,id,completionMsgSize,completionMessage,replyAddress};
+      
+      auto launchCompletionFromNRT = [](FifoMsg* inmsg)
+      {        
+        auto runCompletion = [](FifoMsg* msg){
+          // std::cout << "In FIFOMsg\n";
+          Context* c = static_cast<Context*>(msg->mData);
+          World* world = c->mWorld;
+          index id = c->mID;
+          auto ft = getInterfaceTable();
+          void* space = ft->fRTAlloc(world,sizeof(CommandAsyncComplete));
+          CommandAsyncComplete* cmd = new (space) CommandAsyncComplete(world, id,c->mReplyAddress);
+          runAsyncCommand(world, cmd, c->mReplyAddress, c->mCompletionMsgSize, c->mCompletionMessage);
+          if(c->mCompletionMsgSize) ft->fRTFree(world,c->mCompletionMessage); 
+        };
+        
+        auto tidyup = [](FifoMsg* msg)
+        {
+          Context* c = static_cast<Context*>(msg->mData);
+          delete c;
+        };
+        
+        auto ft = getInterfaceTable();
+        FifoMsg fwd = *inmsg;
+        fwd.Set(inmsg->mWorld, runCompletion, tidyup, inmsg->mData);
+        if(inmsg->mWorld->mRunning)
+          ft->fSendMsgToRT(inmsg->mWorld,fwd);
+      };
+      
+      FifoMsg msg;
+      msg.Set(world, launchCompletionFromNRT, nullptr, c);
+      
+      if(world->mRunning) ft->fSendMsgFromRT(world,msg);
+    }
+        
+    struct CommandProcess: public NRTCommand
+    {
+      CommandProcess(World* world, sc_msg_iter* args, void* replyAddr): NRTCommand{world, args, replyAddr},mParams{Client::getParameterDescriptors()}
+      {
+        auto& ar = *args;
+        
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+           ptr->mDone = false;
+           mParams.template setParameterValuesRT<ParamsFromOSC>(nullptr, world, ar);
+           mSynchronous = static_cast<bool>(ar.geti());
+        } //if this fails, we'll hear about it in stage2 anyway
+      }
+
+      explicit CommandProcess(index id,bool synchronous,Params* params):NRTCommand{id},mSynchronous(synchronous),
+      mParams{Client::getParameterDescriptors()}
+      {
+       if(params)
+       {
+          mParams = *params;
+          mOverwriteParams = true;
+       }
+      }
+      
+      
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/process";
+        return cmd.c_str();
+      }
+      
+      bool stage2(World* world)
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+                    
+          auto& params = ptr->mParams;
+          if(mOverwriteParams) params = mParams;
+          auto& client = ptr->mClient;
+          
+
+          
+//          if(mOSCData)
+//          {
+//             params.template setParameterValuesRT<ParamsFromOSC>(nullptr, world, *mOSCData);
+//             mSynchronous = static_cast<bool>(mOSCData->geti());
+//          }
+                    
+          Result result = validateParameters(params);
+          Wrapper::printResult(world, result);
+          if (result.status() != Result::Status::kError)
+          {
+//            client.done()
+            client.setSynchronous(mSynchronous);
+            index id = NRTCommand::mID;
+            size_t completionMsgSize = mCompletionMsgSize;
+            char* completionMessage = mCompletionMessage;
+            void* replyAddress = copyReplyAddress(NRTCommand::mReplyAddress);
+            
+            auto callback = [world,id,completionMsgSize,completionMessage,replyAddress](){
+              doProcessCallback(world,id,completionMsgSize,completionMessage,replyAddress);
+            };
+                    
+            result = mSynchronous ? client.enqueue(params) : client.enqueue(params,callback);
+            Wrapper::printResult(world, result);
+            
+            if(result.ok())
+            {
+              ptr->mDone = false;
+              mResult = client.process();
+              Wrapper::printResult(world,mResult);
+              
+              bool error =mResult.status() == Result::Status::kError;
+              
+              if(error) ptr->mDone = true;
+              return mSynchronous && !error;
+            }
+          }
+        }
+        else
+        {
+          mResult = Result{Result::Status::kError, "No ", Wrapper::getName(), " with ID ", NRTCommand::mID};
+          Wrapper::printResult(world,mResult);
+        }
+        return false;
+      }
+
+      //Only for blocking execution
+      bool stage3(World* world) //rt
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          ptr->mParams.template forEachParamType<BufferT, AssignBuffer>(world);
+//          NRTCommand::sendReply(world, name(), mResult.ok());
+          return true;
+        }
+        // std::cout << "Ohno\n";
+        return false;
+      }
+      
+      //Only for blocking execution
+      bool stage4(World*) //nrt
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          ptr->mParams.template forEachParamType<BufferT, impl::CleanUpBuffer>();
+          
+          if(NRTCommand::mID >= 0 && mSynchronous)
+            NRTCommand::sendReply(name(), mResult.ok());
+          ptr->mDone = true;
+          return true;
+        }
+        return false;
+      }
+      
+
+      bool synchronous()
+      {
+        return mSynchronous;
+      }
+
+      void addCompletionMessage(size_t size, char* message)//, void* addr)
+      {
+        mCompletionMsgSize = size;
+        mCompletionMessage = message;
+      }
+       
+//      private:
+        Result mResult;
+        bool mSynchronous;
+        size_t mCompletionMsgSize{0};
+        char* mCompletionMessage{nullptr};
+        Params mParams;
+        bool mOverwriteParams{false};
+    };
+    
+    struct CommandProcessNew: public NRTCommand
+    {
+      CommandProcessNew(World* world, sc_msg_iter* args,void* replyAddr)
+       : mNew{world, args, replyAddr},
+         mProcess{mNew.mID,false,nullptr}
+     {
+        mProcess.mSynchronous = args->geti();
+        mProcess.mReplyAddress = mNew.mReplyAddress;
+     }
+      
+      CommandProcessNew(index id, World* world, FloatControlsIter& args, Unit* x)
+        : mNew{id, world, args, x},
+          mProcess{id}
+      {}
+              
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/processNew";
+        return cmd.c_str();
+      }
+      
+      bool stage2(World* world)
+      {
+        return mNew.stage2(world) ? mProcess.stage2(world) : false;
+      }
+      
+      bool stage3(World* world) //rt
+      {
+        return mProcess.stage3(world);
+      }
+
+      bool stage4(World* world) //nrt
+      {
+        return mProcess.stage4(world);
+      }
+      
+      void cleanup(World* world)
+      {
+        mProcess.mReplyAddress = nullptr; 
+        mProcess.cleanup(world);
+      }
+      
+      bool synchronous()
+      {
+        return mProcess.synchronous();
+      }
+      
+      void addCompletionMessage(size_t size, char* message)
+      {
+        mProcess.addCompletionMessage(size, message);
+      }
+
+    private:
+        CommandNew mNew;
+        CommandProcess mProcess;
+    };
+    
+    
+    struct CommandCancel: public NRTCommand
+    {
+      CommandCancel(World* world, sc_msg_iter* args, void* replyAddr)
+        : NRTCommand{world, args, replyAddr}
+      {}
+      
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/cancel";
+        return cmd.c_str();
+      }
+      
+      bool stage2(World*)
+      {
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+          auto& client = ptr->mClient;
+          if(!client.synchronous())
+          {
+            client.cancel();
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    
+    struct CommandSetParams: public NRTCommand
+    {
+      CommandSetParams(World* world, sc_msg_iter* args, void* replyAddr)
+        : NRTCommand{world, args, replyAddr}
+      {
+        auto& ar = *args;
+        if(auto ptr = get(NRTCommand::mID).lock())
+        {
+           ptr->mParams.template setParameterValuesRT<ParamsFromOSC>(nullptr, world, ar);
+           Result result = validateParameters(ptr->mParams);
+           ptr->mClient.setParams(ptr->mParams);
+        } else printNotFound(NRTCommand::mID);
+      }
+      
+      static const char* name()
+      {
+        static std::string cmd = std::string(Wrapper::getName()) + "/setParams";
+        return cmd.c_str();
+      }
+    };
+    
+        
+    template<typename Command>
+    static auto runAsyncCommand(World* world, Command* cmd, void* replyAddr,
+                                      size_t completionMsgSize, char* completionMsgData)
+    {
+          auto ft = getInterfaceTable();
+
+          return ft->fDoAsynchronousCommand(world, replyAddr,Command::name(),cmd,
+          [](World* w, void* d) { return static_cast<Command*>(d)->stage2(w); },
+          [](World* w, void* d) { return static_cast<Command*>(d)->stage3(w); },
+          [](World* w, void* d) { return static_cast<Command*>(d)->stage4(w); },
+          [](World* w, void* d)
+          {
+              auto cmd = static_cast<Command*>(d);
+              cmd->cleanup(w);
+              cmd->~Command();
+              getInterfaceTable()->fRTFree(w,d);
+          },
+          static_cast<int>(completionMsgSize), completionMsgData);
+    }
+    
+   
+    static auto runAsyncCommand(World* world, CommandProcess* cmd, void* replyAddr,
+                                      size_t completionMsgSize, char* completionMsgData)
+    {
+          if(!cmd->synchronous())
+          {
+            
+            auto msgcopy = (char*)getInterfaceTable()->fRTAlloc(world,completionMsgSize);
+            memcpy(msgcopy, completionMsgData, completionMsgSize);
+            cmd->addCompletionMessage(completionMsgSize,msgcopy);
+            return runAsyncCommand<CommandProcess>(world, cmd, replyAddr, 0, nullptr);
+          }
+          else return runAsyncCommand<CommandProcess>(world, cmd, replyAddr, completionMsgSize, completionMsgData);
+    }
+   
+    static auto runAsyncCommand(World* world, CommandProcessNew* cmd, void* replyAddr,
+                                      size_t completionMsgSize, char* completionMsgData)
+    {
+          if(!cmd->synchronous())
+          {
+            auto msgcopy = (char*)getInterfaceTable()->fRTAlloc(world,completionMsgSize);
+            memcpy(msgcopy, completionMsgData, completionMsgSize);
+            cmd->addCompletionMessage(completionMsgSize,msgcopy);
+            return runAsyncCommand<CommandProcessNew>(world, cmd, replyAddr, 0, nullptr);
+          }
+          else return runAsyncCommand<CommandProcessNew>(world, cmd, replyAddr, completionMsgSize, completionMsgData);
+    }
+  
+  
+    template<typename Command>
+    static void defineNRTCommand()
+    {
+      auto ft = getInterfaceTable();
+      auto commandRunner = [](World* world, void*, struct sc_msg_iter* args, void* replyAddr)
+      {
+          
+          auto ft = getInterfaceTable();
+          void* space = ft->fRTAlloc(world,sizeof(Command));
+          Command* cmd = new (space) Command(world, args, replyAddr);
+          //This is brittle, but can't think of something better offhand
+          //This is the only place we can check for a completion message at the end of the OSC packet
+          //beause it has to be passed on to DoAsynhronousCommand at this point. However, detecting correctly
+          //relies on the Command type having fully consumed arguments from the args iterator in the constructor for cmd
+          size_t completionMsgSize{args ? args->getbsize() : 0};
+          assert(completionMsgSize <= std::numeric_limits<int>::max());
+          char* completionMsgData = nullptr;
+          
+          if (completionMsgSize) {
+            completionMsgData = (char*)ft->fRTAlloc(world, completionMsgSize);
+            args->getb(completionMsgData, completionMsgSize);
+          }
+          runAsyncCommand(world, cmd, replyAddr, completionMsgSize, completionMsgData);
+          
+          if(completionMsgSize) ft->fRTFree(world, completionMsgData); 
+          
+      };
+      ft->fDefinePlugInCmd(Command::name(),commandRunner,nullptr);
+    }
+    
+    
+    
+    struct NRTProgressUnit: SCUnit
+    {
+    
+      static const char* name()
+      {
+        static std::string n = std::string(Wrapper::getName()) + "Monitor";
+        return n.c_str();
+      }
+    
+      NRTProgressUnit()
+      {
+        mInterval = static_cast<index>(0.02 / controlDur());
+        set_calc_function<NRTProgressUnit, &NRTProgressUnit::next>();
+        Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
+      }
+      
+      void next(int)
+      {
+        if (0 == mCounter++)
+        {
+          index id = static_cast<index>(mInBuf[0][0]);
+          if(auto ptr = get(id).lock())
+          {
+            if(ptr->mClient.done()) mDone = 1;
+            out0(0) = static_cast<float>(ptr->mClient.progress());
+          }
+          else
+            std::cout << "WARNING: No " << Wrapper::getName() << " with ID " << id << std::endl;
+        }
+        mCounter %= mInterval;
+      }
+      
+    private:
+      index mInterval;
+      index mCounter{0};
+    };
+    
+    
+    struct NRTTriggerUnit: SCUnit
+    {
+      
+      static index count(){
+        static index counter = -1;
+        return counter--;
+      }
+      
+      index ControlOffset() { return mSpecialIndex + 1; }
+      
+      index ControlSize()
+      {
+        return index(mNumInputs)
+                - mSpecialIndex //used for oddball cases
+                - 3; //id + trig + blocking;
+      }
+      
+      static const char* name()
+      {
+        static std::string n = std::string(Wrapper::getName()) + "Trigger";
+        return n.c_str();
+      }
+      
+      NRTTriggerUnit()
+      : mControlsIterator{mInBuf + ControlOffset(),ControlSize()},mParams{Client::getParameterDescriptors()}
+      {
+        mID = static_cast<index>(mInBuf[0][0]);
+        if(mID == -1) mID = count();
+        auto cmd = NonRealTime::rtalloc<CommandNew>(mWorld,mID,mWorld, mControlsIterator, this);
+        runAsyncCommand(mWorld, cmd, nullptr, 0, nullptr);
+        mInst = get(mID);
+        set_calc_function<NRTTriggerUnit, &NRTTriggerUnit::next>();
+        Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
+      }
+      
+      ~NRTTriggerUnit()
+      {
+        if(auto ptr = mInst.lock())
+        {
+          auto cmd = NonRealTime::rtalloc<CommandFree>(mWorld,mID);
+          runAsyncCommand(mWorld, cmd, nullptr, 0, nullptr); 
+        }
+      }
+      
+      void next(int)
+      {
+      
+        
+        index triggerInput = static_cast<index>(mInBuf[static_cast<index>(mNumInputs) - 2][0]);
+        mTrigger = mTrigger || triggerInput;
+        
+//        if(auto ptr = mInst->lock())
+//        if(auto ptr = get(mID).lock())
+//        {
+          bool  trigger = (!mPreviousTrigger) && triggerInput;//mTrigger;
+          mPreviousTrigger = triggerInput;
+          mTrigger = 0;
+//          auto& client = ptr->mClient;
+                  
+          if(trigger)
+          {
+            mControlsIterator.reset(1 + mInBuf); //add one for ID
+//            auto& params = ptr->mParams;
+            Wrapper::setParams(this,mParams,mControlsIterator,true,false);
+            bool blocking = mInBuf[mNumInputs - 1][0] > 0;
+            CommandProcess* cmd = rtalloc<CommandProcess>(mWorld,mID,blocking,&mParams);
+            runAsyncCommand(mWorld,cmd, nullptr,0, nullptr);
+            mRunCount++;
+          }
+          else
+          {
+              if(auto ptr = get(mID).lock())
+              {
+                auto& client = ptr->mClient;
+                mDone = ptr->mDone;
+                out0(0) = mDone ? 1 : static_cast<float>(client.progress());
+              }
+          }
+//        }
+//        else printNotFound(id);
+      }
+      
+    private:
+      bool mPreviousTrigger{false};
+      bool mTrigger{false};
+      Result mResult;
+      impl::FloatControlsIter mControlsIterator;
+      index mID;
+      index mRunCount{0};
+      WeakCacheEntryPointer mInst;
+      Params mParams;
+    };
+    
+    struct NRTModelQueryUnit: SCUnit
+    {
+      using Delegate = impl::RealTimeBase<Client,Wrapper>;
+      
+      index ControlOffset() { return mSpecialIndex + 2; }
+      index ControlSize()
+      { 
+        return index(mNumInputs)
+                - mSpecialIndex //used for oddball cases
+                - 2; // trig + id
+      }
+      
+      static const char* name()
+      {
+        static std::string n = std::string(Wrapper::getName()) + "Query";
+        return n.c_str();
+      }
+            
+      NRTModelQueryUnit()
+        //Offset controls by 1 to account for ID
+      : mControls{mInBuf + ControlOffset(),ControlSize()}
+      {
+        index id = static_cast<index>(in0(1));
+        mInst = get(id);
+        if(auto ptr = mInst.lock())
+        {
+          auto& client = ptr->mClient;
+          mDelegate.init(*this,client,mControls);
+          set_calc_function<NRTModelQueryUnit, &NRTModelQueryUnit::next>();
+          Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
+        }else printNotFound(id);
+      }
+      
+      void next(int)
+      {
+        index id = static_cast<index>(in0(1));
+        if(auto ptr = mInst.lock())
+        {
+          auto& client = ptr->mClient;
+          auto& params = ptr->mParams;
+          mControls.reset(mInBuf + ControlOffset());
+          mDelegate.next(*this,client,params,mControls);
+        }else printNotFound(id);
+      }
+      
+    private:
+      Delegate mDelegate;
+      FloatControlsIter mControls;
+      index mID;
+      WeakCacheEntryPointer mInst;
+    };
+    
+    
+    using ParamSetType = typename Client::ParamSetType;
+    
+    template <size_t N, typename T>
+    using SetupMessageCmd = typename FluidSCMessaging<Wrapper,Client>::template SetupMessageCmd<N,T>;
+  
+  
+    template<bool, typename CommandType>
+    struct DefineCommandIf
+    {
+      void operator()() { }
+    };
+
+
+    template<typename CommandType>
+    struct DefineCommandIf<true, CommandType>
+    {
+      void operator()() {
+        // std::cout << CommandType::name() << std::endl; 
+        defineNRTCommand<CommandType>();
+      }
+    };
+    
+    template<bool, typename UnitType>
+    struct RegisterUnitIf
+    {
+      void operator()(InterfaceTable*) {}
+    };
+
+    template<typename UnitType>
+    struct RegisterUnitIf<true, UnitType>
+    {
+      void operator()(InterfaceTable* ft) { registerUnit<UnitType>(ft,UnitType::name()); }
+    };
+
+    
+    using IsRTQueryModel_t = typename Client::isRealTime;
+    static constexpr bool IsRTQueryModel = IsRTQueryModel_t::value;
+       
+    static constexpr bool IsModel =  Client::isModelObject::value;
+       
+  
+  public:
+    static void setup(InterfaceTable* ft, const char*)
+    {
+      defineNRTCommand<CommandNew>();
+      DefineCommandIf<!IsRTQueryModel, CommandProcess>()();
+      DefineCommandIf<!IsRTQueryModel, CommandProcessNew>()();
+      DefineCommandIf<!IsRTQueryModel, CommandCancel>()();
+      
+      DefineCommandIf<IsModel,CommandSetParams>()();
+      
+      defineNRTCommand<CommandFree>();
+      RegisterUnitIf<!IsRTQueryModel,NRTProgressUnit>()(ft);
+      RegisterUnitIf<!IsRTQueryModel,NRTTriggerUnit>()(ft);
+
+      RegisterUnitIf<IsRTQueryModel,NRTModelQueryUnit>()(ft);
+      Client::getMessageDescriptors().template iterate<SetupMessageCmd>();
+      
+      
+      static std::string flushCmd = std::string(Wrapper::getName()) + "/flush";
+      
+      ft->fDefinePlugInCmd(flushCmd.c_str(),[](World*, void*, struct sc_msg_iter*, void* ){
+        mCache.clear();
+      },nullptr);
+    }
+
+
+    void init(){};
+
+  private:
+    static Result validateParameters(ParamSetType& p)
+    {
+      auto results = p.constrainParameterValues();
+      for (auto& r : results)
+      {
+        if (!r.ok()) return r;
+      }
+      return {};
+    }
+
+    template <size_t N, typename T>
+    struct AssignBuffer
+    {
+      void operator()(const typename BufferT::type& p, World* w)
+      {
+        if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->assignToRT(w);
+      }
+    };
+
+    template <size_t N, typename T>
+    struct CleanUpBuffer
+    {
+      void operator()(const typename BufferT::type& p)
+      {
+        if (auto b = static_cast<SCBufferAdaptor*>(p.get())) b->cleanUp();
+      }
+    };
+
+    FifoMsg      mFifoMsg;
+    char*        mCompletionMessage = nullptr;
+    void*        mReplyAddr = nullptr;
+    const char*  mName = nullptr;
+    index        checkThreadInterval;
+    index        pollCounter{0};
+    index        mPreviousTrigger{0};
+    bool         mSynchronous{true};
+    Result       mResult;
+  };
+  
+  template<typename Client, typename Wrapper>
+  typename NonRealTime<Client, Wrapper>::Cache  NonRealTime<Client,Wrapper>::mCache{};
+  
+} 
+}
+}
diff --git a/include/wrapper/RealTimeBase.hpp b/include/wrapper/RealTimeBase.hpp
new file mode 100644
index 0000000..ab4e324
--- /dev/null
+++ b/include/wrapper/RealTimeBase.hpp
@@ -0,0 +1,166 @@
+#pragma once 
+
+#include <SC_PlugIn.hpp>
+
+namespace fluid{
+namespace client{
+namespace impl{
+  template <typename Client, class Wrapper>
+  struct RealTimeBase
+  {    
+    using HostVector = FluidTensorView<float, 1>;
+    using Params = typename Client::ParamSetType;
+    template<typename T, bool>
+      struct doExpectedCount;
+      
+      template<typename T>
+      struct doExpectedCount<T, false>
+      {
+        static void count(const T& d,FloatControlsIter& c,Result& status)
+        {
+          if(!status.ok()) return;
+          
+          if(c.remain())
+          {
+            index statedSize = d.fixedSize;
+            
+            if(c.remain() < statedSize)
+                status =  {Result::Status::kError,"Ran out of arguments at ", d.name};
+            
+            //fastforward
+            for(index i=0; i < statedSize; ++i) c.next();
+            
+          }
+        }
+      };
+
+      template<typename T>
+      struct doExpectedCount<T, true>
+      {
+        static void count(const T& d,FloatControlsIter& c,Result& status)
+        {
+          if(!status.ok()) return;
+          
+          if(c.remain())
+          {
+            index statedSize = 1; 
+          
+            if(c.remain() < statedSize)
+                status =  {Result::Status::kError,"Ran out of arguments at ", d.name};
+            
+            //fastforward
+            for(index i=0; i < statedSize; ++i) c.next();
+            
+          }
+        }
+      };
+    template<size_t N, typename T>
+    struct ExpectedCount{
+      void operator ()(const T& descriptor,FloatControlsIter& c, Result& status)
+      {
+        doExpectedCount<T,IsSharedClientRef<typename T::type>::value>::count(descriptor,c,status);
+      }
+    };
+
+    Result expectedSize(FloatControlsIter& controls)
+    {
+      if(controls.size() < Client::getParameterDescriptors().count())
+      {
+        return {Result::Status::kError,"Fewer parameters than exepected. Got ", controls.size(), "expect at least", Client::getParameterDescriptors().count()};
+      }
+      
+      Result countScan;
+      Client::getParameterDescriptors().template iterate<ExpectedCount>(
+          std::forward<FloatControlsIter&>(controls),
+          std::forward<Result&>(countScan));
+      return countScan;
+    }
+
+    // static index ControlOffset(Unit* unit) { return unit->mSpecialIndex + 1; }
+    // static index ControlSize(Unit* unit) { return static_cast<index>(unit->mNumInputs) - unit->mSpecialIndex - 1  -(IsModel_t<Client>::value ? 1 : 0); }
+    
+    void init(SCUnit& unit, Client& client, FloatControlsIter& controls)
+    {
+      assert(!(client.audioChannelsOut() > 0 && client.controlChannelsOut() > 0) &&"Client can't have both audio and control outputs");
+      // consoltr.reset(unit.mInBuf + unit.mSpecialIndex + 1);
+      client.sampleRate(unit.fullSampleRate());
+      mInputConnections.reserve(asUnsigned(client.audioChannelsIn()));
+      mOutputConnections.reserve(asUnsigned(client.audioChannelsOut()));
+      mAudioInputs.reserve(asUnsigned(client.audioChannelsIn()));
+      mOutputs.reserve(asUnsigned(
+          std::max(client.audioChannelsOut(), client.controlChannelsOut())));
+
+
+          Result r;
+          if(!(r = expectedSize(controls)).ok())
+          {
+//            mCalcFunc = Wrapper::getInterfaceTable()->fClearUnitOutputs;
+            std::cout
+                << "ERROR: " << Wrapper::getName()
+                << " wrong number of arguments."
+                << r.message()
+                << std::endl;
+            return;
+          }
+
+
+      for (index i = 0; i < client.audioChannelsIn(); ++i)
+      {
+        mInputConnections.emplace_back(unit.isAudioRateIn(static_cast<int>(i)));
+        mAudioInputs.emplace_back(nullptr, 0, 0);
+      }
+
+      for (index i = 0; i < client.audioChannelsOut(); ++i)
+      {
+        mOutputConnections.emplace_back(true);
+        mOutputs.emplace_back(nullptr, 0, 0);
+      }
+
+      for (index i = 0; i < client.controlChannelsOut(); ++i)
+      { 
+        mOutputs.emplace_back(nullptr, 0, 0); 
+      }
+   }
+    
+   void next(SCUnit& unit, Client& client,Params& params,FloatControlsIter& controls)
+   {   
+     bool trig =  IsModel_t<Client>::value ? !mPrevTrig  && unit.in0(0) > 0 : false;
+
+     mPrevTrig = trig;
+     
+     Wrapper::setParams(&unit, params, controls);
+     params.constrainParameterValuesRT(nullptr);
+     
+     for (index i = 0; i < client.audioChannelsIn(); ++i)
+     {
+        assert(i <= std::numeric_limits<int>::max());
+       if (mInputConnections[asUnsigned(i)])
+         mAudioInputs[asUnsigned(i)].reset(const_cast<float*>(unit.in(static_cast<int>(i))), 0,unit.fullBufferSize());
+     }
+     
+     for (index i = 0; i < client.audioChannelsOut(); ++i)
+     {
+       assert(i <= std::numeric_limits<int>::max());
+       if (mOutputConnections[asUnsigned(i)])
+         mOutputs[asUnsigned(i)].reset(unit.out(static_cast<int>(i)), 0,
+                                       unit.fullBufferSize());
+     }
+     
+     for (index i = 0; i < client.controlChannelsOut(); ++i)
+     {
+       assert(i <= std::numeric_limits<int>::max());
+       mOutputs[asUnsigned(i)].reset(unit.out(static_cast<int>(i)), 0, 1);
+     }
+     client.process(mAudioInputs, mOutputs, mContext);
+   }  
+  private:
+    std::vector<bool>       mInputConnections;
+    std::vector<bool>       mOutputConnections;
+    std::vector<HostVector> mAudioInputs;
+    std::vector<HostVector> mOutputs;
+    FluidContext            mContext;
+    bool                    mPrevTrig;    
+  };
+}
+}
+}
diff --git a/include/wrapper/Realtime.hpp b/include/wrapper/Realtime.hpp
new file mode 100644
index 0000000..64bff83
--- /dev/null
+++ b/include/wrapper/Realtime.hpp
@@ -0,0 +1,129 @@
+#pragma once
+
+#include "ArgsFromClient.hpp"
+#include "Meta.hpp"
+#include "RealTimeBase.hpp"
+#include <clients/common/FluidBaseClient.hpp>
+#include <SC_PlugIn.hpp>
+
+// Real Time Processor
+namespace fluid {
+namespace client {  
+namespace impl {
+  
+template <typename Client, class Wrapper>
+class RealTime : public SCUnit
+{
+  
+  using Delegate = impl::RealTimeBase<Client,Wrapper>;
+  using Params = typename Client::ParamSetType;
+  
+public:
+
+  // static index ControlOffset(Unit* unit) { return Delegate::ControlOffset(unit); }
+  // static index ControlSize(Unit* unit)   { return Delegate::ControlSize(unit); }
+
+  static index ControlOffset(Unit* unit) { return unit->mSpecialIndex + 1; }
+  static index ControlSize(Unit* unit) 
+  { 
+    return static_cast<index>(unit->mNumInputs) 
+                                - unit->mSpecialIndex 
+                                - 1  
+                                - (IsModel_t<Client>::value ? 1 : 0); 
+  }
+
+  static void setup(InterfaceTable* ft, const char* name)
+  {
+    
+    registerUnit<RealTime>(ft,name);
+    ft->fDefineUnitCmd(name, "latency", doLatency);
+  }
+
+  static void doLatency(Unit* unit, sc_msg_iter*)
+  {
+    float l[]{
+         static_cast<float>(static_cast<RealTime*>(unit)->mClient.latency())
+    };
+    auto ft = Wrapper::getInterfaceTable();
+
+    std::stringstream ss;
+    ss << '/' << Wrapper::getName() << "_latency";
+    // std::cout << ss.str() << ": " << l[0] << std::endl;
+    ft->fSendNodeReply(&unit->mParent->mNode, -1, ss.str().c_str(), 1, l);
+  }
+
+  RealTime()
+    : mControls{mInBuf + ControlOffset(this),ControlSize(this)},
+      mClient{Wrapper::setParams(this, mParams, mControls,true)}
+  {
+    init();
+  }
+
+  void init()
+  {
+//    auto& client = mClient;
+  
+    mDelegate.init(*this,mClient,mControls);
+    mCalcFunc = make_calc_function<RealTime, &RealTime::next>();
+    Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
+
+    // assert(
+    //     !(client.audioChannelsOut() > 0 && client.controlChannelsOut() > 0) &&
+    //     "Client can't have both audio and control outputs");
+    // 
+    // Result r;
+    // if(!(r = expectedSize(mWrapper->mControlsIterator)).ok())
+    // {
+    //   mCalcFunc = Wrapper::getInterfaceTable()->fClearUnitOutputs;
+    //   std::cout
+    //       << "ERROR: " << Wrapper::getName()
+    //       << " wrong number of arguments."
+    //       << r.message()
+    //       << std::endl;
+    //   return;
+    // }
+    // 
+    // mWrapper->mControlsIterator.reset(mInBuf + mSpecialIndex + 1);
+    // 
+    // client.sampleRate(fullSampleRate());
+    // mInputConnections.reserve(asUnsigned(client.audioChannelsIn()));
+    // mOutputConnections.reserve(asUnsigned(client.audioChannelsOut()));
+    // mAudioInputs.reserve(asUnsigned(client.audioChannelsIn()));
+    // mOutputs.reserve(asUnsigned(
+    //     std::max(client.audioChannelsOut(), client.controlChannelsOut())));
+    // 
+    // for (index i = 0; i < client.audioChannelsIn(); ++i)
+    // {
+    //   mInputConnections.emplace_back(isAudioRateIn(static_cast<int>(i)));
+    //   mAudioInputs.emplace_back(nullptr, 0, 0);
+    // }
+    // 
+    // for (index i = 0; i < client.audioChannelsOut(); ++i)
+    // {
+    //   mOutputConnections.emplace_back(true);
+    //   mOutputs.emplace_back(nullptr, 0, 0);
+    // }
+    // 
+    // for (index i = 0; i < client.controlChannelsOut(); ++i)
+    // { mOutputs.emplace_back(nullptr, 0, 0); }
+    // 
+    // mCalcFunc = make_calc_function<RealTime, &RealTime::next>();
+    // Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
+  }
+
+  void next(int)
+  {
+    mControls.reset(mInBuf + ControlOffset(this));
+    mDelegate.next(*this,mClient,mParams,mControls);
+  }
+private:
+  Delegate mDelegate;
+  FloatControlsIter   mControls;
+  Params mParams{Client::getParameterDescriptors()};
+  Client mClient;
+  Wrapper* mWrapper{static_cast<Wrapper*>(this)};
+};
+
+}
+}
+}
diff --git a/release-packaging/Classes/FluidAmpGate.sc b/release-packaging/Classes/FluidAmpGate.sc
index 1fe4a29..a751bb0 100644
--- a/release-packaging/Classes/FluidAmpGate.sc
+++ b/release-packaging/Classes/FluidAmpGate.sc
@@ -1,4 +1,4 @@
-FluidAmpGate : UGen {
+FluidAmpGate : FluidRTUGen {
 	*ar { arg in = 0, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, maxSize = 88200;
 		^this.multiNew('audio', in.asAudioRateInput(this), rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq, maxSize)
 	}
diff --git a/release-packaging/Classes/FluidAmpSlice.sc b/release-packaging/Classes/FluidAmpSlice.sc
index d39e1af..e5a133a 100644
--- a/release-packaging/Classes/FluidAmpSlice.sc
+++ b/release-packaging/Classes/FluidAmpSlice.sc
@@ -1,4 +1,4 @@
-FluidAmpSlice : UGen {
+FluidAmpSlice : FluidRTUGen {
 	*ar { arg in = 0, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85;
 
 		^this.multiNew('audio', in.asAudioRateInput(this), fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq)
diff --git a/release-packaging/Classes/FluidAudioTransport.sc b/release-packaging/Classes/FluidAudioTransport.sc
new file mode 100644
index 0000000..ce46568
--- /dev/null
+++ b/release-packaging/Classes/FluidAudioTransport.sc
@@ -0,0 +1,13 @@
+FluidAudioTransport : FluidRTUGen {
+
+    init { |...theInputs|
+        theInputs;
+        inputs = theInputs;
+        this.specialIndex = 1; //two audio inputs
+        // ^this.initOutputs(1,rate);
+    }
+
+	*ar { arg in = 0, in2 = 0, interpolation = 0.0, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
+		^this.multiNew('audio', in.asAudioRateInput, in2, interpolation, windowSize, hopSize, fftSize, maxFFTSize)
+	}
+}
diff --git a/release-packaging/Classes/FluidBufAmpGate.sc b/release-packaging/Classes/FluidBufAmpGate.sc
index cd32d7b..c644b8d 100644
--- a/release-packaging/Classes/FluidBufAmpGate.sc
+++ b/release-packaging/Classes/FluidBufAmpGate.sc
@@ -1,37 +1,44 @@
-FluidBufAmpGate : UGen {
+FluidBufAmpGate : FluidBufProcessor {
 
-	*new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, doneAction = 0, blocking|
-		var maxSize = max(minLengthAbove + lookBack, max(minLengthBelow,lookAhead));
+	*kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, trig = 1, blocking = 0| 
+        
+        var maxSize = max(minLengthAbove + lookBack, max(minLengthBelow,lookAhead));
 
-		source = source.asUGenInput;
-		indices = indices.asUGenInput;
-
-		source.isNil.if {"FluidBufAmpSlice:  Invalid source buffer".throw};
-		indices.isNil.if {"FluidBufAmpSlice:  Invalid features buffer".throw};
-
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq, maxSize, doneAction, blocking);
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+                
+		^FluidProxyUgen.kr(\FluidBufAmpGateTrigger,-1, source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq,maxSize,  trig, blocking);
 	}
 
-	*kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, doneAction = 0|
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, freeWhenDone = true, action |
 
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq,  doneAction,blocking:0);
-	}
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, action |
+        var maxSize = max(minLengthAbove + lookBack, max(minLengthBelow,lookAhead));
 
-		^FluidNRTProcess.new(
-			server, this, action, [indices]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq
+		source = source ? -1;
+		indices = indices ? -1; 
+
+		^this.new(
+			server, nil, [indices]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq, maxSize, 0],freeWhenDone,action
         );
 	}
 
-     *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, action|
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, rampUp = 10, rampDown = 10, onThreshold = -90, offThreshold = -90, minSliceLength = 1, minSilenceLength = 1, minLengthAbove = 1, minLengthBelow = 1, lookBack = 0, lookAhead = 0, highPassFreq = 85, freeWhenDone = true, action |
 
-		^FluidNRTProcess.new(
-			server, this, action, [indices], blocking: 1
-		).process(
-              source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq
-		);
-	}
+
+        var maxSize = max(minLengthAbove + lookBack, max(minLengthBelow,lookAhead));
+
+       source = source ? -1;
+       indices = indices ? -1; 
+
+       ^this.new(
+           server, nil, [indices]
+       ).processList(
+           [source, startFrame, numFrames, startChan, numChans, indices, rampUp, rampDown, onThreshold, offThreshold, minSliceLength, minSilenceLength, minLengthAbove, minLengthBelow, lookBack, lookAhead, highPassFreq, maxSize, 1],freeWhenDone,action
+        );
+   }
+   
 }
+FluidBufAmpGateTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufAmpSlice.sc b/release-packaging/Classes/FluidBufAmpSlice.sc
index d2ceae4..2787176 100644
--- a/release-packaging/Classes/FluidBufAmpSlice.sc
+++ b/release-packaging/Classes/FluidBufAmpSlice.sc
@@ -1,36 +1,40 @@
-FluidBufAmpSlice : UGen {
+FluidBufAmpSlice : FluidBufProcessor {
 
-	*new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, doneAction = 0, blocking|
+	*kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, trig = 1, blocking = 0| 
+        
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
 
-		source = source.asUGenInput;
-		indices = indices.asUGenInput;
-
-		source.isNil.if {"FluidBufAmpSlice:  Invalid source buffer".throw};
-		indices.isNil.if {"FluidBufAmpSlice:  Invalid features buffer".throw};
-
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq, doneAction, blocking);
+        source.isNil.if {"FluidBufAmpSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufAmpSlice:  Invalid features buffer".throw};
+                
+		^FluidProxyUgen.kr(\FluidBufAmpSliceTrigger, -1, source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq, trig, blocking);
 	}
 
-	*kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, doneAction = 0|
+    *process { |server,source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, freeWhenDone = true, action |
 
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq, doneAction,blocking:0);
-	}
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
 
-    *process { |server,source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, action |
+        source.isNil.if {"FluidBufAmpSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufAmpSlice:  Invalid features buffer".throw};
 
-		^FluidNRTProcess.new(
-			server, this, action, [indices]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq
+		^this.new(server, nil, [indices]).processList(            
+			[source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq,0],freeWhenDone, action
 		);
 	}
 
-     *processBlocking { |server,source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, action|
+    *processBlocking { |server,source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, fastRampUp = 1, fastRampDown = 1, slowRampUp = 100, slowRampDown = 100, onThreshold = -144, offThreshold = -144, floor = -144, minSliceLength = 2, highPassFreq = 85, freeWhenDone = true, action |
+
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufAmpSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufAmpSlice:  Invalid features buffer".throw};
 
-		^FluidNRTProcess.new(
-			server, this, action, [indices], blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq
+		^this.new(server, nil, [indices]).processList(            
+			[source, startFrame, numFrames, startChan, numChans, indices, fastRampUp, fastRampDown, slowRampUp, slowRampDown, onThreshold, offThreshold, floor, minSliceLength, highPassFreq,1],freeWhenDone, action
 		);
 	}
 }
+FluidBufAmpSliceTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufAudioTransport.sc b/release-packaging/Classes/FluidBufAudioTransport.sc
new file mode 100644
index 0000000..5850a0c
--- /dev/null
+++ b/release-packaging/Classes/FluidBufAudioTransport.sc
@@ -0,0 +1,59 @@
+FluidBufAudioTransport : FluidBufProcessor {
+
+    *objectClassName{
+        ^\FluidBufAudioTransp
+    }
+
+	*kr  { |source1, startFrame1 = 0, numFrames1 = -1, startChan1 = 0, numChans1 = -1, source2, startFrame2 = 0, numFrames2 = -1, startChan2 = 0, numChans2 = -1, destination, interpolation = 0.0, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        source1.isNil.if {"FluidAudioTransport:  Invalid source 1 buffer".throw};
+        source2.isNil.if {"FluidAudioTransport:  Invalid source 2 buffer".throw};
+        source1 = source1.asUGenInput;
+        source2 = source2.asUGenInput;
+
+        destination.isNil.if {"FluidAudioTransport:  Invalid destination buffer".throw};
+        destination = destination.asUGenInput;
+
+
+		^FluidProxyUgen.kr(this.objectClassName++\Trigger,-1, source1, startFrame1, numFrames1, startChan1, numChans1, source2, startFrame1, numFrames1, startChan2, numChans2, destination, interpolation, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
+	}
+
+
+	*process { |server, source1, startFrame1 = 0, numFrames1 = -1, startChan1 = 0, numChans1 = -1, source2, startFrame2 = 0, numFrames2 = -1, startChan2 = 0, numChans2 = -1, destination, interpolation=0.0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        source1.isNil.if {"FluidAudioTransport:  Invalid source 1 buffer".throw};
+        source2.isNil.if {"FluidAudioTransport:  Invalid source 2 buffer".throw};
+        source1 = source1.asUGenInput;
+        source2 = source2.asUGenInput;
+
+        destination.isNil.if {"FluidAudioTransport:  Invalid destination buffer".throw};
+        destination = destination.asUGenInput;
+
+		^this.new(
+			server, nil, [destination]
+		).processList(
+			[source1, startFrame1, numFrames1, startChan1, numChans1, source2, startFrame2, numFrames2, startChan2, numChans2, destination, interpolation, windowSize, hopSize, fftSize,maxFFTSize,0], freeWhenDone, action
+		)
+	}
+
+    *processBlocking { |server, source1, startFrame1 = 0, numFrames1 = -1, startChan1 = 0, numChans1 = -1, source2, startFrame2 = 0, numFrames2 = -1, startChan2 = 0, numChans2 = -1, destination, interpolation=0.0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        source1.isNil.if {"FluidAudioTransport:  Invalid source 1 buffer".throw};
+        source2.isNil.if {"FluidAudioTransport:  Invalid source 2 buffer".throw};
+        source1 = source1.asUGenInput;
+        source2 = source2.asUGenInput;
+
+        destination.isNil.if {"FluidAudioTransport:  Invalid destination buffer".throw};
+        destination = destination.asUGenInput;
+
+		^this.new(
+			server, nil, [destination]
+		).processList(
+			[source1, startFrame1, numFrames1, startChan1, numChans1, source2, startFrame2, numFrames2, startChan2, numChans2, destination, interpolation, windowSize, hopSize, fftSize,maxFFTSize,1], freeWhenDone, action
+		)
+	}
+}
+FluidBufAudioTransportTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufCompose.sc b/release-packaging/Classes/FluidBufCompose.sc
index 51d1f80..d5d8cc5 100644
--- a/release-packaging/Classes/FluidBufCompose.sc
+++ b/release-packaging/Classes/FluidBufCompose.sc
@@ -1,34 +1,39 @@
-FluidBufCompose : UGen {
+FluidBufCompose : FluidBufProcessor {
 
-    *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, doneAction = 0, blocking|
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, trig = 1, blocking = 1| 
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
 
-		source = source.asUGenInput;
-		destination = destination.asUGenInput;
+        source.isNil.if {"FluidBufCompose:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufCompose:  Invalid destination buffer".throw};
 
-		source.isNil.if {"FluidBufCompose:  Invalid source buffer".throw};
-		destination.isNil.if {"FluidBufCompose:  Invalid destination buffer".throw};
-
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufComposeTrigger,-1, source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain, trig, blocking);
 	}
 
-/*    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, doneAction = 0|
 
-        ^this.multiNew('control', source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain, doneAction, blocking:1);
-	}*/
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
 
+        source.isNil.if {"FluidBufCompose:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufCompose:  Invalid destination buffer".throw};
+        
+	    ^this.new( server, nil, [destination]).processList([source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain, 1], freeWhenDone, action);//NB always blocking
+	}
 
-	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, action|
-	^FluidNRTProcess.new(
-            server, this, action, [destination], blocking:1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain
-		);
+   *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, freeWhenDone = true, action|
 
-	}
+       source = source.asUGenInput;
+       destination = destination.asUGenInput;
 
-   *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, gain = 1, destination, destStartFrame = 0, destStartChan = 0, destGain = 0, action|
-    ^process(
-	   source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain
-      );
+       source.isNil.if {"FluidBufCompose:  Invalid source buffer".throw};
+       destination.isNil.if {"FluidBufCompose:  Invalid destination buffer".throw};
+       
+       ^this.new(
+           server, nil, [destination]
+       ).processList([source, startFrame, numFrames, startChan, numChans, gain, destination, destStartFrame, destStartChan, destGain, 1], freeWhenDone, action);
 	}
 }
+FluidBufComposeTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufFlatten.sc b/release-packaging/Classes/FluidBufFlatten.sc
new file mode 100644
index 0000000..e204ac1
--- /dev/null
+++ b/release-packaging/Classes/FluidBufFlatten.sc
@@ -0,0 +1,47 @@
+FluidBufFlatten : FluidBufProcessor {
+
+
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, axis = 1, trig = 1, blocking = 1|
+
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufFlatten:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufFlatten:  Invalid destination buffer".throw};
+
+        ^FluidProxyUgen.kr(\FluidBufFlattenTrigger,-1,  source, startFrame, numFrames, startChan, numChans, destination, axis, trig, blocking);
+	}
+
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, axis = 1, freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufFlatten:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufFlatten:  Invalid destination buffer".throw};
+
+	^this.new(
+            server, nil, [destination],
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, axis,0],freeWhenDone,action
+		);
+
+	}
+
+   *processBlocking  { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, axis = 1, freeWhenDone = true, action|
+
+       source = source.asUGenInput;
+       destination = destination.asUGenInput;
+
+       source.isNil.if {"FluidBufFlatten:  Invalid source buffer".throw};
+       destination.isNil.if {"FluidBufFlatten:  Invalid destination buffer".throw};
+
+   ^this.new(
+           server, nil, [destination],
+       ).processList(
+           [source, startFrame, numFrames, startChan, numChans, destination, axis,1],freeWhenDone,action
+       );
+
+   }
+}
+FluidBufFlattenTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufHPSS.sc b/release-packaging/Classes/FluidBufHPSS.sc
index a1f2aef..d8913ad 100644
--- a/release-packaging/Classes/FluidBufHPSS.sc
+++ b/release-packaging/Classes/FluidBufHPSS.sc
@@ -1,45 +1,52 @@
-FluidBufHPSS : UGen {
+FluidBufHPSS : FluidBufProcessor {
 
-	*new1 {|rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking|
+	*kr  {|source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0|
 
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-		source = source.asUGenInput;
-		harmonic = harmonic.asUGenInput;
-		percussive = percussive.asUGenInput;
-		residual = residual.asUGenInput;
-		source.isNil.if {"FluidBufHPSS:  Invalid source buffer".throw};
+        harmonic = harmonic ? -1;
+        percussive = percussive ? -1;
+        residual = residual ? -1;
+        source.isNil.if {"FluidBufHPSS:  Invalid source buffer".throw};
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, maxFFTSize, harmFilterSize, percFilterSize, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufHPSSTrigger, -1, source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, maxFFTSize, harmFilterSize, percFilterSize, trig, blocking
+        );
 	}
 
-	*kr {|source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
+   *process {|server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone=true, action|
 
-        ^this.multiNew(
-            'control', source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, doneAction, blocking:0
-        );
-	}
+       var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+       harmonic = harmonic ? -1;
+       percussive = percussive ? -1;
+       residual = residual ? -1;
+       source.isNil.if {"FluidBufHPSS:  Invalid source buffer".throw};
 
-   *process {|server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
 
-		^FluidNRTProcess.new(
-			server, this, action, [harmonic, percussive, residual].select{|x| x!= -1}
-		).process(
-			source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize
+		^this.new(
+			server, nil, [harmonic, percussive, residual].select{|x| x!= -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, maxFFTSize, harmFilterSize, percFilterSize,0], freeWhenDone,action
 		);
 
 	}
 
-       *processBlocking {|server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
+    *processBlocking {|server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, harmonic = -1, percussive = -1, residual = -1, harmFilterSize = 17, percFilterSize = 31, maskingMode = 0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone=true, action|
 
-		^FluidNRTProcess.new(
-			server, this, action, [harmonic, percussive, residual].select{|x| x!= -1}, blocking:1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize
-		);
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-	}
+        harmonic = harmonic ? -1;
+        percussive = percussive ? -1;
+        residual = residual ? -1;
+        source.isNil.if {"FluidBufHPSS:  Invalid source buffer".throw};
+
+
+ 		^this.new(
+ 			server, nil, [harmonic, percussive, residual].select{|x| x!= -1}
+ 		).processList(
+ 			[source, startFrame, numFrames, startChan, numChans, harmonic, percussive, residual, harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, maxFFTSize,harmFilterSize, percFilterSize,1], freeWhenDone,action
+ 		);
+
+ 	}
 }
+FluidBufHPSSTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufLoudness.sc b/release-packaging/Classes/FluidBufLoudness.sc
index 1b0b994..8b15d68 100644
--- a/release-packaging/Classes/FluidBufLoudness.sc
+++ b/release-packaging/Classes/FluidBufLoudness.sc
@@ -1,5 +1,5 @@
-FluidBufLoudness : UGen{
-    *new1 { |rate,source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, doneAction = 0, blocking = 0|
+FluidBufLoudness : FluidBufProcessor{
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, padding = 1, trig = 1, blocking = 0|
 
         var maxwindowSize = windowSize.nextPowerOfTwo;
 
@@ -9,26 +9,41 @@ FluidBufLoudness : UGen{
         source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
         features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
 
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, features, kWeighting, truePeak, windowSize, hopSize, maxwindowSize, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufLoudnessTrigger, -1, source, startFrame, numFrames, startChan, numChans, features,padding, kWeighting, truePeak, windowSize, hopSize, maxwindowSize, trig, blocking);
     }
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, doneAction = 0|
-        ^this.multiNew('control', source, startFrame, numFrames, startChan, numChans, features, kWeighting, truePeak, windowSize, hopSize, doneAction, blocking:0 );
-    }
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, padding = 1, freeWhenDone = true, action|
+
+        var maxwindowSize = windowSize.nextPowerOfTwo;
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, kWeighting, truePeak, windowSize, hopSize
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features, padding, kWeighting, truePeak, windowSize, hopSize, maxwindowSize,0],freeWhenDone,action
 		);
     }
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features], blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, kWeighting, truePeak, windowSize, hopSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, padding = 1, freeWhenDone = true, action|
+
+        var maxwindowSize = windowSize.nextPowerOfTwo;
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features,padding, kWeighting, truePeak, windowSize, hopSize, maxwindowSize,1],freeWhenDone,action
 		);
     }
 }
+FluidBufLoudnessTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufMFCC.sc b/release-packaging/Classes/FluidBufMFCC.sc
index 458e327..8e371e9 100644
--- a/release-packaging/Classes/FluidBufMFCC.sc
+++ b/release-packaging/Classes/FluidBufMFCC.sc
@@ -1,5 +1,5 @@
-FluidBufMFCC : UGen{
-    *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
+FluidBufMFCC : FluidBufProcessor{
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, trig = 1, blocking = 0|
 
         var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
         source = source.asUGenInput;
@@ -8,30 +8,39 @@ FluidBufMFCC : UGen{
         source.isNil.if {"FluidBufMFCC:  Invalid source buffer".throw};
         features.isNil.if {"FluidBufMFCC:  Invalid features buffer".throw};
 
-        //NB For wrapped versions of NRT classes, we set the params for maxima to
-        //whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-        // same goes to maxNumCoeffs, which is passed numCoeffs in this case
-
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, features, numCoeffs, numBands, minFreq, maxFreq,  numCoeffs, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufMFCCTrigger, -1, source, startFrame, numFrames, startChan, numChans, features, padding, numCoeffs, numBands, minFreq, maxFreq,numCoeffs, windowSize, hopSize, fftSize, maxFFTSize,trig, blocking);
     }
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-        ^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, features, numCoeffs, numBands, minFreq, maxFreq,  numCoeffs, windowSize, hopSize, fftSize, doneAction);
-    }
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone=true, action |
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufMFCC:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufMFCC:  Invalid features buffer".throw};
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, action |
-		^FluidNRTProcess.new(
-			server, this, action, [features]
-		).process(
-			 source, startFrame, numFrames, startChan, numChans, features, numCoeffs, numBands, minFreq, maxFreq, windowSize, hopSize, fftSize
+		^this.new(
+			server, nil,[features]
+		).processList(
+			 [source, startFrame, numFrames, startChan, numChans, features, padding, numCoeffs, numBands, minFreq, maxFreq, numCoeffs,windowSize, hopSize, fftSize, maxFFTSize,0],freeWhenDone,action
 		);
     }
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, action |
-		^FluidNRTProcess.new(
-			server, this, action, [features],blocking: 1
-		).process(
-			 source, startFrame, numFrames, startChan, numChans, features, numCoeffs, numBands, minFreq, maxFreq, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone=true, action |
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufMFCC:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufMFCC:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil,[features]
+		).processList(
+			 [source, startFrame, numFrames, startChan, numChans, features, padding, numCoeffs, numBands, minFreq, maxFreq,numCoeffs, windowSize, hopSize, fftSize, maxFFTSize,1],freeWhenDone,action
 		);
     }
 }
+FluidBufMFCCTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufMelBands.sc b/release-packaging/Classes/FluidBufMelBands.sc
index 6ec3f8f..b11ffb7 100644
--- a/release-packaging/Classes/FluidBufMelBands.sc
+++ b/release-packaging/Classes/FluidBufMelBands.sc
@@ -1,38 +1,51 @@
-FluidBufMelBands : UGen {
-		*new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
+FluidBufMelBands : FluidBufProcessor {
 
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, trig = 1, blocking = 0|
 
-		source = source.asUGenInput;
-		features = features.asUGenInput;
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-		source.isNil.if {"FluidBufMelBands:  Invalid source buffer".throw};
-		features.isNil.if {"FluidBufMelBands:  Invalid features buffer".throw};
+        source = source.asUGenInput;
+        features = features.asUGenInput;
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-		// same for maxNumBands which is passed numBands
+        source.isNil.if {"FluidBufMelBands:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufMelBands:  Invalid features buffer".throw};
 
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, features, numBands, minFreq, maxFreq, numBands, normalize, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
-	}
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, features, numBands, minFreq, maxFreq, numBands, normalize, windowSize, hopSize, fftSize, doneAction);
+		^FluidProxyUgen.kr(\FluidBufMelBandsTrigger,-1, source, startFrame, numFrames, startChan, numChans, features, padding, numBands, minFreq, maxFreq, numBands, normalize, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
 	}
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, numBands, minFreq, maxFreq, normalize, windowSize, hopSize, fftSize
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufMelBands:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufMelBands:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features, padding, numBands, minFreq, maxFreq, numBands, normalize, windowSize, hopSize, fftSize, maxFFTSize, 0],freeWhenDone,action
         );
 	}
 
-   *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features], blocking:1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, numBands, minFreq, maxFreq, normalize, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  numBands = 40, minFreq = 20, maxFreq = 20000, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufMelBands:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufMelBands:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features, padding, numBands, minFreq, maxFreq, numBands, normalize, windowSize, hopSize, fftSize, maxFFTSize, 1],freeWhenDone,action
         );
+	}
 }
-}
\ No newline at end of file
+FluidBufMelBandsTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufNMF.sc b/release-packaging/Classes/FluidBufNMF.sc
index 1d41eed..418a005 100644
--- a/release-packaging/Classes/FluidBufNMF.sc
+++ b/release-packaging/Classes/FluidBufNMF.sc
@@ -1,47 +1,37 @@
-FluidBufNMF : UGen {
-
-        *new1 {|rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth, bases, basesMode = 0, activations, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1, doneAction = 0, blocking = 0|
-
-        source = source.asUGenInput;
-        resynth = resynth.asUGenInput;
-        bases = bases.asUGenInput;
-        activations = activations.asUGenInput;
-
-        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};
+FluidBufNMF : FluidBufProcessor 
+{
+    *kr  {|source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth, bases, basesMode = 0, activations, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1, trig = 1, blocking = 0| 
 
+        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};        
         resynth = resynth ? -1;
         bases = bases ? -1;
         activations = activations ? -1;
 
-        ^super.new1(rate,source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components, iterations, windowSize, hopSize, fftSize, doneAction, blocking);
-
+        ^FluidProxyUgen.kr(\FluidBufNMFTrigger,-1,source.asUGenInput, startFrame, numFrames, startChan, numChans, resynth.asUGenInput, bases.asUGenInput, basesMode, activations.asUGenInput, actMode, components, iterations, windowSize, hopSize, fftSize, trig, blocking);
     }
+    
+    *process { |server,  source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth = -1, bases = -1, basesMode = 0, activations = -1, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1,freeWhenDone = true, action|
 
-    *kr {|source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth, bases, basesMode = 0, activations, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1, doneAction = 0|
-        ^this.multiNew(\control,source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components, iterations, windowSize, hopSize, fftSize, doneAction);
-
-    }
-
-
-    *process { |server,  source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth = -1, bases = -1, basesMode = 0, activations = -1, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1, action|
-
-        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};
-
-		^FluidNRTProcess.new(
-			server, this, action, [resynth, bases, activations].select{|x| x!= -1}
-		).process(
-			source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components,iterations, windowSize, hopSize, fftSize, windowType, randomSeed
-		);
+        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};        
+        resynth = resynth ? -1;
+        bases = bases ? -1;
+        activations = activations ? -1;
+        
+       ^this.new(
+            server,nil,[resynth, bases, activations].select{|x| x!= -1}     
+        ).processList([source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components,iterations, windowSize, hopSize, fftSize,0],freeWhenDone,action); 
     }
+    
+    *processBlocking { |server,  source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth = -1, bases = -1, basesMode = 0, activations = -1, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1,freeWhenDone = true, action|
 
-    *processBlocking { |server,  source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, resynth = -1, bases = -1, basesMode = 0, activations = -1, actMode = 0, components = 1, iterations = 100, windowSize = 1024, hopSize = -1, fftSize = -1, windowType = 0, randomSeed = -1, action|
-
-        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};
-
-		^FluidNRTProcess.new(
-			server, this, action, [resynth, bases, activations].select{|x| x!= -1},blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components,iterations, windowSize, hopSize, fftSize, windowType, randomSeed
-		);
+        source.isNil.if {"FluidBufNMF:  Invalid source buffer".throw};        
+        resynth = resynth ? -1;
+        bases = bases ? -1;
+        activations = activations ? -1;
+        
+       ^this.new(
+            server,nil,[resynth, bases, activations].select{|x| x!= -1}     
+        ).processList([source, startFrame, numFrames, startChan, numChans, resynth, bases, basesMode, activations, actMode, components,iterations, windowSize, hopSize, fftSize, 1],freeWhenDone,action); 
     }
 }
+FluidBufNMFTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufNMFCross.sc b/release-packaging/Classes/FluidBufNMFCross.sc
new file mode 100644
index 0000000..3f0bce8
--- /dev/null
+++ b/release-packaging/Classes/FluidBufNMFCross.sc
@@ -0,0 +1,49 @@
+FluidBufNMFCross : FluidBufProcessor {
+
+    *kr  { |source, target, output , timeSparsity = 7, polyphony = 10, continuity = 7, iterations = 50, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0|
+
+        source = source.asUGenInput;
+        target = target.asUGenInput;
+        output = output.asUGenInput;
+        source.isNil.if {"FluidBufNMFCross:  Invalid source buffer".throw};
+        target.isNil.if {"FluidBufNMFCross:  Invalid target buffer".throw};
+        output.isNil.if {"FluidBufNMFCross:  Invalid output buffer".throw};
+
+		^FluidProxyUgen.kr(\FluidBufNMFCrossTrigger, -1, source, target, output, timeSparsity, polyphony, continuity, iterations,  windowSize, hopSize, fftSize, trig, blocking);
+	}
+
+    *process { |server, source, target, output , timeSparsity = 7, polyphony = 10, continuity = 7, iterations = 50, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        target = target.asUGenInput;
+        output = output.asUGenInput;
+        source.isNil.if {"FluidBufNMFCross:  Invalid source buffer".throw};
+        target.isNil.if {"FluidBufNMFCross:  Invalid target buffer".throw};
+        output.isNil.if {"FluidBufNMFCross:  Invalid output buffer".throw};
+
+
+        ^this.new(
+			server, nil, [output]
+		).processList(
+			[source, target, output, timeSparsity, polyphony, continuity, iterations,  windowSize, hopSize, fftSize,0],freeWhenDone, action
+		);
+	}
+
+    *processBlocking { |server, source, target, output , timeSparsity = 7, polyphony = 10, continuity = 7, iterations = 50, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        target = target.asUGenInput;
+        output = output.asUGenInput;
+        source.isNil.if {"FluidBufNMFCross:  Invalid source buffer".throw};
+        target.isNil.if {"FluidBufNMFCross:  Invalid target buffer".throw};
+        output.isNil.if {"FluidBufNMFCross:  Invalid output buffer".throw};
+
+
+        ^this.new(
+			server, nil, [output]
+		).processList(
+			[source, target, output, timeSparsity, polyphony, continuity, iterations,  windowSize, hopSize, fftSize,1],freeWhenDone, action
+		);
+	}
+}
+FluidBufNMFCrossTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufNNDSVD.sc b/release-packaging/Classes/FluidBufNNDSVD.sc
new file mode 100644
index 0000000..3aeb6ce
--- /dev/null
+++ b/release-packaging/Classes/FluidBufNNDSVD.sc
@@ -0,0 +1,48 @@
+FluidBufNNDSVD : FluidBufProcessor{
+
+	*kr  { |source, bases, activations, minComponents = 1, maxComponents = 200, coverage = 0.5, method = 0, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0| 
+        
+        source.isNil.if {"FluidBufNNDSVD:  Invalid source buffer".throw};
+        bases.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        activations.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        source = source.asUGenInput;
+        bases = bases.asUGenInput;
+        activations = activations.asUGenInput;
+        
+		^FluidProxyUgen.kr1(\FluidBufNNDSVDTrigger, -1, source, bases, activations, minComponents, maxComponents, coverage, method, windowSize, hopSize, fftSize, trig, blocking);
+	}
+
+
+	*process { |server, source, bases, activations, minComponents = 1, maxComponents = 200, coverage = 0.5, method = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+        
+        source.isNil.if {"FluidBufNNDSVD:  Invalid source buffer".throw};
+        bases.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        activations.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        source = source.asUGenInput;
+        bases = bases.asUGenInput;
+        activations = activations.asUGenInput;
+                
+		^this.new(
+			server, nil, [bases]
+		).processList(
+			[source, bases, activations, minComponents, maxComponents, coverage, method, windowSize, hopSize, fftSize,0],freeWhenDone, action
+		)
+	}
+
+    *processBlocking { |server, source, bases, activations, minComponents = 1, maxComponents = 200, coverage = 0.5, method = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+        
+        source.isNil.if {"FluidBufNNDSVD:  Invalid source buffer".throw};
+        bases.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        activations.isNil.if {"FluidBufNNDSVD:  Invalid bases buffer".throw};
+        source = source.asUGenInput;
+        bases = bases.asUGenInput;
+        activations = activations.asUGenInput;
+                
+		^this.new(
+			server, nil, [bases]
+		).processList(
+			[source, bases, activations, minComponents, maxComponents, coverage, method, windowSize, hopSize, fftSize,1],freeWhenDone, action
+		)
+	}
+}
+FluidBufNNDSVDTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufNoveltySlice.sc b/release-packaging/Classes/FluidBufNoveltySlice.sc
index 7467349..b6c5dc9 100644
--- a/release-packaging/Classes/FluidBufNoveltySlice.sc
+++ b/release-packaging/Classes/FluidBufNoveltySlice.sc
@@ -1,7 +1,8 @@
-FluidBufNoveltySlice : UGen {
-		*new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0 |
+FluidBufNoveltySlice : FluidBufProcessor {
 
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1 , blocking = 0| 
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
 		source = source.asUGenInput;
 		indices = indices.asUGenInput;
@@ -9,29 +10,42 @@ FluidBufNoveltySlice : UGen {
 		source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
 		indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
 
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize, maxFFTSize, kernelSize, filterSize, doneAction, blocking);
+		^FluidProxyUgen.kr(\FluidBufNoveltySliceTrigger, -1, source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize, maxFFTSize, kernelSize, filterSize, trig, blocking);
 
 	}
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0 |
-
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize, doneAction);
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action |
+        
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-	}
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, action |
-		^FluidNRTProcess.new(
-			server, this, action, [indices]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize
+        source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
+        
+		^this.new(
+			server, nil, [indices]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize,  maxFFTSize, kernelSize, filterSize,0],freeWhenDone,action
 		);
 	}
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, action |
-		^FluidNRTProcess.new(
-			server, this, action, [indices], blocking:1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, feature = 0, kernelSize = 3, threshold = 0.5, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action |
+        
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
+        
+		^this.new(
+			server, nil, [indices]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, indices, feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize, maxFFTSize, kernelSize, filterSize,1],freeWhenDone,action
 		);
 	}
 }
+FluidBufNoveltySliceTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufOnsetSlice.sc b/release-packaging/Classes/FluidBufOnsetSlice.sc
index 218e71c..2f9a754 100644
--- a/release-packaging/Classes/FluidBufOnsetSlice.sc
+++ b/release-packaging/Classes/FluidBufOnsetSlice.sc
@@ -1,37 +1,49 @@
-FluidBufOnsetSlice : UGen {
-    *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
-
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
-
-		source = source.asUGenInput;
-		indices = indices.asUGenInput;
+FluidBufOnsetSlice : FluidBufProcessor {
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0| 
+        
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufOnsetSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufOnsetSlice:  Invalid features buffer".throw};
+                
+		^FluidProxyUgen.kr(\FluidBufOnsetSliceTrigger, -1, source, startFrame, numFrames, startChan, numChans, indices, metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
+	}
 
-		source.isNil.if {"FluidBufOnsetSlice:  Invalid source buffer".throw};
-		indices.isNil.if {"FluidBufOnsetSlice:  Invalid features buffer".throw};
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+        
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
 
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, indices, metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
+        source.isNil.if {"FluidBufOnsetSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufOnsetSlice:  Invalid features buffer".throw};
+                
+		^this.new(
+			server, nil, [indices]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, indices,  metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize,maxFFTSize,0],freeWhenDone,action
+		);
 	}
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, indices, metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize, doneAction);
-	}
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+        
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [indices]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices,  metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize
-		);
-	}
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
 
-     *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [indices], blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, indices,  metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize
+        source.isNil.if {"FluidBufOnsetSlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufOnsetSlice:  Invalid features buffer".throw};
+                
+		^this.new(
+			server, nil, [indices]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, indices,  metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize,maxFFTSize,1],freeWhenDone,action
 		);
 	}
 }
+FluidBufOnsetSliceTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufPitch.sc b/release-packaging/Classes/FluidBufPitch.sc
index 71e89c7..d62190b 100644
--- a/release-packaging/Classes/FluidBufPitch.sc
+++ b/release-packaging/Classes/FluidBufPitch.sc
@@ -1,39 +1,51 @@
-FluidBufPitch : UGen{
+FluidBufPitch : FluidBufProcessor{
 
-    *new1 {|rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
+	*kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, trig = 1, blocking = 0|
 
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-		source = source.asUGenInput;
-		features = features.asUGenInput;
+        source = source.asUGenInput;
+        features = features.asUGenInput;
 
-		source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
-		features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
+        source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, features, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufPitchTrigger, -1, source, startFrame, numFrames, startChan, numChans, features, padding, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
 
 	}
 
-		*kr {|source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-        ^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, features, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, doneAction);
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
 
-	}
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize
+        source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features, padding, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, maxFFTSize, 0], freeWhenDone, action
 		);
 	}
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features], blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, features, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        features = features.asUGenInput;
+
+        source.isNil.if {"FluidBufPitch:  Invalid source buffer".throw};
+        features.isNil.if {"FluidBufPitch:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, features, padding, algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, maxFFTSize, 1], freeWhenDone, action
 		);
 	}
 }
+FluidBufPitchTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufSTFT.sc b/release-packaging/Classes/FluidBufSTFT.sc
new file mode 100644
index 0000000..3726ef2
--- /dev/null
+++ b/release-packaging/Classes/FluidBufSTFT.sc
@@ -0,0 +1,47 @@
+FluidBufSTFT : FluidBufProcessor {
+
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, magnitude, phase, resynth, inverse = 0,windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, trig = 1, blocking = 1|
+
+        // source = source.asUGenInput;
+
+        // source.isNil.if {"FluidBufScale:  Invalid source buffer".throw};
+        source = source ? -1;
+        magnitude = magnitude ? -1;
+        phase = phase ? -1;
+        resynth = resynth ? - 1;
+
+        ^FluidProxyUgen.kr(\FluidBufSTFTTrigger, -1, source, startFrame, numFrames, startChan, magnitude, phase, resynth, inverse, padding, windowSize, hopSize, fftSize, trig, blocking);
+	}
+
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, magnitude, phase, resynth, inverse = 0, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
+
+        // source = source.asUGenInput;
+
+        // source.isNil.if {"FluidBufSTFT:  Invalid source buffer".throw};
+        source = source ? -1;
+        magnitude = magnitude ? -1;
+        phase = phase ? -1;
+        resynth = resynth ? - 1;
+
+	    ^this.new(
+            server, nil, [magnitude,phase,resynth].select{|b| b != -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, magnitude, phase, resynth, inverse, padding, windowSize, hopSize, fftSize, 0], freeWhenDone, action
+		);
+	}
+
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, magnitude, phase, resynth, inverse = 0, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1,freeWhenDone = true, action|
+
+        // source = source.asUGenInput;
+        source = source ? -1;
+        magnitude = magnitude ? -1;
+        phase = phase ? -1;
+        resynth = resynth ? - 1;
+
+	    ^this.new(
+            server, nil, [magnitude,phase,resynth].select{|b| b != -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, magnitude, phase, resynth, inverse, padding, windowSize, hopSize, fftSize, 1], freeWhenDone, action
+		);
+	}
+}
diff --git a/release-packaging/Classes/FluidBufScale.sc b/release-packaging/Classes/FluidBufScale.sc
new file mode 100644
index 0000000..62c47e7
--- /dev/null
+++ b/release-packaging/Classes/FluidBufScale.sc
@@ -0,0 +1,44 @@
+FluidBufScale : FluidBufProcessor {
+
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, inputLow = 0, inputHigh = 1, outputLow = 0, outputHigh = 1, trig = 1, blocking = 1|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufScale:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufScale:  Invalid destination buffer".throw};
+        
+        ^FluidProxyUgen.kr(\FluidBufScaleTrigger, -1, source, startFrame, numFrames, startChan, numChans, destination, inputLow, inputHigh, outputLow, outputHigh, trig, blocking);
+	}
+
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, inputLow = 0, inputHigh = 1, outputLow = 0, outputHigh = 1, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufScale:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufScale:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, inputLow, inputHigh, outputLow, outputHigh, 0], freeWhenDone, action
+		);
+	}
+
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, inputLow = 0, inputHigh = 1, outputLow = 0, outputHigh = 1, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufScale:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufScale:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, inputLow, inputHigh, outputLow, outputHigh, 1], freeWhenDone, action
+		);
+	}
+}
+FluidBufScaleTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufSelect.sc b/release-packaging/Classes/FluidBufSelect.sc
new file mode 100644
index 0000000..ff0a9d7
--- /dev/null
+++ b/release-packaging/Classes/FluidBufSelect.sc
@@ -0,0 +1,62 @@
+FluidBufSelect : FluidBufProcessor {
+
+    *kr  { |source, destination, indices=#[-1], channels=#[-1], trig = 1, blocking = 1|
+
+        var params;
+
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        indices = indices.asArray;
+        channels = channels.asArray;
+
+        indices = [indices.size] ++ indices;
+        channels = [channels.size] ++ channels;
+
+        source.isNil.if {"FluidBufSelect:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufSelect:  Invalid destination buffer".throw};
+
+        params = indices ++ channels ++ [trig, blocking]
+
+        ^FluidProxyUgen.kr(\FluidBufSelectTrigger,-1, source, destination, *params);
+	}
+
+
+	*process { |server, source, destination, indices=#[-1], channels=#[-1], freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufSelect:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufSelect:  Invalid destination buffer".throw};
+
+        indices = indices.asArray;
+        channels = channels.asArray;
+
+		indices = [indices.size] ++ indices;
+        channels = [channels.size] ++ channels;
+
+        ^this.new(server, nil, [destination]).processList([source, destination]++ indices ++ channels ++ [1], freeWhenDone, action);//NB always blocking
+	}
+
+   *processBlocking { |server, source, destination, indices=#[-1], channels=#[-1], freeWhenDone = true, action|
+
+       source = source.asUGenInput;
+       destination = destination.asUGenInput;
+
+       source.isNil.if {"FluidBufSelect:  Invalid source buffer".throw};
+       destination.isNil.if {"FluidBufSelect:  Invalid destination buffer".throw};
+
+       indices = indices.asArray;
+       channels = channels.asArray;
+
+       indices = [indices.size] ++ indices;
+       channels = [channels.size] ++ channels;
+
+
+       ^this.new(
+           server, nil, [destination]
+       ).processList([source, destination]++ indices ++ channels ++ [1], freeWhenDone, action);//NB always blocking
+	}
+}
+FluidBufSelectTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufSelectEvery.sc b/release-packaging/Classes/FluidBufSelectEvery.sc
new file mode 100644
index 0000000..3339e51
--- /dev/null
+++ b/release-packaging/Classes/FluidBufSelectEvery.sc
@@ -0,0 +1,44 @@
+FluidBufSelectEvery : FluidBufProcessor {
+
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, frameHop = 1, channelHop = 1, trig = 1, blocking = 1|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufSelectEvery:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufSelectEvery:  Invalid destination buffer".throw};
+        
+        ^FluidProxyUgen.kr(\FluidBufSelectEveryTrigger, -1, source, startFrame, numFrames, startChan, numChans, destination, frameHop, channelHop, trig, blocking);
+	}
+
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, frameHop = 1, channelHop = 1, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufSelectEvery:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufSelectEvery:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, frameHop, channelHop, 0], freeWhenDone, action
+		);
+	}
+
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, frameHop = 1, channelHop = 1, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufSelectEvery:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufSelectEvery:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, frameHop, channelHop, 1], freeWhenDone, action
+		);
+	}
+}
+FluidBufSelectEveryTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufSines.sc b/release-packaging/Classes/FluidBufSines.sc
index dce7f43..781ed64 100644
--- a/release-packaging/Classes/FluidBufSines.sc
+++ b/release-packaging/Classes/FluidBufSines.sc
@@ -1,39 +1,51 @@
-FluidBufSines : UGen{
+FluidBufSines : FluidBufProcessor {
 
-    *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, trig = 1, blocking = 0|
 
-		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-		source = source.asUGenInput;
-		sines = sines.asUGenInput;
-		residual = residual.asUGenInput;
+        source = source.asUGenInput;
+        sines = sines !? {sines.asUGenInput} ?? {-1};
+        residual = residual !? {residual.asUGenInput} ?? {-1};
 
-		source.isNil.if {"FluidBufSines:  Invalid source buffer".throw};
+        source.isNil.if {"FluidBufSines:  Invalid source buffer".throw};
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
+		^FluidProxyUgen.multiNew(\FluidBufSinesTrigger, -1, source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
 	}
 
-    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize, doneAction);
-	}
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        sines = sines !? {sines.asUGenInput} ?? {-1};
+        residual = residual !? {residual.asUGenInput} ?? {-1};
+
+        source.isNil.if {"FluidBufSines:  Invalid source buffer".throw};
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-				^FluidNRTProcess.new(
-			server, this, action, [sines, residual].select{|x| x!= -1}
-		).process(
-			source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize
+		^this.new(
+			server, nil, [sines, residual].select{|x| x!= -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize,maxFFTSize,0],freeWhenDone = true,action
 		);
 	}
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, action|
-				^FluidNRTProcess.new(
-			server, this, action, [sines, residual].select{|x| x!= -1}, blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, sines = -1, residual = -1, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize = 1024, hopSize = -1, fftSize = -1, freeWhenDone = true, action|
+
+        var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+        source = source.asUGenInput;
+        sines = sines !? {sines.asUGenInput} ?? {-1};
+        residual = residual !? {residual.asUGenInput} ?? {-1};
+
+        source.isNil.if {"FluidBufSines:  Invalid source buffer".throw};
+
+		^this.new(
+			server, nil, [sines, residual].select{|x| x!= -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, sines, residual, bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize,maxFFTSize,1],freeWhenDone,action
 		);
 	}
 
 }
+FluidBufSinesTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufSpectralShape.sc b/release-packaging/Classes/FluidBufSpectralShape.sc
index bdbdb4a..b4bb4ab 100644
--- a/release-packaging/Classes/FluidBufSpectralShape.sc
+++ b/release-packaging/Classes/FluidBufSpectralShape.sc
@@ -1,6 +1,10 @@
-FluidBufSpectralShape : UGen {
+FluidBufSpectralShape : FluidBufProcessor {
 
-        *new1{ |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0, blocking = 0|
+    *objectClassName{
+        ^\FluidBufSpecShp
+    }
+
+    *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, trig = 1, blocking = 0|
 
 		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
@@ -10,33 +14,42 @@ FluidBufSpectralShape : UGen {
 		source.isNil.if {"FluidBufSpectralShape:  Invalid source buffer".throw};
 		features.isNil.if {"FluidBufSpectralShape:  Invalid features buffer".throw};
 
-		//NB For wrapped versions of NRT classes, we set the params for maxima to
-		//whatever has been passed in language-side (e.g maxFFTSize still exists as a parameter for the server plugin, but makes less sense here: it just needs to be set to a legal value)
-
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, features, windowSize, hopSize, fftSize, maxFFTSize, doneAction, blocking);
+		^FluidProxyUgen.kr(this.objectClassName++\Trigger, -1, source, startFrame, numFrames, startChan, numChans, features, padding, windowSize, hopSize, fftSize, maxFFTSize, trig, blocking);
 
 	}
 
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
 
-    *kr{ |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, doneAction = 0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, features, windowSize, hopSize, fftSize, doneAction);
+		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
 
-	}
+		source = source.asUGenInput;
+		features = features.asUGenInput;
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features]
-		).process(
-			 source, startFrame, numFrames, startChan, numChans, features, windowSize, hopSize, fftSize
+		source.isNil.if {"FluidBufSpectralShape:  Invalid source buffer".throw};
+		features.isNil.if {"FluidBufSpectralShape:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			 [source, startFrame, numFrames, startChan, numChans, features, padding, windowSize, hopSize, fftSize, maxFFTSize, 0], freeWhenDone, action
 		);
 	}
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features,  windowSize = 1024, hopSize = -1, fftSize = -1, action|
-		^FluidNRTProcess.new(
-			server, this, action, [features], blocking: 1
-		).process(
-			 source, startFrame, numFrames, startChan, numChans, features, windowSize, hopSize, fftSize
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, features, windowSize = 1024, hopSize = -1, fftSize = -1, padding = 1, freeWhenDone = true, action|
+
+		var maxFFTSize = if (fftSize == -1) {windowSize.nextPowerOfTwo} {fftSize};
+
+		source = source.asUGenInput;
+		features = features.asUGenInput;
+
+		source.isNil.if {"FluidBufSpectralShape:  Invalid source buffer".throw};
+		features.isNil.if {"FluidBufSpectralShape:  Invalid features buffer".throw};
+
+		^this.new(
+			server, nil, [features]
+		).processList(
+			 [source, startFrame, numFrames, startChan, numChans, features, padding, windowSize, hopSize, fftSize, maxFFTSize, 1], freeWhenDone, action
 		);
 	}
-
 }
+FluidBufSpectralShapeTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufStats.sc b/release-packaging/Classes/FluidBufStats.sc
index 830b6c8..c181c9a 100644
--- a/release-packaging/Classes/FluidBufStats.sc
+++ b/release-packaging/Classes/FluidBufStats.sc
@@ -1,34 +1,52 @@
-FluidBufStats : UGen{
-
-    *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, doneAction=0, blocking = 0|
-
-		source = source.asUGenInput;
-		stats = stats.asUGenInput;
-
-		source.isNil.if {"FluidBufStats:  Invalid source buffer".throw};
-		stats.isNil.if {"FluidBufStats:  Invalid stats buffer".throw};
-
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, stats, numDerivs, low, middle, high,doneAction, blocking);
+FluidBufStats : FluidBufProcessor {
+
+	*kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, outliersCutoff = -1, weights, trig = 1, blocking = 0|
+        
+        source = source.asUGenInput;
+        stats = stats.asUGenInput;
+        weights = weights.asUGenInput;
+
+        source.isNil.if {"FluidBufStats:  Invalid source buffer".throw};
+        stats.isNil.if {"FluidBufStats:  Invalid stats buffer".throw};
+        weights = weights ? -1;
+        
+		^FluidProxyUgen.kr(\FluidBufStatsTrigger, -1, source, startFrame, numFrames, startChan, numChans, stats, numDerivs, low, middle, high, outliersCutoff, weights, trig, blocking);
 	}
 
-	*kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, doneAction=0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, stats, numDerivs, low, middle, high,doneAction);
-	}
-
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, action|
-		^FluidNRTProcess.new(
-			server, this, action, [stats]
-		).process(
-			source, startFrame, numFrames, startChan, numChans, stats,numDerivs, low, middle, high
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, outliersCutoff = -1, weights, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        stats = stats.asUGenInput;
+        weights = weights.asUGenInput;
+
+        source.isNil.if {"FluidBufStats:  Invalid source buffer".throw};
+        stats.isNil.if {"FluidBufStats:  Invalid stats buffer".throw};
+        weights = weights ? -1;
+            
+		^this.new(
+			server, nil, [stats]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, stats,numDerivs, low, middle, high, outliersCutoff, weights, 0], freeWhenDone, action 
 		);
 	}
 
-   *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, action|
-		^FluidNRTProcess.new(
-			server, this, action, [stats], blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, stats,numDerivs, low, middle, high
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, stats, numDerivs = 0, low = 0, middle = 50, high = 100, outliersCutoff = -1, weights, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        stats = stats.asUGenInput;
+        weights = weights.asUGenInput;
+
+        source.isNil.if {"FluidBufStats:  Invalid source buffer".throw};
+        stats.isNil.if {"FluidBufStats:  Invalid stats buffer".throw};
+        weights = weights ? -1;
+            
+		^this.new(
+			server, nil, [stats]
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, stats,numDerivs, low, middle, high, outliersCutoff, weights, 1], freeWhenDone, action 
 		);
 	}
 
+
 }
+FluidBufStatsTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufThreadDemo.sc b/release-packaging/Classes/FluidBufThreadDemo.sc
index 44d960b..393920b 100644
--- a/release-packaging/Classes/FluidBufThreadDemo.sc
+++ b/release-packaging/Classes/FluidBufThreadDemo.sc
@@ -1,29 +1,34 @@
-FluidBufThreadDemo : UGen{
+FluidBufThreadDemo : FluidBufProcessor{
 
-    *new1 {|rate, result, time, doneAction = 0, blocking = 0 |
-		result = result.asUGenInput;
-		result.isNil.if {this.class.name+":  Invalid output buffer".throw};
-        ^super.new1(rate, result, time, doneAction, blocking);
-	 }
+	*kr  {|result, time, trig = 1, blocking = 0|
 
+        result = result.asUGenInput;
+        result.isNil.if {this.class.name+":  Invalid output buffer".throw};
 
-	*kr {|result, time, doneAction = 0|
-        ^this.new1(\control, result, time, doneAction);
+        ^FluidProxyUgen.kr(\FluidBufThreadDemoTrigger, -1, result, time, trig, blocking);
 	 }
 
-    *process { |server, result, time = 1000, action|
-		^FluidNRTProcess.new(
-			server, this, action, [result]
-		).process(
-			result, time
+    *process { |server, result, time = 1000, freeWhenDone = true, action|
+
+
+        result ?? {this.class.name+":  Invalid output buffer".throw};
+
+		^this.new(
+			server, nil, [result]
+		).processList(
+			[result.asUGenInput, time, 0], freeWhenDone, action
 		);
     }
 
-    *processBlocking { |server, result, time = 1000, action|
-		^FluidNRTProcess.new(
-			server, this, action, [result], blocking: 1
-		).process(
-			result, time
+    *processBlocking { |server, result, time = 1000, freeWhenDone = true, action|
+
+        result ?? {this.class.name+":  Invalid output buffer".throw};
+
+		^this.new(
+			server, nil, [result]
+		).processList(
+			[result.asUGenInput, time, 1], freeWhenDone, action
 		);
     }
 }
+FluidBufThreadDemoTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufThresh.sc b/release-packaging/Classes/FluidBufThresh.sc
new file mode 100644
index 0000000..9e3f6ca
--- /dev/null
+++ b/release-packaging/Classes/FluidBufThresh.sc
@@ -0,0 +1,46 @@
+FluidBufThresh : FluidBufProcessor {
+
+    *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, destination, threshold = 0, trig = 1, blocking = 1|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufThresh:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufThresh:  Invalid destination buffer".throw};
+        
+        ^FluidProxyUgen.kr(\FluidBufThreshTrigger, -1, source, startFrame, numFrames, startChan, numChans, destination, threshold, trig, blocking);
+	}
+
+	*process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1,  destination, threshold = 0, freeWhenDone = true,  action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufThresh:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufThresh:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination],
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, threshold, 0], freeWhenDone, action
+		);
+
+	}
+
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1,  destination, threshold = 0, freeWhenDone = true, action|
+        
+        source = source.asUGenInput;
+        destination = destination.asUGenInput;
+
+        source.isNil.if {"FluidBufThresh:  Invalid source buffer".throw};
+        destination.isNil.if {"FluidBufThresh:  Invalid destination buffer".throw};
+        
+	    ^this.new(
+            server, nil, [destination],
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, destination, threshold, 1], freeWhenDone, action
+		);
+
+	}
+}
+FluidBufThreshTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufTransientSlice.sc b/release-packaging/Classes/FluidBufTransientSlice.sc
index 19362ea..38ff7a7 100644
--- a/release-packaging/Classes/FluidBufTransientSlice.sc
+++ b/release-packaging/Classes/FluidBufTransientSlice.sc
@@ -1,30 +1,44 @@
-FluidBufTransientSlice : UGen{
-    	*new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, doneAction = 0, blocking = 0|
+FluidBufTransientSlice : FluidBufProcessor {
 
-		source = source.asUGenInput;
-		indices = indices.asUGenInput;
+    *objectClassName{^\FluidBufTrSlice}
 
-		source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
-		indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
+	*kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, trig = 1, blocking = 0|
 
-		^super.new1(rate, source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength, doneAction, blocking);
-	}
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
 
-	*kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, doneAction = 0|
-		^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength, doneAction);
+		^FluidProxyUgen.kr(this.objectClassName++\Trigger, -1, source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength, trig, blocking);
 	}
 
-    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, action|
-        ^FluidNRTProcess.new(
-			server, this, action,[indices]
-        ).process(source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength
+    *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
+
+        ^this.new(
+			server, nil,[indices]
+        ).processList([source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength,0], freeWhenDone, action
         );
     }
 
-    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, action|
-        ^FluidNRTProcess.new(
-			server, this, action,[indices], blocking: 1
-        ).process(source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, indices, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, minSliceLength = 1000, freeWhenDone = true, action|
+
+        source = source.asUGenInput;
+        indices = indices.asUGenInput;
+
+        source.isNil.if {"FluidBufNoveltySlice:  Invalid source buffer".throw};
+        indices.isNil.if {"FluidBufNoveltySlice:  Invalid features buffer".throw};
+
+        ^this.new(
+			server, nil,[indices]
+        ).processList([source, startFrame, numFrames, startChan, numChans, indices, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, minSliceLength,1], freeWhenDone, action
         );
     }
 }
+FluidBufTransientSliceTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidBufTransients.sc b/release-packaging/Classes/FluidBufTransients.sc
index 00cecbb..1b71414 100644
--- a/release-packaging/Classes/FluidBufTransients.sc
+++ b/release-packaging/Classes/FluidBufTransients.sc
@@ -1,36 +1,44 @@
-FluidBufTransients : UGen {
+FluidBufTransients : FluidBufProcessor {
 
+	 *kr  { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, trig = 1, blocking = 0|
 
-    	 *new1 { |rate, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, doneAction = 0, blocking = 0 |
+ 		source = source.asUGenInput;
+ 		transients = transients ? -1;
+ 		residual = residual ? -1;
 
-		source = source.asUGenInput;
-		transients = transients.asUGenInput;
-		residual = residual.asUGenInput;
+ 		source.isNil.if {"FluidBufTransients:  Invalid source buffer".throw};
 
-		source.isNil.if {"FluidBufTransients:  Invalid source buffer".throw};
-
-        ^super.new1(rate, source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, doneAction, blocking);
+        ^FluidProxyUgen.kr(\FluidBufTransientsTrigger, -1, source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, trig, blocking);
 	}
 
+	 *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, freeWhenDone = true, action|
 
-	 *kr { |source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, doneAction = 0|
-        ^this.multiNew(\control, source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength, doneAction);
+ 		source = source.asUGenInput;
+ 		transients = transients ? -1;
+ 		residual = residual ? -1;
 
-	}
+ 		source.isNil.if {"FluidBufTransients:  Invalid source buffer".throw};
 
-	 *process { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, action|
-		^FluidNRTProcess.new(
-			server, this, action,[transients, residual].select{|x| x!= -1}
-		).process(
-			source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength
+		^this.new(
+			server, nil,[transients, residual].select{|x| x!= -1}
+		).processList(
+			[source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength,0],freeWhenDone,action
 		);
 	}
 
-   *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, action|
-		^FluidNRTProcess.new(
-			server, this, action,[transients, residual].select{|x| x!= -1}, blocking: 1
-		).process(
-			source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength
-		);
-	}
+    *processBlocking { |server, source, startFrame = 0, numFrames = -1, startChan = 0, numChans = -1, transients = -1, residual = -1, order = 20, blockSize = 256, padSize = 128, skew = 0, threshFwd = 2, threshBack = 1.1, windowSize = 14, clumpLength = 25, freeWhenDone = true, action|
+
+       source = source.asUGenInput;
+       transients = transients ? -1;
+       residual = residual ? -1;
+
+       source.isNil.if {"FluidBufTransients:  Invalid source buffer".throw};
+
+       ^this.new(
+           server, nil,[transients, residual].select{|x| x!= -1}
+       ).processList(
+           [source, startFrame, numFrames, startChan, numChans, transients, residual, order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength,1],freeWhenDone = true,action
+       );
+   }
 }
+FluidBufTransientsTrigger : FluidProxyUgen {}
diff --git a/release-packaging/Classes/FluidCorpusBuilders.sc b/release-packaging/Classes/FluidCorpusBuilders.sc
new file mode 100644
index 0000000..efb81de
--- /dev/null
+++ b/release-packaging/Classes/FluidCorpusBuilders.sc
@@ -0,0 +1,165 @@
+FluidLoadFolder {
+	var  path, labelFunc,channelFunc;
+	var < files;
+	var < index;
+	var < buffer;
+
+	*new{ |path, labelFunc, channelFunc |
+		^super.newCopyArgs(path, labelFunc,channelFunc);
+	}
+
+	play { |server, action|
+		var sizes,channels,maxChan, startEnd,counter;
+		server ?? {server = Server.default};
+		files = SoundFile.collect(path +/+ '*');
+		sizes = files.collect{|f|f.numFrames()};
+		channels = files.collect{|f| f.numChannels()};
+		startEnd = sizes.inject([0],{|a,b| a ++ (b + a[a.size - 1])}).slide(2).clump(2);
+		maxChan = channels[channels.maxIndex];
+		counter = 0;
+		index = IdentityDictionary();
+		forkIfNeeded{
+			buffer = Buffer.alloc(server,sizes.reduce('+'),maxChan);
+			server.sync;
+			buffer.updateInfo;
+			buffer.query;
+			server.sync;
+			this.files.do{|f,i|
+				var channelMap,label,entry;
+				OSCFunc({
+					if(labelFunc.notNil)
+					{ label = labelFunc.value(path,i) }
+					{ label = (f.path.basename).asSymbol };
+					entry = IdentityDictionary();
+					entry.add(\bounds->startEnd[i]);
+					entry.add(\numchans->f.numChannels);
+					entry.add(\sr->f.sampleRate);
+					entry.add(\path->f.path);
+					index.add(label->entry);
+					counter = counter + 1;
+					if(counter == (files.size)) {action !? action.value(index)};
+				},"/done",server.addr,argTemplate:["/b_readChannel"]).oneShot;
+				if(channelFunc.notNil)
+				{  channelMap = channelFunc.value(channels[i],maxChan,i) }
+				{  channelMap = Array.series(channels[i]) ++ -1.dup(maxChan - channels[i])}; //using -1 as a silence channel ID to fill the blanks (see SC_BufReadCommand::CopyChannels)
+				buffer.readChannel(f.path,bufStartFrame:startEnd[i][0], channels:channelMap);
+			}
+		};
+	}
+}
+
+
+FluidSliceCorpus {
+	var < sliceFunc, labelFunc;
+	var < index;
+
+	*new { |sliceFunc, labelFunc|
+		^super.newCopyArgs(sliceFunc,labelFunc);
+	}
+
+	play{ |server,sourceBuffer,bufIdx, action, tasks = 4|
+		var counter, tmpIndices,perf,jobs,total,uid, completed, pointstotal;
+		uid = UniqueID.next;
+		sourceBuffer ?? {"No buffer to slice".error; ^nil};
+		bufIdx ?? {"No slice point dictionary passed".error;^nil};
+		server ?? {server = Server.default};
+		index = IdentityDictionary();
+		counter = 0;
+		completed = 0;
+		jobs = List.newFrom(bufIdx.keys);
+		total = jobs.size;
+		pointstotal = 0;
+		perf = { |tmpIndices|
+			var idx,v,k = jobs.pop;
+			v = bufIdx[k];
+			counter = counter + 1;
+			idx = counter;
+			("Slicing" + counter ++ "/" ++ total).postln;
+			OSCFunc({
+				tmpIndices.loadToFloatArray(action:{ |a|
+					var sliceindex = 1;
+					completed =  completed + 1;
+					("FluidSliceCorpus:" + ( completed.asString ++ "/" ++ total)).postln;
+					if(a[0] != -1){
+						var rawPoints = Array.newFrom(a).asInteger;
+						if(rawPoints[0] != [v[\bounds][0]]){rawPoints = [v[\bounds][0]] ++ rawPoints};
+						if(rawPoints.last != [v[\bounds][1]]){rawPoints=rawPoints ++ [v[\bounds][1]]};
+
+						rawPoints.doAdjacentPairs{|a,b|
+							var dict;
+							if ((b - a) >= 1){
+								dict = IdentityDictionary();
+								dict.putAll(v);
+								dict[\bounds] = [a,b];
+								index.add(((k ++ "-" ++sliceindex).asSymbol)->dict);
+								sliceindex = sliceindex + 1;
+							}
+						}
+					}{
+						var dict = IdentityDictionary();
+						dict.putAll(v);
+						index.add((k ++ "-1").asSymbol->dict);
+					};
+					if(jobs.size > 0){perf.value(tmpIndices)}{ tmpIndices.free };
+					if(completed == total) {action !? action.value(index)};
+				})
+			},'/doneslice' ++ uid ++ counter,server.addr).oneShot;
+			{
+				var numframes,onsets;
+				numframes = v[\bounds].reverse.reduce('-');
+				onsets = sliceFunc.value(sourceBuffer, v[\bounds][0],numframes,tmpIndices);
+				SendReply.kr(Done.kr(onsets),'/doneslice' ++ uid ++ idx);
+				FreeSelfWhenDone.kr(onsets);
+			}.play;
+		};
+		tasks ?? {tasks  = 4};
+		tasks.asInteger.min(jobs.size).do{perf.value(Buffer.new)};
+	}
+}
+
+FluidProcessSlices{
+	var < featureFunc;
+
+	*new { |featureFunc|
+		^super.newCopyArgs(featureFunc);
+	}
+
+	play{ |server, sourceBuffer, bufIdx, action, tasks = 4|
+		var counter,perf,jobs,total,uid, completed;
+
+		sourceBuffer ?? {"No buffer to slice".error; ^nil};
+		bufIdx ?? {"No slice point dictionary passed".error;^nil};
+		server ?? {server = Server.default};
+
+		uid = UniqueID.next;
+		jobs = List.newFrom(bufIdx.keys);
+		total = jobs.size;
+		counter = 0;
+		completed = 0;
+		perf = {|jobID|
+			var idx,v, k = jobs.pop;
+			v = bufIdx[k];
+			counter = counter + 1;
+			("Processing" + counter ++ "/" ++ total).postln;
+			idx = counter;
+			v[\index] = counter;
+			v[\voice] = jobID;
+			OSCFunc({
+				completed = completed + 1;
+				("FluidProcessSlices:" + (completed.asString ++ "/" ++ total)).postln;
+				if(jobs.size > 0){perf.value(jobID)};
+				if(completed == total){action !? action.value(v);};
+			},"/doneFeature" ++ uid ++ counter,server.addr).oneShot;
+
+			{
+				var numframes,feature;
+				numframes = v[\bounds].reverse.reduce('-');
+				feature = featureFunc.value(sourceBuffer, v[\bounds][0], numframes, k->v);
+				SendReply.kr(Done.kr(feature),'/doneFeature' ++ uid ++ idx);
+				FreeSelfWhenDone.kr(feature);
+			}.play(server);
+		};
+		tasks ?? {tasks  = 4};
+		tasks.asInteger.min(jobs.size).do{|jobIDs|perf.value(jobIDs)};
+	}
+}
diff --git a/release-packaging/Classes/FluidDataSet.sc b/release-packaging/Classes/FluidDataSet.sc
new file mode 100644
index 0000000..12c7edb
--- /dev/null
+++ b/release-packaging/Classes/FluidDataSet.sc
@@ -0,0 +1,105 @@
+
+FluidDataSet : FluidDataObject
+{
+    *new{|server| ^super.new(server) }
+
+    addPointMsg{|label,buffer|
+        buffer = this.prEncodeBuffer(buffer);
+        ^this.prMakeMsg(\addPoint,id,label.asSymbol,buffer);
+    }
+
+	addPoint{|label, buffer, action|
+      actions[\addPoint] = [nil,action];
+	  this.prSendMsg(this.addPointMsg(label,buffer));
+	}
+
+    getPointMsg{|label,buffer|
+        buffer = this.prEncodeBuffer(buffer);
+        ^this.prMakeMsg(\getPoint,id,label.asSymbol,buffer,["/b_query",buffer.asUGenInput]);
+    }
+
+    getPoint{|label, buffer, action|
+      actions[\getPoint] = [nil,action];
+      this.prSendMsg(this.getPointMsg(label,buffer));
+    }
+
+    updatePointMsg{|label,buffer|
+        buffer = this.prEncodeBuffer(buffer);
+        ^this.prMakeMsg(\updatePoint,id,label.asSymbol,buffer,["/b_query",buffer.asUGenInput]);
+    }
+
+    updatePoint{|label, buffer, action|
+      actions[\updatePoint] = [nil,action];
+      this.prSendMsg(this.updatePointMsg(label,buffer));
+    }
+
+    deletePointMsg{|label| ^this.prMakeMsg(\deletePoint,id,label.asSymbol);}
+
+    deletePoint{|label, buffer, action|
+      actions[\deletePoint] = [nil,action];
+      this.prSendMsg(this.deletePointMsg(label));
+    }
+
+    setPointMsg{|label,buffer|
+        buffer = this.prEncodeBuffer(buffer);
+        ^this.prMakeMsg(\setPoint,id,label.asSymbol,buffer,["/b_query",buffer.asUGenInput]);
+    }
+
+	setPoint{|label, buffer, action|
+      actions[\setPoint] = [nil,action];
+	  this.prSendMsg(this.setPointMsg(label,buffer));
+	}
+
+	clearMsg { ^this.prMakeMsg(\clear,id); }
+
+    clear { |action|
+      actions[\clear] = [nil,action];
+	  this.prSendMsg(this.clearMsg);
+	}
+
+    mergeMsg{|sourceDataSet, overwrite = 0|
+        ^this.prMakeMsg(\merge,id,sourceDataSet.asUGenInput,overwrite);
+    }
+
+	merge{|sourceDataSet, overwrite = 0, action|
+        actions[\merge] = [nil,action];
+		this.prSendMsg(this.mergeMsg(sourceDataSet,overwrite));
+	}
+
+    printMsg { ^this.prMakeMsg(\print,id); }
+
+	print { |action=(postResponse)|
+		actions[\print] = [string(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.printMsg);
+	}
+
+	toBufferMsg{|buffer, transpose = 0, labelSet|
+        buffer = this.prEncodeBuffer(buffer);
+       ^this.prMakeMsg(\toBuffer, id, buffer, transpose, labelSet.asUGenInput,["/b_query",buffer.asUGenInput]);
+    }
+
+	toBuffer{|buffer, transpose = 0, labelSet, action|
+      actions[\toBuffer] = [nil,action];
+		this.prSendMsg(this.toBufferMsg(buffer, transpose, labelSet));
+	}
+
+	fromBufferMsg{|buffer, transpose = 0, labelSet|
+        buffer = this.prEncodeBuffer(buffer);
+       ^this.prMakeMsg(\fromBuffer, id, buffer, transpose, labelSet.asUGenInput,["/b_query",buffer.asUGenInput]);
+    }
+
+	fromBuffer{|buffer, transpose = 0, labelSet, action|
+      actions[\fromBuffer] = [nil,action];
+		this.prSendMsg(this.fromBufferMsg(buffer, transpose, labelSet));
+	}
+
+	getIdsMsg{|labelSet|
+        ^this.prMakeMsg(\getIds, id, labelSet.asUGenInput);
+    }
+
+	getIds{|labelSet, action|
+      actions[\getIds] = [nil,action];
+	  this.prSendMsg(this.getIdsMsg(labelSet));
+	}
+}
+
diff --git a/release-packaging/Classes/FluidDataSetQuery.sc b/release-packaging/Classes/FluidDataSetQuery.sc
new file mode 100644
index 0000000..c7df3ca
--- /dev/null
+++ b/release-packaging/Classes/FluidDataSetQuery.sc
@@ -0,0 +1,84 @@
+
+FluidDataSetQuery : FluidDataObject {
+
+    addColumnMsg { |column|
+        ^this.prMakeMsg(\addColumn,id,column);
+    }
+
+	addColumn{|column, action|
+        actions[\addColumn] = [nil,action];
+        this.prSendMsg(this.addColumnMsg(column));
+	}
+
+    addRangeMsg{|start,count|
+        ^this.prMakeMsg(\addRange,id,start,count);
+    }
+
+	addRange{|start, count, action|
+        actions[\addRange] = [nil, action];
+		this.prSendMsg(this.addRangeMsg(start, count));
+	}
+
+    filterMsg{|column, condition, value, action|
+        ^this.prMakeMsg(\filter,id,column,condition.asSymbol,value);
+    }
+
+	filter{|column, condition, value, action|
+        actions[\filter] = [nil, action];
+		this.prSendMsg(this.filterMsg(column, condition, value));
+	}
+
+    andMsg{ |column, condition, value|
+        ^this.prMakeMsg(\and,id,column, condition.asSymbol, value);
+    }
+
+	and{|column, condition, value, action|
+        actions[\and] = [nil, action];
+		this.prSendMsg(this.andMsg(column,condition,value));
+	}
+
+    orMsg{|column, condition, value|
+        ^this.prMakeMsg(\or,id,column, condition.asSymbol, value)
+    }
+
+	or{|column, condition, value, action|
+        actions[\or] = [nil,action];
+		this.prSendMsg(this.orMsg(column, condition, value));
+	}
+
+    clearMsg{
+        ^this.prMakeMsg(\clear,id);
+    }
+
+	clear{|action|
+        actions[\clear] = [nil, action];
+		this.prSendMsg(this.clearMsg);
+	}
+
+    limitMsg{|rows|
+        ^this.prMakeMsg(\limit,id,rows);
+    }
+
+	limit{|rows, action|
+        actions[\limit] = [nil,action];
+		this.prSendMsg(this.limitMsg(rows));
+	}
+
+    transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform,id,sourceDataSet.id,destDataSet.id);
+    }
+
+    transform{|sourceDataSet, destDataSet, action|
+        actions[\transform] = [nil,action];
+        this.prSendMsg(this.transformMsg(sourceDataSet,destDataSet));
+    }
+
+    transformJoinMsg{|source1DataSet, source2DataSet, destDataSet|
+        ^this.prMakeMsg(\transformJoin,id,source1DataSet.id, source2DataSet.id, destDataSet.id);
+    }
+
+	transformJoin{|source1DataSet, source2DataSet, destDataSet, action|
+        actions[\transformJoin] = [nil,action];
+        this.prSendMsg(this.transformJoinMsg(source1DataSet, source2DataSet, destDataSet));
+    }
+}
diff --git a/release-packaging/Classes/FluidDataSetWr.sc b/release-packaging/Classes/FluidDataSetWr.sc
new file mode 100644
index 0000000..c72c12d
--- /dev/null
+++ b/release-packaging/Classes/FluidDataSetWr.sc
@@ -0,0 +1,15 @@
+FluidDataSetWr : FluidBufProcessor {
+	*kr  { |dataset,idPrefix = "", idNumber = 0,buf, trig=1, blocking = 1|
+        var args;
+        buf ?? {(this.class.name ++ ": No input buffer provided").error};
+        
+        idNumber = idNumber !? {[2,1,idNumber.asInteger.asUGenInput]} ?? {[2,0,0]};
+        idPrefix = idPrefix !? {[idPrefix.asString.size] ++ idPrefix.asString.ascii} ?? {0};
+
+        args = [-1] ++ dataset.asUGenInput ++idPrefix ++ idNumber ++ buf.asUGenInput ++  trig ++ blocking;
+
+        ^FluidProxyUgen.kr(\FluidDataSetWrTrigger,*args);
+	}
+}
+
+FluidDataSetWrTrigger : FluidProxyUgen {} 
diff --git a/release-packaging/Classes/FluidHPSS.sc b/release-packaging/Classes/FluidHPSS.sc
index 44e92bf..8fecd18 100644
--- a/release-packaging/Classes/FluidHPSS.sc
+++ b/release-packaging/Classes/FluidHPSS.sc
@@ -1,4 +1,4 @@
-FluidHPSS : MultiOutUGen {
+FluidHPSS : FluidRTMultiOutUGen {
 	*ar { arg in = 0, harmFilterSize=17, percFilterSize = 31, maskingMode=0, harmThreshFreq1 = 0.1, harmThreshAmp1 = 0, harmThreshFreq2 = 0.5, harmThreshAmp2 = 0, percThreshFreq1 = 0.1, percThreshAmp1 = 0, percThreshFreq2 = 0.5, percThreshAmp2 = 0, windowSize= 1024, hopSize= -1, fftSize= -1, maxFFTSize = 16384, maxHarmFilterSize = 101, maxPercFilterSize = 101;
 		^this.multiNew('audio', in.asAudioRateInput(this), harmFilterSize, percFilterSize, maskingMode, harmThreshFreq1, harmThreshAmp1, harmThreshFreq2, harmThreshAmp2, percThreshFreq1, percThreshAmp1, percThreshFreq2, percThreshAmp2, windowSize, hopSize, fftSize, maxFFTSize, maxHarmFilterSize, maxPercFilterSize)
 	}
diff --git a/release-packaging/Classes/FluidKDTree.sc b/release-packaging/Classes/FluidKDTree.sc
new file mode 100644
index 0000000..57ef743
--- /dev/null
+++ b/release-packaging/Classes/FluidKDTree.sc
@@ -0,0 +1,62 @@
+FluidKDTree : FluidRealTimeModel
+ {
+
+    var neighbours,radius,lookup;
+
+    *new{ |server, numNeighbours = 1, radius = 0, lookupDataSet|
+        ^super.new(server,[numNeighbours,radius,lookupDataSet ? -1])
+        .numNeighbours_(numNeighbours)
+        .radius_(radius)
+        .lookupDataSet_(lookupDataSet);
+    }
+
+    numNeighbours_{|k|neighbours = k.asInteger; }
+    numNeighbours{ ^neighbours; }
+
+    radius_{|r| radius = r.asUGenInput;}
+    radius{ ^radius; }
+
+    lookupDataSet_{|ds| lookup = ds ? -1; }
+    lookupDataSet{|ds|  ^ (lookup ? -1) }
+
+    prGetParams{^[this.numNeighbours,this.radius,this.lookupDataSet,-1,-1];}
+
+    fitMsg{ |dataSet| ^this.prMakeMsg(\fit,this.id,dataSet.id);}
+
+	fit{|dataSet,action|
+        actions[\fit] = [nil,action];
+		this.prSendMsg(this.fitMsg(dataSet));
+	}
+
+    kNearestMsg{|buffer|
+        ^this.prMakeMsg(\kNearest,id,this.prEncodeBuffer(buffer));
+    }
+
+	kNearest{ |buffer, action|
+        actions[\kNearest] = [strings(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.kNearestMsg(buffer));
+	}
+
+    kNearestDistMsg {|buffer|
+        ^this.prMakeMsg(\kNearestDist,id,this.prEncodeBuffer(buffer));
+    }
+
+	kNearestDist { |buffer, action|
+        actions[\kNearestDist] = [numbers(FluidMessageResponse,_,nil,_),action];
+		this.prSendMsg(this.kNearestDistMsg(buffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer, numNeighbours = 1, lookupDataSet|
+        this.numNeighbours_(numNeighbours);
+        lookupDataSet = lookupDataSet ? -1;
+        this.lookupDataSet_(lookupDataSet);
+
+        ^FluidKDTreeQuery.kr(K2A.ar(trig),
+                this, this.numNeighbours, this.radius, this.lookupDataSet.asUGenInput,
+                this.prEncodeBuffer(inputBuffer),
+                this.prEncodeBuffer(outputBuffer));
+    }
+
+}
+
+FluidKDTreeQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidKMeans.sc b/release-packaging/Classes/FluidKMeans.sc
new file mode 100644
index 0000000..31fda02
--- /dev/null
+++ b/release-packaging/Classes/FluidKMeans.sc
@@ -0,0 +1,121 @@
+FluidKMeans : FluidRealTimeModel {
+
+	var clusters, maxiter;
+
+	*new {|server, numClusters = 4, maxIter = 100|
+		^super.new(server,[numClusters,maxIter])
+		.numClusters_(numClusters)
+		.maxIter_(maxIter);
+	}
+
+	numClusters_{|n| clusters = n.asInteger}
+	numClusters{ ^clusters }
+
+	maxIter_{|i| maxiter = i.asInteger}
+	maxIter{ ^maxiter }
+
+	prGetParams{^[this.numClusters,this.maxIter,-1,-1];}
+
+	fitMsg{ |dataSet| ^this.prMakeMsg(\fit,id,dataSet.id);}
+
+	fit{|dataSet, action|
+		actions[\fit] = [
+			numbers( FluidMessageResponse, _, this.numClusters ,_),
+			action
+		];
+		this.prSendMsg(this.fitMsg(dataSet));
+	}
+
+	fitPredictMsg{|dataSet, labelSet|
+		^this.prMakeMsg(\fitPredict, id, dataSet.id, labelSet.id)
+	}
+
+	fitPredict{|dataSet, labelSet,action|
+		actions[\fitPredict] = [
+			numbers(FluidMessageResponse, _, this.numClusters, _),
+			action
+		];
+		this.prSendMsg(this.fitPredictMsg(dataSet,labelSet));
+	}
+
+	predictMsg{|dataSet, labelSet|
+		^this.prMakeMsg(\predict, id, dataSet.id, labelSet.id)
+	}
+
+	predict{ |dataSet, labelSet, action|
+		actions[\predict] = [
+			numbers(FluidMessageResponse, _, this.numClusters, _),
+			action
+		];
+		this.prSendMsg(this.predictMsg(dataSet,labelSet));
+	}
+
+	predictPointMsg{|buffer|
+		^this.prMakeMsg(\predictPoint, id, this.prEncodeBuffer(buffer))
+	}
+
+	predictPoint { |buffer, action|
+		actions[\predictPoint] = [number(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.predictPointMsg(buffer))
+	}
+
+	fitTransformMsg{|srcDataSet, dstDataSet|
+		^this.prMakeMsg(\fitTransform, id, srcDataSet.id, dstDataSet.id)
+	}
+
+	fitTransform{|srcDataSet, dstDataSet,action|
+		actions[\fitTransform] = [nil,action];
+		this.prSendMsg(this.fitTransformMsg(srcDataSet,dstDataSet));
+	}
+
+	transformMsg{|srcDataSet, dstDataSet|
+		^this.prMakeMsg(\transform, id, srcDataSet.id, dstDataSet.id)
+	}
+
+	transform{ |srcDataSet, dstDataSet, action|
+		actions[\transform] = [nil,action];
+		this.prSendMsg(this.transformMsg(srcDataSet,dstDataSet));
+	}
+
+	transformPointMsg{ |sourceBuffer, targetBuffer|
+		^this.prMakeMsg(\transformPoint, id,
+			this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(targetBuffer),
+            ["/b_query", targetBuffer.asUGenInput]);
+    }
+
+	transformPoint { |sourceBuffer, targetBuffer, action|
+		actions[\transformPoint] = [nil,{action.value(targetBuffer)}];
+		this.prSendMsg(this.transformPointMsg(sourceBuffer, targetBuffer));
+	}
+
+	getMeansMsg{|dataSet| ^this.prMakeMsg(\getMeans, id, dataSet.asUGenInput) }
+
+    getMeans{ |dataSet, action|
+        actions[\getMeans] = [nil, action];
+		this.prSendMsg(this.getMeansMsg(dataSet));
+	}
+
+	setMeansMsg{|dataSet| ^this.prMakeMsg(\setMeans, id, dataSet.asUGenInput) }
+
+    setMeans{ |dataSet, action|
+        actions[\setMeans] = [nil, action];
+		this.prSendMsg(this.setMeansMsg(dataSet));
+	}
+
+	clearMsg{ ^this.prMakeMsg(\clear, id) }
+
+    clear{ |action|
+        actions[\clear] = [nil, action];
+		this.prSendMsg(this.clearMsg);
+	}
+
+	kr{|trig, inputBuffer,outputBuffer|
+		^FluidKMeansQuery.kr(K2A.ar(trig),
+			this, clusters, maxiter,
+			this.prEncodeBuffer(inputBuffer),
+			this.prEncodeBuffer(outputBuffer));
+	}
+}
+
+FluidKMeansQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidKNNClassifier.sc b/release-packaging/Classes/FluidKNNClassifier.sc
new file mode 100644
index 0000000..0161bb1
--- /dev/null
+++ b/release-packaging/Classes/FluidKNNClassifier.sc
@@ -0,0 +1,49 @@
+FluidKNNClassifier : FluidRealTimeModel {
+
+    var <>numNeighbours, <>weight;
+
+	*new {|server, numNeighbours = 3, weight = 1|
+		^super.new(server,[numNeighbours,weight])
+        .numNeighbours_(numNeighbours)
+        .weight_(weight);
+	}
+
+    prGetParams{^[this.numNeighbours,this.weight,-1,-1];}
+
+    fitMsg{|dataSet, labelSet|
+        ^this.prMakeMsg(\fit, id, dataSet.id, labelSet.id)
+    }
+
+	fit{|dataSet, labelSet, action|
+        actions[\fit] = [nil,action];
+	    this.prSendMsg(this.fitMsg(dataSet, labelSet));
+	}
+
+    predictMsg{|dataSet, labelSet|
+        ^this.prMakeMsg(\predict, id, dataSet.id, labelSet.id)
+    }
+
+    predict{|dataSet, labelSet, action|
+        actions[\predict] = [nil, action];
+		this.prSendMsg(this.predictMsg(dataSet, labelSet));
+	}
+
+    predictPointMsg{|buffer|
+        ^this.prMakeMsg(\predictPoint, id, this.prEncodeBuffer(buffer))
+    }
+
+	predictPoint {|buffer, action|
+		actions[\predictPoint] = [string(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.predictPointMsg(buffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer|
+        ^FluidKNNClassifierQuery.kr(K2A.ar(trig),
+                this, this.numNeighbours, this.weight,
+                this.prEncodeBuffer(inputBuffer),
+                this.prEncodeBuffer(outputBuffer));
+    }
+
+}
+
+FluidKNNClassifierQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidKNNRegressor.sc b/release-packaging/Classes/FluidKNNRegressor.sc
new file mode 100644
index 0000000..8c622a5
--- /dev/null
+++ b/release-packaging/Classes/FluidKNNRegressor.sc
@@ -0,0 +1,48 @@
+FluidKNNRegressor : FluidRealTimeModel {
+
+    var <>numNeighbours, <>weight;
+
+	*new {|server, numNeighbours = 3, weight = 1|
+		^super.new(server,[numNeighbours,weight])
+        .numNeighbours_(numNeighbours)
+        .weight_(weight);
+	}
+
+    prGetParams{^[this.numNeighbours,this.weight,-1,-1];}
+
+    fitMsg{|sourceDataSet, targetDataSet|
+        ^this.prMakeMsg(\fit,this.id,sourceDataSet.id,targetDataSet.id)
+    }
+
+	fit{|sourceDataSet, targetDataSet, action|
+        actions[\fit] = [nil,action];
+	    this.prSendMsg(this.fitMsg(sourceDataSet, targetDataSet));
+	}
+
+    predictMsg{ |sourceDataSet, targetDataSet|
+        ^this.prMakeMsg(\predict,this.id,sourceDataSet.id,targetDataSet.id)
+    }
+
+	predict{ |sourceDataSet, targetDataSet,action|
+        actions[\predict] = [nil, action];
+		this.prSendMsg(this.predictMsg(sourceDataSet, targetDataSet));
+	}
+
+    predictPointMsg { |buffer|
+        ^this.prMakeMsg(\predictPoint,id, this.prEncodeBuffer(buffer));
+    }
+
+	predictPoint { |buffer, action|
+		actions[\predictPoint] = [number(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.predictPointMsg(buffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer|
+        ^FluidKNNRegressorQuery.kr(K2A.ar(trig),
+                this, this.numNeighbours, this.weight,
+                this.prEncodeBuffer(inputBuffer),
+                this.prEncodeBuffer(outputBuffer));
+    }
+}
+
+FluidKNNRegressorQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidLabelSet.sc b/release-packaging/Classes/FluidLabelSet.sc
new file mode 100644
index 0000000..7f0d9c3
--- /dev/null
+++ b/release-packaging/Classes/FluidLabelSet.sc
@@ -0,0 +1,54 @@
+FluidLabelSet : FluidDataObject {
+
+    *new{|server| ^super.new(server) }
+
+    addLabelMsg{|identifier,label|
+        ^this.prMakeMsg(\addLabel,id,identifier.asSymbol,label.asSymbol);
+    }
+
+	addLabel{|identifier, label, action|
+        actions[\addLabel] = [nil, action];
+		this.prSendMsg(this.addLabelMsg(identifier,label));
+	}
+
+    updateLabelMsg{|identifier, label|
+        ^this.prMakeMsg(\updateLabel, id, identifier.asSymbol, label.asSymbol);
+    }
+
+	updateLabel{|identifier, label, action|
+        actions[\updateLabel] = [nil,action];
+		this.prSendMsg(this.updateLabelMsg(identifier,label));
+	}
+
+    getLabelMsg{|identifier|
+        ^this.prMakeMsg(\getLabel, id, identifier.asSymbol);
+    }
+
+	getLabel{|identifier, action|
+        actions[\getLabel] = [string(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.getLabelMsg(identifier));
+	}
+
+    deleteLabelMsg{|identifier, action|
+    	^this.prMakeMsg(\deleteLabel, id, identifier.asSymbol);
+    }
+
+	deleteLabel{|identifier, action|
+        actions[\deleteLabel] = [nil, action];
+		this.prSendMsg(this.deleteLabelMsg(identifier));
+	}
+
+    clearMsg { ^this.prMakeMsg(\clear,id); }
+
+    clear { |action|
+      actions[\clear] = [nil,action];
+      this.prSendMsg(this.clearMsg);
+    }
+
+    printMsg { ^this.prMakeMsg(\print,id); }
+
+	print { |action=(postResponse)|
+		actions[\print] = [string(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.printMsg);
+	}
+}
diff --git a/release-packaging/Classes/FluidLoudness.sc b/release-packaging/Classes/FluidLoudness.sc
index 36bece6..ac8372d 100644
--- a/release-packaging/Classes/FluidLoudness.sc
+++ b/release-packaging/Classes/FluidLoudness.sc
@@ -1,4 +1,4 @@
-FluidLoudness : MultiOutUGen {
+FluidLoudness : FluidRTMultiOutUGen {
 	*kr { arg in = 0, kWeighting = 1, truePeak = 1, windowSize = 1024, hopSize = 512, maxwindowSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), kWeighting, truePeak, windowSize, hopSize, maxwindowSize);
 	}
diff --git a/release-packaging/Classes/FluidMDS.sc b/release-packaging/Classes/FluidMDS.sc
new file mode 100644
index 0000000..c7332b1
--- /dev/null
+++ b/release-packaging/Classes/FluidMDS.sc
@@ -0,0 +1,39 @@
+FluidMDS : FluidModelObject {
+	classvar < manhattan = 0;
+	classvar < euclidean = 1;
+	classvar < sqeuclidean = 2;
+	classvar < max = 3;
+	classvar < min = 4;
+	classvar < kl = 5;
+	classvar < cosine = 5;
+
+    var <>numDimensions, <>distanceMetric;
+
+	*new {|server,numDimensions = 2, distanceMetric = 1|
+		^super.new(server,[numDimensions, distanceMetric])
+        .numDimensions_(numDimensions)
+        .distanceMetric_(distanceMetric);
+	}
+
+    prGetParams{
+        ^[this.numDimensions, this.distanceMetric];
+    }
+
+	fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform,id, sourceDataSet.id,  destDataSet.id);
+    }
+
+	fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [nil,action];
+        this.fitTransformMsg(sourceDataSet,destDataSet).postln;
+
+		this.prSendMsg(this.fitTransformMsg(sourceDataSet,destDataSet));
+	}
+
+	// not implemented
+	cols {|action|}
+	read{|filename,action|}
+	write{|filename,action|}
+	size { |action|}
+
+}
diff --git a/release-packaging/Classes/FluidMFCC.sc b/release-packaging/Classes/FluidMFCC.sc
index 76d37b6..f4e2bc4 100644
--- a/release-packaging/Classes/FluidMFCC.sc
+++ b/release-packaging/Classes/FluidMFCC.sc
@@ -1,9 +1,10 @@
-FluidMFCC : MultiOutUGen {
+FluidMFCC : FluidRTMultiOutUGen {
 
 	*kr { arg in = 0, numCoeffs = 13, numBands = 40, minFreq = 20, maxFreq = 20000,  maxNumCoeffs = 40, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), numCoeffs, numBands, minFreq, maxFreq,  maxNumCoeffs, windowSize, hopSize, fftSize, maxFFTSize);
 	}
 
+
 	init {arg ...theInputs;
 		inputs = theInputs;
 		^this.initOutputs(inputs.at(5),rate);
diff --git a/release-packaging/Classes/FluidMLP.sc b/release-packaging/Classes/FluidMLP.sc
new file mode 100644
index 0000000..23e5624
--- /dev/null
+++ b/release-packaging/Classes/FluidMLP.sc
@@ -0,0 +1,152 @@
+FluidMLPRegressor : FluidRealTimeModel {
+
+	const <identity = 0;
+	const <sigmoid  =  1;
+	const <relu = 2;
+	const <tanh = 3;
+
+    var <>hidden, <>activation, <>outputActivation, <>tapIn, <>tapOut, <>maxIter, <>learnRate, <>momentum, <>batchSize, <>validation;
+
+	*new {|server, hidden = #[3,3] , activation = 2, outputActivation = 0, tapIn = 0, tapOut = -1,maxIter = 1000, learnRate = 0.0001, momentum = 0.9, batchSize = 50, validation = 0.2|
+
+		^super.new(server, [hidden.size] ++ hidden ++ [activation, outputActivation, tapIn, tapOut, maxIter, learnRate, momentum, batchSize, validation])
+            .hidden_(hidden)
+            .activation_(activation)
+            .outputActivation_(outputActivation)
+            .tapIn_(tapIn)
+            .tapOut_(tapOut)
+            .maxIter_(maxIter)
+            .learnRate_(learnRate)
+            .momentum_(momentum)
+            .batchSize_(batchSize)
+            .validation_(validation);
+	}
+
+    prGetParams{
+        ^[this.hidden.size] ++ this.hidden ++ [this.activation, this.outputActivation, this.tapIn, this.tapOut, this.maxIter, this.learnRate, this.momentum, this.batchSize, this.validation, -1, -1]
+    }
+
+    clearMsg{ ^this.prMakeMsg(\clear, id) }
+
+    clear{ |action|
+        actions[\clear] = [nil, action];
+		this.prSendMsg(this.clearMsg);
+	}
+
+    fitMsg{|sourceDataSet, targetDataSet|
+        ^this.prMakeMsg(\fit,id,sourceDataSet.id, targetDataSet.id);
+    }
+
+	fit{|sourceDataSet, targetDataSet, action|
+	   actions[\fit] = [numbers(FluidMessageResponse,_,1,_),action];
+       this.prSendMsg(this.fitMsg(sourceDataSet,targetDataSet));
+	}
+
+    predictMsg{|sourceDataSet, targetDataSet|
+        ^this.prMakeMsg(\predict,id,sourceDataSet.id, targetDataSet.id);
+    }
+
+	predict{|sourceDataSet, targetDataSet, action|
+	   actions[\predict] = [nil,action];
+       this.prSendMsg(this.predictMsg(sourceDataSet,targetDataSet));
+	}
+
+
+	predictPointMsg { |sourceBuffer, targetBuffer|
+        ^this.prMakeMsg(\predictPoint,id,
+            this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(targetBuffer),
+            ["/b_query", targetBuffer.asUGenInput]);
+    }
+
+	predictPoint { |sourceBuffer, targetBuffer, action|
+        actions[\predictPoint] = [nil,{action.value(targetBuffer)}];
+        this.predictPointMsg(sourceBuffer, targetBuffer);
+		this.prSendMsg(this.predictPointMsg(sourceBuffer, targetBuffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer, tapIn = 0, tapOut = -1|
+        var params;
+        tapIn = tapIn ? this.tapIn;
+        tapOut = tapOut ? this.tapOut;
+
+        this.tapIn_(tapIn).tapOut_(tapOut);
+
+        params = this.prGetParams.drop(-2) ++ [this.prEncodeBuffer(inputBuffer),
+        this.prEncodeBuffer(outputBuffer)];
+
+        ^FluidMLPRegressorQuery.kr(K2A.ar(trig),this, *params);
+    }
+
+}
+
+FluidMLPRegressorQuery : FluidRTQuery {}
+
+FluidMLPClassifier : FluidRealTimeModel {
+
+	const <identity = 0;
+	const <sigmoid  =  1;
+	const <relu = 2;
+	const <tanh = 3;
+
+    var <>hidden, <>activation, <> maxIter, <>learnRate, <> momentum, <>batchSize, <>validation;
+
+	*new {|server, hidden = #[3,3] , activation = 2, maxIter = 1000, learnRate = 0.0001, momentum = 0.9, batchSize = 50, validation = 0.2|
+		^super.new(server,[hidden.size] ++ hidden ++ [activation,  maxIter, learnRate,  momentum, batchSize, validation])
+        .hidden_(hidden)
+			.activation_(activation)
+			.maxIter_(maxIter)
+			.learnRate_(learnRate)
+			.momentum_(momentum)
+			.batchSize_(batchSize)
+			.validation_(validation);
+	}
+
+    prGetParams{
+        ^[ this.hidden.size] ++ this.hidden ++ [this.activation,  this.maxIter, this.learnRate,  this.momentum, this.batchSize, this.validation, -1, -1];
+    }
+
+    clearMsg{ ^this.prMakeMsg(\clear,id) }
+
+	clear{ |action|
+        actions[\clear] = [nil,action];
+		this.prSendMsg(this.clearMsg);
+	}
+
+    fitMsg{|sourceDataSet, targetLabelSet|
+        ^this.prMakeMsg(\fit,id,sourceDataSet.id, targetLabelSet.id);
+    }
+
+	fit{|sourceDataSet, targetLabelSet, action|
+       actions[\fit] = [numbers(FluidMessageResponse,_,1,_),action];
+	   this.prSendMsg(this.fitMsg(sourceDataSet,targetLabelSet));
+	}
+
+    predictMsg{|sourceDataSet, targetLabelSet|
+        ^this.prMakeMsg(\predict,id,sourceDataSet.id, targetLabelSet.id);
+    }
+
+	predict{ |sourceDataSet, targetLabelSet, action|
+        actions[\predict]=[nil,action];
+		this.prSendMsg(this.predictMsg(sourceDataSet,targetLabelSet));
+	}
+
+    predictPointMsg { |sourceBuffer|
+        ^this.prMakeMsg(\predictPoint,id,this.prEncodeBuffer(sourceBuffer))
+    }
+
+	predictPoint { |sourceBuffer, action|
+        actions[\predictPoint] = [string(FluidMessageResponse,_,_),action];
+		this.prSendMsg(this.predictPointMsg(sourceBuffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer|
+
+        var params = this.prGetParams.drop(-2) ++  [this.prEncodeBuffer(inputBuffer),
+        this.prEncodeBuffer(outputBuffer)];
+
+        ^FluidMLPClassifierQuery.kr(K2A.ar(trig),this, *params);
+    }
+}
+
+FluidMLPClassifierQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidManipulationJSON.sc b/release-packaging/Classes/FluidManipulationJSON.sc
new file mode 100644
index 0000000..875902b
--- /dev/null
+++ b/release-packaging/Classes/FluidManipulationJSON.sc
@@ -0,0 +1,68 @@
++ FluidDataObject {
+	tmpJSONFilename{
+		^Platform.defaultTempDir++"tmp_fluid_data_"++
+		Date.localtime.stamp++"_"++UniqueID.next++".json";
+	}
+
+	dump {|action|
+		var filename = this.tmpJSONFilename;
+		action ?? {action = postResponse};
+		this.write(filename, {
+				action.value(this.parseJSON(File.readAllString(filename)));
+				File.delete(filename);
+			});
+	}
+
+	load{|dict, action|
+		var filename = this.tmpJSONFilename;
+		File.use(filename, "wt", { |f| f.write(this.asJSON(dict));});
+		this.read(filename, {
+				action.notNil.if{ action.value; };
+				File.delete(filename);
+		});
+	}
+
+	toDict{|obj|
+		var converted;
+		if(obj.class === Event){
+			converted = obj.as(Dictionary);
+			converted.keysValuesChange{|k,v|this.toDict(v)}
+			^converted;
+		};
+		if(obj.class === Array){
+			converted = obj.collect{|v| this.toDict(v)};
+			^converted;
+		};
+		^obj;
+	}
+
+	parseJSON{|jsonStr|
+		var parsed = jsonStr;
+		jsonStr.do({|char,pos|
+			var inString = false;
+			char.switch(
+				$",{(jsonStr[pos-1]==$\ && inString).not.if({inString = inString.not})},
+				${,{ if(inString.not){parsed[pos] = $(} },
+				$},{ if(inString.not){parsed[pos] = $)} }
+			)
+		});
+		^this.toDict(parsed.interpret);
+	}
+
+	asJSON{|d|
+		if(d.isNumber){^d};
+		if(d.isString){^d.asString.asCompileString};
+		if(d.isKindOf(Symbol)){^this.asJSON(d.asString)};
+		if(d.isKindOf(Dictionary))
+		{
+		  ^"{" ++ (
+			d.keys.asList.collect{|k|
+			k.asString.asCompileString ++ ":" + this.asJSON(d[k])
+			}).join(", ") ++ "}"
+		};
+		if(d.isKindOf(SequenceableCollection))
+		{
+			^"[" ++ d.collect({|x|this.asJSON(x)}).join(", ")++ "]";
+		};
+	}
+}
diff --git a/release-packaging/Classes/FluidMelBands.sc b/release-packaging/Classes/FluidMelBands.sc
index db0aa35..12ee90d 100644
--- a/release-packaging/Classes/FluidMelBands.sc
+++ b/release-packaging/Classes/FluidMelBands.sc
@@ -1,4 +1,4 @@
-FluidMelBands : MultiOutUGen {
+FluidMelBands : FluidRTMultiOutUGen {
 
 	*kr { arg in = 0, numBands = 40, minFreq = 20, maxFreq = 20000, maxNumBands = 120, normalize = 1, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), numBands, minFreq, maxFreq, maxNumBands, normalize, windowSize, hopSize, fftSize, maxFFTSize);
diff --git a/release-packaging/Classes/FluidMessageResponse.sc b/release-packaging/Classes/FluidMessageResponse.sc
new file mode 100644
index 0000000..0ebba79
--- /dev/null
+++ b/release-packaging/Classes/FluidMessageResponse.sc
@@ -0,0 +1,41 @@
+FluidMessageResponse : Object
+{
+    //selectors is an array of functions
+    //my cunning thought is that those that need extra data (e..g numbers()) can
+    //use partial applicaiton
+    *collectArgs{ |selectors,a|
+        var response = [];
+        var idx = 0;
+        selectors.do{ |selector|
+            var newThings;
+            # newThings,idx = selector.value(a, idx);
+            response = response ++ newThings;
+        };
+
+        if(response.size == 1,
+            {^response[0]},{^response})
+    }
+
+    *string{ |a, offset|
+        ^[a]
+    }
+
+    *strings {|a,offset|
+        //TODO add an n argument as with numbers() to make this less omnivorous
+        ^[a.drop(offset)];
+    }
+
+    *numbers{ |a, n, offset|
+        n = n ? a.size - offset; //send n = nil to consume everything
+        ^[a.copyRange(offset, offset + n),offset + n]
+    }
+
+    *number{ |a,offset|
+        ^[a[offset]];
+    }
+
+    *buffer{ |a,server,offset|
+        server = server ? Server.default ;
+        ^[Buffer.cachedBufferAt(server, a[offset]), offset + 1]
+    }
+}
diff --git a/release-packaging/Classes/FluidMessageTest.sc b/release-packaging/Classes/FluidMessageTest.sc
new file mode 100644
index 0000000..dffb399
--- /dev/null
+++ b/release-packaging/Classes/FluidMessageTest.sc
@@ -0,0 +1,120 @@
+FluidMessageTest : FluidModelObject {
+
+    var server;
+
+    // *kr { |trig = 1, blocking = 0| 
+    // 
+    //     ^this.multiNew('control', trig, blocking);
+    // }
+
+    testReturnStrings { |server, nodeID, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnStrings');
+
+        OSCFunc(
+            { |msg|
+                var resp =FluidMessageResponse.collectArgs(
+                4.collect{string(FluidMessageResponse,_,_)}, msg.drop(3));
+                if(action.notNil){action.value(resp);};
+        },'/testReturnStrings').oneShot;
+
+    }
+
+    testReturnNumbers{ |server, nodeID, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnNumbers');
+
+        OSCFunc(
+        { |msg|
+                var result = FluidMessageResponse.collectArgs(
+                    [numbers(FluidMessageResponse,_,100,_)], msg.drop(3));
+                if(action.notNil){action.value(result);};
+        },'/testReturnNumbers').oneShot;
+    }
+
+    testReturnOneString{ |server, nodeID, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnOneString');
+
+        OSCFunc(
+        { |msg|
+                var result = FluidMessageResponse.collectArgs(
+                    [string(FluidMessageResponse,_,_)], msg.drop(3));
+                if(action.notNil){action.value(result);};
+        },'/testReturnOneString').oneShot;
+    }
+
+    testReturnOneNumber{ |server, nodeID, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnOneNumber');
+
+        OSCFunc(
+        { |msg|
+                var result = msg.drop(3);
+                if(action.notNil){action.value(result);};
+        },'/testReturnOneNumber').oneShot;
+    }
+
+    testAccessBuffer{ |server, nodeID, buf, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testAccessBuffer', buf.asUGenInput);
+
+        OSCFunc(
+        { |msg|
+                var result = FluidMessageResponse.collectArgs([numbers(FluidMessageResponse,_,1,_)],msg.drop(3));
+                if(action.notNil){action.value(result);};
+        },'/testAccessBuffer').oneShot;
+    }
+
+    testPassString{ |server, nodeID, str, a, b, c, d, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testPassString', str, a, b, c);
+
+        OSCFunc(
+        { |msg|
+                if(action.notNil){action.value;};
+        },'/testPassString').oneShot;
+    }
+
+
+    testReturnBuffer{ |server, nodeID, b, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnBuffer', b.asUGenInput);
+
+        OSCFunc(
+        { |msg|
+                var result = result = FluidMessageResponse.collectArgs([buffer(FluidMessageResponse,_,server,_)],msg.drop(3));
+                if(action.notNil){action.value(result);};
+        },'/testReturnBuffer').oneShot;
+    }
+
+    testReturnHetero{ |server, nodeID, action|
+
+        server = server ? Server.default;
+
+        server.sendMsg('/u_cmd',nodeID,this.synthIndex,'testReturnHetero');
+
+        OSCFunc(
+        { |msg|
+                var result = result = FluidMessageResponse.collectArgs([string(FluidMessageResponse,_,_), numbers(FluidMessageResponse,_,2,_)],msg.drop(3));
+                if(action.notNil){action.value(result);};
+        },'/testReturnHetero').oneShot;
+    }
+
+
+
+}
diff --git a/release-packaging/Classes/FluidNMFFilter.sc b/release-packaging/Classes/FluidNMFFilter.sc
index a4ab279..75a0f74 100644
--- a/release-packaging/Classes/FluidNMFFilter.sc
+++ b/release-packaging/Classes/FluidNMFFilter.sc
@@ -1,4 +1,4 @@
-FluidNMFFilter : MultiOutUGen {
+FluidNMFFilter : FluidRTMultiOutUGen {
 
 	*ar { arg in = 0, bases, maxComponents = 1, iterations = 10, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('audio', in.asAudioRateInput(this), bases, maxComponents, iterations, windowSize, hopSize, fftSize, maxFFTSize);
diff --git a/release-packaging/Classes/FluidNMFMatch.sc b/release-packaging/Classes/FluidNMFMatch.sc
index 0c438d5..16dd827 100644
--- a/release-packaging/Classes/FluidNMFMatch.sc
+++ b/release-packaging/Classes/FluidNMFMatch.sc
@@ -1,4 +1,4 @@
-FluidNMFMatch : MultiOutUGen {
+FluidNMFMatch : FluidRTMultiOutUGen {
 
 	*kr { arg in = 0, bases, maxComponents = 1, iterations = 10, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), bases, maxComponents, iterations, windowSize, hopSize, fftSize, maxFFTSize);
diff --git a/release-packaging/Classes/FluidNMFMorph.sc b/release-packaging/Classes/FluidNMFMorph.sc
new file mode 100644
index 0000000..ed95f43
--- /dev/null
+++ b/release-packaging/Classes/FluidNMFMorph.sc
@@ -0,0 +1,23 @@
+FluidNMFMorph : FluidRTUGen {
+
+	*ar { arg source = -1, target = -1, activations = -1, autoassign = 1, interp = 0, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
+
+		source = source ?? {-1};
+		target = target ?? {-1};
+		activations = activations ?? {-1};
+
+		^this.new1('audio', source, target, activations, autoassign, interp, windowSize, hopSize, fftSize, maxFFTSize);
+	}
+
+	init {arg ...theInputs;
+		inputs = theInputs;
+		specialIndex = -1;
+	}
+
+	checkInputs {
+		if(inputs.last.rate != 'scalar') {
+			^(": maxFFTSize cannot be modulated.");
+		};
+		^this.checkValidInputs;
+	}
+}
diff --git a/release-packaging/Classes/FluidNRTProcess.sc b/release-packaging/Classes/FluidNRTProcess.sc
index 5a7e009..c8df9ea 100644
--- a/release-packaging/Classes/FluidNRTProcess.sc
+++ b/release-packaging/Classes/FluidNRTProcess.sc
@@ -11,7 +11,7 @@ FluidNRTProcess : Object{
             "FluidNRTProcess: Server not running".throw;
         });
 		if (ugen.isNil){
-			"FluidNRTProcess: UGen is nil".throw;
+			"FluidNRTProcess : FluidRTUGen is nil".throw;
 		};
 		outputBuffers = outputBuffers.collect{|b|
 			var checked = server.cachedBufferAt(b.asUGenInput);
@@ -27,7 +27,7 @@ FluidNRTProcess : Object{
         var c = Condition.new(false);
 
 		synth = {
-            ugen.performList(\new1,\control, ugenArgs.collect{|a| a.asUGenInput} ++ Done.freeSelf ++ blocking);
+            FreeSelfWhenDone.kr(ugen.performList(\new1,\control, ugenArgs.collect{|a| a.asUGenInput} ++ 1 ++ blocking));
 		}.play(server);
 		synth.postln;
 
diff --git a/release-packaging/Classes/FluidNormalize.sc b/release-packaging/Classes/FluidNormalize.sc
new file mode 100644
index 0000000..94eb422
--- /dev/null
+++ b/release-packaging/Classes/FluidNormalize.sc
@@ -0,0 +1,70 @@
+FluidNormalize : FluidRealTimeModel {
+
+    var <>min, <>max, <>invert;
+
+	*new {|server, min = 0, max = 1, invert = 0|
+		^super.new(server,[min,max,invert])
+        .min_(min).max_(max).invert_(invert);
+	}
+
+    prGetParams{
+        ^[this.min,this.max,this.invert,-1,-1];
+    }
+
+
+    fitMsg{|dataSet|
+        ^this.prMakeMsg(\fit,id,dataSet.id)
+    }
+
+	fit{|dataSet, action|
+        actions[\fit] = [nil,action];
+		this.prSendMsg(this.fitMsg(dataSet));
+	}
+
+    transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform,id,sourceDataSet.id,destDataSet.id);
+    }
+
+	transform{|sourceDataSet, destDataSet, action|
+		actions[\transform] = [nil,action];
+        this.prSendMsg(this.transformMsg(sourceDataSet, destDataSet));
+	}
+
+    fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform,id,sourceDataSet.id,destDataSet.id)
+    }
+
+	fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [nil,action];
+		this.prSendMsg(this.fitTransformMsg(sourceDataSet, destDataSet));
+	}
+
+    transformPointMsg{|sourceBuffer, destBuffer|
+        ^this.prMakeMsg(\transformPoint,id,
+            this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(destBuffer),
+            ["/b_query",destBuffer.asUGenInput]
+        );
+    }
+
+	transformPoint{|sourceBuffer, destBuffer, action|
+        actions[\transformPoint] = [nil,{action.value(destBuffer)}];
+        this.prSendMsg(this.transformPointMsg(sourceBuffer, destBuffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer,min,max,invert|
+
+        min = min ? this.min;
+        max = max ? this.max;
+        invert = invert ? this.invert;
+
+        this.min_(min).max_(max).invert_(invert);
+
+        ^FluidNormalizeQuery.kr( K2A.ar(trig),
+                this, this.min, this.max, this.invert, this.prEncodeBuffer(inputBuffer), this.prEncodeBuffer(outputBuffer)); 
+    }
+
+
+}
+
+FluidNormalizeQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidNoveltySlice.sc b/release-packaging/Classes/FluidNoveltySlice.sc
index a0ecbe1..d724017 100644
--- a/release-packaging/Classes/FluidNoveltySlice.sc
+++ b/release-packaging/Classes/FluidNoveltySlice.sc
@@ -1,4 +1,4 @@
-FluidNoveltySlice : UGen {
+FluidNoveltySlice : FluidRTUGen {
 	*ar { arg in = 0, feature = 0, kernelSize = 3, threshold = 0.8, filterSize = 1, minSliceLength = 2, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384, maxKernelSize = 101, maxFilterSize = 100;
 		^this.multiNew('audio', in.asAudioRateInput(this), feature, kernelSize, threshold, filterSize, minSliceLength, windowSize, hopSize, fftSize, maxFFTSize, maxKernelSize, maxFilterSize)
 	}
diff --git a/release-packaging/Classes/FluidOnsetSlice.sc b/release-packaging/Classes/FluidOnsetSlice.sc
index 2ecbb51..c376e83 100644
--- a/release-packaging/Classes/FluidOnsetSlice.sc
+++ b/release-packaging/Classes/FluidOnsetSlice.sc
@@ -1,4 +1,4 @@
-FluidOnsetSlice : UGen {
+FluidOnsetSlice : FluidRTUGen {
 	*ar { arg in = 0, metric = 0, threshold = 0.5, minSliceLength = 2, filterSize = 5, frameDelta = 0, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('audio', in.asAudioRateInput(this), metric, threshold, minSliceLength, filterSize, frameDelta, windowSize, hopSize, fftSize, maxFFTSize)
 	}
diff --git a/release-packaging/Classes/FluidPCA.sc b/release-packaging/Classes/FluidPCA.sc
new file mode 100644
index 0000000..20190c5
--- /dev/null
+++ b/release-packaging/Classes/FluidPCA.sc
@@ -0,0 +1,63 @@
+FluidPCA : FluidRealTimeModel{
+
+    var <>numDimensions;
+
+    *new {|server, numDimensions = 2|
+    	^super.new(server,[numDimensions]).numDimensions_(numDimensions);
+    }
+
+    prGetParams{
+        ^[numDimensions,-1,-1];
+    }
+
+    fitMsg{|dataSet|
+        ^this.prMakeMsg(\fit,id, dataSet.id);
+    }
+
+    fit{|dataSet, action|
+        actions[\fit] = [nil, action];
+        this.prSendMsg(this.fitMsg(dataSet));
+    }
+
+    transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform, id, sourceDataSet.id, destDataSet.id);
+    }
+
+    transform{|sourceDataSet, destDataSet, action|
+        actions[\transform] = [numbers(FluidMessageResponse,_,1,_),action];
+        this.prSendMsg(this.transformMsg(sourceDataSet,destDataSet));
+    }
+
+    fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform,id, sourceDataSet.id, destDataSet.id);
+    }
+
+    fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [numbers(FluidMessageResponse,_,1,_),action];
+    	this.prSendMsg(this.fitTransformMsg(sourceDataSet,destDataSet));
+    }
+
+    transformPointMsg{|sourceBuffer, destBuffer|
+        ^this.prMakeMsg(\transformPoint,id,
+            this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(destBuffer),
+            ["/b_query",destBuffer.asUGenInput]
+        );
+    }
+
+    transformPoint{|sourceBuffer, destBuffer, action|
+        actions[\transformPoint] = [nil,{action.value(destBuffer)}];
+        this.prSendMsg(this.transformPointMsg(sourceBuffer,destBuffer));
+    }
+
+    kr{|trig, inputBuffer,outputBuffer,numDimensions|
+
+        numDimensions = numDimensions ? this.numDimensions;
+        this.numDimensions_(numDimensions);
+
+        ^FluidPCAQuery.kr(K2A.ar(trig),this, this.numDimensions, this.prEncodeBuffer(inputBuffer), this.prEncodeBuffer(outputBuffer));
+    }
+
+}
+
+FluidPCAQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidPitch.sc b/release-packaging/Classes/FluidPitch.sc
index b56eba7..3e6b676 100644
--- a/release-packaging/Classes/FluidPitch.sc
+++ b/release-packaging/Classes/FluidPitch.sc
@@ -1,4 +1,4 @@
-FluidPitch : MultiOutUGen {
+FluidPitch : FluidRTMultiOutUGen {
 
 	*kr { arg in = 0, algorithm = 2, minFreq = 20, maxFreq = 10000, unit = 0, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), algorithm, minFreq, maxFreq, unit, windowSize, hopSize, fftSize, maxFFTSize);
diff --git a/release-packaging/Classes/FluidProviderTest.sc b/release-packaging/Classes/FluidProviderTest.sc
new file mode 100644
index 0000000..e368dbe
--- /dev/null
+++ b/release-packaging/Classes/FluidProviderTest.sc
@@ -0,0 +1,59 @@
+FluidProviderTest : FluidModelObject {
+
+/*    var <> server;
+    var <> nodeID;
+
+    *new{ |server, name|
+
+
+
+    }*/
+
+    // *kr{ |name,vals|
+    //     ^this.new1('control',name,vals);
+	// }
+    // 
+    // *new1 { |rate, name,vals|
+    //     var ascii = name.ascii;
+	// 	var args;
+	// 	vals ?? {vals = []};
+	// 	if(vals.isArray.not) {vals = [vals]};
+	// 	args = ([rate, ascii.size].addAll(ascii) ++ vals.size).addAll(vals).addAll([1,1]);
+	// 	args.postln;
+	// 	^super.new1(*args);
+    // }
+
+/*    init { |size...chars|
+        specialIndex = -1;
+        inputs = [size].addAll(chars);
+    }*/
+
+    addPoint{|server, nodeID, args, action|
+        this.prSendMsg(server, nodeID, 'addPoint',args,action);
+    }
+
+    updatePoint{|server, nodeID, args, action|
+        this.prSendMsg(server, nodeID, 'updatePoint',args,action);
+    }
+
+    deletePoint{|server, nodeID, args, action|
+        this.prSendMsg(server,nodeID,  'deletePoint',args,action);
+    }
+
+    prSendMsg { |server, nodeID, msg, args, action,parser|
+
+        server = server ? Server.default;
+
+        server.listSendMsg(['/u_cmd',nodeID.nodeID,this.synthIndex,msg].addAll(args));
+
+        OSCFunc(
+            { |msg|
+                var result = FluidMessageResponse.collectArgs(parser,msg.drop(3));
+                if(action.notNil){action.value(result)}{action.value};
+        },'/'++msg).oneShot;
+    }
+
+
+
+
+}   
diff --git a/release-packaging/Classes/FluidRobustScale.sc b/release-packaging/Classes/FluidRobustScale.sc
new file mode 100644
index 0000000..963745b
--- /dev/null
+++ b/release-packaging/Classes/FluidRobustScale.sc
@@ -0,0 +1,69 @@
+FluidRobustScale : FluidRealTimeModel {
+
+    var <>low, <>high, <>invert;
+
+	*new {|server, low = 25, high = 75, invert = 0|
+		^super.new(server,[low,high,invert])
+		.low_(low).high_(high).invert_(invert);
+	}
+
+    prGetParams{
+        ^[this.low,this.high,this.invert,-1,-1];
+    }
+
+
+    fitMsg{|dataSet|
+        ^this.prMakeMsg(\fit,id,dataSet.id)
+    }
+
+	fit{|dataSet, action|
+        actions[\fit] = [nil,action];
+		this.prSendMsg(this.fitMsg(dataSet));
+	}
+
+    transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform,id,sourceDataSet.id,destDataSet.id);
+    }
+
+	transform{|sourceDataSet, destDataSet, action|
+		actions[\transform] = [nil,action];
+        this.prSendMsg(this.transformMsg(sourceDataSet, destDataSet));
+	}
+
+    fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform,id,sourceDataSet.id,destDataSet.id)
+    }
+
+	fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [nil,action];
+		this.prSendMsg(this.fitTransformMsg(sourceDataSet, destDataSet));
+	}
+
+    transformPointMsg{|sourceBuffer, destBuffer|
+        ^this.prMakeMsg(\transformPoint,id,
+            this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(destBuffer),
+            ["/b_query",destBuffer.asUGenInput]
+        );
+    }
+
+	transformPoint{|sourceBuffer, destBuffer, action|
+        actions[\transformPoint] = [nil,{action.value(destBuffer)}];
+        this.prSendMsg(this.transformPointMsg(sourceBuffer, destBuffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer,low,high,invert|
+
+        low = low ? this.low;
+        high = high ? this.high;
+		invert = invert ? this.invert;
+
+        this.low_(low).high_(high).invert_(invert);
+
+        ^FluidRobustScaleQuery.kr(K2A.ar(trig),this, this.low, this.high, this.invert, this.prEncodeBuffer(inputBuffer), this.prEncodeBuffer(outputBuffer));
+    }
+
+
+}
+
+FluidRobustScaleQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidSTFTPass.sc b/release-packaging/Classes/FluidSTFTPass.sc
index d3456fd..c79d600 100644
--- a/release-packaging/Classes/FluidSTFTPass.sc
+++ b/release-packaging/Classes/FluidSTFTPass.sc
@@ -1,4 +1,4 @@
-FluidSTFTPass : UGen {
+FluidSTFTPass : FluidRTUGen {
 	*ar { arg in = 0, windowSize= 1024, hopSize= -1, fftSize= -1, maxFFTSize = 16384;
 		^this.multiNew('audio', in.asAudioRateInput(this), windowSize, hopSize, fftSize, maxFFTSize)
 	}
diff --git a/release-packaging/Classes/FluidServerCache.sc b/release-packaging/Classes/FluidServerCache.sc
new file mode 100644
index 0000000..6f9a3c9
--- /dev/null
+++ b/release-packaging/Classes/FluidServerCache.sc
@@ -0,0 +1,93 @@
+FluidProxyUgen : UGen {
+
+	var <>pluginname;
+
+	*kr { |pluginname...args|
+        args = args.collect{|x| x.asUGenInput}
+		^this.new1('control', pluginname,*args)
+	}
+
+	init { |pluginname...args|
+		this.pluginname = pluginname;
+		inputs = args;
+		rate = 'control';
+	}
+
+	name{
+		^pluginname.asString;
+	}
+
+    poll{ |trig = 10, label, trigid = -1|
+        ^super.poll(trig, label ? this.name, trigid)
+    }
+}
+
+FluidServerCache {
+
+	var <cache;
+
+	*new{ ^super.new.init }
+
+	init{
+		cache = IdentityDictionary.new;
+	}
+
+	do { |server, func|
+		cache[server]!?{cache[server].do{|x|func.value(x)}}
+	}
+
+    doAll {|func|
+        cache.do{|subCache|
+            subCache.do{|item|
+                func.value(item)
+            }
+        }
+    }
+
+    postln{
+        cache.postln;
+    }
+
+	at { |server,id|
+		^cache[server].tryPerform(\at,id)
+	}
+
+	includesKey{|server,key|
+		^cache[server].tryPerform(\includesKey,key)
+	}
+
+	put {|server,id,x|
+		cache[server][id] = x;
+	}
+
+	remove { |server,id|
+		cache[server]!? {cache[server].removeAt(id)};
+	}
+
+	initCache {|server|
+		cache[server] ?? {
+			cache[server] = IdentityDictionary.new;
+			NotificationCenter.register(server,\newAllocators,this,
+			{
+					this.clearCache(server);
+			});
+		}
+	}
+
+	clearCache { |server|
+		cache[server] !?
+        {
+            var bundle = [];
+            cache[server].values.do{|i|
+                if(i.respondsTo(\freeMsg)){
+                    bundle = bundle.add(i.freeMsg); //server objects
+                }{
+                 i.free; //OSCFunc
+                }
+            };
+            server.listSendBundle(nil,bundle);
+            cache.removeAt(server);
+        };
+	}
+
+}
diff --git a/release-packaging/Classes/FluidServerObject.sc b/release-packaging/Classes/FluidServerObject.sc
new file mode 100644
index 0000000..66625fc
--- /dev/null
+++ b/release-packaging/Classes/FluidServerObject.sc
@@ -0,0 +1,344 @@
+FluidServerObject
+{
+    classvar serverCaches;
+    classvar count;
+    classvar persistent = true;
+    var <server,<id;
+
+    *version{|server|
+        server ?? {server = Server.default};
+        server.sendMsg("/cmd","/"++this.objectClassName++'/version');
+    }
+
+    *initClass {
+        serverCaches = IdentityDictionary.new;
+        count = 0;
+        ServerBoot.add({serverCaches[this]!?{serverCaches[this].cache.put(Server.internal,nil);}},Server.internal);
+    }
+
+    *initCache {|server|
+        serverCaches[this] ?? { serverCaches[this] = FluidServerCache.new};
+
+        if(server === Server.internal and: serverCaches[this].cache[Server.internal].isNil)
+        {
+            this.flush(Server.internal)
+        };
+
+        serverCaches[this].initCache(server);
+        NotificationCenter.register(server,\newAllocators,this,{ count = 0; });
+    }
+
+    *newMsg{|id, params|
+        params = params !? {params.collect(_.asUGenInput)};
+        // ("Newms"++params).postln;
+          ^['/cmd',this.objectClassName ++ '/new',id] ++ params
+    }
+
+    *new{ |server, id, params, action, callNew = true|
+        var newObj;
+        server ?? {server = Server.default};
+        if(server.serverRunning.not){"Server not running".warn};
+        id !? { id = id.asInteger }
+           ?? { id = count; count = count + 1; };
+        newObj = super.newCopyArgs(server,id,action);
+        // params.postln;
+        if(callNew) {server.listSendMsg(this.newMsg(id,params))};
+        ^newObj.cache
+    }
+
+    cache {
+        this.class.initCache(server);
+        serverCaches[this.class].put(server,this.id,this);
+    }
+
+    uncache{
+        serverCaches[this.class].remove(server,id);
+    }
+
+    prMakeMsg{|msg,id...args|
+        ^['/cmd',"%/%".format(this.class.objectClassName,msg),id].addAll(args);
+    }
+
+    freeMsg {
+        var msg;
+        id ?? {" % already freed".format(this.class.name).warn; ^nil};
+        this.uncache;
+        msg = this.prMakeMsg(\free,id);
+        id = nil;
+        ^msg;
+    }
+
+    free{
+        var msg = this.freeMsg;
+        msg !? {server.listSendMsg(msg)} ?? {^nil};
+    }
+
+    *freeAll{|server|
+        serverCaches[this] !? {|cache|
+            cache.clearCache(server ? Server.default);
+        };
+        count = 0;
+    }
+
+    asUGenInput{ ^id }
+
+    asString {
+        ^"%(%)".format(this.class.name,id).asString;
+    }
+
+    asSymbol {
+        ^id.asSymbol
+    }
+
+    *objectClassName { ^this.name.asSymbol }
+
+    *flushMsg { ^['/cmd',this.objectClassName ++ '/flush'] }
+
+    *flush {|server| server.listSendMsg(this.flushMsg)}
+}
+
+FluidBufProcessor : FluidServerObject
+{
+    var <processAction;
+    var <outputBuffers;
+    var <freeWhenDone;
+    classvar responder;
+    classvar count;
+
+    *cmdPeriod {
+        serverCaches[this] !? {|cache|
+            cache.doAll{|processor| processor !? { processor.free;} };
+            serverCaches[this] = nil;
+        };
+        count = 0;
+    }
+
+    *initCache {|server|
+        // "initcache".postln;
+        // this.done.postln;
+        super.initCache(server);
+        CmdPeriod.add(this);
+        if(serverCaches[this].includesKey(server,\processResponder).not)
+        {
+            serverCaches[this].put(server,\processResponder,OSCFunc({|m|
+                var id = m.last.asInteger;
+                // "I'm in the pizza hut".postln;
+                serverCaches[this].at(server,id) !? {|p|
+                    // "I'm in the taco bell".postln ;
+                    p!?{
+                        p.processAction!?{|a|
+                            var bufs = p.outputBuffers;
+
+                            bufs = bufs.collect{|b|
+                                if(b.isKindOf(Buffer))
+                                {b}
+                                {Buffer.cachedBufferAt(server,b)};
+                            };
+                            a.valueArray(valueArray(bufs));
+                        };
+                        if(p.freeWhenDone){p.free};
+                    }
+                }
+            },this.done ,server.addr).fix)
+        }
+    }
+
+    *new {|server,id,outputBuffers|
+        ^super.new(server,id, nil, nil,false).init(outputBuffers);
+    }
+
+    init{ |ob|
+        outputBuffers = ob;
+    }
+
+    *done {
+        ^"/%/process".format(this.objectClassName);
+    }
+
+    wait {
+        var condition = Condition.new;
+        id ?? {Error("% already freed".format(this.class.name)).throw};
+        OSCFunc({
+            condition.unhang;
+        },this.class.done,server.addr,argTemplate:[nil,id]).oneShot;
+        condition.hang;
+    }
+
+    processMsg {|params|
+        var msg;
+        var completionMsg = outputBuffers !?    {
+            [["/sync"]] ++ outputBuffers.collect{|b| ["/b_query", b.asUGenInput]}
+        } ?? {[]};
+
+        // completionMsg.postln;
+        id ?? {Error("% already freed".format(this.class.name)).throw};
+        msg = this.prMakeMsg(\processNew,id).addAll(params).add(completionMsg);
+        // msg.postln;
+        ^msg;
+    }
+
+    processList { |params,shouldFree,action|
+        freeWhenDone = shouldFree;
+        processAction = action;
+        params = params.collect(_.asUGenInput);
+        server.listSendMsg(this.processMsg(params));
+    }
+
+    cancelMsg{
+        id ?? {Error("% already freed".format(this.class.name)).throw};
+        ^this.prMakeMsg(\cancel, id);
+    }
+
+    cancel{
+        server.listSendMsg(this.cancelMsg);
+    }
+
+    kr{  ^FluidProxyUgen.kr(this.class.objectClassName ++ "Monitor",id) }
+}
+
+FluidOSCPatternInversion : OSCMessageDispatcher
+{
+    value {|msg, time, addr, recvPort|
+        var msgpath = msg[0].asSymbol;
+        active.keysValuesDo({|key, func|
+            if(msgpath.matchOSCAddressPattern(key), {func.value(msg, time, addr, recvPort);});
+        })
+    }
+}
+
+
+FluidDataObject : FluidServerObject
+{
+    classvar postResponse;
+
+    var <actions;
+
+    *initClass{
+        postResponse = _.postln;
+    }
+
+    *initCache{ |server|
+        super.initCache(server);
+        if(serverCaches[this].includesKey(server,\messageResponder).not)
+        {
+            serverCaches[this].put(server,\messageResponder,OSCFunc.new({|m|
+                var id = m[1].asInteger;
+                var method;
+                serverCaches[this].at(server,id) !? { |p|
+                    method = m[0].asString.findRegexp("/"++this.name++"/(.*)")[1][1].asSymbol;
+                    p.actions[method] !? {|a|
+                        //two items: parser and action
+                        var parser = a[0];
+                        var action = a[1];
+                        var result = FluidMessageResponse.collectArgs(parser,m[2..]);
+                        action.value(result);
+                    }
+                }
+            },'/' ++ this.objectClassName ++ '/*',server.addr, dispatcher:FluidOSCPatternInversion.new).fix)
+        }
+    }
+
+    *new{|server...args|
+        // args.flatten.postln;
+        ^super.new(server,params:args.flatten).init;
+    }
+
+    *cachedInstanceAt{|server,id|
+        this.initCache(server);
+        ^serverCaches[this].at(server,id);
+    }
+
+    init {
+        actions = IdentityDictionary.new;
+    }
+
+    prEncodeBuffer { |buf| buf !? {^buf.asUGenInput} ?? {^-1} }
+
+    prSendMsg {|msg| server !? {server.listSendMsg(msg)};}
+
+    colsMsg { ^this.prMakeMsg(\cols,id);}
+
+    cols{ |action=(postResponse)|
+        actions[\cols] = [numbers(FluidMessageResponse,_,1,_),action];
+        this.prSendMsg(this.colsMsg)
+    }
+
+    readMsg { |filename| ^this.prMakeMsg(\read,id,filename.asString);}
+
+    read{|filename, action|
+      actions[\read] = [nil,action];
+      this.prSendMsg(this.readMsg(filename));
+    }
+
+    writeMsg {|filename|
+        // ^['/cmd',this.class.name ++ '/write',id,filename.asString]
+        ^this.prMakeMsg(\write,id,filename.asString);
+    }
+
+    write{|filename, action|
+      actions[\write] = [nil,action];
+      this.prSendMsg(this.writeMsg(filename));
+    }
+
+    sizeMsg{
+        // ^['/cmd',this.class.name ++ '/size',id]
+        ^this.prMakeMsg(\size,id);
+    }
+
+    size {|action=(postResponse)|
+      actions[\size] = [numbers(FluidMessageResponse,_,1,_),action];
+      this.prSendMsg(this.sizeMsg);
+    }
+}
+
+FluidModelObject : FluidDataObject
+{
+    prGetParams{
+        "Subclass should provide this".throw;
+    }
+
+    prUpdateStateMsg{
+        var params = this.prGetParams.value.collect(_.asUGenInput);
+        ^this.prMakeMsg(\setParams,id) ++ params;
+    }
+
+    prSendMsg {|msg|
+        //These need to happen sequentially, but not simultaneously
+        //sending as a bundle makes reasoning about timing w/r/t other
+        //commands more awkward, unless we set the offet to 0 (in which case,
+        //noisy 'late' messages)
+        super.prSendMsg(this.prUpdateStateMsg);
+        super.prSendMsg(msg);
+    }
+}
+
+FluidRealTimeModel : FluidModelObject
+{
+    *new{ |server, params|
+        ^super.new(server,params++[-1,-1]);
+    }
+}
+
+FluidRTQuery : FluidProxyUgen
+{
+    *kr{ |trig,obj...args|
+        ^super.kr(this.name,trig,obj.asUGenInput, *args)
+    }
+}
+
+
+FluidRTUGen : UGen
+{
+    *version{|server|
+        server ?? {server = Server.default};
+        server.sendMsg("/cmd","/"++this.name++'/version');
+    }
+}
+
+FluidRTMultiOutUGen : MultiOutUGen
+{
+    *version{|server|
+        server ?? {server = Server.default};
+        server.sendMsg("/cmd","/"++this.name++'/version');
+    }
+}
diff --git a/release-packaging/Classes/FluidSines.sc b/release-packaging/Classes/FluidSines.sc
index 8676004..a85d2a0 100755
--- a/release-packaging/Classes/FluidSines.sc
+++ b/release-packaging/Classes/FluidSines.sc
@@ -1,4 +1,4 @@
-FluidSines : MultiOutUGen {
+FluidSines : FluidRTMultiOutUGen {
 	*ar { arg in = 0, bandwidth = 76, detectionThreshold = -96, birthLowThreshold = -24, birthHighThreshold = -60, minTrackLen = 15, trackingMethod = 0, trackMagRange = 15, trackFreqRange = 50, trackProb = 0.5, windowSize= 1024, hopSize= -1, fftSize= -1, maxFFTSize=16384;
 		^this.multiNew('audio', in.asAudioRateInput(this), bandwidth, detectionThreshold,birthLowThreshold, birthHighThreshold, minTrackLen, trackingMethod, trackMagRange, trackFreqRange, trackProb, windowSize, hopSize, fftSize, maxFFTSize)
 	}
diff --git a/release-packaging/Classes/FluidSpectralShape.sc b/release-packaging/Classes/FluidSpectralShape.sc
index ada4f20..1a3fa2d 100644
--- a/release-packaging/Classes/FluidSpectralShape.sc
+++ b/release-packaging/Classes/FluidSpectralShape.sc
@@ -1,4 +1,4 @@
-FluidSpectralShape : MultiOutUGen {
+FluidSpectralShape : FluidRTMultiOutUGen {
 
 	*kr { arg in = 0, windowSize = 1024, hopSize = -1, fftSize = -1, maxFFTSize = 16384;
 		^this.multiNew('control', in.asAudioRateInput(this), windowSize, hopSize, fftSize, maxFFTSize);
diff --git a/release-packaging/Classes/FluidStandardize.sc b/release-packaging/Classes/FluidStandardize.sc
new file mode 100644
index 0000000..dca033c
--- /dev/null
+++ b/release-packaging/Classes/FluidStandardize.sc
@@ -0,0 +1,59 @@
+FluidStandardize : FluidRealTimeModel {
+
+    var <>invert;
+
+    *new {|server, invert = 0|
+		^super.new(server,[invert]).invert_(invert);
+	}
+
+    prGetParams{
+        ^[this.invert, -1, 1];
+    }
+
+	fitMsg{|dataSet|
+        ^this.prMakeMsg(\fit,id,dataSet.id);
+    }
+
+    fit{|dataSet, action|
+        actions[\fit] = [nil, action];
+		this.prSendMsg(this.fitMsg(dataSet));
+	}
+
+	transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform,id,sourceDataSet.id,destDataSet.id);
+    }
+
+	transform{|sourceDataSet, destDataSet, action|
+        actions[\transform] = [nil,action];
+		this.prSendMsg(this.transformMsg(sourceDataSet,destDataSet));
+	}
+
+    fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform,id,sourceDataSet.id,destDataSet.id)
+    }
+
+	fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [nil,action];
+		this.prSendMsg(this.fitTransformMsg(sourceDataSet, destDataSet));
+	}
+
+
+    transformPointMsg{|sourceBuffer, destBuffer|
+        ^this.prMakeMsg(\transformPoint, id, this.prEncodeBuffer(sourceBuffer), this.prEncodeBuffer(destBuffer),["/b_query",destBuffer.asUGenInput]);
+    }
+
+	transformPoint{|sourceBuffer, destBuffer, action|
+        actions[\transformPoint] = [nil, {action.value(destBuffer)}];
+        this.prSendMsg(this.transformPointMsg(sourceBuffer,destBuffer));
+	}
+
+    kr{|trig, inputBuffer,outputBuffer,invert|
+
+        invert = invert ? this.invert;
+        this.invert_(invert);
+
+        ^FluidStandardizeQuery.kr(K2A.ar(trig),this, this.invert, this.prEncodeBuffer(inputBuffer), this.prEncodeBuffer(outputBuffer));
+    }
+}
+
+FluidStandardizeQuery : FluidRTQuery {}
diff --git a/release-packaging/Classes/FluidSubscriberTest.sc b/release-packaging/Classes/FluidSubscriberTest.sc
new file mode 100644
index 0000000..a04776f
--- /dev/null
+++ b/release-packaging/Classes/FluidSubscriberTest.sc
@@ -0,0 +1,40 @@
+FluidSubscriberTest : FluidModelObject {
+
+    var <> providerName;
+    var <> nodeID;
+
+    // *kr { |provider|
+    //     ^this.multiNew('control',provider);
+	// }
+    // 
+    // *new1 { |rate, provider|
+    //     var ascii = provider.ascii;
+    //     ^super.new1(*[rate, ascii.size].addAll(ascii));
+    // }
+    // 
+    // init { |size...chars|
+    //     //Send the number of inputs (size of provider string) as specialIndex,
+    //     //so server plugin knows what's going on
+    //     specialIndex = -1;
+    //     inputs = [size].addAll(chars);
+    //     providerName = chars.collectAs({|x|x.asInteger.asAscii}, String);
+    // }
+
+    providerLookup { |server, nodeID, label, action|
+        this.prSendMsg(server, nodeID, 'providerLookup', label, action,
+            [string(FluidMessageResponse,_,_),numbers(FluidMessageResponse,_,2,_)] );
+    }
+
+    prSendMsg { |server, nodeID, msg, args, action,parser|
+
+        server = server ? Server.default;
+
+        server.listSendMsg(['/u_cmd',nodeID.nodeID,this.synthIndex,msg].addAll(args));
+
+        OSCFunc(
+            { |msg|
+                var result = FluidMessageResponse.collectArgs(parser,msg.drop(3));
+                if(action.notNil){action.value(result)}{action.value};
+        },'/'++msg).oneShot;
+    }
+}
diff --git a/release-packaging/Classes/FluidTransientSlice.sc b/release-packaging/Classes/FluidTransientSlice.sc
index b4f4ecc..3d228d3 100644
--- a/release-packaging/Classes/FluidTransientSlice.sc
+++ b/release-packaging/Classes/FluidTransientSlice.sc
@@ -1,4 +1,4 @@
-FluidTransientSlice : UGen {
+FluidTransientSlice : FluidRTUGen {
 	*ar { arg in = 0, order = 20, blockSize = 256, padSize = 128, skew = 0.0, threshFwd = 2.0, threshBack = 1.1, windowSize=14, clumpLength=25, minSliceLength = 1000;
 		^this.multiNew('audio', in.asAudioRateInput(this), order, blockSize, padSize, skew, threshFwd ,threshBack, windowSize, clumpLength, minSliceLength)
 	}
diff --git a/release-packaging/Classes/FluidTransients.sc b/release-packaging/Classes/FluidTransients.sc
index ef0c968..972bf98 100644
--- a/release-packaging/Classes/FluidTransients.sc
+++ b/release-packaging/Classes/FluidTransients.sc
@@ -1,4 +1,4 @@
-FluidTransients : MultiOutUGen {
+FluidTransients : FluidRTMultiOutUGen {
 	*ar { arg in = 0, order = 20, blockSize = 256, padSize = 128, skew = 0.0, threshFwd = 2.0, threshBack = 1.1, windowSize=14, clumpLength=25;
 		^this.multiNew('audio', in.asAudioRateInput(this), order, blockSize, padSize, skew, threshFwd, threshBack, windowSize, clumpLength)
 	}
diff --git a/release-packaging/Classes/FluidUMAP.sc b/release-packaging/Classes/FluidUMAP.sc
new file mode 100644
index 0000000..5b183f9
--- /dev/null
+++ b/release-packaging/Classes/FluidUMAP.sc
@@ -0,0 +1,87 @@
+FluidUMAP : FluidRealTimeModel {
+
+    var <>numDimensions, <>numNeighbours, <>minDist, <>iterations, <>learnRate;
+
+	*new {|server,numDimensions = 2, numNeighbours = 15, minDist = 0.1, iterations = 200, learnRate = 0.1|
+		^super.new(server,[numDimensions, numNeighbours, minDist, iterations, learnRate])
+        .numDimensions_(numDimensions)
+        .numNeighbours_(numNeighbours)
+        .minDist_(minDist)
+        .iterations_(iterations)
+        .learnRate_(learnRate);
+	}
+
+    prGetParams{
+        ^[
+            this.numDimensions,
+            this.numNeighbours,
+            this.minDist,
+            this.iterations,
+            this.learnRate,
+			-1,-1
+        ]
+    }
+
+    fitTransformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\fitTransform, id, sourceDataSet.id, destDataSet.id)
+    }
+
+	fitTransform{|sourceDataSet, destDataSet, action|
+        actions[\fitTransform] = [nil, action];
+		this.prSendMsg(this.fitTransformMsg(sourceDataSet,destDataSet));
+	}
+
+	fitMsg{|dataSet|
+        ^this.prMakeMsg(\fit,id, dataSet.id);
+    }
+
+    fit{|dataSet, action|
+        actions[\fit] = [nil, action];
+        this.prSendMsg(this.fitMsg(dataSet));
+    }
+
+    transformMsg{|sourceDataSet, destDataSet|
+        ^this.prMakeMsg(\transform, id, sourceDataSet.id, destDataSet.id);
+    }
+
+    transform{|sourceDataSet, destDataSet, action|
+        actions[\transform] = [nil, action];
+        this.prSendMsg(this.transformMsg(sourceDataSet,destDataSet));
+    }
+
+
+    transformPointMsg{|sourceBuffer, destBuffer|
+        ^this.prMakeMsg(\transformPoint,id,
+            this.prEncodeBuffer(sourceBuffer),
+            this.prEncodeBuffer(destBuffer),
+            ["/b_query",destBuffer.asUGenInput]
+        );
+    }
+
+    transformPoint{|sourceBuffer, destBuffer, action|
+        actions[\transformPoint] = [nil,{action.value(destBuffer)}];
+        this.prSendMsg(this.transformPointMsg(sourceBuffer,destBuffer));
+    }
+
+	kr{|trig, inputBuffer,outputBuffer,numDimensions|
+
+        numDimensions = numDimensions ? this.numDimensions;
+        this.numDimensions_(numDimensions);
+
+        ^FluidUMAPQuery.kr(K2A.ar(trig),
+            this,
+			this.numDimensions,
+			this.numNeighbours,
+            this.minDist,
+            this.iterations,
+            this.learnRate,
+			this.prEncodeBuffer(inputBuffer),
+			this.prEncodeBuffer(outputBuffer));
+    }
+
+	// not implemented
+	cols {|action|}
+	size { |action|}
+}
+
+FluidUMAPQuery : FluidRTQuery {}
diff --git a/release-packaging/Examples/buffer_compositing/bufcompose-MS-FIR.scd b/release-packaging/Examples/buffer_compositing/bufcompose-MS-FIR.scd
index b13b37a..d72ecc9 100644
--- a/release-packaging/Examples/buffer_compositing/bufcompose-MS-FIR.scd
+++ b/release-packaging/Examples/buffer_compositing/bufcompose-MS-FIR.scd
@@ -19,7 +19,11 @@ FluidBufCompose.process(s,b, numChans: 1, gain: -3.0.dbamp * -1.0, startChan: 1,
 
 // (optional) compare auraly the stereo with the MS
 b.play;
-{PlayBuf.ar(1,[c,d])}.play;
+{PlayBuf.ar(1, [c,d])}.play;
+
+//check nullsum with real-time versions
+{PlayBuf.ar(1, c) - PlayBuf.ar(2, b).madd(-3.0.dbamp).sum}.play;
+{PlayBuf.ar(1, d) - PlayBuf.ar(2, b).madd(-3.0.dbamp * [1,-1]).sum}.play;
 
 // The geeky bit: copy the side (buffer d) on itself with specific amplitudes and delays, in effect applying a FIR filter through expensive convolution
 
diff --git a/release-packaging/Examples/buffer_compositing/fileiterator-2passes.scd b/release-packaging/Examples/buffer_compositing/fileiterator-2passes.scd
index e1d05ef..502518c 100644
--- a/release-packaging/Examples/buffer_compositing/fileiterator-2passes.scd
+++ b/release-packaging/Examples/buffer_compositing/fileiterator-2passes.scd
@@ -40,6 +40,6 @@ c.postln
 b.play
 
 
-{PlayBuf.ar(1,b.bufnum,startPos:c[740])}.play
+{PlayBuf.ar(1,b.bufnum,startPos:c[15])}.play
 
 Buffer.freeAll
\ No newline at end of file
diff --git a/release-packaging/Examples/buffer_compositing/fileiterator.scd b/release-packaging/Examples/buffer_compositing/fileiterator.scd
index 9808f72..7e0f32a 100644
--- a/release-packaging/Examples/buffer_compositing/fileiterator.scd
+++ b/release-packaging/Examples/buffer_compositing/fileiterator.scd
@@ -37,4 +37,4 @@ b.plot
 c.postln
 b.play
 
-{PlayBuf.ar(1,b.bufnum,startPos:c[740])}.play
+{PlayBuf.ar(1,b.bufnum,startPos:c[15])}.play
diff --git a/release-packaging/Examples/dataset/0-demo-dataset-maker-utilities.scd b/release-packaging/Examples/dataset/0-demo-dataset-maker-utilities.scd
new file mode 100644
index 0000000..cbbd4b1
--- /dev/null
+++ b/release-packaging/Examples/dataset/0-demo-dataset-maker-utilities.scd
@@ -0,0 +1,169 @@
+// define a few processes
+(
+~ds = FluidDataSet(s);//no name needs to be provided
+//define as many buffers as we have parallel voices/threads in the extractor processing (default is 4)
+~mfccbuf = 4.collect{Buffer.new};
+~statsbuf = 4.collect{Buffer.new};
+~flatbuf = 4.collect{Buffer.new};
+
+// here we instantiate a loader which creates a single large buffer with a dictionary of what was included in it
+// ~loader = FluidLoadFolder("/Volumes/machins/projets/newsfeed/sons/smallnum/");
+~loader = FluidLoadFolder(File.realpath(FluidLoadFolder.class.filenameSymbol).dirname +/+ "../AudioFiles");
+
+// here we instantiate a further slicing step if needs be, which iterate through all the items of the FluidLoadFolder and slice the slices with the declared function.
+~slicer = FluidSliceCorpus({ |src,start,num,dest|
+	FluidBufOnsetSlice.kr(src, start, num, metric: 9, minSliceLength: 17, indices:dest, threshold:0.7, blocking: 1)
+});
+
+// here we instantiate a process of description and dataset writing, which will run each slice of the previous slice and write the entry. Note the chain of Done.kr triggers.
+~extractor = FluidProcessSlices({|src,start,num,data|
+	var mfcc, stats, writer, flatten,mfccBuf, statsBuf, flatBuf, label, voice;
+	label = data.key;
+    voice = data.value[\voice];
+	mfcc = FluidBufMFCC.kr(src, startFrame:start, numFrames:num, numChans:1, features:~mfccbuf[voice], trig:1, blocking: 1);
+	stats = FluidBufStats.kr(~mfccbuf[voice], stats:~statsbuf[voice], trig:Done.kr(mfcc), blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice], destination:~flatbuf[voice], trig:Done.kr(stats), blocking: 1);
+	writer = FluidDataSetWr.kr(~ds, label, nil, ~flatbuf[voice], trig: Done.kr(flatten), blocking: 1)
+});
+)
+
+
+//////////////////////////////////////////////////////////////////////////
+//loading process
+
+// just run the loader
+(
+t = Main.elapsedTime;
+~loader.play(s,action:{(Main.elapsedTime - t).postln;"Loaded".postln;});
+)
+
+//load and play to test if it is that quick - it is!
+(
+t = Main.elapsedTime;
+~loader.play(s,action:{(Main.elapsedTime - t).postln;"Loaded".postln;{var start, stop; PlayBuf.ar(~loader.index[~loader.index.keys.asArray.last.asSymbol][\numchans],~loader.buffer,startPos: ~loader.index[~loader.index.keys.asArray.last.asSymbol][\bounds][0])}.play;});
+)
+
+//ref to the buffer
+~loader.buffer
+//size of item
+~loader.index.keys.size
+//a way to get all keys info sorted by time
+~stuff = Array.newFrom(~loader.index.keys).sort.collect{|x|~loader.index[x][\bounds]}.sort{|a,b| a[0]<b[0]};
+
+//or to iterate in the underlying dictionary (unsorted)
+(
+~loader.index.pairsDo{ |k,v,i|
+	k.postln;
+	v.pairsDo{|l,u,j|
+		"\t\t\t".post;
+		(l->u).postln;
+	}
+}
+)
+
+// or write to file a human readable, sorted version of the database after sorting it by index.
+(
+a = File("/tmp/sc-loading.json","w");
+~stuffsorted = Array.newFrom(~loader.index.keys).sort{|a,b| ~loader.index[a][\bounds][0]< ~loader.index[b][\bounds][0]}.do{|k|
+	v =  ~loader.index[k];
+	a.write(k.asString ++  "\n");
+	v.pairsDo{|l,u,j|
+		a.write("\t\t\t" ++ (l->u).asString ++ "\n");
+	}
+};
+a.close;
+)
+
+//////////////////////////////////////////////////////////////////////////
+// slicing process
+
+// just run the slicer
+(
+t = Main.elapsedTime;
+~slicer.play(s,~loader.buffer,~loader.index,action:{(Main.elapsedTime - t).postln;"Slicing done".postln});
+)
+
+//slice count
+~slicer.index.keys.size
+
+// iterate
+(
+~slicer.index.pairsDo{ |k,v,i|
+	k.postln;
+	v.pairsDo{|l,u,j|
+		"\t\t\t".post;
+		(l->u).postln;
+	}
+}
+)
+
+///// write to file in human readable format, in order.
+(
+a = File("/tmp/sc-spliting.json","w");
+~stuffsorted = Array.newFrom(~slicer.index.keys).sort{|a,b| ~slicer.index[a][\bounds][0]< ~slicer.index[b][\bounds][0]}.do{|k|
+	v =  ~slicer.index[k];
+	a.write(k.asString ++  "\n");
+	v.pairsDo{|l,u,j|
+		a.write("\t\t\t" ++ (l->u).asString ++ "\n");
+	}
+};
+a.close;
+)
+
+//////////////////////////////////////////////////////////////////////////
+// description process
+
+// just run the descriptor extractor
+(
+t = Main.elapsedTime;
+~extractor.play(s,~loader.buffer,~slicer.index,action:{(Main.elapsedTime - t).postln;"Features done".postln});
+)
+
+// write the dataset to file with the native JSON
+~ds.write("/tmp/sc-dataset.json")
+
+// open the file in your default json editor
+"open /tmp/sc-dataset.json".unixCmd
+
+//////////////////////////////////////////////////////////////////////////
+// manipulating and querying the data
+
+//building a tree
+~tree = FluidKDTree(s);
+~tree.fit(~ds,{"Fitted".postln;});
+
+//retrieve a sound to match
+~targetsound = Buffer(s);
+~targetname = ~slicer.index.keys.asArray.scramble[0].asSymbol;
+#a,b = ~slicer.index[~targetname][\bounds];
+FluidBufCompose.process(s,~loader.buffer,a,(b-a),numChans: 1, destination: ~targetsound,action: {~targetsound.play;})
+
+//describe the sound to match
+(
+{
+	var mfcc, stats, flatten;
+	mfcc = FluidBufMFCC.kr(~targetsound,features:~mfccbuf[0],trig:1);
+	stats = FluidBufStats.kr(~mfccbuf[0],stats:~statsbuf[0],trig:Done.kr(mfcc));
+	flatten = FluidBufFlatten.kr(~statsbuf[0],destination:~flatbuf[0],trig:Done.kr(stats));
+	FreeSelfWhenDone.kr(flatten);
+}.play;
+)
+
+//find its nearest neighbours
+~friends = Array;
+~tree.numNeighbours = 5;
+~tree.kNearest(~flatbuf[0],{|x| ~friends = x.postln;})
+
+// play them in a row
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~friends[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~friends[i].postln;
+	dur.wait;
+	};
+}.play;
+)
diff --git a/release-packaging/Examples/dataset/1-learning examples/10a-weighted-MFCCs-comparison.scd b/release-packaging/Examples/dataset/1-learning examples/10a-weighted-MFCCs-comparison.scd
new file mode 100644
index 0000000..b8308d9
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/10a-weighted-MFCCs-comparison.scd	
@@ -0,0 +1,235 @@
+// define a few processes
+(
+~ds = FluidDataSet(s);
+~dsW = FluidDataSet(s);
+~dsL = FluidDataSet(s);
+//define as many buffers as we have parallel voices/threads in the extractor processing (default is 4)
+~loudbuf = 4.collect{Buffer.new};
+~weightbuf = 4.collect{Buffer.new};
+~mfccbuf = 4.collect{Buffer.new};
+~statsbuf = 4.collect{Buffer.new};
+~flatbuf = 4.collect{Buffer.new};
+
+// here we instantiate a loader as per example 0
+~loader = FluidLoadFolder(File.realpath(FluidBufPitch.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/");
+
+// here we instantiate a further slicing step as per example 0
+~slicer = FluidSliceCorpus({ |src,start,num,dest|
+	FluidBufOnsetSlice.kr(src,start,num,metric: 9, minSliceLength: 17, indices:dest, threshold:0.2,blocking: 1)
+});
+
+// here we instantiate a process of description and dataset writing, as per example 0
+~extractor = FluidProcessSlices({|src,start,num,data|
+	var label, voice, mfcc, stats, flatten;
+	label = data.key;
+    voice = data.value[\voice];
+	mfcc = FluidBufMFCC.kr(src, startFrame:start, numFrames:num, numChans:1, features:~mfccbuf[voice], padding: 2, trig:1, blocking: 1);
+	stats = FluidBufStats.kr(~mfccbuf[voice], stats:~statsbuf[voice], numDerivs: 1, trig:Done.kr(mfcc), blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice], destination:~flatbuf[voice], trig:Done.kr(stats), blocking: 1);
+	FluidDataSetWr.kr(~ds, label, nil, ~flatbuf[voice], Done.kr(flatten), blocking: 1);
+});
+
+// here we make another processor, this time with doing an amplitude weighing
+~extractorW = FluidProcessSlices({|src,start,num,data|
+	var label, voice, loud, weights, mfcc, stats, flatten;
+	label = data.key;
+    voice = data.value[\voice];
+	mfcc = FluidBufMFCC.kr(src, startFrame:start, numFrames:num, numChans:1, features:~mfccbuf[voice], padding: 2, trig:1, blocking: 1);
+	loud = FluidBufLoudness.kr(src, startFrame:start, numFrames:num, numChans:1, features:~loudbuf[voice], padding: 2, trig:Done.kr(mfcc), blocking: 1);
+	weights = FluidBufScale.kr(~loudbuf[voice], numChans: 1, destination: ~weightbuf[voice], inputLow: -70, inputHigh: 0, trig: Done.kr(loud), blocking: 1);
+	stats = FluidBufStats.kr(~mfccbuf[voice], stats:~statsbuf[voice], numDerivs: 1, weights: ~weightbuf[voice], trig:Done.kr(weights), blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice], destination:~flatbuf[voice], trig:Done.kr(stats), blocking: 1);
+	FluidDataSetWr.kr(~dsW, label, nil, ~flatbuf[voice], Done.kr(flatten), blocking: 1);
+});
+
+// and here we make a little processor for loudness if we want to poke at it
+~extractorL = FluidProcessSlices({|src,start,num,data|
+	var label, voice, loud, stats, flatten;
+	label = data.key;
+    voice = data.value[\voice];
+	loud = FluidBufLoudness.kr(src, startFrame:start, numFrames:num, numChans:1, features:~mfccbuf[voice], trig:1, padding: 2, blocking: 1);
+	stats = FluidBufStats.kr(~mfccbuf[voice], stats:~statsbuf[voice], numDerivs: 1, trig:Done.kr(loud), blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice], destination:~flatbuf[voice], trig:Done.kr(stats), blocking: 1);
+	FluidDataSetWr.kr(~dsL, label, nil, ~flatbuf[voice], Done.kr(flatten), blocking: 1);
+});
+)
+
+//////////////////////////////////////////////////////////////////////////
+//loading process
+
+//load and play to test if it is that quick - it is!
+(
+t = Main.elapsedTime;
+~loader.play(s,action:{(Main.elapsedTime - t).postln;"Loaded".postln;{var start, stop; PlayBuf.ar(~loader.index[~loader.index.keys.asArray.last.asSymbol][\numchans],~loader.buffer,startPos: ~loader.index[~loader.index.keys.asArray.last.asSymbol][\bounds][0])}.play;});
+)
+
+//////////////////////////////////////////////////////////////////////////
+// slicing process
+
+// run the slicer
+(
+t = Main.elapsedTime;
+~slicer.play(s,~loader.buffer,~loader.index,action:{(Main.elapsedTime - t).postln;"Slicing done".postln});
+)
+
+//slice count
+~slicer.index.keys.size
+
+//////////////////////////////////////////////////////////////////////////
+// description process
+
+// run both descriptor extractor - here they are separate to the batch process duration
+(
+t = Main.elapsedTime;
+~extractor.play(s,~loader.buffer,~slicer.index,action:{(Main.elapsedTime - t).postln;"Features done".postln});
+)
+
+(
+t = Main.elapsedTime;
+~extractorW.play(s,~loader.buffer,~slicer.index,action:{(Main.elapsedTime - t).postln;"Features done".postln});
+)
+
+//////////////////////////////////////////////////////////////////////////
+// manipulating and querying the data
+
+// extracting whatever stats we want. In this case, mean/std/lowest/highest, and the same on the first derivative - excluding MFCC0 as it is mostly volume, keeping MFCC1-12
+
+(
+~curated = FluidDataSet(s);
+~curatedW = FluidDataSet(s);
+~curator = FluidDataSetQuery.new(s);
+)
+
+(
+~curator.addRange(1,12,{
+	~curator.addRange(14,12,{
+		~curator.addRange(53,12,{
+			~curator.addRange(79,12,{
+				~curator.addRange(92,12,{
+					~curator.addRange(105,12,{
+						~curator.addRange(144,12,{
+							~curator.addRange(170,12);
+						});
+					});
+				});
+			});
+		});
+	});
+});
+)
+~curator.transform(~ds,~curated)
+~curator.transform(~dsW,~curatedW)
+
+//check the dimension count
+~ds.print
+~dsW.print
+~curated.print
+~curatedW.print
+
+//building a tree for each dataset
+~tree = FluidKDTree(s,5);
+~tree.fit(~ds,{"Fitted".postln;});
+~treeW = FluidKDTree(s,5);
+~treeW.fit(~dsW,{"Fitted".postln;});
+~treeC = FluidKDTree(s,5);
+~treeC.fit(~curated,{"Fitted".postln;});
+~treeCW = FluidKDTree(s,5);
+~treeCW.fit(~curatedW,{"Fitted".postln;});
+
+//select a sound to match
+// EITHER retrieve a random slice
+~targetsound = Buffer(s);
+~targetname = ~slicer.index.keys.asArray.scramble.last.asSymbol;
+#a,b = ~slicer.index[~targetname][\bounds];
+FluidBufCompose.process(s,~loader.buffer,a,(b-a),numChans: 1, destination: ~targetsound,action: {~targetsound.play;})
+
+// OR just load a file in that buffer
+~targetsound = Buffer.read(s,Platform.resourceDir +/+ "sounds/a11wlk01.wav");
+
+//describe the sound to match
+(
+{
+	var loud, weights, mfcc, stats, flatten, stats2, written;
+	mfcc = FluidBufMFCC.kr(~targetsound,features:~mfccbuf[0],padding: 2, trig:1);
+	stats = FluidBufStats.kr(~mfccbuf[0],stats:~statsbuf[0], numDerivs: 1,trig:Done.kr(mfcc));
+	flatten = FluidBufFlatten.kr(~statsbuf[0],destination:~flatbuf[0],trig:Done.kr(stats));
+	loud = FluidBufLoudness.kr(~targetsound,features:~loudbuf[0],padding: 2,trig:Done.kr(flatten),blocking: 1);
+	weights = FluidBufScale.kr(~loudbuf[0],numChans: 1,destination: ~weightbuf[0],inputLow: -70,inputHigh: 0,trig: Done.kr(loud),blocking: 1);
+	stats2 = FluidBufStats.kr(~mfccbuf[0],stats:~statsbuf[0], numDerivs: 1, weights: ~weightbuf[0], trig:Done.kr(weights),blocking: 1);
+	written = FluidBufFlatten.kr(~statsbuf[0],destination:~flatbuf[1],trig:Done.kr(stats2));
+	FreeSelf.kr(Done.kr(written));
+}.play;
+)
+
+//go language side to extract the right dimensions
+~flatbuf[0].getn(0,182,{|x|~curatedBuf = Buffer.loadCollection(s, x[[0,1,4,6,7,8,11,13].collect{|x|var y=x*13+1;(y..(y+11))}.flat].postln)})
+~flatbuf[1].getn(0,182,{|x|~curatedWBuf = Buffer.loadCollection(s, x[[0,1,4,6,7,8,11,13].collect{|x|var y=x*13+1;(y..(y+11))}.flat].postln)})
+
+//find its nearest neighbours
+~tree.kNearest(~flatbuf[0],{|x| ~friends = x.postln;})
+~treeW.kNearest(~flatbuf[1],{|x| ~friendsW = x.postln;})
+~treeC.kNearest(~curatedBuf,{|x| ~friendsC = x.postln;})
+~treeCW.kNearest(~curatedWBuf,{|x| ~friendsCW = x.postln;})
+
+
+// play them in a row
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~friends[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~friends[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~friendsW[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~friendsW[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~friendsC[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~friendsC[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~friendsCW[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~friendsCW[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+//explore dynamic range (changing the weigting's value of 0 in lines 44 and 168 will change the various weights given to quieter parts of the signal
+(
+t = Main.elapsedTime;
+~extractorL.play(s,~loader.buffer,~slicer.index,action:{(Main.elapsedTime - t).postln;"Features done".postln});
+)
+~norm = FluidNormalize.new(s)
+~norm.fit(~dsL)
+~norm.dump({|x|x["data_min"][[8,12]].postln;x["data_max"][[8,12]].postln;})//here we extract the stats from the dataset by retrieving the stored maxima of the fitting process in FluidNormalize
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/10b-weighted-pitch-comparison.scd b/release-packaging/Examples/dataset/1-learning examples/10b-weighted-pitch-comparison.scd
new file mode 100644
index 0000000..a063065
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/10b-weighted-pitch-comparison.scd	
@@ -0,0 +1,73 @@
+//load a part of a sound that has 3 clear components: a clear pitch component to start, a noisy pitchless ending and DC offset silence on both ends
+(
+b = Buffer.read(s,File.realpath(FluidBufPitch.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav",42250,44100);
+~pitches = Buffer(s);
+~stats = Buffer(s);
+~loud = Buffer(s);
+~scaled = Buffer(s);
+~brutePitchStats = Array;
+~loudnessWeighedPitchStats = Array;
+~confidenceWeighedPitchStats = Array;
+~condidenceWeightedPitchIQRStats = Array;
+~pitchIQRStats = Array;
+)
+
+b.play
+b.plot
+
+FluidBufPitch.process(s,b,features: ~pitches)
+FluidBufStats.process(s,~pitches,stats:~stats)
+~stats.getn(0,14,{|x|~brutePitchStats = x; x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+
+//observe the data - there are something clearly "wrong" in there - mostly, should we consider the stats on pitch when the confidence is low?
+~pitches.plot(separately: true)
+
+//let's check the loudness
+FluidBufLoudness.process(s,b,features: ~loud)
+FluidBufStats.process(s,~loud,stats:~stats)
+~stats.getn(0,14,{|x|x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+
+~loud.plot(separately: true)
+
+//it seems the loudness of the noisy section will not help us reject the silence. But let's try
+FluidBufScale.process(s,~loud,numChans: 1,destination: ~scaled,inputLow: -60,inputHigh: -20)
+FluidBufStats.process(s,~pitches, stats:~stats,weights: ~scaled)
+~stats.getn(0,14,{|x|~loudnessWeighedPitchStats = x; x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+//not much difference but let's listen
+
+//average pitch
+c = {SinOsc.ar(~brutePitchStats[0],mul: 0.05)}.play
+//compare with the source
+b.play
+c.free
+//loudness-weighted average
+c = {SinOsc.ar(~loudnessWeighedPitchStats[0],mul: 0.05)}.play
+//compare with the source
+b.play
+c.free
+//hmmm, worse! That is because we did remove the low amplitude skewing to wards the default value (high) which was balancing our noisy peak with low pitch and low pitch confidence...
+
+//let's instead weight against the pitch confidence, first applying a threshold to so we pull down any middle value we want to ignore
+FluidBufThresh.process(s, ~pitches, startChan: 1, numChans: 1, destination: ~scaled, threshold: 0.8)
+FluidBufStats.process(s,~pitches, stats:~stats,weights: ~scaled)
+~stats.getn(0,14,{|x|~confidenceWeighedPitchStats = x;x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+
+//let's listen
+c = {SinOsc.ar(~confidenceWeighedPitchStats[0],mul: 0.05)}.play
+//compare with the source
+b.play
+c.free
+// much better! it is even better when we move the threshold above but 0.8 confidence is quite high...  If we look at our stats we see that there are still minima in the low hundreds, and maxima in the very top...These must be statistically far enough and few enough just to mess a bit our stats, so let's use the inter-quantile range to first remove them then compute the stats.
+FluidBufStats.process(s,~pitches, stats:~stats,weights: ~scaled,outliersCutoff: 1.5)
+~stats.getn(0,14,{|x|~confidenceWeightedPitchIQRStats = x;x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+//now that is impressive!
+c = {SinOsc.ar(~confidenceWeightedPitchIQRStats[0],mul: 0.05)}.play
+b.play
+c.free
+
+//for completion, here is just with rejection of outliers - not as good, but a decent second best!
+FluidBufStats.process(s,~pitches, stats:~stats,outliersCutoff: 1.5)
+~stats.getn(0,14,{|x|~pitchIQRStats = x;x.reshape(7,2).do{|y| "%\t\t\t%\n".postf(y[0].round(0.1),y[1].round(0.01))}})
+c = {SinOsc.ar(~pitchIQRStats[0],mul: 0.05)}.play
+b.play
+c.free
diff --git a/release-packaging/Examples/dataset/1-learning examples/11-compositing-datasets.scd b/release-packaging/Examples/dataset/1-learning examples/11-compositing-datasets.scd
new file mode 100644
index 0000000..08789b4
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/11-compositing-datasets.scd	
@@ -0,0 +1,353 @@
+// here we will define a process that creates and populates a series of parallel dataset, one of each 'feature-space' that we can then eventually manipulate more easily than individual dimensions.
+
+// define a few datasets
+(
+~pitchDS = FluidDataSet(s);
+~loudDS = FluidDataSet(s);
+~mfccDS = FluidDataSet(s);
+~durDS = FluidDataSet(s);
+
+//define as many buffers as we have parallel voices/threads in the extractor processing (default is 4)
+~pitchbuf = 4.collect{Buffer.new};
+~statsPitchbuf = 4.collect{Buffer.new};
+~weightPitchbuf = 4.collect{Buffer.new};
+~flatPitchbuf = 4.collect{Buffer.new};
+~loudbuf = 4.collect{Buffer.new};
+~statsLoudbuf = 4.collect{Buffer.new};
+~flatLoudbuf = 4.collect{Buffer.new};
+~weightMFCCbuf = 4.collect{Buffer.new};
+~mfccbuf = 4.collect{Buffer.new};
+~statsMFCCbuf = 4.collect{Buffer.new};
+~flatMFCCbuf = 4.collect{Buffer.new};
+
+// here we instantiate a loader as per example 0
+~loader = FluidLoadFolder(File.realpath(FluidBufPitch.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/");
+
+// here we instantiate a further slicing step as per example 0
+~slicer = FluidSliceCorpus({ |src,start,num,dest|
+	FluidBufOnsetSlice.kr(src ,start, num, indices:dest, metric: 9, threshold:0.2, minSliceLength: 17, blocking: 1)
+});
+
+// here we make the full processor building our 3 source datasets
+~extractor = FluidProcessSlices({|src,start,num,data|
+	var label, voice, pitch, pitchweights, pitchstats, pitchflat, loud, statsLoud, flattenLoud, mfcc, mfccweights, mfccstats, mfccflat, writePitch, writeLoud;
+	label = data.key;
+    voice = data.value[\voice];
+	// the pitch computation is independant so it starts right away
+	pitch = FluidBufPitch.kr(src, startFrame:start, numFrames:num, numChans:1, features:~pitchbuf[voice], unit: 1, trig:1, blocking: 1);
+	pitchweights = FluidBufThresh.kr(~pitchbuf[voice], numChans: 1, startChan: 1, destination: ~weightPitchbuf[voice], threshold: 0.7, trig:Done.kr(pitch), blocking: 1);//pull down low conf
+	pitchstats = FluidBufStats.kr(~pitchbuf[voice], stats:~statsPitchbuf[voice], numDerivs: 1, weights: ~weightPitchbuf[voice], outliersCutoff: 1.5, trig:Done.kr(pitchweights), blocking: 1);
+	pitchflat = FluidBufFlatten.kr(~statsPitchbuf[voice],destination:~flatPitchbuf[voice],trig:Done.kr(pitchstats),blocking: 1);
+	writePitch = FluidDataSetWr.kr(~pitchDS,label, nil, ~flatPitchbuf[voice], Done.kr(pitchflat),blocking: 1);
+	// the mfcc need loudness to weigh, so let's start with that
+	loud = FluidBufLoudness.kr(src,startFrame:start, numFrames:num, numChans:1, features:~loudbuf[voice], trig:Done.kr(writePitch), blocking: 1);//here trig was 1
+	//we can now flatten and write Loudness in its own trigger tree
+	statsLoud = FluidBufStats.kr(~loudbuf[voice], stats:~statsLoudbuf[voice], numDerivs: 1, trig:Done.kr(loud), blocking: 1);
+	flattenLoud = FluidBufFlatten.kr(~statsLoudbuf[voice],destination:~flatLoudbuf[voice],trig:Done.kr(statsLoud),blocking: 1);
+	writeLoud = FluidDataSetWr.kr(~loudDS,label, nil, ~flatLoudbuf[voice], Done.kr(flattenLoud),blocking: 1);
+	//we can resume from the loud computation trigger
+	mfcc = FluidBufMFCC.kr(src,startFrame:start,numFrames:num,numChans:1,features:~mfccbuf[voice],trig:Done.kr(writeLoud),blocking: 1);//here trig was loud
+	mfccweights = FluidBufScale.kr(~loudbuf[voice],numChans: 1,destination: ~weightMFCCbuf[voice],inputLow: -70,inputHigh: 0, trig: Done.kr(mfcc), blocking: 1);
+	mfccstats = FluidBufStats.kr(~mfccbuf[voice], stats:~statsMFCCbuf[voice], startChan: 1, numDerivs: 1, weights: ~weightMFCCbuf[voice], trig:Done.kr(mfccweights), blocking: 1);//remove mfcc0 and weigh by loudness instead
+	mfccflat = FluidBufFlatten.kr(~statsMFCCbuf[voice],destination:~flatMFCCbuf[voice],trig:Done.kr(mfccstats),blocking: 1);
+	FluidDataSetWr.kr(~mfccDS,label, nil, ~flatMFCCbuf[voice], Done.kr(mfccflat),blocking: 1);
+});
+
+)
+//////////////////////////////////////////////////////////////////////////
+//loading process
+
+//load and play to test if it is that quick - it is!
+(
+t = Main.elapsedTime;
+~loader.play(s,action:{(Main.elapsedTime - t).postln;"Loaded".postln;{var start, stop; PlayBuf.ar(~loader.index[~loader.index.keys.asArray.last.asSymbol][\numchans],~loader.buffer,startPos: ~loader.index[~loader.index.keys.asArray.last.asSymbol][\bounds][0])}.play;});
+)
+
+//////////////////////////////////////////////////////////////////////////
+// slicing process
+
+// run the slicer
+(
+t = Main.elapsedTime;
+~slicer.play(s,~loader.buffer,~loader.index,action:{(Main.elapsedTime - t).postln;"Slicing done".postln});
+)
+//slice count
+~slicer.index.keys.size
+
+//////////////////////////////////////////////////////////////////////////
+// description process
+
+// run the descriptor extractor (errors will be given, this is normal: the pitch conditions are quite exacting and therefore many slices are not valid)
+(
+t = Main.elapsedTime;
+~extractor.play(s,~loader.buffer,~slicer.index,action:{(Main.elapsedTime - t).postln;"Features done".postln});
+)
+
+// make a dataset of durations for querying that too (it could have been made in the process loop, but hey, we have dictionaries we can manipulate too!)
+(
+~dict = Dictionary.new;
+~temp = ~slicer.index.collect{ |k| [k[\bounds][1] - k[\bounds][0]]};
+~dict.add(\data -> ~temp);
+~dict.add(\cols -> 1);
+~durDS.load(~dict)
+)
+
+//////////////////////////////////////////////////////////////////////////
+// manipulating and querying the data
+
+~pitchDS.print;
+~loudDS.print;
+~mfccDS.print;
+~durDS.print;
+
+///////////////////////////////////////////////////////
+//reduce the MFCC timbral space stats (many potential ways to explore here... - 2 are provided to compare, with and without the derivatives before running a dimension reduction)
+~tempDS = FluidDataSet(s);
+
+~query = FluidDataSetQuery(s);
+~query.addRange(0,24);//add only means and stddev of the 12 coeffs...
+~query.addRange((7*12),24);// and the same stats of the first derivative (moving 7 stats x 12 mfccs to the right)
+~query.transform(~mfccDS, ~tempDS);
+
+//check that you end up with the expected 48 dimensions
+~tempDS.print;
+
+// standardizing before the PCA, as argued here:
+// https://scikit-learn.org/stable/auto_examples/preprocessing/plot_scaling_importance.html
+~stan = FluidStandardize(s);
+~stanDS = FluidDataSet(s);
+~stan.fitTransform(~tempDS,~stanDS)
+
+//shrinking A: using 2 stats on the values, and 2 stats on the redivative (12 x 2 x 2 = 48 dim)
+~pca = FluidPCA(s,4);//shrink to 4 dimensions
+~timbreDSd = FluidDataSet(s);
+~pca.fitTransform(~stanDS,~timbreDSd,{|x|x.postln;})//accuracy
+
+//shrinking B: using only the 2 stats on the values
+~query.clear;
+~query.addRange(0,24);//add only means and stddev of the 12 coeffs...
+~query.transform(~stanDS, ~tempDS);//retrieve the values from the already standardized dataset
+
+//check you have the expected 24 dimensions
+~tempDS.print;
+
+//keep its own PCA so we can keep the various states for later transforms
+~pca2 = FluidPCA(s,4);//shrink to 4 dimensions
+~timbreDS = FluidDataSet(s);
+~pca2.fitTransform(~tempDS,~timbreDS,{|x|x.postln;})//accuracy
+
+// comparing NN for fun
+~targetDSd = Buffer(s)
+~targetDS = Buffer(s)
+~tree = FluidKDTree(s,5)
+
+// you can run this a few times to have fun
+(
+~target = ~slicer.index.keys.asArray.scramble.[0].asSymbol;
+~timbreDSd.getPoint(~target, ~targetDSd);
+~timbreDS.getPoint(~target, ~targetDS);
+)
+
+~tree.fit(~timbreDSd,{~tree.kNearest(~targetDSd,{|x|~nearestDSd = x.postln;})})
+~tree.fit(~timbreDS,{~tree.kNearest(~targetDS,{|x|~nearestDS = x.postln;})})
+
+// play them in a row
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~nearestDSd[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~nearestDSd[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~nearestDS[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~nearestDS[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+///////////////////////////////////////////////////////
+// compositing queries - defining a target and analysing it
+
+~globalDS = FluidDataSet(s);
+
+// define a source
+~targetsound = Buffer.read(s,File.realpath(FluidBufPitch.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav",42250,44100);
+~targetsound.play
+
+// analyse it as above, using voice 0 in the arrays of buffer to store the info
+(
+{
+	var label, voice, pitch, pitchweights, pitchstats, pitchflat, loud, statsLoud, flattenLoud, mfcc, mfccweights, mfccstats, mfccflat, writePitch, writeLoud;
+	pitch = FluidBufPitch.kr(~targetsound, numChans:1, features:~pitchbuf[0], unit: 1, trig:1, blocking: 1);
+	pitchweights = FluidBufThresh.kr(~pitchbuf[0], numChans: 1, startChan: 1, destination: ~weightPitchbuf[0], threshold: 0.7, trig:Done.kr(pitch), blocking: 1);
+	pitchstats = FluidBufStats.kr(~pitchbuf[0], stats:~statsPitchbuf[0], numDerivs: 1, weights: ~weightPitchbuf[0], outliersCutoff: 1.5, trig:Done.kr(pitchweights), blocking: 1);
+	pitchflat = FluidBufFlatten.kr(~statsPitchbuf[0],destination:~flatPitchbuf[0],trig:Done.kr(pitchstats),blocking: 1);
+	loud = FluidBufLoudness.kr(~targetsound, numChans:1, features:~loudbuf[0], trig:Done.kr(pitchflat), blocking: 1);
+	statsLoud = FluidBufStats.kr(~loudbuf[0], stats:~statsLoudbuf[0], numDerivs: 1, trig:Done.kr(loud), blocking: 1);
+	flattenLoud = FluidBufFlatten.kr(~statsLoudbuf[0],destination:~flatLoudbuf[0],trig:Done.kr(statsLoud),blocking: 1);
+	mfcc = FluidBufMFCC.kr(~targetsound,numChans:1,features:~mfccbuf[0],trig:Done.kr(flattenLoud),blocking: 1);
+	mfccweights = FluidBufScale.kr(~loudbuf[0],numChans: 1,destination: ~weightMFCCbuf[0],inputLow: -70,inputHigh: 0, trig: Done.kr(mfcc), blocking: 1);
+	mfccstats = FluidBufStats.kr(~mfccbuf[0], stats:~statsMFCCbuf[0], startChan: 1, numDerivs: 1, weights: ~weightMFCCbuf[0], trig:Done.kr(mfccweights), blocking: 1);
+	mfccflat = FluidBufFlatten.kr(~statsMFCCbuf[0],destination:~flatMFCCbuf[0],trig:Done.kr(mfccstats),blocking: 1);
+	FreeSelf.kr(Done.kr(mfccflat));
+}.play;
+)
+
+// a first query - length and pitch
+~query.clear
+~query.filter(0,"<",44100+22050)//column0 a little smaller than our source
+~query.and(0,">", 44100-22050)//also as far as a little larger than the source
+~query.transformJoin(~durDS, ~pitchDS, ~tempDS); //this passes to ~tempDS only the points that have the same label than those in ~durDS that satisfy the condition. No column were added so nothing from ~durDS is copied
+
+// print to see how many slices (rows) we have
+~tempDS.print
+
+// further conditions to assemble the query
+~query.clear
+~query.filter(11,">",0.7)//column11 (median of pitch confidence) larger than 0.7
+~query.addRange(0,4) //copy only mean and stddev of pitch and confidence
+~query.transform(~tempDS, ~globalDS); // pass it to the final search
+
+// print to see that we have less items, with only their pitch
+~globalDS.print
+
+// compare knearest on both globalDS and tempDS
+// assemble search buffer
+~targetPitch = Buffer(s)
+FluidBufCompose.process(s, ~flatPitchbuf[0],numFrames: 4,destination: ~targetPitch)
+
+// feed the trees
+~tree.fit(~pitchDS,{~tree.kNearest(~flatPitchbuf[0],{|x|~nearestA = x.postln;})}) //all the points with all the stats
+~tree.fit(~globalDS,{~tree.kNearest(~targetPitch,{|x|~nearestB = x.postln;})}) //just the points with the right lenght conditions, with the curated stats
+
+// play them in a row
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~nearestA[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~nearestA[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+// with our duration limits, strange results appear eventually
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~nearestB[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~nearestB[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+///////////////////////////////////////////////////////
+// compositing queries to weigh - defining a target and analysing it
+
+// make sure to define and describe the source above (lines 178 to 201)
+
+// let's make normalised versions of the 3 datasets, keeping the normalisers separate to query later
+~loudDSn = FluidDataSet(s);
+~pitchDSn = FluidDataSet(s);
+~timbreDSn = FluidDataSet(s);
+
+~normL = FluidNormalize(s)
+~normP = FluidNormalize(s)
+~normT = FluidNormalize(s)
+
+~normL.fitTransform(~loudDS, ~loudDSn);
+~normP.fitTransform(~pitchDS, ~pitchDSn);
+~normT.fitTransform(~timbreDSd, ~timbreDSn);
+
+// let's assemble these datasets
+~query.clear
+~query.addRange(0,4)
+~query.transformJoin(~pitchDSn,~timbreDSn, ~tempDS) //appends 4 dims of pitch to 4 dims of timbre
+~query.transformJoin(~loudDSn, ~tempDS, ~globalDS) // appends 4 dims of loud to the 8 dims above
+
+~globalDS.print//12 dim: 4 timbre, 4 pitch, 4 loud, all normalised between 0 and 1
+~globalDS.write("/tmp/test12dims.json") // write to file to look at the values
+
+// let's assemble the query
+// first let's normalise our target descriptors
+(
+~targetPitch = Buffer(s);
+~targetLoud = Buffer(s);
+~targetMFCC = Buffer(s);
+~targetMFCCs = Buffer(s);
+~targetMFCCsp = Buffer(s);
+~targetTimbre = Buffer(s);
+~targetAll= Buffer(s);
+)
+
+~normL.transformPoint(~flatLoudbuf[0], ~targetLoud) //normalise the loudness (all dims)
+~normP.transformPoint(~flatPitchbuf[0], ~targetPitch) //normalise the pitch (all dims)
+FluidBufCompose.process(s,~flatMFCCbuf[0],numFrames: 24,destination: ~targetMFCC) // copy the process of dimension reduction above
+FluidBufCompose.process(s,~flatMFCCbuf[0],startFrame: (7*12), numFrames: 24, destination: ~targetMFCC,destStartFrame: 24) //keeping 48 dims
+~stan.transformPoint(~targetMFCC,~targetMFCCs) //standardize with the same coeffs
+~pca.transformPoint(~targetMFCCs, ~targetMFCCsp) //then down to 4
+~normT.transformPoint(~targetMFCCsp, ~targetTimbre) //then normalised
+FluidBufCompose.process(s, ~targetTimbre,destination: ~targetAll) // assembling the single query
+FluidBufCompose.process(s, ~targetPitch, numFrames: 4, destination: ~targetAll, destStartFrame: 4) // copying the 4 stats of pitch we care about
+FluidBufCompose.process(s, ~targetLoud, numFrames: 4, destination: ~targetAll, destStartFrame: 8) // same for loudness
+//check the sanity
+~targetAll.query
+
+// now let's see which is nearest that point
+~tree.fit(~globalDS,{~tree.kNearest(~targetAll,{|x|~nearest = x.postln;})}) //just the points with the right lenght conditions, with the curated stats
+
+// play them in a row
+(
+Routine{
+5.do{|i|
+	var dur;
+	v = ~slicer.index[~nearest[i].asSymbol];
+	dur = (v[\bounds][1] - v[\bounds][0]) / s.sampleRate;
+	{BufRd.ar(v[\numchans],~loader.buffer,Line.ar(v[\bounds][0],v[\bounds][1],dur, doneAction: 2))}.play;
+	~nearest[i].postln;
+	dur.wait;
+	};
+}.play;
+)
+
+// to change the relative weight of each dataset, let's change the normalisation range. Larger ranges will mean larger distance, and therefore less importance for that parameter.
+// for instance to downplay pitch, let's make it larger by a factor of 10 around the center of 0.5
+~normP.max = 5.5
+~normP.min = -4.5
+~normP.fitTransform(~pitchDS, ~pitchDSn);
+// here we can re-run just the part that composites the pitch
+~normP.transformPoint(~flatPitchbuf[0], ~targetPitch) //normalise the pitch (all dims)
+FluidBufCompose.process(s, ~targetPitch, numFrames: 4, destination: ~targetAll, destStartFrame: 4) // copying the 4 stats of pitch we care about
+
+//see that the middle 4 values are much larger in range
+~targetAll.getn(0,12,{|x|x.postln;})
+
+// let's re-assemble these datasets
+~query.transformJoin(~pitchDSn,~timbreDSn, ~tempDS) //appends 4 dims of pitch to 4 dims of timbre
+~query.transformJoin(~loudDSn, ~tempDS, ~globalDS) // appends 4 dims of loud to the 8 dims above
+
+// now let's see which is nearest that point
+~tree.fit(~globalDS,{~tree.kNearest(~targetAll,{|x|~nearest = x.postln;})}) //just the points with the right lenght conditions, with the curated stats
+
+///////////////////////////////////////////////
+// todo: segment then query musaik
diff --git a/release-packaging/Examples/dataset/1-learning examples/12-windowed-clustered-segmentation.scd b/release-packaging/Examples/dataset/1-learning examples/12-windowed-clustered-segmentation.scd
new file mode 100644
index 0000000..00182af
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/12-windowed-clustered-segmentation.scd	
@@ -0,0 +1,230 @@
+// load a source folder
+~loader = FluidLoadFolder(File.realpath(FluidBufPitch.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/");
+~loader.play;
+
+//slightly oversegment with novelty
+//segments should still make sense but might cut a few elements in 2 or 3
+~slicer = FluidSliceCorpus({ |src,start,num,dest| FluidBufNoveltySlice.kr(src,start,num,indices:dest, feature: 1, kernelSize: 29, threshold: 0.1, filterSize: 5, hopSize: 128, blocking: 1)});
+~slicer.play(s, ~loader.buffer,~loader.index);
+
+//test the segmentation by looping them
+(
+~originalindices = Array.newFrom(~slicer.index.keys).sort{|a,b| ~slicer.index[a][\bounds][0]< ~slicer.index[b][\bounds][0]}.collect{|x|~slicer.index[x][\bounds]};
+d = {arg start=0, end = 44100;
+	BufRd.ar(1, ~loader.buffer, Phasor.ar(0,1,start,end,start),0,1);
+}.play;
+
+w = Window.new(bounds:Rect(100,100,400,60)).front;
+b = ControlSpec(0, ~originalindices.size - 1, \linear, 1); // min, max, mapping, step
+c = StaticText(w, Rect(340, 20, 50, 20)).align_(\center);
+a = Slider(w, Rect(10, 20, 330, 20))
+.action_({var val = b.map(a.value).asInteger;
+	c.string_(val.asString);
+	d.set(\start,~originalindices[val][0], \end, ~originalindices[val][1]);
+});
+)
+
+//analyse each segment with 20 MFCCs in a dataset and spectralshapes in another one
+(
+~featuresbuf = 4.collect{Buffer.new};
+~statsbuf = 4.collect{Buffer.new};
+~flatbuf = 4.collect{Buffer.new};
+~slicesMFCC = FluidDataSet(s);
+~slicesShapes = FluidDataSet(s);
+~extractor = FluidProcessSlices({|src,start,num,data|
+	var features, stats, writer, flatten,mfccBuf, statsBuf, flatBuf, label, voice;
+	label = data.key;
+	voice = data.value[\voice];
+	features = FluidBufMFCC.kr(src,startFrame:start,numFrames:num,numChans:1, numCoeffs: 20, features:~featuresbuf[voice],trig:1,blocking: 1);
+	stats = FluidBufStats.kr(~featuresbuf[voice],stats:~statsbuf[voice],trig:Done.kr(features),blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice],destination:~flatbuf[voice],trig:Done.kr(stats),blocking: 1);
+	writer = FluidDataSetWr.kr(~slicesMFCC,label, nil, ~flatbuf[voice], Done.kr(flatten),blocking: 1);
+	features = FluidBufSpectralShape.kr(src,startFrame:start,numFrames:num,numChans:1, features:~featuresbuf[voice],trig:Done.kr(writer),blocking: 1);
+	stats = FluidBufStats.kr(~featuresbuf[voice],stats:~statsbuf[voice],trig:Done.kr(features),blocking: 1);
+	flatten = FluidBufFlatten.kr(~statsbuf[voice],destination:~flatbuf[voice],trig:Done.kr(stats),blocking: 1);
+	writer = FluidDataSetWr.kr(~slicesShapes,label, nil, ~flatbuf[voice], Done.kr(flatten),blocking: 1);
+});
+)
+
+(
+t = Main.elapsedTime;
+~extractor.play(s,~loader.buffer, ~slicer.index, action:{(Main.elapsedTime - t).postln;"Analysis done".postln});
+)
+
+~originalindices.size
+~slicesMFCC.print
+~slicesShapes.print
+
+//run a window over consecutive segments, forcing them in 2 classes, and merging the consecutive segments of similar class
+//we overlap the analysis with the last (original) slice to check for continuity
+(
+~winSize = 4;//the number of consecutive items to split in 2 classes;
+~curated = FluidDataSet(s);
+~query = FluidDataSetQuery(s);
+~stan = FluidStandardize(s);
+~kmeans = FluidKMeans(s,2,1000);
+~windowDS = FluidDataSet(s);
+~windowLS = FluidLabelSet(s);
+)
+
+//curate stats (MFCCs)
+~query.clear
+~query.addRange((0*20)+1,10);
+~query.transform(~slicesMFCC,~curated);
+
+//OR
+//curate stats (moments)
+~query.clear
+~query.addRange(0,3);
+~query.transform(~slicesShapes,~curated);
+
+//OR
+//curate both
+~query.clear
+~query.addColumn(0);//add col 0 (mean of mfcc0 as 'loudness')
+~query.transform(~slicesMFCC,~curated);//mfcc0 as loudness
+~query.clear;
+~query.addRange(0,3);//add some spectral moments
+~query.transformJoin(~slicesShapes, ~curated, ~curated);//join in centroids
+
+//optionally standardize in place
+~stan.fitTransform(~curated, ~curated);
+
+~curated.print
+
+//retrieve the dataset as dictionary
+~curated.dump{|x|~sliceDict = x;};
+
+~originalslicesarray = ~originalindices.flop[0] ++ ~loader.buffer.numFrames
+~orginalkeys = Array.newFrom(~slicer.index.keys).sort{|a,b| ~slicer.index[a][\bounds][0]< ~slicer.index[b][\bounds][0]}
+
+//the windowed function, recursive to deal with sync dependencies
+(
+~windowedFunct = {arg head, winSize, overlap;
+	var nbass = [], assignments = [], tempDict = ();
+	//check the size of everything to not overrun
+	winSize = (~originalslicesarray.size - head).min(winSize);
+	//copy the items to a subdataset from hear
+	winSize.do{|i|
+		tempDict.put((i.asString), ~sliceDict["data"][(~orginalkeys[(i+head)]).asString]);//here one could curate which stats to take
+		// "whichslices:%\n".postf(i+head);
+	};
+	~windowDS.load(Dictionary.newFrom([\cols, ~sliceDict["cols"].asInteger, \data, tempDict]), action: {
+		// "% - loaded\n".postf(head);
+
+		//kmeans 2 and retrieve ordered array of class assignations
+		~kmeans.fitPredict(~windowDS, ~windowLS, action: {|x|
+			nbass = x;
+			// "% - fitted1: ".postf(head); nbass.postln;
+
+			if (nbass.includes(winSize.asFloat), {
+				~kmeans.fitPredict(~windowDS, ~windowLS, {|x|
+					nbass = x;
+					// "% - fitted2: ".postf(head); nbass.postln;
+					if (nbass.includes(winSize.asFloat), {
+						~kmeans.fitPredict(~windowDS, ~windowLS, {|x|
+							nbass = x;
+							// "% - fitted3: ".postf(head); nbass.postln;
+						});
+					});
+				});
+			});
+
+			~windowLS.dump{|x|
+				var assignments = x.at("data").asSortedArray.flop[1].flatten;
+				"% - assigned ".postf(head);
+
+				assignments.postln;
+
+				(winSize-1).do{|i|
+					if (assignments[i+1] != assignments[i], {
+						~newindices= ~newindices ++ (~originalslicesarray[head+i+1]).asInteger;
+						~newkeys = ~newkeys ++ (~orginalkeys[head+i+1]);
+					});
+
+				};
+				//if we still have some frames to do, do them
+				if (((winSize + head) < ~originalslicesarray.size), {
+					"-----------------".postln;
+					~windowedFunct.value(head + winSize - overlap, winSize, overlap);
+				}, {~newindices = (~newindices ++ ~loader.buffer.numFrames); "done".postln;});//if we're done close the books
+			};
+		});
+	});
+}
+)
+
+//the job
+
+//test 1 - start at the begining, consider 4 items at a time, make 2 clusters, overlap 1
+~newindices = [~originalslicesarray[0]]; ~newkeys = [~orginalkeys[0]];
+~windowedFunct.value(0, 4, 1);
+
+//OPTIONAL: try again with more clusters (3) and a wider window (6) and more overlap (2)
+~newindices = [~originalslicesarray[0]]; ~newkeys = [~orginalkeys[0]];
+~kmeans.numClusters = 3;
+~windowedFunct.value(0,6,2);
+
+//compare sizes
+~orginalkeys.size
+~newkeys.size;
+
+//export to reaper
+(
+//first create a new file that ends with rpp - it will overwrite if the file exists
+f = File.new("/tmp/clusteredslices-" ++ Date.getDate.stamp ++".rpp","w+");
+
+if (f.isOpen , {
+	var path, prevpath ="", sr, count, dur, realDur;
+	//write the header
+	f.write("<REAPER_PROJECT 0.1 \"5.99/OSX64\" 1603037150\n\n");
+
+	//a first track with the originalslicearray
+	//write the track header
+	f.write("<TRACK\nNAME \"novelty output\"\n");
+	// iterate through the items in the track
+	~orginalkeys.do{|v, i|
+		path = ~slicer.index[v][\path];
+		if (path != prevpath, {
+			sr = 	~slicer.index[v][\sr];
+			prevpath = path;
+			count = 0;
+		});
+		dur = ~originalslicesarray[i+1] - ~originalslicesarray[i];
+		if ( dur > 0, {
+			f.write("<ITEM\nPOSITION " ++ (~originalslicesarray[i] / sr) ++ "\nLENGTH " ++ (dur / sr) ++ "\nNAME \"" ++ v ++ "\"\nSOFFS " ++ (count / sr) ++ "\n<SOURCE WAVE\nFILE \"" ++ path ++ "\"\n>\n>\n");
+		});
+		count = count + dur;
+	};
+	//write the track footer
+	f.write(">\n");
+
+	// a second track with the new ~indices
+	prevpath = "";
+	//write the track header
+	f.write("<TRACK\nNAME \"clustered output\"\n");
+	// iterate through the items in the track
+	~newkeys.do{|v, i|
+		dur = ~newindices[i+1] - ~newindices[i];
+		if (dur > 0, {
+			path = ~slicer.index[v][\path];
+			if (path != prevpath, {
+				sr = ~slicer.index[v][\sr];
+				prevpath = path;
+				count = 0;
+			});
+			f.write("<ITEM\nPOSITION " ++ (~newindices[i] / sr) ++ "\nLENGTH " ++ (dur / sr) ++ "\nNAME \"" ++ v ++ "\"\nSOFFS " ++ (count / sr) ++ "\n<SOURCE WAVE\nFILE \"" ++ path ++ "\"\n>\n>\n");
+			count = count + dur;
+		});
+	};
+	//write the track footer
+	f.write(">\n");
+
+	//write the footer
+	f.write(">\n");
+	f.close;
+});
+)
+
+(then open the time-stamped reaper file clusterdslice in the folder tmp)
+"open /tmp".unixCmd
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/13-massive-parallelisation-example.scd b/release-packaging/Examples/dataset/1-learning examples/13-massive-parallelisation-example.scd
new file mode 100644
index 0000000..81b960d
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/13-massive-parallelisation-example.scd	
@@ -0,0 +1,324 @@
+// Lookup in a KDTree using melbands
+// Demonstration of a massive parallel approach to batch process swiftly in SC
+
+s.options.numBuffers = 16384 //The method below for doing the analysus quickly needs lots of buffers
+s.reboot
+
+//Step 0: Make a corpus
+
+//We'll jam together some random flucoma sounds for illustrative purposes
+//Get some files
+(
+~audioexamples_path = File.realpath(FluidBufMelBands.class.filenameSymbol).dirname.withTrailingSlash +/+ "../AudioFiles/*.wav";
+~allTheSounds = SoundFile.collect(~audioexamples_path);
+~testSounds = ~allTheSounds;
+~testSounds.do{|f| f.path.postln}; // print out the files that are loaded
+)
+
+//Load the files into individual buffers:
+(
+~audio_buffers = ~testSounds.collect{|f|
+	Buffer.readChannel(
+		server: s,
+		path:f.path,
+		channels:[0],
+		action:{("Loaded" + f.path).postln;}
+	)
+};
+)
+
+//Do a segmentation of each buffer, in parallel
+(
+fork{
+	~index_buffers = ~audio_buffers.collect{Buffer.new};
+	s.sync;
+	~count = ~audio_buffers.size;
+	~audio_buffers.do{|src,i|
+		FluidBufOnsetSlice.process(
+			server:s,
+			source:src,
+			indices:~index_buffers[i],
+			metric: 9,
+			threshold:0.2,
+			minSliceLength: 17,
+			action:{
+				(~testSounds[i].path ++ ":" +  ~index_buffers[i].numFrames + "slices").postln;
+				~count = ~count - 1;
+				if(~count == 0){"Done slicing".postln};
+			}
+		);
+	}
+}
+)
+
+// we now have an array of index buffers, one per source buffer, each containing the segmentation points as a frame positions
+// this allows us to make an array of sizes
+~index_buffers.collect{|b| b.numFrames}.sum
+
+//For each of these segments, let's make a datapoint using the mean melbands.
+// There's a number of ways of skinning this cat w/r/t telling the server what to do, but here we want to minimize traffic between language and server, and also produce undertsandable code
+
+//First, we'll grab the onset points as language-side arrays, then scroll through each slice getting the mean melbands
+(
+// - a dataset to keep the mean melbands in
+~mels = FluidDataSet(s);
+// - a dictionary to keep the slice points in for later playback
+~slices = Dictionary();
+//The code below (as well as needing lots of buffers), creates lots of threads and we need a big ass scheduling queue
+~clock = TempoClock(queueSize:8192);
+)
+
+
+// Do the Mel analysis in a cunning parallel fashion
+(
+{
+	var counter, remaining;
+	var condition = Condition.new;  // used to create a test condition to pause the routine ...
+	var index_arrays = Dictionary();
+
+	"Process started. Please wait.".postln;
+
+	~total_slice_count = ~index_buffers.collect{|b| b.numFrames}.sum + ~index_buffers.size; //we get an extra slice in buffer
+	~featurebuffers = ~total_slice_count.collect{Buffer.new};  // create a buffer per slice
+
+	//Make our dictionary FluidDataSet-shaped
+	~slices.put("cols",3);//[bufnum,start,end] for each slice
+	~slices.put("data",Dictionary());
+
+	//Collect each set of onsets into a language side array and store them in a dict
+	~index_buffers.do{|b,i| // iterate over the input buffer array
+		{
+			b.loadToFloatArray(  // load to language side array
+				action:{|indices|
+					//Glue the first and last samples of the buffer on to the index list, and place in dictionary with the
+					//Buffer object as a key
+
+					index_arrays.put(~audio_buffers[i], Array.newFrom([0] ++ indices ++ (~audio_buffers[i].numFrames - 1)));
+
+					if(i==(~index_buffers.size-1)) {condition.unhang};
+				}
+			)
+		}.fork(stackSize:~total_slice_count);
+	};
+	condition.hang; //Pause until all the callbacks above have completed
+	"Arrays loaded. Starting on the analysis, please wait.".postln;
+
+	//For each of these lists of points, we want to scroll over the indices in pairs and get some mel bands
+	counter = 0;
+	remaining = ~total_slice_count;
+
+	s.sync;
+
+	// now iterate over Dict and calc melbands
+
+	index_arrays.keysValuesDo{|buffer, indices|
+		indices.doAdjacentPairs{|start,end,num|
+			var analysis = Routine({|counter|
+				FluidBufMelBands.processBlocking(
+					server:s,
+					source:buffer,
+					startFrame:start,
+					numFrames:(end-1) - start,
+					features:~featurebuffers[counter],
+					action:{
+						remaining = remaining - 1;
+						if(remaining == 0) { ~numMelBands = ~featurebuffers[0].numChannels;condition.unhang };
+					}
+				);
+			});
+
+			~slices["data"].put(counter,[buffer.bufnum,start,end]);
+
+			//I'm spawning new threads to wait for the analysis callback from the server. The final callback will un-hang this thread
+			analysis.value(counter); //Done differently to other blocks because I need to pass in the value of counter
+			counter = counter + 1;
+		}
+	};
+	condition.hang;
+	"Analysis of % slices done.\n".postf(~total_slice_count);
+}.fork(clock:~clock);
+)
+
+
+// Run stats on each mel buffer
+
+// create a stats buffer for each of the slices
+~statsbuffers = ~total_slice_count.collect{Buffer.new}; // create n Slices buffers - to be filled with (40 mel bands * 7 stats)
+
+// run stats on all the buffers
+(
+{
+	var remaining = ~total_slice_count;
+	~featurebuffers.do{|buffer,i|
+		FluidBufStats.processBlocking(
+			server:s,
+			source:buffer,
+			stats:~statsbuffers[i],
+			action:{
+				remaining = remaining - 1;
+				if(remaining == 0) { "done".postln};
+			}
+		);
+	};
+}.fork(clock:~clock);
+)
+
+~featurebuffers.size
+
+//Flatten each stats buffer into a data point
+~flatbuffers = ~total_slice_count.collect{Buffer.new};// create an array of flatten stats
+
+(
+{
+	var remaining = ~total_slice_count;
+	~statsbuffers.do{|buffer,i|
+		FluidBufFlatten.processBlocking(
+			server:s,
+			source:buffer,
+			destination:~flatbuffers[i],
+			action:{
+				remaining = remaining - 1;
+				if(remaining == 0) { "Got flat points".postln; };
+			}
+		);
+	};
+}.fork(clock:~clock);
+)
+
+
+//Ram each flat point into a data set. At this point we have more data than we need, but we'll prune in moment
+(
+"Filling dataset".postln;
+~mels.clear;
+
+// ~flatbuffers = flatbuffers;
+~flatbuffers.do{|buf,i|
+	~mels.addPoint(i,buf);
+};
+
+~mels.print;
+)
+
+
+// Prune & standardise
+
+// Tidy up the temp arrays of buffers we do not need anymore
+
+(
+"Cleaning".postln;
+(~featurebuffers ++ ~statsbuffers ++ ~flatbuffers).do{|buf| buf.free};
+)
+
+//Above we sneakily made a dictionary of slice data for playback (bufnum,start,end). Let's throw it in a dataset
+~slicedata = FluidDataSet(s);  // will hold slice data (bufnum,start,end) for playback
+
+//dict -> dataset
+(
+~slicedata.load(~slices);
+~slicedata.print;
+)
+
+// Step 1. Let's prune and standardize before fitting to a tree
+(
+~meanmels = FluidDataSet(s);//will hold pruned mel data
+~stdmels = FluidDataSet(s);//will standardised, pruned mel data
+~standardizer = FluidStandardize(s);
+~pruner = FluidDataSetQuery(s);
+~tree = FluidKDTree(s,numNeighbours:10,lookupDataSet:~slicedata);//we have to supply the lookup data set when we make the tree (boo!)
+)
+
+//Prune, standardize and fit KDTree
+(
+{
+	~meanmels.clear;
+	~stdmels.clear;
+	~pruner.addRange(0,~numMelBands).transform(~mels,~meanmels); //prune with a 'query' -- so this is dropping all but ~meanmels
+	~standardizer.fitTransform(~meanmels,~stdmels);
+	~tree.fit(~stdmels,{"KDTree ready".postln});
+}.fork(clock:~clock);
+)
+
+~meanmels.print
+
+//Step 2: Set the FluidStandardizer and FluidKDTree up for listening
+//set the buffers and busses needed
+(
+~stdInputPoint = Buffer.alloc(s,40);
+~stdOutputPoint = Buffer.alloc(s,40);
+~treeOutputPoint = Buffer.alloc(s,3 * 10);//numNeighbours x triples of bufnum,start,end
+)
+
+
+// let's play a random sound (to make sure we understand our data structure!
+(
+{
+	var randPoint, buf, start, stop, dur;
+
+	randPoint = ~slices["data"].keys.asArray.scramble[0];	 //   this good way of getting - but recast as strong
+
+	buf= ~slices["data"][randPoint][0];
+	start = ~slices["data"][randPoint][1];
+	stop = ~slices["data"][randPoint][2];
+
+	dur = stop - start;
+
+	BufRd.ar(1,buf, Line.ar(start,stop,dur/s.sampleRate, doneAction: 2), 0, 2);
+}.play
+)
+
+
+// Query KD tree
+
+// a target sound from outside our dataset
+~inBuf = Buffer.readChannel(s, Platform.resourceDir +/+ "sounds/a11wlk01.wav", numFrames:15000, channels:[0]);
+~inBuf.play
+
+//OR one from within (but just the begining so beware of the difference!)
+~inBuf = Buffer.alloc(s,15000);
+~randomSlice = ~slices["data"].keys.asArray.scramble[0];
+~audio_buffers[~slices["data"][~randomSlice][0]].copyData(~inBuf,srcStartAt: ~slices["data"][~randomSlice][1], numSamples: 15000.min(~slices["data"][~randomSlice][2] - (~slices["data"][~randomSlice][1])));
+~inBuf.play
+
+// now try getting a point, playing it, grabbing nearest neighbour and playing it ...
+
+(
+~inBufMels = Buffer(s);
+~inBufStats = Buffer(s);
+~inBufFlat = Buffer(s);
+~inBufComp = Buffer(s);
+~inBufStand = Buffer(s);
+)
+
+// FluidBuf Compose is buf version of dataSetQuery
+
+(
+FluidBufMelBands.process(s, ~inBuf, features: ~inBufMels, action: {
+	FluidBufStats.process(s, ~inBufMels, stats:~inBufStats, action: {
+		FluidBufFlatten.process(s, ~inBufStats, destination:~inBufFlat, action: {
+			FluidBufCompose.process(s, ~inBufFlat, numFrames: ~numMelBands, destination: ~inBufComp, action: {
+				~standardizer.transformPoint(~inBufComp, ~inBufStand, {
+					~tree.kNearest(~inBufStand,{ |a|a.postln;~nearest = a;})
+				})
+			})
+		})
+	})
+})
+)
+
+// playback nearest in order
+(
+fork{
+	~nearest.do{|i|
+		var  buf, start, stop, dur;
+
+		buf= ~slices["data"][i.asInteger][0];
+		start = ~slices["data"][i.asInteger][1];
+		stop = ~slices["data"][i.asInteger][2];
+		dur = (stop - start)/ s.sampleRate;
+		{BufRd.ar(1,buf, Line.ar(start,stop,dur, doneAction: 2), 0, 2);}.play;
+
+		i.postln;
+		dur.wait;
+	};
+}
+)
diff --git a/release-packaging/Examples/dataset/1-learning examples/1a-starting-1D-example.scd b/release-packaging/Examples/dataset/1-learning examples/1a-starting-1D-example.scd
new file mode 100644
index 0000000..02fb085
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/1a-starting-1D-example.scd	
@@ -0,0 +1,73 @@
+s.reboot
+~ds = FluidDataSet.new(s)
+~point = Buffer.alloc(s,1,1)
+(
+Routine{
+	10.do{|i|
+		~point.set(0,i);
+		~ds.addPoint(i.asString,~point,{("addPoint"+i).postln}); //because buffer.set do an immediate update in the RT thread we can take for granted it'll be updated when we call addPoint
+		s.sync; //but we need to sync to make sure everything is done on the DataSet before the next iteration
+	}
+}.play
+)
+~ds.print;
+
+/*** KDTREE ***/
+~tree = FluidKDTree.new(s)
+~tree.fit(~ds,action:{"Done indexing".postln})
+
+~tree.numNeighbours = 5; //play with this
+(
+Routine{
+	10.do{|i|
+		~point.set(0,i);
+		~tree.kNearest(~point, {|x| "Neighbours for a value of % are ".postf(i); x.postln});
+		s.sync;
+	}
+}.play
+)
+
+/*** KMEANS ***/
+
+~kmeans = FluidKMeans.new(s,maxIter:100);
+~kmeans.numClusters = 2; //play with this
+~kmeans.fit(~ds,action:{|x| "Done fitting with these number of items per cluster ".post;x.postln;})
+
+(
+Routine{
+	10.do{|i|
+		~point.set(0,i);
+		~kmeans.predictPoint(~point,{|x| ("Predicted Cluster for a value of " + i ++ ":" + x).postln});
+		s.sync;
+	}
+}.play
+)
+
+~labels = FluidLabelSet(s);
+
+~kmeans.predict(~ds,~labels, {|x| ("Size of each cluster" +  x).postln})
+
+(
+~labels.size{|x|
+	Routine{x.asInteger.do{|i|
+		~labels.getLabel(i,action: {|l|
+			("Label for entry " + i ++ ":" + l).postln;
+		});
+		s.sync;
+	}
+	}.play;
+};
+)
+
+// or simply print it
+~labels.print
+
+// or dump and format
+(
+~labels.dump{|x|
+	var keys = x["data"].keys.asArray.sort;
+	keys.do{|key|
+		"Label for entry % is %\n".postf(key, x["data"][key][0]);
+	}
+}
+)
diff --git a/release-packaging/Examples/dataset/1-learning examples/2a-starting-1D-example2.scd b/release-packaging/Examples/dataset/1-learning examples/2a-starting-1D-example2.scd
new file mode 100644
index 0000000..faa0ada
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/2a-starting-1D-example2.scd	
@@ -0,0 +1,67 @@
+s.reboot
+~ds = FluidDataSet.new(s)
+~point = Buffer.alloc(s,1,1)
+(
+Routine{
+    10.do{|i|
+        var d;
+        if(i<=4,{d=i},{d=i+5});
+        ~point.set(0,d);
+        ~ds.addPoint(i.asString,~point,{("addPoint"+i).postln});
+        s.sync;
+    }
+}.play
+)
+~ds.print;
+
+/*** KDTREE ***/
+~tree = FluidKDTree.new(s)
+~tree.fit(~ds,action:{"Done indexing".postln})
+
+~tree.numNeighbours = 5; //play with this
+(
+Routine{
+	15.do{|i|
+		~point.set(0,i);
+		~tree.kNearest(~point, {|x| "Neighbours for a value of % are ".postf(i); x.post;" with respective distances of ".post;});
+		~tree.kNearestDist(~point, {|x| x.postln});
+		s.sync;
+	}
+}.play
+)
+
+
+/*** KMEANS ***/
+
+~kmeans = FluidKMeans.new(s,maxIter:100)
+~kmeans.numClusters = 2; //play with this
+~kmeans.fit(~ds, action:{|x| "Done fitting with these number of items per cluster ".post;x.postln;})
+
+(
+Routine{
+    15.do{|i|
+        ~point.set(0,i);
+		~kmeans.predictPoint(~point,{|x| ("Predicted Cluster for a value of " + i ++ ":" + x).postln});
+        s.sync;
+    }
+}.play
+)
+
+~labels = FluidLabelSet(s);
+
+~kmeans.predict(~ds,~labels, {|x| ("Size of each cluster" +  x).postln})
+
+(
+~labels.size{|x|
+	Routine{x.asInteger.do{|i| //size does not return a value, but we can retrieve it via a function
+		~labels.getLabel(i,action: {|l|
+			("Label for entry " + i ++ ":" + l).postln;
+		});
+		s.sync;
+	}
+	}.play;
+};
+)
+
+// or simply print it
+~labels.print
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/3a-classifier-example.scd b/release-packaging/Examples/dataset/1-learning examples/3a-classifier-example.scd
new file mode 100644
index 0000000..5f80842
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/3a-classifier-example.scd	
@@ -0,0 +1,64 @@
+(
+~simpleInput = FluidDataSet(s);
+~simpleOutput = FluidLabelSet(s);
+b = Buffer.alloc(s,2);
+~knn = FluidKNNClassifier(s);
+~knn.numNeighbours = 3
+)
+
+(
+var w,v,myx,myy;
+
+//initialise the mouse position holder
+myx=0;
+myy=0;
+
+//make a window and a full size view
+w = Window.new("Viewer",  Rect(100,Window.screenBounds.height - 400, 310, 310)).front;
+v = View.new(w,Rect(0,0, 310, 310));
+
+//creates a function that reacts to mousedown
+v.mouseDownAction = {|view, x, y|myx=x;myy=y;w.refresh;
+	// myx.postln;myy.postln;
+	Routine{
+		b.setn(0,[myx,myy]);
+		~knn.predictPoint(b, action: {|x|x.postln;});
+		s.sync;
+}.play;};
+
+//custom redraw function
+w.drawFunc = {
+	100.do { |i|
+		if (i < 50, {Pen.color = Color.white;} ,{Pen.color = Color.red;});
+		Pen.addRect(Rect(i.div(10)*30+10,i.mod(10)*30+10,20,20));
+		Pen.perform(\fill);
+	};
+	Pen.color = Color.black;
+	Pen.addOval(Rect(myx-5, myy-5,10,10));
+	Pen.perform(\stroke);
+};
+)
+
+(
+//populates a dataset with the same squares as the gui (their centres) (old method, iterating over buffers. A dictionary approach would be more efficient, see the example in this folder)
+Routine{
+	50.do{|i|
+	var	x = i.div(10)*30+20;
+			var y = i.mod(10)*30+20;
+	b.setn(0,[x,y]);
+		~simpleInput.addPoint(i.asString,b,{("Added Input" + i).postln});
+			~simpleOutput.addLabel(i.asString,"White",{("Added Output" + i).postln});
+		s.sync;
+			b.setn(0,[x+150,y]);
+		~simpleInput.addPoint((i+50).asString,b,{("Added Input" + (i+50)).postln});
+		~simpleOutput.addLabel((i+50).asString,"Red",{("Added Output" + (i+50)).postln});
+		s.sync;
+	};
+	\done.postln;
+	}.play;
+)
+
+// fit the dataset
+~knn.fit(~simpleInput,~simpleOutput, action:{"fitting done".postln})
+
+// now click on the grid and read the estimated class according to the nearest K neighbours.
diff --git a/release-packaging/Examples/dataset/1-learning examples/4-regressor-example.scd b/release-packaging/Examples/dataset/1-learning examples/4-regressor-example.scd
new file mode 100644
index 0000000..e7f2b38
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/4-regressor-example.scd	
@@ -0,0 +1,74 @@
+s.reboot
+
+~urn = { |n=31416, min=0,max=31415| (min..max).scramble.keep(n) };
+
+// creates 200 indices, then values of the output of a fundion with a predictable shape of a sinewave
+n = 200
+~idx = ~urn.value(n)
+~data = n.collect{|i|sin(~idx[i]/5000)}
+
+// creates the dataset with these associated indices and values
+(
+~simpleInput = FluidDataSet(s);
+~simpleOutput = FluidDataSet(s);
+b = Buffer.alloc(s,1);
+c = Buffer.alloc(s,1);
+~mappingviz = Buffer.alloc(s,512);
+)
+
+(
+Routine{
+    n.do{|i|
+        b.set(0,~idx[i]);
+        c.set(0,~data[i]);
+        ~simpleInput.addPoint(i.asString,b,{("Added Input" + i).postln});
+        ~simpleOutput.addPoint(i.asString,c,{("Added Output" + i).postln});
+        ~mappingviz.set((~idx[i]/61.4).asInteger,~data[i]);
+        s.sync;
+    }
+}.play
+)
+
+~simpleInput.print
+~simpleOutput.print
+
+//look at the seeing material
+~mappingviz.plot(minval:-1,maxval:1)
+
+//create a buffer to query
+~mappingresult = Buffer.alloc(s,512);
+
+//make the process then fit the data
+~knn = FluidKNNRegressor(s,3,1)
+~knn.fit(~simpleInput, ~simpleOutput, action:{"fitting done".postln})
+
+// query 512 points along the line (slow because of all that sync'ing)
+(
+~knn.numNeighbours = 1; // change to see how many points the system uses to regress
+Routine{
+	512.do{|i|
+		b.set(0,i*61);
+		~knn.predictPoint(b,action:{|d|~mappingresult.set(i,d);});
+		s.sync;
+		i.postln;
+	}
+}.play
+)
+
+// look at the interpolated values
+~mappingresult.plot
+
+// change the number of neighbours to regress on
+~knn.numNeighbours_(5)
+~knn.fit(~simpleInput, ~simpleOutput, action:{"fitting done".postln})
+
+// instead of doing the mapping per point, let's do a dataset of 512 points
+~target = FluidDataSet(s)
+~target.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom(512.collect{|i|[i.asString, [i.asFloat * 61]]}.flatten)]))
+~regressed = FluidDataSet(s)
+~knn.predict(~target, ~regressed, action:{"prediction done".postln})
+
+//dump the regressed values
+~outputArray = Array.newClear(512);
+~regressed.dump{|x| x["data"].keysValuesDo{|key,val|~outputArray[key.asInteger] = val[0]}}
+~outputArray.plot
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/5-normalization-and-standardization-example.scd b/release-packaging/Examples/dataset/1-learning examples/5-normalization-and-standardization-example.scd
new file mode 100644
index 0000000..1cf3de6
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/5-normalization-and-standardization-example.scd	
@@ -0,0 +1,120 @@
+(
+// set some variables
+~nb_of_dim = 10;
+~dataset = FluidDataSet(s);
+)
+
+(
+// fill up the dataset with 20 entries of 10 column/dimension/descriptor value each. The naming of the item's label is arbitrary as usual
+Routine{
+	var buf = Buffer.alloc(s,~nb_of_dim);
+	20.do({ arg i;
+		buf.loadCollection(Array.fill(~nb_of_dim,{rrand(0.0,100.0)}));
+		~dataset.addPoint("point-"++i.asInteger.asString, buf);
+		s.sync;
+	});
+	buf.free;
+	\done.postln;
+}.play
+)
+
+~dataset.print;
+
+// make a buf for getting points back
+~query_buf = Buffer.alloc(s,~nb_of_dim);
+
+// look at a point to see that it has points in it
+~dataset.getPoint("point-0",~query_buf,{~query_buf.getn(0,~nb_of_dim,{|x|x.postln;});});
+
+// look at another point to make sure it's different...
+~dataset.getPoint("point-7",~query_buf,{~query_buf.getn(0,~nb_of_dim,{|x|x.postln;});});
+
+///////////////////////////////////////////////////////
+// exploring full dataset normalization and standardization
+
+// make a FluidNormalize
+~normalize = FluidNormalize(s,0,1);
+
+// fits the dataset to find the coefficients
+~normalize.fit(~dataset,{"done".postln;});
+
+// making an empty 'normed_dataset' which is required for the normalize function
+~normed_dataset = FluidDataSet(s);
+
+// normalize the full dataset
+~normalize.transform(~dataset,~normed_dataset,{"done".postln;});
+
+// look at a point to see that it has points in it
+~normed_dataset.getPoint("point-0",~query_buf,{~query_buf.getn(0,~nb_of_dim,{|x|x.postln;});});
+// 10 numbers between 0.0 and 1.0 where each column/dimension/descriptor is certain to have at least one item on which it is 0 and one on which it is 1
+// query a few more for fun
+
+// try FluidStandardize
+~standardize = FluidStandardize(s);
+
+// fits the dataset to find the coefficients
+~standardize.fit(~dataset,{"done".postln;});
+
+// standardize the full dataset
+~standardized_dataset = FluidDataSet(s);
+~standardize.transform(~dataset,~standardized_dataset,{"done".postln;});
+
+// look at a point to see that it has points in it
+~standardized_dataset.getPoint("point-0",~query_buf,{~query_buf.getn(0,~nb_of_dim,{|x|x.postln;});});
+// 10 numbers that are standardize, which mean that, for each column/dimension/descriptor, the average of all the points will be 0. and the standard deviation 1.
+
+////////////////////////////////////////////////////
+// exploring point querying  concepts via norm and std
+
+// Once a dataset is normalized / standardized, query points have to be scaled accordingly to be used in distance measurement. In our instance, values were originally between 0 and 100, and now they will be between 0 and 1 (norm), or their average will be 0. (std). If we have data that we want to match from a similar ranging input, which is usually the case, we will need to normalize the searching point in each dimension using the same coefficients.
+
+// first, make sure you have run all the code above, since we will query these datasets
+
+// get a know point as a query point
+~dataset.getPoint("point-7",~query_buf);
+
+// find the 2 points with the shortest distances in the dataset
+~tree = FluidKDTree.new(s,numNeighbours:2);
+~tree.fit(~dataset)
+~tree.kNearest(~query_buf, {|x| ("Labels:" + x).postln});
+~tree.kNearestDist(~query_buf, {|x| ("Distances:" + x).postln});
+// its nearest neighbourg is itself: it should be itself and the distance should be 0. The second point is depending on your input dataset.
+
+// normalise that point (~query_buf) to be at the right scale
+~normbuf = Buffer.alloc(s,~nb_of_dim);
+~normalize.transformPoint(~query_buf,~normbuf);
+~normbuf.getn(0,~nb_of_dim,{arg vec;vec.postln;});
+
+// make a tree of the normalized database and query with the normalize buffer
+~normtree = FluidKDTree.new(s,numNeighbours:2);
+~normtree.fit(~normed_dataset)
+~normtree.kNearest(~normbuf,  {|x| ("Labels:" + x).postln});
+~normtree.kNearestDist(~normbuf, {|x| ("Distances:" + x).postln});
+// its nearest neighbourg is still itself as it should be, but the 2nd neighbourg might have changed. The distance is now different too
+
+// standardize that same point (~query_buf) to be at the right scale
+~stdbuf = Buffer.alloc(s,~nb_of_dim);
+~standardize.transformPoint(~query_buf,~stdbuf);
+~stdbuf.getn(0,~nb_of_dim,{arg vec;vec.postln;});
+
+// make a tree of the standardized database and query with the normalize buffer
+~stdtree = FluidKDTree.new(s, numNeighbours: 2);
+~stdtree.fit(~standardized_dataset)
+~stdtree.kNearest(~stdbuf, {|x| ("Labels:" + x).postln});
+~stdtree.kNearestDist(~stdbuf, {|x| ("Distances:" + x).postln});
+// its nearest neighbourg is still itself as it should be, but the 2nd neighbourg might have changed yet again. The distance is also different too
+
+// where it starts to be interesting is when we query points that are not in our original dataset
+
+// fill with known values (50.0 for each of the 10 column/dimension/descriptor, aka the theoretical middle point of the multidimension space) This could be anything but it is fun to aim in the middle.
+~query_buf.fill(0,~nb_of_dim,50);
+
+// normalize and standardize the query buffer. Note that we do not need to fit since we have not added a point to our reference dataset
+~normalize.transformPoint(~query_buf,~normbuf);
+~standardize.transformPoint(~query_buf,~stdbuf);
+
+//query the single nearest neighbourg via 3 different data scaling. Depending on the random source at the begining, you should get (small or large) differences between the 3 answers!
+[~tree,~normtree,~stdtree].do{|t| t.numNeighbours =1  };
+~tree.kNearest(~query_buf, {|x| ("Original:" + x).post;~tree.kNearestDist(~query_buf, {|x| (" with a distance of " + x).postln});});
+~normtree.kNearest(~normbuf, {|x| ("Normalized:" + x).post;~normtree.kNearestDist(~normbuf, {|x| (" with a distance of " + x).postln});});
+~stdtree.kNearest(~stdbuf, {|x| ("Standardized:" + x).post; ~stdtree.kNearestDist(~stdbuf, {|x| (" with a distance of " + x).postln});});
diff --git a/release-packaging/Examples/dataset/1-learning examples/7a-making-datasets-with-json.scd b/release-packaging/Examples/dataset/1-learning examples/7a-making-datasets-with-json.scd
new file mode 100644
index 0000000..829e474
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/7a-making-datasets-with-json.scd	
@@ -0,0 +1,52 @@
+// create the data dictionary
+~data = Dictionary.new
+7.do{|i| ~data.add(("entry-"++i).asSymbol -> 10.collect{|j|j/10 + i})}
+
+// nest that dictionary in the dataset format, adding the number of columns
+~dict = Dictionary.new
+~dict.add(\data -> ~data)
+~dict.add(\cols -> 10)
+
+//create a dataset, then loading the dictionary
+~ds =  FluidDataSet(s);
+~ds.load(~dict)
+~ds.print
+
+//fun with kdtree to see it actually works
+~kdtree = FluidKDTree.new(s,numNeighbours:5)
+~kdtree.fit(~ds,{\done.postln;})
+~target = Buffer.loadCollection(s,(4).dup(10));
+~kdtree.kNearest(~target, {|a|a.postln;})
+~kdtree.kNearestDist(~target, {|a|a.postln;})
+
+
+/////////////////////////////////////////////
+// creating a labelset the same way
+
+// creating the data dictionary
+~data2 = Dictionary.new
+7.do{|i| ~data2.add(("entry-"++i).asSymbol -> (if( i.odd, {["odd"]},{["even"]})))}
+
+// nesting again
+~dict2 = Dictionary.new
+~dict2.add(\data -> ~data2)
+~dict2.add(\cols -> 1)
+
+// creating a labelset and loading the dictionary
+~ls =  FluidLabelSet(s);
+~ls.load(~dict2)
+~ls.print
+
+// testin with a classifier toy example
+~classifier = FluidKNNClassifier.new(s, numNeighbours:2);
+~classifier.fit(~ds,~ls, {\done.postln;})
+
+// run many times for random pleasure
+(
+fork{
+	var value = 7.rand;
+	~ds.getPoint(("entry-"++value).asSymbol,~target);
+	s.sync;
+	~classifier.predictPoint(~target, action: {|x|"entry % is an % entry.\n".postf(value,x);})
+}
+)
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/8a-mlp-didactic.scd b/release-packaging/Examples/dataset/1-learning examples/8a-mlp-didactic.scd
new file mode 100644
index 0000000..54810e2
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/8a-mlp-didactic.scd	
@@ -0,0 +1,83 @@
+// basic xor to show non-linearity guestimating of MLP
+// see https://medium.com/@jayeshbahire/the-xor-problem-in-neural-networks-50006411840b
+// and https://youtu.be/188B6k_F9jU
+
+// make 2 datasets as our truth
+(
+Routine{
+	d = Dictionary.new;
+	d.add(\cols -> 2);
+	d.add(\data -> Dictionary.newFrom(["f-f", [0,0], "f-t", [0,1], "t-f", [1,0], "t-t", [1,1]]));
+    ~mlpHelpSource = FluidDataSet.new(s);
+	s.sync;
+    ~mlpHelpSource.load(d);
+	s.sync;
+	d.add(\cols -> 1);
+	d.add(\data -> Dictionary.newFrom(["f-f", [0], "f-t", [1], "t-f", [1], "t-t", [0]]));
+    ~mlpHelpTarget = FluidDataSet.new(s);
+	s.sync;
+    ~mlpHelpTarget.load(d);
+	s.sync;
+}.play;
+)
+
+//check our thruth tables
+~mlpHelpSource.print
+~mlpHelpTarget.print
+
+// make an MLPregressor
+~mlp = FluidMLPRegressor(s, [3], FluidMLPRegressor.sigmoid, FluidMLPRegressor.sigmoid,maxIter:1000,learnRate: 0.1,momentum: 0.1,batchSize: 1,validation: 0);//1000 epoch at a time
+//train it by executing the following line multiple time, and observe the error
+~mlp.fit(~mlpHelpSource,~mlpHelpTarget,{|x|x.postln;});
+
+//to make a plot of the error let's do a classic 'shades of truth' (a grid of 11 x 11 with each values of truth between 0 and 1
+(
+Routine{
+		d = Dictionary.new;
+
+	d.add(\cols -> 2);
+	d.add(\data -> Dictionary.newFrom(121.collect{|x|[x.asString, [x.div(10)/10,x.mod(10)/10]]}.flatten));
+    ~mlpHelpShades = FluidDataSet.new(s);
+	s.sync;
+    ~mlpHelpShades.load(d);
+	s.sync;
+}.play;
+)
+
+// check it
+~mlpHelpShades.print
+
+// let's make a destination for our regressions
+~mlpHelpRegressed = FluidDataSet.new(s);
+
+// then predict the full DataSet in our trained network
+~mlp.predict(~mlpHelpShades,~mlpHelpRegressed);
+
+// estimated values
+~mlpHelpRegressed.print;
+
+// lets extract them as an array
+~assignments = Array.new(121); ~mlpHelpRegressed.dump{|x|~assignments = x.at("data").atAll(x.at("data").keys.asArray.sort{|a,b|a.asInteger < b.asInteger}).flatten.postln;};
+
+//and draw them
+(
+w = Window("scatter", Rect(128, 64, 200, 200));
+w.drawFunc = {
+    Pen.use {
+        ~assignments.do{|val,ind|
+			var x = (ind.div(10)*20);
+			var y = (ind.mod(10)*20);
+            var r = Rect(x,y,20,20);
+			Pen.fillColor = Color.grey(val);
+            Pen.fillRect(r);
+        }
+    }
+};
+w.refresh;
+w.front;
+)
+
+~mlp.free
+~mlpHelpShades.free
+~mlpHelpSource.free
+~mlpHelpTarget.free
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/8b-mlp-synth-control.scd b/release-packaging/Examples/dataset/1-learning examples/8b-mlp-synth-control.scd
new file mode 100644
index 0000000..49a3d38
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/8b-mlp-synth-control.scd	
@@ -0,0 +1,90 @@
+//1- make the gui then the synth below
+(
+var trained = 0, entering = 0;
+var va = Array.fill(10,{0.5});
+var input = Buffer.alloc(s,2);
+var output = Buffer.alloc(s,10);
+var mlp = FluidMLPRegressor(s,[6],activation: 1,outputActivation: 1,maxIter: 1000,learnRate: 0.1,momentum: 0,batchSize: 1,validation: 0);
+var entry = 0;
+
+~inData = FluidDataSet(s);
+~outData = FluidDataSet(s);
+
+w = Window("ChaosSynth", Rect(10, 10, 790, 320)).front;
+a = MultiSliderView(w,Rect(10, 10, 400, 300)).elasticMode_(1).isFilled_(1);
+a.value=va;
+a.action = {arg q;
+	b.set(\val, q.value);
+	va = q.value;};
+f = Slider2D(w,Rect(420,10,300, 300));
+f.x = 0.5;
+f.y = 0.5;
+f.action = {arg x,y; //if trained, predict the point f.x f.y
+	if (entering == 1, { //if entering a point, add to the the database f.x f.y against the array va
+		input.setn(0, [f.x, f.y]);
+		output.setn(0, va);
+		~inData.addPoint(entry.asSymbol,input);
+		~outData.addPoint(entry.asSymbol,output);
+		entering = 0;
+		entry = entry + 1;
+		{d.value = 0;}.defer;
+	}, { //if not entering a point
+		if (trained == 1, { //if trained
+			input.setn(0, [f.x, f.y]);
+			mlp.predictPoint(input,output,{
+				output.getn(0,10,{
+					|x|va = x; b.set(\val, va); {a.value = va;}.defer;});
+			});
+		});
+	});
+};
+
+c = Button(w, Rect(730,240,50, 20)).states_([["train", Color.red, Color.white], ["trained", Color.white, Color.grey]]).action_{
+	mlp.fit(~inData,~outData,{|x|
+		trained = 1;
+		{
+			c.value = 1;
+			e.value = x.round(0.001).asString;
+		}.defer;
+	});//train the network
+};
+d = Button(w, Rect(730,10,50, 20)).states_([["entry", Color.white, Color.grey], ["entry",  Color.red, Color.white]]).action_{
+	entering = 1;
+};
+StaticText(w,Rect(732,260,50,20)).string_("Error:");
+e = TextField(w,Rect(730,280,50,20)).string_(0.asString);
+StaticText(w,Rect(732,70,50,20)).string_("rate:");
+TextField(w,Rect(730,90,50,20)).string_(0.1.asString).action_{|in|mlp.learnRate = in.value.asFloat.postln;};
+StaticText(w,Rect(732,110,50,20)).string_("momentum:");
+TextField(w,Rect(730,130,50,20)).string_(0.0.asString).action_{|in|mlp.momentum = in.value.asFloat.postln;};
+StaticText(w,Rect(732,150,50,20)).string_("maxIter:");
+TextField(w,Rect(730,170,50,20)).string_(1000.asString).action_{|in| mlp.maxIter = in.value.asInteger.postln;};
+StaticText(w,Rect(732,190,50,20)).string_("validation:");
+TextField(w,Rect(730,210,50,20)).string_(0.0.asString).action_{|in|mlp.validation = in.value.asFloat.postln;};
+)
+
+//2- the synth
+(
+b = {
+	arg val = #[0,0,0,0,0,0,0,0,0,0];
+	var osc1, osc2, feed1, feed2, base1=69, base2=69, base3 = 130;
+	#feed2,feed1 = LocalIn.ar(2);
+	osc1 = MoogFF.ar(SinOsc.ar((((feed1 * val[0]) +  val[1]) * base1).midicps,mul: (val[2] * 50).dbamp).atan,(base3 - (val[3] * (FluidLoudness.kr(feed2, 1, 0, hopSize: 64)[0].clip(-120,0) + 120))).lag(128/44100).midicps, val[4] * 3.5);
+	osc2 = MoogFF.ar(SinOsc.ar((((feed2 * val[5]) +  val[6]) * base2).midicps,mul: (val[7] * 50).dbamp).atan,(base3 - (val[8] * (FluidLoudness.kr(feed1, 1, 0, hopSize: 64)[0].clip(-120,0) + 120))).lag(128/44100).midicps, val[9] * 3.5);
+	Out.ar(0,LeakDC.ar([osc1,osc2],mul: 0.1));
+	LocalOut.ar([osc1,osc2]);
+}.play;
+)
+
+
+
+~inData.print;
+~outData.print;
+
+/////////
+//3 - play with the multislider
+//4 - when you like a spot, click entry (become read) then a position in the 2D graph where this point should be
+//5 - do that for a few points
+//6 - click train
+//7 - the 2D graph controls the 10D
+//8 - if you like a new sound and you want to update the graph, just click entry, then where it should be in the 2D, then retrain when you are happy
diff --git a/release-packaging/Examples/dataset/1-learning examples/8c-mlp-regressor-as-dim-redux.scd b/release-packaging/Examples/dataset/1-learning examples/8c-mlp-regressor-as-dim-redux.scd
new file mode 100644
index 0000000..6c59b6e
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/8c-mlp-regressor-as-dim-redux.scd	
@@ -0,0 +1,161 @@
+s.reboot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers
+(
+~raw = FluidDataSet(s);
+~norm = FluidDataSet(s);
+~retrieved = FluidDataSet(s);
+~audio = Buffer.read(s,File.realpath(FluidBufMelBands.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav");
+~melfeatures = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 40);
+~datapoint = Buffer.alloc(s, 40);
+~queryPoint = Buffer.alloc(s, 2);
+~dQueryPoint = Buffer.alloc(s, 2);
+~dpN =Buffer.alloc(s, 40);
+~dpMLPn =Buffer.alloc(s, 40);
+~dpMLP =Buffer.alloc(s, 40);
+)
+
+// process the melbands
+FluidBufMelBands.process(s,~audio, features: ~melfeatures,action: {\done.postln;});
+
+// Divide the time series in 100, and take the mean of each segment and add this as a point to the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(40, 1);
+	var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~melfeatures.numFrames / 100).asInteger;
+	var stats = FluidBufStats.kr(source: ~melfeatures, startFrame: count * chunkLen, numFrames: chunkLen, stats: ~stats, trig: trig, blocking: 1);
+	var rd = BufRd.kr(40, ~stats, DC.kr(0), 0, 1);
+	var bufWr, dsWr;
+	40.do{|i|
+		bufWr = BufWr.kr(rd[i], buf, DC.kr(i));
+	};
+	dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats));
+	LocalOut.kr( Done.kr(dsWr));
+	FreeSelf.kr(count - 99);
+	Poll.kr(trig,(100-count));
+}.play;
+)
+// wait for the count to reaches 0 in the post window. Check the dataset if curious (loads of small numbers)
+~raw.print;
+
+// normalize the input
+~normalizer = FluidNormalize(s);
+~normalizer.fitTransform(~raw,~norm);
+~norm.print; //a more decent range
+
+//we can then run the AE - the server might become yellow :)
+~mlp = FluidMLPRegressor(s,[9,2,9],activation: 1,outputActivation: 1,tapIn: 0,tapOut: 2,maxIter: 10000,learnRate: 0.1,momentum: 0.1,batchSize: 10,validation: 0.1);
+~mlp.fit(~norm,~norm,{|x|x.postln;});// run this a few times, until you are happy with the error
+
+//we can then retrieve the hidden layer #2 because of the tapOut parameter
+~mlp.predict(~norm,~retrieved);
+
+//check the structure of retrieved
+~retrieved.print;
+
+//let's normalise it for display
+~normData = FluidDataSet(s);
+~reducedarray = Array.new(100);
+~normalView = FluidNormalize(s,0.1,0.9);
+(
+~normalView.fitTransform(~retrieved,~normData, action:{
+	~normData.dump{|x| 100.do{|i|
+		~reducedarray.add(x["data"][i.asString])
+	}};
+});
+)
+~normData.print;
+
+//make a basic KD tree to retrieve the nearest entry in 2D
+~kdtree = FluidKDTree(s,numNeighbours: 1);
+~kdtree.fit(~normData);
+
+//prepare the normalizers and the neural net for inverse query
+(
+~normalView.invert = 1;
+~normalizer.invert = 1;
+~mlp.tapIn = 2;
+~mlp.tapOut = -1;
+)
+
+//Visualise and query the 2D projection of our original 40D data
+(
+var w,v,myx,myy,vRNN, vRN, vMN, vM;
+
+~arrayRawNn = Array.new(40);
+~arrayRawN = Array.new(40);
+~arrayMLPn = Array.new(40);
+~arrayMLP = Array.new(40);
+
+//initialise the mouse position holder
+myx=130;
+myy=130;
+
+w = Window("AutoEncoder", Rect(64, 64, 770, 270));
+v = View.new(w,Rect(0,0, 310, 310));
+
+vRNN = MultiSliderView(w,Rect(270,8,240,115)).value_(~arrayRawNn).readOnly_(true).elasticMode_(1).isFilled_(true);
+vRN = MultiSliderView(w,Rect(270,147,240,115)).value_(~arrayRawN).readOnly_(true).elasticMode_(1).isFilled_(true);
+vMN = MultiSliderView(w,Rect(520,10,240,115)).value_(~arrayMLPn).readOnly_(true).elasticMode_(1).isFilled_(true);
+vM = MultiSliderView(w,Rect(520,147,240,115)).value_(~arrayMLP).readOnly_(true).elasticMode_(1).isFilled_(true);
+
+StaticText(w,Rect(275,120,490,30)).string_("above: normalised nearest neighbour\nbelow: original nearest neighbour").font_(Font("Monaco", 10));
+StaticText(w,Rect(525,120,490,30)).string_("above: regressed values at coordinates\nbelow: denormalised regressed values").font_(Font("Monaco", 10));
+
+//creates a function that reacts to mousedown
+v.mouseMoveAction = {|view, x, y|
+	myx=x.clip(10,260);
+	myy=y.clip(10,260);
+	w.refresh;
+	Routine{
+		~queryPoint.setn(0,([myx,myy] - 10 / 250));//set the query point to the coordinate
+		~kdtree.kNearest(~queryPoint, action: {|nearest| //retrieve the nearest point
+			~norm.getPoint(nearest, ~dpN, action: { //get the normalised 40d
+				~raw.getPoint(nearest, ~datapoint, action: { // get the original 40d
+					~normalView.transformPoint(~queryPoint, ~dQueryPoint, action: { //denormalise the 2d coordinate to get the right range of values for the MLP
+						~mlp.predictPoint(~dQueryPoint, ~dpMLPn, action:  { //predict from the middle (2d) to the normalised output (40d)
+							~normalizer.transformPoint(~dpMLPn, ~dpMLP, action:  { //denormalised the 40d
+								~datapoint.getn(0,40,{|x|~arrayRawN = x; //retrieve the nearest
+									~dpN.getn(0,40,{|x|~arrayRawNn = x; // retrieve the normalised nearest
+										~dpMLPn.getn(0,40,{|x|~arrayMLPn = x; //retrieve the predicted normalised 40d
+											~dpMLP.getn(0,40,{|x|~arrayMLP = x; //retrieve the denormalised predicted 40d
+												AppClock.sched(0,{ // update the visualisation of the 4 arrays
+													vRNN.value=~arrayRawNn;
+													vRN.value=~arrayRawN * 15;
+													vMN.value=~arrayMLPn;
+													vM.value=~arrayMLP * 15;
+												});
+											});
+										});
+									});
+								});
+							});
+						});
+					});
+				});
+			});
+		});
+	}.play;
+};
+//custom redraw function
+w.drawFunc = {
+	Pen.use {
+		~reducedarray.size.do{|i|
+			var coord = (~reducedarray[i] * 250) + 7;
+			var r = Rect(coord[0],coord[1],6,6);
+			Pen.fillColor = Color.blue;
+			Pen.fillOval(r);
+		};
+	};
+	Pen.color = Color.red;
+	Pen.addOval(Rect(myx-4, myy-4,8,8));
+	Pen.perform(\stroke);
+	Pen.color = Color.black;
+	Pen.addRect(Rect(10,10,250,250));
+	Pen.perform(\stroke);
+};
+w.refresh;
+w.front;
+)
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/1-learning examples/9-regressor-comparison.scd b/release-packaging/Examples/dataset/1-learning examples/9-regressor-comparison.scd
new file mode 100644
index 0000000..84e80da
--- /dev/null
+++ b/release-packaging/Examples/dataset/1-learning examples/9-regressor-comparison.scd	
@@ -0,0 +1,98 @@
+//In this patch we will try to make sense of a few behaviours of the regressors we have. This is a toy example with 3 then 4 samples, but it showcases a few of the behaviours and assumptions we might have that might be innaccurate.
+
+//Here we make a 3-points pair of dataset.
+
+~dsIN = FluidDataSet(s);
+~dsIN.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\point1, [10], \point2, [20], \point3, [30]])]));
+~dsOUT = FluidDataSet(s);
+~dsOUT.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\point1, [0.8], \point2, [0.2], \point3, [0.5]])]));
+
+//check the values
+~dsIN.print;~dsOUT.print;
+// make a graph to visualise it
+(0.dup(10) ++ 0.8 ++ 0.dup(9) ++ 0.2 ++ 0.dup(9) ++ 0.5 ++ 0.dup(10)).plot(\source,discrete: true, minval:0, maxval: 1).plotMode=\bars;
+
+//Let's make a complete dataset to predict each points in our examples:
+~dsALLin = FluidDataSet(s);
+~dsALLin.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom(Array.fill(41,{|x| [x.asSymbol, [x]];}).flatten(1);)]));
+~dsALLin.print
+
+//We'll regress these values via KNN and plot
+~regK = FluidKNNRegressor(s,numNeighbours: 2,weight: 1);
+~dsALLknn = FluidDataSet(s);
+~regK.fit(~dsIN,~dsOUT);
+~regK.predict(~dsALLin,~dsALLknn);
+
+//retrieve and plot our data
+(
+~knnALLval = Array.new(41);
+~dsALLknn.dump{|x| 41.do{|i|
+	~knnALLval.add((x["data"][i.asString]))
+}};
+)
+~knnALLval.flatten(1).plot(\source,discrete: true, minval:0, maxval: 1).plotMode=\bars;
+
+//Regressing directly these value-pairs in knn we see a full set of values being predicted: we can see what looks like linear interpolation, but not outside the boundaries. This is because we make a weighted average of the nearest 2 neigbourgs, which are not necessarily around the predicted value, they might both be on the same side like 0 to 9 (10 and 20 are nearest) and 31 to 40 (20 and 30 are nearest).
+
+//Let's do the same process with MLP
+~regM = FluidMLPRegressor(s,hidden: [4],activation: 1,outputActivation: 1,maxIter: 10000,learnRate: 0.1,momentum: 0,batchSize: 1,validation: 0);
+~dsALLmlp = FluidDataSet(s);
+~regM.fit(~dsIN,~dsOUT,{|x|x.postln;});
+~regM.predict(~dsALLin,~dsALLmlp);
+
+(
+~mlpALLval = Array.new(41);
+~dsALLmlp.dump{|x| 41.do{|i|
+	~mlpALLval.add((x["data"][i.asString]))
+}};
+)
+~mlpALLval.flatten(1).plot(\source,discrete: true, minval:0, maxval: 1).plotMode=\bars;
+
+//We see that we have a large bump and nothing else. This is because our input are very large (10-30) and outside the optimal range of the activation function (0-1 for sigmoid) so our network saturates and cannot recover. If we normalise our inputs and we rerun the network we get a curve that fits the 3 values. You can fit more than once to get more iterations and lower the error.
+
+~norm = FluidNormalize(s);
+~norm.fitTransform(~dsIN,~dsIN); //fit and normalise in place our training data
+~norm.transform(~dsALLin, ~dsALLin); //and normalise in place our sampling data
+~regM.clear;//resets the seeds
+~regM.fit(~dsIN,~dsOUT,{|x|x.postln;}); //a few hits will show a very low error
+~regM.predict(~dsALLin,~dsALLmlp);
+
+(
+~mlpALLval = Array.new(41);
+~dsALLmlp.dump{|x| 41.do{|i|
+	~mlpALLval.add((x["data"][i.asString]))
+}};
+)
+~mlpALLval.flatten(1).plot(\source,discrete: true, minval:0, maxval: 1).plotMode=\bars;
+
+//Now we can add one value to our sparse dataset. Note that we revert back to full range values here for the example
+~dsIN.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\point1, [10], \point2, [20], \point3, [30], \point4, [22]])]));
+~dsOUT.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\point1, [0.8], \point2, [0.2], \point3, [0.5], \point4, [0.26]])]));
+~source = (0.dup(10) ++ 0.8 ++ 0.dup(9) ++ [0.2, 0, 0.26] ++ 0.dup(7) ++ 0.5 ++ 0.dup(10)); ~source.plot(\source,discrete: true, minval:0, maxval: 1).plotMode=\bars;
+
+//Before re-processing, trying to estimate what will happen is a good exercice. Then execute the code below.
+
+(
+~norm.fitTransform(~dsIN,~dsIN, { //fit and normalise in place our training data (our sampling data is still normalised to the same range
+	~regK.fit(~dsIN,~dsOUT, { //knn fit
+		~regK.predict(~dsALLin,~dsALLknn, { //knn predict
+			~regM.fit(~dsIN,~dsOUT,{|x|x.postln; //mlp fit
+				~regM.predict(~dsALLin,~dsALLmlp, { //mlp predict
+					~mlpALLval = Array.new(41); //mlp retrieve
+					~dsALLmlp.dump{|x| 41.do{|i|
+						~mlpALLval.add((x["data"][i.asString]));
+					}};
+					~knnALLval = Array.new(41);//knn retrieve
+					~dsALLknn.dump{|x| 41.do{|i|
+						~knnALLval.add((x["data"][i.asString]));
+					};//draw everything
+					{[~source, ~knnALLval.flatten(1), ~mlpALLval.flatten(1)].flop.flatten(1).plot(\source,numChannels: 3, discrete: false, minval:0, maxval: 1).plotMode=\bars;}.defer;
+					};
+				});
+			});
+		});
+	});
+});
+)
+
+//The first thing to meditate upon is how much of a kink assymetrically sampled data makes in nearest-distance regression. That can be soften by having a larger number of neigbourgs but not much. With this in mind, example 4-regressor-example.maxpat should be explored again. This is where neural net shines. Its curve barely moved and still matches the data. Interestingly, it provides values that are somehow sensible outside of the training dataset too.
\ No newline at end of file
diff --git a/release-packaging/Examples/dataset/2-various other examples/scaling-dimension-as-weighting/2-3Dscaling.scd b/release-packaging/Examples/dataset/2-various other examples/scaling-dimension-as-weighting/2-3Dscaling.scd
new file mode 100644
index 0000000..71b7e7f
--- /dev/null
+++ b/release-packaging/Examples/dataset/2-various other examples/scaling-dimension-as-weighting/2-3Dscaling.scd	
@@ -0,0 +1,161 @@
+// Make:
+// - A kmeans
+// - a datasetquery
+// - a normalizer
+// - a standardizer
+// - 3 DataSets of example points R-G-B descriptions
+// - 3 DataSets for the scaled versions
+// - 1 summative dataset and a LabelSet for predicted labels
+
+(
+~classifier = FluidKMeans(s,5, 1000);
+~query = FluidDataSetQuery(s);
+~stan = FluidStandardize(s);
+~norm = FluidNormalize(s);
+~sourceR = FluidDataSet(s);
+~sourceG = FluidDataSet(s);
+~sourceB = FluidDataSet(s);
+~scaledR = FluidDataSet(s);
+~scaledG = FluidDataSet(s);
+~scaledB = FluidDataSet(s);
+~composited = FluidDataSet(s);
+~labels = FluidLabelSet(s);
+)
+
+//Make some random, but clustered test points, each descriptor category in a separate dataset
+(
+~sourceR.load(Dictionary.newFrom([\cols, 1, \data, (Dictionary.newFrom(40.collect{|x| [x, 1.0.sum3rand]}.flatten))]));
+~sourceG.load(Dictionary.newFrom([\cols, 1, \data, (Dictionary.newFrom(40.collect{|x| [x, 1.0.rand2]}.flatten))]));
+~sourceB.load(Dictionary.newFrom([\cols, 1, \data, (Dictionary.newFrom(40.collect{|x| [x, (0.5.sum3rand).squared + [0.75,-0.1].choose]}.flatten))]));
+)
+
+//here we manipulate
+
+//assemble the scaled dataset
+(
+~query.addColumn(0, {
+	~query.transformJoin(~sourceB, ~sourceG, ~composited, {
+		~query.transformJoin(~sourceR, ~composited, ~composited);
+	});
+});
+)
+
+~composited.print
+
+//Fit the classifier to the example DataSet and labels, and then run prediction on the test data into our mapping label set
+~classifier.fitPredict(~composited,~labels,{~labels.dump{|x|~labeldict = x;};~composited.dump{|x|~compodict=x;};});
+
+//Visualise:
+(
+w = Window("sourceClasses", Rect(128, 64, 820, 120));
+w.drawFunc = {
+	Pen.use{
+		~compodict["data"].keysValuesDo{|key,  colour|
+			Pen.fillColor = Color.fromArray((colour * 0.5 + 0.5 ).clip(0,1) ++ 1);
+			Pen.fillRect( Rect( (key.asFloat * 20 + 10), (~labeldict["data"].at(key).asInteger[0] * 20 + 10),15,15));
+		};
+	};
+};
+w.refresh;
+w.front;
+)
+
+// standardize our colours and rerun
+(
+~stan.fitTransform(~sourceR, ~scaledR, {
+	~stan.fitTransform(~sourceG, ~scaledG, {
+		~stan.fitTransform(~sourceB, ~scaledB, {
+			//assemble
+			~query.addColumn(0, {
+				~query.transformJoin(~scaledB, ~scaledG, ~composited, {
+					~query.transformJoin(~scaledR, ~composited, ~composited, {
+						//fit
+						~classifier.fitPredict(~composited,~labels,{~labels.dump{|x|~labeldict2 = x;};~composited.dump{|x|~compodict2=x;};});
+					});
+				});
+			});
+		});
+	});
+});
+)
+
+//Visualise:
+(
+w = Window("stanClasses", Rect(128, 204, 820, 120));
+w.drawFunc = {
+	Pen.use{
+		~compodict2["data"].keysValuesDo{|key,  colour|
+			Pen.fillColor = Color.fromArray((colour * 0.25 + 0.5 ).clip(0,1) ++ 1);
+			Pen.fillRect( Rect( (key.asFloat * 20 + 10), (~labeldict2["data"].at(key).asInteger[0] * 20 + 10),15,15));
+		};
+	};
+};
+w.refresh;
+w.front;
+)
+
+//now let's normalise instead
+(
+~norm.fitTransform(~sourceR, ~scaledR, {
+	~norm.fitTransform(~sourceG, ~scaledG, {
+		~norm.fitTransform(~sourceB, ~scaledB, {
+			//assemble
+			~query.addColumn(0, {
+				~query.transformJoin(~scaledB, ~scaledG, ~composited, {
+					~query.transformJoin(~scaledR, ~composited, ~composited, {
+						//fit
+						~classifier.fitPredict(~composited,~labels,{~labels.dump{|x|~labeldict2 = x;};~composited.dump{|x|~compodict2=x;};});
+					});
+				});
+			});
+		});
+	});
+});
+)
+
+//Visualise:
+(
+w = Window("normClasses", Rect(128, 344, 820, 120));
+w.drawFunc = {
+	Pen.use{
+		~compodict2["data"].keysValuesDo{|key,  colour|
+			Pen.fillColor = Color.fromArray((colour * 0.25 + 0.5 ).clip(0,1) ++ 1);
+			Pen.fillRect( Rect( (key.asFloat * 20 + 10), (~labeldict2["data"].at(key).asInteger[0] * 20 + 10),15,15));
+		};
+	};
+};
+w.refresh;
+w.front;
+)
+
+// let's mess up with the scaling of one dimension: let's multiply the range of Red by 10
+~norm.min = -10;
+~norm.max = 10;
+(
+~norm.fitTransform(~sourceR, ~scaledR, {
+	//assemble
+	~query.addColumn(0, {
+		~query.transformJoin(~scaledB, ~scaledG, ~composited, {
+			~query.transformJoin(~scaledR, ~composited, ~composited, {
+				//fit
+				~classifier.fitPredict(~composited,~labels,{~labels.dump{|x|~labeldict2 = x;};~composited.dump{|x|~compodict2=x;};});
+			});
+		});
+	});
+});
+)
+
+//Visualise:
+(
+w = Window("norm10rClasses", Rect(128, 484, 820, 120));
+w.drawFunc = {
+	Pen.use{
+		~compodict2["data"].keysValuesDo{|key,  colour|
+			Pen.fillColor = Color.fromArray((colour * 0.25 + 0.5 ).clip(0,1) ++ 1);
+			Pen.fillRect( Rect( (key.asFloat * 20 + 10), (~labeldict2["data"].at(key).asInteger[0] * 20 + 10),15,15));
+		};
+	};
+};
+w.refresh;
+w.front;
+)
diff --git a/release-packaging/Examples/segmenting/nb_of_slices.scd b/release-packaging/Examples/segmenting/nb_of_slices.scd
index c30174e..83f27d6 100644
--- a/release-packaging/Examples/segmenting/nb_of_slices.scd
+++ b/release-packaging/Examples/segmenting/nb_of_slices.scd
@@ -7,6 +7,7 @@ c = Buffer.new(s);
 // with basic params
 Routine{
 	var startTime, target, tolerance, startThresh, prevThresh, curThresh, curVal, prevVal, iters, maxIters, dVal, dThresh;
+
 	startTime = Main.elapsedTime;
 	prevThresh = 0.1; //initial threshold (between 0.00001 and 0.99999
 	target = 10; //number of slices desired
@@ -14,14 +15,17 @@ Routine{
 	maxIters = 100; //max number of iterations acceptable
 
 	//makes a first iteration
-	FluidBufNoveltySlice.process(s,b, indices: c, threshold:prevThresh,action:{|x|prevVal = x.numFrames});
+	FluidBufNoveltySlice.process(s,b, indices: c, threshold:prevThresh).wait;
+	prevVal = c.numFrames;
+
 	//makes a second iteration
 	if ( (prevVal <  target), {
 		curThresh = (prevThresh * 0.5).max(0.000001);
 	}, {
 		curThresh = (prevThresh * 2).min(0.999999);
 	});
-	FluidBufNoveltySlice.process(s,b, indices: c, threshold:curThresh,action:{|x|curVal = x.numFrames});
+	FluidBufNoveltySlice.process(s,b, indices: c, threshold:curThresh).wait;
+	curVal = c.numFrames;
 
 	//makes further iterations until the result is achieved, or the maximum of acceptable iterations is reached
 	iters = 2;
@@ -42,7 +46,8 @@ Routine{
 			//if we have
 			curThresh = (((dThresh / dVal) * (target - curVal)) + curThresh).min(0.999999).max(0.000001);
 		});
-		FluidBufNoveltySlice.process(s,b, indices: c, threshold:curThresh,action:{|x|curVal = x.numFrames});
+		FluidBufNoveltySlice.process(s,b, indices: c, threshold:curThresh).wait;
+		curVal = c.numFrames;
 	}
 	);
 	//depending on the outcome, gives the right info back
diff --git a/release-packaging/HelpSource/Classes/FluidAmpGate.schelp b/release-packaging/HelpSource/Classes/FluidAmpGate.schelp
index 880a960..2f61f63 100644
--- a/release-packaging/HelpSource/Classes/FluidAmpGate.schelp
+++ b/release-packaging/HelpSource/Classes/FluidAmpGate.schelp
@@ -19,16 +19,16 @@ ARGUMENT:: in
 	The audio to be processed.
 
 ARGUMENT:: rampUp
-	The number of samples the absolute envelope follower will take to reach the next value when raising.
+	The number of samples the envelope follower will take to reach the next value when raising.
 
 ARGUMENT:: rampDown
-	The number of samples the absolute envelope follower will take to reach the next value when falling.
+	The number of samples the envelope follower will take to reach the next value when falling.
 
 ARGUMENT:: onThreshold
-	The threshold in dB of the absolute envelope follower to trigger an onset, aka to go ON when in OFF state.
+	The threshold in dB of the envelope follower to trigger an onset, aka to go ON when in OFF state.
 
 ARGUMENT:: offThreshold
-	The threshold in dB of the absolute envelope follower to trigger an offset, , aka to go ON when in OFF state.
+	The threshold in dB of the envelope follower to trigger an offset, , aka to go ON when in OFF state.
 
 ARGUMENT:: minSliceLength
 	The length in samples that the Slice will stay ON. Changes of states during that period will be ignored.
@@ -37,10 +37,10 @@ ARGUMENT:: minSilenceLength
 	The length in samples that the Slice will stay OFF. Changes of states during that period will be ignored.
 
 ARGUMENT:: minLengthAbove
-	The length in samples that the absolute envelope have to be above the threshold to consider it a valid transition to ON. The Slice will start at the first sample when the condition is met. Therefore, this affects the latency.
+	The length in samples that the envelope have to be above the threshold to consider it a valid transition to ON. The Slice will start at the first sample when the condition is met. Therefore, this affects the latency.
 
 ARGUMENT:: minLengthBelow
-	The length in samples that the absolute envelope have to be below the threshold to consider it a valid transition to OFF. The Slice will end at the first sample when the condition is met. Therefore, this affects the latency.
+	The length in samples that the envelope have to be below the threshold to consider it a valid transition to OFF. The Slice will end at the first sample when the condition is met. Therefore, this affects the latency.
 
 ARGUMENT:: lookBack
 	The length of the buffer kept before an onset to allow the algorithm, once a new Slice is detected, to go back in time (up to that many samples) to find the minimum amplitude as the Slice onset point. This affects the latency of the algorithm.
@@ -49,7 +49,7 @@ ARGUMENT:: lookAhead
 	The length of the buffer kept after an offset to allow the algorithm, once the Slice is considered finished, to wait further in time (up to that many samples) to find a minimum amplitude as the Slice offset point. This affects the latency of the algorithm.
 
 ARGUMENT:: highPassFreq
-	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths.
+	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths. A frequency of 0 bypasses the filter.
 
 ARGUMENT:: maxSize
 	How large can the buffer be for time-critical conditions, by allocating memory at instantiation time. This cannot be modulated.
@@ -60,63 +60,63 @@ RETURNS::
 EXAMPLES::
 
 code::
-//basic tests: absThresh sanity
+//basic tests: threshold sanity
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12);
 	[source, env]
 }.plot(0.1);
 )
-//basic tests: absThresh hysteresis
+//basic tests: threshold hysteresis
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -16);
 	[source, env]
 }.plot(0.1);
 )
-//basic tests: absThresh min slice
+//basic tests: threshold min slice
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minSliceLength:441);
 	[source, env]
 }.plot(0.1);
 )
-//basic tests: absThresh min silence
+//basic tests: threshold min silence
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minSilenceLength:441);
 	[source, env]
 }.plot(0.1);
 )
-//mid tests: absThresh time hysteresis on
+//mid tests: threshold time hysteresis on
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minLengthAbove:441);
 	[DelayN.ar(source,0.1,441/44100), env]
 }.plot(0.1);
 )
-//mid tests: absThresh time hysteresis off
+//mid tests: threshold time hysteresis off
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minLengthBelow:441);
 	[DelayN.ar(source,0.1,441/44100), env]
 }.plot(0.1);
 )
-//mid tests: absThresh with lookBack
+//mid tests: threshold with lookBack
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookBack:441);
 	[DelayN.ar(source,0.1,441/44100), env]
 }.plot(0.1);
 )
-//mid tests: absThresh with lookAhead
+//mid tests: threshold with lookAhead
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookAhead:441);
 	[DelayN.ar(source,0.1,441/44100), env]
 }.plot(0.1);
 )
-//mid tests: absThresh with asymetrical lookBack and lookAhead
+//mid tests: threshold with asymetrical lookBack and lookAhead
 (
 {var env, source = SinOsc.ar(320,0,LFTri.ar(10).abs);
 	env = FluidAmpGate.ar(source, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookBack:221, lookAhead:441);
@@ -129,7 +129,7 @@ b = Buffer.read(s,File.realpath(FluidAmpGate.class.filenameSymbol).dirname.withT
 //have fun with a gate (explore lookahead and lookback, but correct for latency, which will be the greatest of the lookahead and lookback)
 (
 {var env, source = PlayBuf.ar(1,b);
-	env = FluidAmpGate.ar(source, rampUp:441, rampDown:2205, onThreshold:-27, offThreshold: -31, minSilenceLength:1100, lookBack:441, highPassFreq:20);
+	env = FluidAmpGate.ar(source, rampUp:441, rampDown:2205, onThreshold:-27, offThreshold: -31, minSilenceLength:4410, lookBack:441, highPassFreq:20);
 	[DelayN.ar(source,delaytime:441/44100), env]
 }.plot(2, separately:true);
 )
diff --git a/release-packaging/HelpSource/Classes/FluidAmpSlice.schelp b/release-packaging/HelpSource/Classes/FluidAmpSlice.schelp
index 72d87e8..e22dac7 100644
--- a/release-packaging/HelpSource/Classes/FluidAmpSlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidAmpSlice.schelp
@@ -43,7 +43,7 @@ ARGUMENT:: minSliceLength
 	The length in samples that the Slice will stay ON. Changes of states during that period will be ignored.
 
 ARGUMENT:: highPassFreq
-	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths.
+	The frequency of the fourth-order link::https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter##Linkwitz–Riley high-pass filter::. This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths. A frequency of 0 bypasses the filter.
 
 RETURNS::
 	An audio stream with square envelopes around the slices. The latency between the input and the output is dependant on the relation between the two envelope followers.
@@ -54,7 +54,8 @@ code::
 // detrending explained
 // Our source here is a sinewave that does not go to silence and has sharp-ish amplitude bumps as onsets we try to track
 (
-{var env, source = SinOsc.ar(320,0,LFSaw.ar(20, 0, -0.4, 0.6));
+{
+            var env, source = SinOsc.ar(320,0,LFSaw.ar(20, 0, -0.4, 0.6));
 	env = FluidAmpSlice.ar(source,fastRampUp: 5,fastRampDown: 50,slowRampUp: 220,slowRampDown: 220, onThreshold: 10, offThreshold: 10,floor: -60);
 	[source, env]
 }.plot(0.08);
@@ -69,7 +70,7 @@ code::
 // another solution: minslicelength
 (
 {var env, source = SinOsc.ar(320,0,LFSaw.ar(20, 0, -0.4, 0.6));
-	env = FluidAmpSlice.ar(source,fastRampUp: 5,fastRampDown: 50,slowRampUp: 220,slowRampDown: 220, onThreshold: 10, offThreshold: 7,floor: -60, minSliceLength: 220);
+	env = FluidAmpSlice.ar(source,fastRampUp: 5,fastRampDown: 50,slowRampUp: 220,slowRampDown: 220, onThreshold: 10, offThreshold: 7,floor: -60, minSliceLength: 441);
 	[source, env]
 }.plot(0.08);
 )
diff --git a/release-packaging/HelpSource/Classes/FluidAudioTransport.schelp b/release-packaging/HelpSource/Classes/FluidAudioTransport.schelp
new file mode 100644
index 0000000..aa8a147
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidAudioTransport.schelp
@@ -0,0 +1,68 @@
+TITLE:: FluidAudioTransport
+summary:: Interpolate between sounds
+categories:: FluidManipulation
+related:: Classes/FluidBufAudioTransport
+
+DESCRIPTION::
+Interpolates between the spectra of two sounds using the Optimal Transport algorithm
+
+See
+Henderson and Solomonm (2019) AUDIO TRANSPORT: A GENERALIZED PORTAMENTO VIA OPTIMAL TRANSPORT, DaFx
+
+
+CLASSMETHODS::
+
+METHOD:: ar
+Process incoming audio signals
+
+ARGUMENT:: in
+Source A
+
+ARGUMENT:: in2
+Source B
+
+ARGUMENT:: interpolation
+The amount to interpolate between A and B (0-1, 0 = A, 1 = B)
+
+ARGUMENT:: windowSize
+	The window size in samples. As AudioTransport relies on spectral frames, we need to decide what precision we give it spectrally and temporally, in line with Gabor Uncertainty principles. http://www.subsurfwiki.org/wiki/Gabor_uncertainty
+
+ARGUMENT:: hopSize
+	The window hop size in samples. As AudioTransport relies on spectral frames, we need to move the window forward. It can be any size but low overlap may create audible artefacts. The -1 default value will default to half of windowSize (overlap of 2).
+
+ARGUMENT:: fftSize
+	The inner FFT/IFFT size. It should be at least 4 samples long; at least the size of the window; and a power of 2. Making it larger than the window size provides interpolation in frequency. The -1 default value will use the next power of 2 equal or above the windowSize.
+
+  ARGUMENT:: maxFFTSize
+  	How large can the FFT be, by allocating memory at instantiation time. This cannot be modulated.
+
+RETURNS::
+    	An audio stream with the interpolated spectrum of the inputs.
+EXAMPLES::
+
+code::
+//didactic - the mouse X axis interpolates between the two sinewaves
+{FluidAudioTransport.ar(SinOsc.ar(220,mul: 0.1),SinOsc.ar(440,mul: 0.02),MouseX.kr())}.play;
+
+//notice how the interpolation quantizes to the FFT bins. Like most spectral processes, it benefits from oversampling the fft... at the cost of  CPU power, obviously.
+{FluidAudioTransport.ar(SinOsc.ar(220,mul: 0.1),SinOsc.ar(440,mul: 0.02),MouseX.kr(),fftSize: 8192)}.play;
+
+// when the signal is steady, larger hopSize can be accommodated to save back on the CPU
+{FluidAudioTransport.ar(SinOsc.ar(220,mul: 0.1),SinOsc.ar(440,mul: 0.02),MouseX.kr(),windowSize: 8192)}.play; // here we get a default hop of half the window so 8 times less than above.
+
+//if you CPU can cope, try this setting, almost smooth, but attacks would smear (the Y axis mixes some in to hear the effect)
+{var attacks = Impulse.ar(1,mul: MouseY.kr(-40,10).dbamp); FluidAudioTransport.ar(SinOsc.ar(220,mul: 0.1,add: attacks),SinOsc.ar(440,mul: 0.02,add: attacks),MouseX.kr(),windowSize: 16000)}.play;
+
+//richer with complex spectra
+//load 2 files
+(
+b = Buffer.read(s,File.realpath(FluidAudioTransport.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Tremblay-CEL-GlitchyMusicBoxMelo.wav");
+c = Buffer.read(s,File.realpath(FluidAudioTransport.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Tremblay-CF-ChurchBells.wav");
+)
+//listen to them
+b.play
+c.play
+//stereo cross!
+{FluidAudioTransport.ar(PlayBuf.ar(2,b,loop: 1),PlayBuf.ar(2,c,loop: 1),MouseX.kr())}.play;
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufAmpGate.schelp b/release-packaging/HelpSource/Classes/FluidBufAmpGate.schelp
index 438208a..c654ee6 100644
--- a/release-packaging/HelpSource/Classes/FluidBufAmpGate.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufAmpGate.schelp
@@ -16,121 +16,122 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
-	This is the method that calls for the slicing to be calculated on a given source buffer.
+METHOD:: process, processBlocking
+This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
-	The server on which the buffers to be processed are allocated.
+The server on which the buffers to be processed are allocated.
 
 ARGUMENT:: source
-	The index of the buffer to use as the source material to be sliced through novelty identification. The different channels of multichannel buffers will be summed.
+The index of the buffer to use as the source material to be sliced through novelty identification. The different channels of multichannel buffers will be summed.
 
 ARGUMENT:: startFrame
-	Where in the srcBuf should the slicing process start, in sample.
+Where in the srcBuf should the slicing process start, in sample.
 
 ARGUMENT:: numFrames
-	How many frames should be processed.
+How many frames should be processed.
 
 ARGUMENT:: startChan
-	For multichannel sources, which channel should be processed.
+For multichannel sources, which channel should be processed.
 
 ARGUMENT:: numChans
-	For multichannel sources, how many channel should be summed.
+For multichannel sources, how many channel should be summed.
 
 ARGUMENT:: indices
-	The index of the buffer where the indices (in sample) of the estimated starting points of slices will be written. The first and last points are always the boundary points of the analysis.
+The index of the buffer where the indices (in sample) of the estimated starting points of slices will be written. The first and last points are always the boundary points of the analysis.
 
 ARGUMENT:: rampUp
-	The number of samples the absolute envelope follower will take to reach the next value when raising.
+The number of samples the envelope follower will take to reach the next value when raising.
 
 ARGUMENT:: rampDown
-	The number of samples the absolute envelope follower will take to reach the next value when falling.
+The number of samples the envelope follower will take to reach the next value when falling.
 
 ARGUMENT:: onThreshold
-	The threshold in dB of the absolute envelope follower to trigger an onset, aka to go ON when in OFF state.
+The threshold in dB of the envelope follower to trigger an onset, aka to go ON when in OFF state.
 
 ARGUMENT:: offThreshold
-	The threshold in dB of the absolute envelope follower to trigger an offset, , aka to go ON when in OFF state.
+The threshold in dB of the envelope follower to trigger an offset, , aka to go ON when in OFF state.
 
 ARGUMENT:: minSliceLength
-	The length in samples that the Slice will stay ON. Changes of states during that period will be ignored.
+The length in samples that the Slice will stay ON. Changes of states during that period will be ignored.
 
 ARGUMENT:: minSilenceLength
-	The length in samples that the Slice will stay OFF. Changes of states during that period will be ignored.
+The length in samples that the Slice will stay OFF. Changes of states during that period will be ignored.
 
 ARGUMENT:: minLengthAbove
-	The length in samples that the absolute envelope have to be above the threshold to consider it a valid transition to ON. The Slice will start at the first sample when the condition is met. Therefore, this affects the latency.
+The length in samples that the envelope have to be above the threshold to consider it a valid transition to ON. The Slice will start at the first sample when the condition is met. Therefore, this affects the latency.
 
 ARGUMENT:: minLengthBelow
-	The length in samples that the absolute envelope have to be below the threshold to consider it a valid transition to OFF. The Slice will end at the first sample when the condition is met. Therefore, this affects the latency.
+The length in samples that the envelope have to be below the threshold to consider it a valid transition to OFF. The Slice will end at the first sample when the condition is met. Therefore, this affects the latency.
 
 ARGUMENT:: lookBack
-	The length of the buffer kept before an onset to allow the algorithm, once a new Slice is detected, to go back in time (up to that many samples) to find the minimum amplitude as the Slice onset point. This affects the latency of the algorithm.
+The length of the buffer kept before an onset to allow the algorithm, once a new Slice is detected, to go back in time (up to that many samples) to find the minimum amplitude as the Slice onset point. This affects the latency of the algorithm.
 
 ARGUMENT:: lookAhead
-	The length of the buffer kept after an offset to allow the algorithm, once the Slice is considered finished, to wait further in time (up to that many samples) to find a minimum amplitude as the Slice offset point. This affects the latency of the algorithm.
+The length of the buffer kept after an offset to allow the algorithm, once the Slice is considered finished, to wait further in time (up to that many samples) to find a minimum amplitude as the Slice offset point. This affects the latency of the algorithm.
 
 ARGUMENT:: highPassFreq
-	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths.
+The frequency of the fourth-order link::https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter##Linkwitz–Riley high-pass filter::. This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths. A frequency of 0 bypasses the filter.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
 
 ARGUMENT:: action
-	A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The metric will be passed indices as an argument.
+A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The metric will be passed indices as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
 code::
 // define a test signal and a destination buffer
 (
-b = Buffer.sendCollection(s, Array.fill(44100,{|i| sin(i*pi/ (44100/640)) * (sin(i*pi/ 22050)).abs}));
-c = Buffer.new(s);
+    b = Buffer.sendCollection(s, Array.fill(44100,{|i| sin(i*pi/ (44100/640)) * (sin(i*pi/ 22050)).abs}));
+    c = Buffer.new(s);
 )
 b.play
 b.plot
-
-//basic tests: absThresh sanity
+//basic tests: threshold sanity
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//basic tests: absThresh hysteresis
+//basic tests: threshold hysteresis
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -16)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//basic tests: absThresh min slice
+//basic tests: threshold min slice
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minSliceLength:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//basic tests: absThresh min silence
+//basic tests: threshold min silence
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minSilenceLength:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//mid tests: absThresh time hysteresis on
+//mid tests: threshold time hysteresis on
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minLengthAbove:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//mid tests: absThresh time hysteresis off
+//mid tests: threshold time hysteresis off
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, minLengthBelow:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//mid tests: absThresh with lookBack
+//mid tests: threshold with lookBack
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookBack:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//mid tests: absThresh with lookAhead
+//mid tests: threshold with lookAhead
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookAhead:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
 
-//mid tests: absThresh with asymetrical lookBack and lookAhead
+//mid tests: threshold with asymetrical lookBack and lookAhead
 FluidBufAmpGate.process(s, b, indices:c, rampUp:5, rampDown:25, onThreshold:-12, offThreshold: -12, lookBack:221, lookAhead:441)
 c.query
 c.getn(0,c.numFrames*2,{|item|item.postln;})
@@ -140,30 +141,33 @@ STRONG::A musical example.::
 CODE::
 //load a buffer
 (
-b = Buffer.read(s,File.realpath(FluidBufAmpGate.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
-c = Buffer.new(s);
+    b = Buffer.read(s, File.realpath(FluidBufAmpGate.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
+    c = Buffer.new(s);
 )
 
 // slice the samples
-FluidBufAmpGate.process(s, b, indices:c, rampUp:110, rampDown:2205, onThreshold:-27, offThreshold: -31, minSilenceLength:1100, lookBack:441, highPassFreq:40)
-c.query
-c.getn(0,c.numFrames*2,{|item|item.postln;})
-//reformatting to read the onsets and offsets as pairs
-c.getn(0,c.numFrames*2,{|items|items.reshape(c.numFrames,2).do({|x| x.postln});})
-
+(
+Routine{
+    FluidBufAmpGate.process(s, b, indices:c, rampUp:110, rampDown:2205, onThreshold:-27, offThreshold: -31, minSilenceLength:1100, lookBack:441, highPassFreq:40).wait;
+    c.query;
+    c.getn(0,c.numFrames*2,{|item|item.postln;});
+    //reformatting to read the onsets and offsets as pairs
+    c.getn(0,c.numFrames*2,{|items|items.reshape(c.numFrames,2).do({|x| x.postln});});
+}.play
+)
 //loops over a splice with the MouseX, taking the respective onset and offset of a given slice
 (
-{
-	BufRd.ar(1, b,
-		Phasor.ar(0,1,
-			BufRd.kr(2, c,
-				MouseX.kr(0, BufFrames.kr(c)), 0, 1)[0],
-			BufRd.kr(2, c,
-				MouseX.kr(1, BufFrames.kr(c)), 0, 1)[1],
-			BufRd.kr(2,c,
-				MouseX.kr(0, BufFrames.kr(c)), 0, 1)[0]
-	), 0, 1);
-}.play;
+    {
+        BufRd.ar(1, b,
+            Phasor.ar(0,1,
+                BufRd.kr(2, c,
+                    MouseX.kr(0, BufFrames.kr(c)), 0, 1)[0],
+                BufRd.kr(2, c,
+                    MouseX.kr(1, BufFrames.kr(c)), 0, 1)[1],
+                BufRd.kr(2,c,
+                    MouseX.kr(0, BufFrames.kr(c)), 0, 1)[0]
+        ), 0, 1);
+    }.play;
 )
 ::
 
@@ -178,15 +182,15 @@ b.play
 
 // create a new buffer as destinations
 c = Buffer.new(s);
-
 //run the process on them
 (
-// with basic params
-Routine{
-	t = Main.elapsedTime;
-	FluidBufAmpGate.process(s, b, indices: c, rampUp:1, rampDown:10, onThreshold: -30);
-	(Main.elapsedTime - t).postln;
-}.play
+    // with basic params
+    Routine{
+        var t = Main.elapsedTime;
+        var proc= FluidBufAmpGate.process(s, b, indices: c, rampUp:1, rampDown:10, onThreshold: -30);
+        proc.wait;
+        (Main.elapsedTime - t).postln;
+    }.play
 )
 
 // list the indicies of detected attacks - the two input channels have been summed. The two channels of the output, respectively onset and offset indices, are interleaved as this is the SuperCollider buffer data formatting
diff --git a/release-packaging/HelpSource/Classes/FluidBufAmpSlice.schelp b/release-packaging/HelpSource/Classes/FluidBufAmpSlice.schelp
index 1cdf44b..0dcca74 100644
--- a/release-packaging/HelpSource/Classes/FluidBufAmpSlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufAmpSlice.schelp
@@ -16,7 +16,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -65,13 +65,15 @@ ARGUMENT:: minSliceLength
 	The length in samples that the Slice will stay ON. Changes of states during that period will be ignored.
 
 ARGUMENT:: highPassFreq
-	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths.
+	The frequency of the fourth-order Linkwitz–Riley high-pass filter (https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter). This is done first on the signal to minimise low frequency intermodulation with very fast ramp lengths. A frequency of 0 bypasses the filter.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
 
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The metric will be passed indices as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -86,7 +88,7 @@ c = Buffer.new(s);
 b.play
 b.plot
 
-//
+//process with symmetrical thresholds
 FluidBufAmpSlice.process(s, b,indices: c,fastRampUp: 5,fastRampDown: 50,slowRampUp: 220,slowRampDown: 220, onThreshold: 10, offThreshold: 10,floor: -60);
 c.query
 c.getn(0,c.numFrames,{|item|item.postln;})
@@ -115,7 +117,7 @@ FluidBufAmpSlice.process(s,b,indices:c,fastRampUp: 10,fastRampDown: 2205,slowRam
 c.query
 c.getn(0,c.numFrames,{|item|item.postln;})
 
-//loops over a splice with the MouseX, taking the respective onset and offset of a given slice
+//loops over a splice with the MouseX
 (
 {
     BufRd.ar(1, b,
@@ -144,12 +146,14 @@ c = Buffer.new(s);
 
 //run the process on them
 (
-// with basic params
-Routine{
-	t = Main.elapsedTime;
-	FluidBufAmpSlice.process(s,b, indices: c, fastRampUp: 10,fastRampDown: 2205,slowRampUp: 4410,slowRampDown: 4410, onThreshold: 10,offThreshold: 5);
-	(Main.elapsedTime - t).postln;
-}.play
+	// with basic params
+	Routine{
+		var t = Main.elapsedTime;
+		var proc = FluidBufAmpSlice.process(s,b, indices: c, fastRampUp: 10,fastRampDown: 2205,slowRampUp: 4410,slowRampDown: 4410, onThreshold: 10,offThreshold: 5);
+		proc.wait;
+		c.query;
+		(Main.elapsedTime - t).postln;
+	}.play
 )
 
 // list the indicies of detected attacks - the two input channels have been summed.
diff --git a/release-packaging/HelpSource/Classes/FluidBufAudioTransport.schelp b/release-packaging/HelpSource/Classes/FluidBufAudioTransport.schelp
new file mode 100644
index 0000000..102e6ee
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufAudioTransport.schelp
@@ -0,0 +1,111 @@
+TITLE:: FluidBufAudioTransport
+summary:: Interpolate between buffers
+categories:: FluidManipulation
+related:: Classes/FluidAudioTransport
+
+DESCRIPTION::
+Interpolates between the spectra of two sounds using the Optimal Transport algorithm
+
+See
+Henderson and Solomonm (2019) AUDIO TRANSPORT: A GENERALIZED PORTAMENTO VIA OPTIMAL TRANSPORT, DaFx
+
+CLASSMETHODS::
+
+METHOD:: process, processBlocking
+Process two audio link::Classes/Buffer::
+
+ARGUMENT:: server
+The server the process runs on
+
+ARGUMENT:: source1
+The first source buffer
+
+ARGUMENT:: startFrame1
+offset into the first source buffer (samples)
+
+ARGUMENT:: numFrames1
+number of samples to use from first source buffer
+
+ARGUMENT:: startChan1
+starting channel of first source buffer
+
+ARGUMENT:: numChans1
+number of channels to process in first source buffer
+
+ARGUMENT:: source2
+the second source buffer
+
+ARGUMENT:: startFrame2
+offset into the second source buffer (samples)
+
+ARGUMENT:: numFrames2
+number of samples to process from second buffer
+
+ARGUMENT:: startChan2
+starting channel for second buffer
+
+ARGUMENT:: numChans2
+number of channels to process in second buffer
+
+ARGUMENT:: destination
+buffer for interpolated audio
+
+ARGUMENT:: interpolation
+The amount to interpolate between A and B (0-1, 0 = A, 1 = B)
+
+ARGUMENT:: windowSize
+	The window size. As spectral differencing relies on spectral frames, we need to decide what precision we give it spectrally and temporally, in line with Gabor Uncertainty principles. http://www.subsurfwiki.org/wiki/Gabor_uncertainty
+
+ARGUMENT:: hopSize
+	The window hop size. As sinusoidal estimation relies on spectral frames, we need to move the window forward. It can be any size but low overlap will create audible artefacts. The -1 default value will default to half of windowSize (overlap of 2).
+
+ARGUMENT:: fftSize
+	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the highest of windowSize and (bandwidth - 1) * 2.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [destination] as an argument.
+
+INSTANCEMETHODS::
+
+private:: synth, server
+
+EXAMPLES::
+
+code::
+//Didactic:
+//Make 2 sinewave sources to be interpolated
+(
+b = Buffer.loadCollection(s, FloatArray.fill(44100, {|a|(a / pi).sin * 0.1}));
+c = Buffer.loadCollection(s, FloatArray.fill(44100, {|a|(a / pi / 2).sin * 0.02}));
+d = Buffer.new
+)
+
+//make an sound interpolating their spectrum
+FluidBufAudioTransport.process(s,b,source2:c,destination:d,interpolation:0.5,action:{"Ding".postln})
+
+// listen to the source and the result
+b.play
+c.play
+d.play
+
+// note that the process is quantized by the spectral bins. For an example of the pros and cons of these settings on this given process, please see the real-time FluidAudioTransport helpfile.
+
+// more interesting sources: two cardboard bowing gestures
+(
+b = Buffer.read(s,File.realpath(FluidBufAudioTransport.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Green-Box641.wav");
+c = Buffer.read(s,File.realpath(FluidBufAudioTransport.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Green-Box639.wav");
+d = Buffer.new
+)
+
+// listen to the source
+b.play
+c.play
+
+// process and listen
+FluidBufAudioTransport.process(s,b,source2:c,destination:d,interpolation:0.5,action:{"Ding".postln})
+d.play
+// try various interpolation factors (0.1 and 0.9 are quite good
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufCompose.schelp b/release-packaging/HelpSource/Classes/FluidBufCompose.schelp
index 5c2b323..d9c2f2c 100644
--- a/release-packaging/HelpSource/Classes/FluidBufCompose.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufCompose.schelp
@@ -12,7 +12,7 @@ The algorithm takes a srcBuf, and writes the information at the provided dstBuf.
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This method triggers the compositing.
 
 ARGUMENT:: server
@@ -48,11 +48,13 @@ ARGUMENT:: destStartChan
 ARGUMENT:: destGain
 	The gain applied to the samples in the region of the destination buffer over which the source is to be copied. The default value (0) will overwrite that section of the destination buffer, and a value of 1.0 would sum the source to the material that was present.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 		A Function to be evaluated once the offline process has finished and destination instance variables have been updated on the client side. The function will be passed destination as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 DISCUSSION::
 	It is important to understand the rules used for determining the final desintinaiton buffer dimensions to get the most out of this object. If needs be, the destination buffer will be resized to the maxima of the requsted source numFrames and numChannels. Frames will be written up to the limit of actually available samples (meaning you can create zero padding); channels  will be written modulo the available channels, taking into account the channel offsets, meaning you can have channels repeat or loop into the source buffer's channels. See the examples below.
@@ -68,29 +70,43 @@ d = Buffer.new(s);
 )
 
 // with basic params (basic summing of each full buffer in all dimensions)
-FluidBufCompose.process(s, source: b,  destination: d);
-FluidBufCompose.process(s, source: c,  destination: d, destGain: 1.0);
-d.query;
-d.play;
-
+(
+Routine{
+    FluidBufCompose.process(s, source: b,  destination: d);
+    FluidBufCompose.process(s, source: c,  destination: d, destGain: 1.0);
+	s.sync;
+    d.query;
+    d.play;
+}.play;
+)
 //constructing a mono buffer, with a quiet punch from the synth, with a choked piano resonance from the left channel
-d.free; d = Buffer.new(s);
-FluidBufCompose.process(s, source: b, numFrames: 9000, gain: 0.5, destination: d);
-FluidBufCompose.process(s, source: c, startFrame:30000, numFrames:44100, numChans:1, gain:0.9, destination: d, destGain: 1.0);
-d.query;
-d.play;
-
+(
+Routine{
+    d.free; d = Buffer.new(s);
+    FluidBufCompose.process(s, source: b, numFrames: 9000, gain: 0.5, destination: d);
+    FluidBufCompose.process(s, source: c, startFrame:30000, numFrames:44100, numChans:1, gain:0.9, destination: d, destGain: 1.0).wait;
+    d.query;
+    d.play;
+}.play
+)
 //constructing a stereo buffer, with the end of the mono synth in both channels, with a piano resonance in swapped stereo
-d.free; d = Buffer.new(s);
-FluidBufCompose.process(s, source: b, startFrame: 441000, numChans: 2, gain: 0.6, destination: d);
-FluidBufCompose.process(s, source: c, numFrames: 78000, startChan: 1, numChans: 2, gain: 0.5, destStartFrame: 22050, destination: d,  destGain: 1.0);
-d.query;
-d.play;
-
+(
+Routine{
+    d.free; d = Buffer.new(s);
+    FluidBufCompose.process(s, source: b, startFrame: 441000, numChans: 2, gain: 0.6, destination: d);
+    FluidBufCompose.process(s, source: c, numFrames: 78000, startChan: 1, numChans: 2, gain: 0.5, destStartFrame: 22050, destination: d,  destGain: 1.0).wait;
+    d.query;
+    d.play;
+}.play
+)
 //constructing a one second buffer: the first second of each buffer, the mono synth on the right, the piano on the left
-d.free; d = Buffer.new(s);
-FluidBufCompose.process(s, source: b, numFrames: 44100, numChans: 1, destStartChan: 1, destination: d);
-FluidBufCompose.process(s, source: c, numFrames:44100, numChans:1, destination: d,  destGain: 1.0);
-d.query;
-d.play;
+(
+Routine{
+    d.free; d = Buffer.new(s);
+    FluidBufCompose.process(s, source: b, numFrames: 44100, numChans: 1, destStartChan: 1, destination: d);
+    FluidBufCompose.process(s, source: c, numFrames:44100, numChans:1, destination: d,  destGain: 1.0).wait;
+    d.query;
+    d.play;
+}.play
+)
 ::
diff --git a/release-packaging/HelpSource/Classes/FluidBufFlatten.schelp b/release-packaging/HelpSource/Classes/FluidBufFlatten.schelp
new file mode 100644
index 0000000..dbe1c2b
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufFlatten.schelp
@@ -0,0 +1,120 @@
+TITLE:: FluidBufFlatten
+summary:: Flatten a multichannel buffer on the server
+categories:: FluidCorpusManipulation
+related:: Classes/Buffer, Classes/FluidBufCompose, Classes/FluidBufSelect, Classes/FluidBufSelectEvery
+
+DESCRIPTION::
+Flatten a multichannel link::Classes/Buffer:: to a single channel. This can be useful for constructing n-dimensional data points for use with link::Classes/FluidDataSet::
+
+The code::axis:: determines how the flattening is arranged. The default value, 1, flattens channel-wise, such that (if we imagine channels are rows, time positions are columns):
+
+table::
+    ## a 1 || a 2 || a 3
+    ## b 1 || b 2 || b 3
+    ## c 1 || c 2 || c 3
+::
+
+becomes
+
+table::
+##  a 1 || b 1 || c 1 || a 2 || b 2 || c 2 || a 3 || b 3 || c 3
+::
+
+whereas with code::axis = 0:: we get
+
+table::
+    ## a 1 || a 2 || a 3 || b 1 || b 2 || b 3 || c 1 || c 2 || c 3
+::
+
+
+CLASSMETHODS::
+
+private::new1
+
+METHOD:: process, processBlocking
+
+Run the process on the given sever, and perfrom code::action:: when done
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+
+ARGUMENT:: source
+The link::Classes/Buffer:: to flatten
+
+ARGUMENT:: startFrame
+	Where in the source should the flattening process start, in samples.
+
+ARGUMENT:: numFrames
+	How many frames should be processed.
+
+ARGUMENT:: startChan
+	For multichannel source buffers, which channel to start processing at.
+
+ARGUMENT:: numChans
+	For multichannel source buffers, how many channels should be processed.
+
+ARGUMENT:: destination
+The link::Classes/Buffer:: to write the flattened data to
+
+ARGUMENT:: axis
+Whether to group points channel-wise or frame-wise
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+Runs when processing is complete
+
+EXAMPLES::
+
+code::
+//FluidBufPitch is useful to illustrate the effect of this, because the pitch and confidence values are easily distinguishable
+
+(
+~path = File.realpath(FluidLoadFolder.class.filenameSymbol).dirname +/+ "../AudioFiles";
+~randomsoundfile = SoundFile.collect(~path +/+ '*').choose;
+b = Buffer.read(s,~randomsoundfile.path,action:{"Sound Loaded".postln});
+~pitchdata = Buffer.new;
+~flatdata = Buffer.new;
+)
+
+//Pitch analysis, writes pitches as frequencies to chan 0, confidences [0-1] to chan 1
+FluidBufPitch.process(s,b,numFrames:512 * 10,numChans:1,features:~pitchdata,action:{"Pitch Analysis Done".postln});
+
+// Flatten and print the flat buffer. We expect to see larger numbers (20-2000) interleaved with smaller (0-1)
+(
+FluidBufFlatten.process(s,~pitchdata, destination: ~flatdata, axis:1, action:{
+	~flatdata.loadToFloatArray(action:{ |a|
+		a.postln;
+	})
+})
+)
+
+//changing the axis, we see all large numbers first
+(
+FluidBufFlatten.process(s,~pitchdata, destination:~flatdata, axis:0, action:{
+	~flatdata.loadToFloatArray(action:{ |a|
+		a.postln;
+	})
+})
+)
+
+//adding the source range make this processor very powerful, but can be quite confusing
+//here we take only one frame starting at the second one (0-counting)
+(
+FluidBufFlatten.process(s,~pitchdata,startFrame: 1,numFrames: 1, destination:~flatdata, action:{
+	~flatdata.loadToFloatArray(action:{ |a|
+		a.postln;
+	})
+})
+)
+//and here we take only the confidences
+(
+FluidBufFlatten.process(s,~pitchdata, startChan: 1, destination:~flatdata, action:{
+	~flatdata.loadToFloatArray(action:{ |a|
+		a.postln;
+	})
+})
+)
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufHPSS.schelp b/release-packaging/HelpSource/Classes/FluidBufHPSS.schelp
index 711bf5b..c2b361c 100644
--- a/release-packaging/HelpSource/Classes/FluidBufHPSS.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufHPSS.schelp
@@ -24,7 +24,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 This is the method that calls for the HPSS to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -102,11 +102,13 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long; at least the size of the window; and a power of 2. Making it larger than the window size provides interpolation in frequency. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [harmonic, percussive, residual] as an argument.
 
-RETURNS::
-	Nothing, as the various destination buffers are declared in the function call.
+returns:: an instance of the processor
 
 Discussion::
 	HPSS works by using median filters on the spectral magnitudes of a sound. It hinges on a simple modelling assumption that tonal components will tend to yield concentrations of energy across time, spread out in frequency, and percussive components will manifest as concentrations of energy across frequency, spread out in time. By using median filters across time and frequency respectively, we get initial esitmates of the tonal-ness / transient-ness of a point in time and frequency. These are then combined into 'masks' that are applied to the orginal spectral data in order to produce a separation.
@@ -128,11 +130,12 @@ code::
 (
 	Routine{
 		t = Main.elapsedTime;
-		FluidBufHPSS.process(s, b, harmonic: c, percussive: d);
+		FluidBufHPSS.process(s, b, harmonic: c, percussive: d).wait;
 		(Main.elapsedTime - t).postln;
 	}.play
 )
-
+c.query
+d.query
 //play the harmonic
 c.play;
 //play the percussive
@@ -143,11 +146,12 @@ d.play;
 
 //more daring parameters, in mode 2
 (
-	Routine{
-		t = Main.elapsedTime;
-          FluidBufHPSS.process(s, b, harmonic: c, percussive: d, residual:e, harmFilterSize:31, maskingMode:2, harmThreshFreq1: 0.005, harmThreshAmp1: 7.5, harmThreshFreq2: 0.168, harmThreshAmp2: 7.5, percThreshFreq1: 0.004, percThreshAmp1: 26.5, percThreshFreq2: 0.152, percThreshAmp2: 26.5,windowSize:4096,hopSize:512);
-		(Main.elapsedTime - t).postln;
-	}.play
+Routine{
+    t = Main.elapsedTime;
+    FluidBufHPSS.process(s, b, harmonic: c, percussive: d, residual:e, harmFilterSize:31, maskingMode:2, harmThreshFreq1: 0.005, harmThreshAmp1: 7.5, harmThreshFreq2: 0.168, harmThreshAmp2: 7.5, percThreshFreq1: 0.004, percThreshAmp1: 26.5, percThreshFreq2: 0.152, percThreshAmp2: 26.5,windowSize:4096,hopSize:512)
+    .wait;
+    (Main.elapsedTime - t).postln;
+}.play
 )
 
 //play the harmonic
@@ -171,9 +175,12 @@ c = Buffer.read(s,File.realpath(FluidBufHPSS.class.filenameSymbol).dirname.withT
 )
 
 // composite one on left one on right as test signals
-FluidBufCompose.process(s, c, numFrames:b.numFrames, startFrame:555000,destStartChan:1, destination:b)
-b.play
-
+(
+Routine{
+    FluidBufCompose.process(s, c, numFrames:b.numFrames, startFrame:555000,destStartChan:1, destination:b).wait;
+    b.play
+}.play
+)
 // create 2 new buffers as destinations
 d = Buffer.new(s); e = Buffer.new(s);
 
@@ -181,7 +188,7 @@ d = Buffer.new(s); e = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufHPSS.process(s, b, harmonic: d, percussive:e);
+    FluidBufHPSS.process(s, b, harmonic: d, percussive:e).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufLoudness.schelp b/release-packaging/HelpSource/Classes/FluidBufLoudness.schelp
index be696d5..86651fd 100644
--- a/release-packaging/HelpSource/Classes/FluidBufLoudness.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufLoudness.schelp
@@ -15,7 +15,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the loudness descriptor to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -51,11 +51,16 @@ ARGUMENT:: windowSize
 ARGUMENT:: hopSize
 	How much the buffered window moves forward, in samples. By default 512 to be similar with all other FluCoMa objects, the EBU specifies other values as per the examples below.
 
+ARGUMENT:: padding
+	Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [features] as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -73,7 +78,7 @@ b.play; b.plot;
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufLoudness.process(s, source:b, features: c);
+	FluidBufLoudness.process(s, source:b, features: c).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -109,7 +114,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufLoudness.process(s, b, features: c, windowSize: 17640, hopSize:4410);
+    FluidBufLoudness.process(s, b, features: c, windowSize: 17640, hopSize:4410).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufMFCC.schelp b/release-packaging/HelpSource/Classes/FluidBufMFCC.schelp
index ec1f1bd..9bc9764 100644
--- a/release-packaging/HelpSource/Classes/FluidBufMFCC.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufMFCC.schelp
@@ -14,7 +14,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the spectral shape descriptors to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -59,11 +59,16 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: padding
+	Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+	Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [features] as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -78,7 +83,7 @@ c = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufMFCC.process(s, b, features: c);
+	FluidBufMFCC.process(s, b, features: c).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -108,7 +113,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufMFCC.process(s, b, numCoeffs:5, features: c);
+    FluidBufMFCC.process(s, b, numCoeffs:5, features: c).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufMelBands.schelp b/release-packaging/HelpSource/Classes/FluidBufMelBands.schelp
index da18154..9d15d33 100644
--- a/release-packaging/HelpSource/Classes/FluidBufMelBands.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufMelBands.schelp
@@ -15,7 +15,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the spectral shape descriptors to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -60,11 +60,16 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: padding
+	Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [features] as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -79,7 +84,7 @@ c = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufMelBands.process(s, b, features: c, numBands:10);
+	FluidBufMelBands.process(s, b, features: c, numBands:10).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -109,7 +114,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-	FluidBufMelBands.process(s, b, features: c, numBands:10);
+	FluidBufMelBands.process(s, b, features: c, numBands:10).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufNMF.schelp b/release-packaging/HelpSource/Classes/FluidBufNMF.schelp
index ba97ecb..cb00040 100644
--- a/release-packaging/HelpSource/Classes/FluidBufNMF.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufNMF.schelp
@@ -35,7 +35,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 This is the method that calls for the factorisation to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -102,11 +102,13 @@ ARGUMENT:: windowType
 ARGUMENT:: randomSeed
 	The NMF process needs to seed its starting point. If specified, the same values will be used. The default of -1 will randomly assign them. (not implemented yet)
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [resynth, bases, activations] as an argument.
 
-RETURNS::
-	Nothing, as the various destination buffers are declared in the function call.
+returns:: an instance of the processor
 
 
 EXAMPLES::
@@ -142,7 +144,7 @@ d.play //////(beware !!!! loud!!!)
 (
 // separate them in 2 components
 Routine {
-	FluidBufNMF.process(s, d, resynth:e, bases: f, activations:g, components:2);
+	FluidBufNMF.process(s, d, resynth:e, bases: f, activations:g, components:2).wait;
 	e.query;
 	f.query;
 	g.query;
@@ -173,22 +175,21 @@ y = Buffer.new(s);
 ~fft_size = 1024;
 ~frame_size = 512;
 ~hop_size = 256;
-~which_component = 3;
+~which_component = 4;
 )
 
 // matrix factorisation, requesting everything - wait for the computation time to appear.
 (
 Routine{
-	t = Main.elapsedTime;
-	FluidBufNMF.process(s,b, 0,-1,0,-1,c,x,0,y,0,5,100,~frame_size,~hop_size,~fft_size);
-	(Main.elapsedTime - t).postln;
+	var t = Main.elapsedTime;
+    FluidBufNMF.process(s,b, 0,-1,0,-1,c,x,0,y,0,5,100,~frame_size,~hop_size,~fft_size)
+    .wait;
+     (Main.elapsedTime - t).postln;
 }.play
 )
 
 //look at the resynthesised components, the bases and the activations
 c.plot; x.plot; y.plot;
-//null test of the sum of sources
-{(PlayBuf.ar(5,c,doneAction:2).sum)+(-1*PlayBuf.ar(1,b,doneAction:2))}.play
 
 // play the components spread in the stereo field
 {Splay.ar(PlayBuf.ar(5,c,doneAction:2))}.play
@@ -196,6 +197,9 @@ c.plot; x.plot; y.plot;
 //play a single source
 {PlayBuf.ar(5,c,doneAction:2)[~which_component].dup}.play
 
+//null test of the sum of sources
+{(PlayBuf.ar(5,c,doneAction:2).sum)+(-1*PlayBuf.ar(1,b,doneAction:2))}.play
+
 //play noise using one of the bases as filter.
 (
 {
@@ -251,7 +255,7 @@ b.play
 // train using the first 2 seconds of the sound file
 (
 Routine {
-	FluidBufNMF.process(s,b,0,44100*5,0,1, ~originalNMF, ~bases, components:10);
+	FluidBufNMF.process(s,b,0,44100*5,0,1, ~originalNMF, ~bases, components:10).wait;
 	~originalNMF.query;
 }.play;
 )
@@ -296,7 +300,7 @@ z.do({|chan| FluidBufCompose.process(s, ~bases, startChan:chan, numChans: 1, des
 //process the whole file, splitting it with the 2 trained bases
 (
 Routine{
-	FluidBufNMF.process(s, b, resynth: ~sortedNMF, bases: ~trainedBases, basesMode: 2, components:2);
+	FluidBufNMF.process(s, b, resynth: ~sortedNMF, bases: ~trainedBases, basesMode: 2, components:2).wait;
 	~originalNMF.query;
 }.play;
 )
@@ -354,7 +358,7 @@ e.query
 (
 // use the seeding basis, without updating
 Routine {
-	FluidBufNMF.process(s, d, resynth:f, bases: e, basesMode: 2, activations:g, components:3);
+	FluidBufNMF.process(s, d, resynth:f, bases: e, basesMode: 2, activations:g, components:3).wait;
 	e.query;
 	f.query;
 	g.query;
@@ -373,7 +377,7 @@ g.plot;
 (
 // use the seeding bases, with updating this time
 Routine {
-	FluidBufNMF.process(s, d, resynth:f, bases: e, basesMode: 1, activations:g, components:3);
+	FluidBufNMF.process(s, d, resynth:f, bases: e, basesMode: 1, activations:g, components:3).wait;
 	e.query;
 	f.query;
 	g.query;
diff --git a/release-packaging/HelpSource/Classes/FluidBufNMFCross.schelp b/release-packaging/HelpSource/Classes/FluidBufNMFCross.schelp
new file mode 100644
index 0000000..d5be65f
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufNMFCross.schelp
@@ -0,0 +1,77 @@
+TITLE:: FluidBufNMFCross
+summary:: Cross Synthesis with Nonnegative Matrix Factorization
+categories:: FluidManipulation
+related:: Classes/FluidBufNMF, Classes/FluidNMFMatch, Classes/FluidNMFFilter
+
+DESCRIPTION::
+
+Produces hybridisations of two link::Classes/Buffer::s by using Nonnegative Maxtrix Factorization (NMF)
+
+See Driedger, J., Prätzlich, T., & Müller, M. (2015). Let it Bee-Towards NMF-Inspired Audio Mosaicing. ISMIR, 350–356. http://ismir2015.uma.es/articles/13_Paper.pdf
+
+The process works by attempting to reconstruct the code::target:: sound using the timbre of the code::source:: sound, resulting in a hybrid whose character depends on how well the target can be represnted by the source's spectral frames.
+
+In contrast to link::Classes/FluidBufNMF::, the size and content of the bases dictionary are fixed in this application to be the spectrogram of the code::source::. Each spectral frame of code::source:: is a template: be aware that NMF is O(N^2) in the number of templates, so longer code::source:: buffers will take dramatically longer to process.
+
+
+CLASSMETHODS::
+
+private:: kr, new1
+
+METHOD:: process, processBlocking
+
+Process two buffers. code::process:: will use its own worker thread on the server, and so avoid blocking the command FIFO queue. For very small jobs, it may be quicker to use code::processBlocking::, which runs directly in the server's queue.
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to process
+
+ARGUMENT:: source
+A link::Classes/Buffer:: whose content will supply the spectral bases used in the hybrid
+
+ARGUMENT:: target
+A link::Classes/Buffer:: whose content will supply the temporal activations used in the hybrid
+
+ARGUMENT:: output
+A link::Classes/Buffer:: to contain the new sound
+
+ARGUMENT:: timeSparsity
+Control the repetition of source templates in the reconstruction by specifying a number of frames within which a template should not be re-used. Units are spectral frames.
+
+ARGUMENT:: polyphony
+Control the spectral density of the output sound by restricting the number of simultaneous templates that can be used. Units are spectral bins.
+
+ARGUMENT:: iterations
+How many iterations of NMF to run
+
+ARGUMENT:: windowSize
+The analysis window size in samples
+
+ARGUMENT:: hopSize
+The analysus hop size in samples (default winSize / 2)
+
+ARGUMENT:: fftSize
+The analsyis FFT size in samples (default = winSize)
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+A function to run when processing is complete, taking the output buffer as its argument
+
+returns:: an instance of the processor
+
+INSTANCEMETHODS::
+
+
+EXAMPLES::
+
+code::
+
+~path = File.realpath(FluidBufNMF.class.filenameSymbol).dirname.withTrailingSlash +/+ "../AudioFiles/"
+b = Buffer.read(s,~path+/+"Nicol-LoopE-M.wav")
+t = Buffer.read(s,~path+/+"Tremblay-SA-UprightPianoPedalWide.wav")
+o = Buffer.new
+FluidBufNMFCross.process(s,t,b,o,action:{"Ding".postln})
+//wait for it to be done. It is a long process.
+o.play
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufNNDSVD.schelp b/release-packaging/HelpSource/Classes/FluidBufNNDSVD.schelp
new file mode 100644
index 0000000..822e4a2
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufNNDSVD.schelp
@@ -0,0 +1,100 @@
+TITLE:: FluidBufNNDSVD
+summary:: Non-Negative Double Singular Value Decomposition on a Buffer
+categories:: FluidManipulation
+related:: Classes/FluidBufNMF
+
+DESCRIPTION::
+Find Initial Bases and Activations for FluidBufNMF via Non-Negative Double Singular Value Decomposition .
+
+See http://nimfa.biolab.si/nimfa.methods.seeding.nndsvd.html
+
+CLASSMETHODS::
+
+METHOD:: process, processBlocking
+This is the method that calls for the decomposition to be calculated on a given source buffer.
+
+ARGUMENT:: server
+The server on which the buffers to be processed are allocated.
+
+ARGUMENT:: source
+The index of the buffer to use as the source material to be decomposed through the NMF process. The different channels of multichannel buffers will be processing sequentially.
+
+ARGUMENT:: bases
+The index of the buffer where the different bases will be written to and/or read from: the behaviour is set in the following argument.
+
+ARGUMENT:: activations
+The index of the buffer where the different activations will be written to and/or read from: the behaviour is set in the following argument.
+
+ARGUMENT:: minComponents
+Minimum number of estimated components
+
+ARGUMENT:: maxComponents
+Maximum number of estimated components
+
+ARGUMENT:: coverage
+Fraction (0 to 1) of information preserved in the decomposition
+
+ARGUMENT:: method
+The method used for the decomposition. Options are:
+
+table::
+## 0 || NMF-SVD || faster
+## 1 || NNDSVDar || more accurate, fill in the zero elements with random values
+## 2 || NNDSVDa || fill in the zero elements with the average
+## 3 || NNDSVD || leave zero elements as zero, works better for sparse spectrograms
+::
+
+ARGUMENT:: windowSize
+	The window size. As spectral differencing relies on spectral frames, we need to decide what precision we give it spectrally and temporally, in line with Gabor Uncertainty principles. http://www.subsurfwiki.org/wiki/Gabor_uncertainty
+
+ARGUMENT:: hopSize
+	The window hop size. As sinusoidal estimation relies on spectral frames, we need to move the window forward. It can be any size but low overlap will create audible artefacts. The -1 default value will default to half of windowSize (overlap of 2).
+
+ARGUMENT:: fftSize
+	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the highest of windowSize and (bandwidth - 1) * 2.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [destination] as an argument.
+
+returns:: an instance of the processor
+
+
+INSTANCEMETHODS::
+
+private:: synth, server
+
+EXAMPLES::
+
+code::
+(
+b = Buffer.read(s,File.realpath(FluidBufNNDSVD.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
+~bases = Buffer.new(s);
+~activations = Buffer.new(s);
+~resynth = Buffer.new(s);
+)
+
+//how many bases do I need to decompose the buffer with 90% accuracy
+(
+Routine{
+    FluidBufNNDSVD.process(s, b, ~bases, ~activations, coverage: 0.9, method: 1).wait;
+    "% bases".format(~bases.numChannels).postln;
+}.play;
+)
+//check how many bases we are returned:
+
+
+//try the same process with less accuracy
+(
+Routine{
+    FluidBufNNDSVD.process(s, b, ~bases, ~activations, coverage: 0.5).wait;
+    "% bases".format(~bases.numChannels).postln;
+}.play
+)
+
+//use the bases to run NMF on
+FluidBufNMF.process(s, b, resynth: ~resynth, bases: ~bases, activations: ~activations,actMode: 2, components: ~bases.numChannels, action: {\done.postln;})
+{PlayBuf.ar(~resynth.numChannels, ~resynth)[2]}.play
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufNoveltySlice.schelp b/release-packaging/HelpSource/Classes/FluidBufNoveltySlice.schelp
index 0dba199..dbbf115 100644
--- a/release-packaging/HelpSource/Classes/FluidBufNoveltySlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufNoveltySlice.schelp
@@ -14,7 +14,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -67,11 +67,13 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 		A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The function will be passed indices as an argument.
 
-RETURNS::
-	Nothing, as the various destination buffers are declared in the function call.
+returns:: an instance of the processor
 
 
 EXAMPLES::
@@ -87,7 +89,7 @@ c = Buffer.new(s);
 // with basic params, with a minimum slight length to avoid over
 Routine{
 	t = Main.elapsedTime;
-	FluidBufNoveltySlice.process(s,b, indices: c, threshold:0.4,filterSize: 4, minSliceLength: 8);
+	FluidBufNoveltySlice.process(s,b, indices: c, threshold:0.4,filterSize: 4, minSliceLength: 8).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -120,11 +122,13 @@ c = Buffer.new(s);
 )
 
 // process with a given filterSize
-FluidBufNoveltySlice.process(s,b, indices: c, kernelSize:31, threshold:0.1, filterSize:1)
-
+(
+Routine{
+    FluidBufNoveltySlice.process(s,b, indices: c, kernelSize:31, threshold:0.1, filterSize:1).wait;
 //check the number of slices: it is the number of frames in the transBuf minus the boundary index.
-c.query;
-
+    c.query;
+}.play;
+)
 //play slice number 3
 (
 {
@@ -164,7 +168,7 @@ c = Buffer.new(s);
 // with basic params
 Routine{
     t = Main.elapsedTime;
-    FluidBufNoveltySlice.process(s,b, indices: c, threshold:0.3);
+    FluidBufNoveltySlice.process(s,b, indices: c, threshold:0.3).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufOnsetSlice.schelp b/release-packaging/HelpSource/Classes/FluidBufOnsetSlice.schelp
index 4942473..e3228f8 100644
--- a/release-packaging/HelpSource/Classes/FluidBufOnsetSlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufOnsetSlice.schelp
@@ -14,7 +14,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -63,7 +63,7 @@ ARGUMENT:: filterSize
 	The size of a smoothing filter that is applied on the novelty curve. A larger filter filter size allows for cleaner cuts on very sharp changes.
 
 ARGUMENT:: frameDelta
-		For certain metrics (HFC, SpectralFlux, MKL, Cosine), the distance does not have to be computed between consecutive frames. By default (0) it is, otherwise this sets the distane between the comparison window in samples.
+		For certain metrics (HFC, SpectralFlux, MKL, Cosine), the distance does not have to be computed between consecutive frames. By default (0) it is, otherwise this sets the distance between the comparison window in samples.
 
 ARGUMENT:: windowSize
 	The window size. As spectral differencing relies on spectral frames, we need to decide what precision we give it spectrally and temporally, in line with Gabor Uncertainty principles. http://www.subsurfwiki.org/wiki/Gabor_uncertainty
@@ -74,11 +74,13 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 		A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The function will be passed indices as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -93,7 +95,7 @@ c = Buffer.new(s);
 // with basic params
 Routine{
 	t = Main.elapsedTime;
-	FluidBufOnsetSlice.process(s,b, indices: c, threshold:0.5);
+	FluidBufOnsetSlice.process(s,b, indices: c, threshold:0.5).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -134,7 +136,7 @@ c = Buffer.new(s);
 // with basic params
 Routine{
     t = Main.elapsedTime;
-    FluidBufOnsetSlice.process(s,b, indices: c, threshold:0.00001);
+    FluidBufOnsetSlice.process(s,b, indices: c, threshold:0.00001).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufPitch.schelp b/release-packaging/HelpSource/Classes/FluidBufPitch.schelp
index 3b8f530..f2352ea 100644
--- a/release-packaging/HelpSource/Classes/FluidBufPitch.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufPitch.schelp
@@ -15,7 +15,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the pitch descriptor to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -44,7 +44,7 @@ ARGUMENT:: algorithm
 	TABLE::
 	## 0 || Cepstrum: Returns a pitch estimate as the location of the second highest peak in the Cepstrum of the signal (after DC).
 	## 1 || Harmonic Product Spectrum: Implements the Harmonic Product Spectrum algorithm for pitch detection . See e.g. FOOTNOTE:: A. Lerch, "An Introduction to Audio Content Analysis: Applications in Signal Processing and Music Informatics." John Wiley & Sons, 2012.https://onlinelibrary.wiley.com/doi/book/10.1002/9781118393550 ::
-	## 2 || YinFFT: Implements the frequency domain version of the YIN algorithm, as described in FOOTNOTE::P. M. Brossier, "Automatic Annotation of Musical Audio for Interactive Applications.” QMUL, London, UK, 2007. :: See also https://essentia.upf.edu/documentation/reference/streaming_PitchYinFFT.html
+## 2 || YinFFT: Implements the frequency domain version of the YIN algorithm, as described in FOOTNOTE::P. M. Brossier, "Automatic Annotation of Musical Audio for Interactive Applications." QMUL, London, UK, 2007. :: See also https://essentia.upf.edu/documentation/reference/streaming_PitchYinFFT.html
 	::
 
 ARGUMENT:: minFreq
@@ -65,11 +65,16 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: padding
+	Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+    Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [features] as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -87,7 +92,7 @@ b.play; b.plot;
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufPitch.process(s, b, features: c);
+	FluidBufPitch.process(s, b, features: c).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -122,7 +127,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufPitch.process(s, b, features: c, minFreq:200, maxFreq:2000, unit:1);
+    FluidBufPitch.process(s, b, features: c, minFreq:200, maxFreq:2000, unit:1).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
@@ -143,7 +148,7 @@ c = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufPitch.process(s, b, features: c,action:{c.loadToFloatArray(action: {|x| d = x.reshape((x.size()/2).asInt, 2)})});
+	FluidBufPitch.process(s, b, features: c,action:{c.loadToFloatArray(action: {|x| d = x.reshape((x.size()/2).asInteger, 2)})}).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -156,14 +161,14 @@ d.postln
 e = Array.new;
 d.do({
 	arg val, i;
-	if ((val[0] > 500) && (val[1] > 0.666)) {e = e.add(i)}; // if pitch is greater than 500Hz and confidence higher than 0.666, keep the index
+	if ((val[0] > 500) && (val[1] > 0.98)) {e = e.add(i)}; // if pitch is greater than 500Hz and confidence higher than 0.98, keep the index
 });
 )
 e.postln;
 
 //granulate only the frames that are in our buffer
-// We need to convert our indices to frame start. Their position was (index * hopSize) - (windowSize) in FluidBufPitch
-f = e.collect({arg i; (i * 512) - 1024});
+// We need to convert our indices to frame start. Their position was (index * hopSize) - (hopSize) in FluidBufPitch
+f = e.collect({arg i; (i * 512) - 512});
 
 // define a basic grain synth
 (
diff --git a/release-packaging/HelpSource/Classes/FluidBufSTFT.schelp b/release-packaging/HelpSource/Classes/FluidBufSTFT.schelp
new file mode 100644
index 0000000..86815f3
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufSTFT.schelp
@@ -0,0 +1,109 @@
+TITLE:: FluidBufSTFT
+summary:: Perform a Short-Time Fourier Transform on one channel of a buffer
+categories:: FluidCorpusManipulation
+related:: Classes/Buffer
+
+DESCRIPTION::
+Performs either a forward or inverse Short-Time Fourier Transform (STFT) on a single channel source buffer~. In the forward case, resulting magnitudes and phases can be written to output buffers. In the inverse case, these buffers can be used to reconstruct the original source into a new buffer.
+
+The magntude and phase buffers are laid out as (number of hops, number of bins). The number of hops is a function of the source length and the hop size. The number of bins is (1 + (fft size / 2)).
+
+The object is restricted to analysing a single source channel, because the channel counts of the magntude and phase buffers would quickly get out of hand otherwise.
+
+CLASSMETHODS::
+
+private::new1
+
+METHOD:: process, processBlocking
+Run the process on the given sever, and perfrom code::action:: when done
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+
+ARGUMENT:: source
+The link::Classes/Buffer:: to use for the forward STFT
+
+ARGUMENT:: startFrame
+The starting point for analysis in the source (in samples)
+
+ARGUMENT:: numFrames
+The duration (in samples) to analyse
+
+ARGUMENT:: startChan
+The channel to analyse
+
+ARGUMENT:: magnitude
+The link::Classes/Buffer:: to write magnitudes to in the forward case, or read from in the inverse case. This is optional for the forward transform, mandatory for the inverse.
+
+ARGUMENT:: phase
+The link::Classes/Buffer:: to write phases to in the forward case, or read from in the inverse case. This is optional for the forward transform, mandatory for the inverse.
+
+ARGUMENT:: resynth
+The link::Classes/Buffer:: to write re-synthesised data to in the inverse case. Ignored for the forward transform. Mandatory in the inverse case.
+
+ARGUMENT:: inverse
+When set to 1, an inverse STFT is performed, and the resynthesised data is written to the resynthesis buffer using overlap-add.
+
+ARGUMENT:: windowSize
+The number of source samples that are analysed at once.
+
+ARGUMENT:: hopSize
+How many samples there are in-between analysis windows. The -1 default value will default to half of windowSize (overlap of 2).
+
+ARGUMENT:: fftSize
+The FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize. For this object it is effectively capped at 65536.
+
+ARGUMENT:: padding
+Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+Runs when processing is complete
+
+INSTANCEMETHODS::
+
+
+EXAMPLES::
+
+code::
+s.reboot
+(
+b = Buffer.read(s,File.realpath(FluidBufSTFT.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
+m = Buffer.new;
+p = Buffer.new;
+r = Buffer.new;
+)
+
+(
+fork{
+	FluidBufSTFT.process(s,source:b,magnitude:m,phase:p).wait;
+	FluidBufSTFT.process(s,magnitude:m,phase:p,resynth:r,inverse:1).wait;
+	"Done".postln;
+}
+)
+
+{ PlayBuf.ar(1,r); }.play
+
+//nullsum
+{ PlayBuf.ar(1,r) - PlayBuf(1,b); }.play
+
+//draw the magnitudes as a greyscale spectrogram
+// make the image
+i = Image.new(m.numFrames, m.numChannels)
+
+//retreive the image and assign to pixels
+(
+m.loadToFloatArray(action: {|x|
+	var mod = m.numChannels;
+	{
+		x.do{
+			|val, index|
+			i.setColor(Color.gray(val), index.div(mod), mod - 1 - index.mod(mod));
+		};
+		i.plot("spectrogram", showInfo: false);
+	}.fork(AppClock)
+});
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufScale.schelp b/release-packaging/HelpSource/Classes/FluidBufScale.schelp
new file mode 100644
index 0000000..7107e5c
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufScale.schelp
@@ -0,0 +1,109 @@
+TITLE:: FluidBufScale
+SUMMARY:: A Scaling Processor for Buffers
+CATEGORIES:: Libraries>FluidDecomposition
+RELATED:: Guides/FluCoMa, Guides/FluidDecomposition, Guides/FluidBufMultiThreading
+
+This class implements a simple Buffer preprocessor, by scaling its values. It draws a simple translation from inputLow to outputLow, and from inputHigh to outputHigh. It is part of the LINK:: Guides/FluidDecomposition:: of LINK:: Guides/FluCoMa::. For more explanations, learning material, and discussions on its musicianly uses, visit http://www.flucoma.org/
+
+The process will return a buffer with the same size and shape than the requested range.
+
+STRONG::Threading::
+
+By default, this UGen spawns a new thread to avoid blocking the server command queue, so it is free to go about with its business. For a more detailed discussion of the available threading and monitoring options, including the two undocumented Class Methods below (.processBlocking and .kr) please read the guide LINK::Guides/FluidBufMultiThreading::.
+
+CLASSMETHODS::
+
+METHOD:: process, processBlocking
+	This is the method that calls for the scaling to be calculated on a given source buffer.
+
+ARGUMENT:: server
+	The server on which the buffer to be processed is allocated.
+
+ARGUMENT:: source
+The index of the buffer to use as the source material to be processed.
+
+ARGUMENT:: startFrame
+	The starting point (in samples) from which to copy in the source buffer.
+
+ARGUMENT:: numFrames
+	The duration (in samples) to copy from the source buffer. The default (-1) copies the full lenght of the buffer.
+
+ARGUMENT:: startChan
+	The first channel from which to copy in the source buffer.
+
+ARGUMENT:: numChans
+	The number of channels from which to copy in the source buffer. This parameter will wrap around the number of channels in the source buffer. The default (-1) copies all of the buffer's channel.
+
+ARGUMENT:: destination
+The index of the buffer to use as the destination for the processed material.
+
+ARGUMENT:: inputLow
+The low reference point of the input. it will be scaled to yield outputLow at the output
+
+ARGUMENT:: inputHigh
+The high reference point of the input. it will be scaled to yield outputHigh at the output
+
+ARGUMENT:: outputLow
+The output value when the input is inputLow
+
+ARGUMENT:: outputHigh
+The output value when the input is inputHigh
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+	A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The metric will be passed indices as an argument.
+
+returns:: an instance of the processor
+
+
+EXAMPLES::
+
+code::
+(
+Routine{
+    // make a buffer of known qualities
+    b = Buffer.sendCollection(s,1.0.series(1.1,2.0));
+    // and a destination buffer
+    c = Buffer(s);
+    // play with the scaling
+    FluidBufScale.process(s, b, destination: c, inputLow: 0, inputHigh: 1, outputLow: 20, outputHigh:10).wait;
+    // retrieve the buffer and enjoy the results.
+	c.getn(0,10,{|x|x.round(0.000001).postln;})
+}.play
+)
+
+// also works in multichannel - explore the following buffer
+
+//process
+(
+Routine{
+    b = Buffer.sendCollection(s,-10.0.series(-9,10.0).scramble,2);
+    c = Buffer(s);
+    s.sync;
+    defer{b.plot(bounds:Rect(400,400,400,400)).plotMode_(\points).bounds};
+    FluidBufScale.process(s, b, destination: c, inputLow: -20, inputHigh: 20, outputLow: 0, outputHigh:1).wait;
+    //enjoy - same shape, different range
+    defer{c.plot(bounds:Rect(800,400,400,400)).plotMode_(\points)};
+}.play;
+)
+
+//also works with a subset of the input, resizing the output
+(
+Routine{
+    b = Buffer.sendCollection(s,0.0.series(0.1,3.0).reshape(3,10).flop.flat,3);
+    c = Buffer(s);
+    s.sync;
+    defer{b.plot(separately: true,bounds:Rect(400,400,400,400)).plotMode_(\points)};
+    //process
+    FluidBufScale.process(s, b, startFrame: 3,numFrames: 4,startChan: 1,numChans: 1, destination: c, inputLow: 0, inputHigh: 3, outputLow: 0, outputHigh:1).wait;
+    //enjoy
+    c.query;
+    c.getn(0,4,{|x|x.postln;});
+    defer{c.plot(separately: true,bounds:Rect(800,400,400,400)).plotMode_(\points)};
+}.play
+)
+::
+
+
diff --git a/release-packaging/HelpSource/Classes/FluidBufSelect.schelp b/release-packaging/HelpSource/Classes/FluidBufSelect.schelp
new file mode 100644
index 0000000..e20a544
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufSelect.schelp
@@ -0,0 +1,62 @@
+TITLE:: FluidBufSelect
+summary:: Cherry pick values from a buffer
+categories:: FluidCorpusManipulation
+related:: Classes/FluidBufSelectEvery
+
+DESCRIPTION::
+Pick sets of values from a buffer, described in terms of a list of frame indices and channel numbers.
+
+CLASSMETHODS::
+
+private::new1
+
+METHOD:: process, processBlocking
+Run the process on the given sever, and perfrom code::action:: when done
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+
+ARGUMENT:: source
+The link::Classes/Buffer:: to select values from
+
+ARGUMENT:: destination
+The link::Classes/Buffer:: to write the selected data to
+
+ARGUMENT:: indices
+A 0-based list of frame indices to recover. Default is [-1], meaning all frames
+
+ARGUMENT:: channels
+A 0-based list of channel numbers to recover. Default is [-1], meaning all frames
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+Runs when processing is complete
+
+EXAMPLES::
+code::
+//send a known collection where the value of each frame in each channel is encoded
+//chan
+b = Buffer.sendCollection(s,30.collect{|x| x.mod(6) + (x.div(6) * 0.1)},6)
+//check the ranges (thus showing a plotter error...)
+b.plot(separately: true).plotMode_(\points)
+//you can also check the collection itself if in doubt
+b.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//let's make a destination buffer
+c = Buffer(s);
+
+//using default values, we copy everything:
+FluidBufSelect.process(s,b,c,action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//more powerful copying, resizing the destination accordingly
+FluidBufSelect.process(s,b,c, indices: [1,3], channels: [2,4], action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//observe the order can be anything, and -1 (default) passes everything in that dimension
+FluidBufSelect.process(s,b,c, indices: [ -1 ] , channels: [3, 1, 4], action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+::
+
diff --git a/release-packaging/HelpSource/Classes/FluidBufSelectEvery.schelp b/release-packaging/HelpSource/Classes/FluidBufSelectEvery.schelp
new file mode 100644
index 0000000..cb83c0e
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufSelectEvery.schelp
@@ -0,0 +1,77 @@
+TITLE:: FluidBufSelectEvery
+summary:: Extract every N samples / channels from a buffer
+categories:: FluidCorpusManipulation
+related:: Classes/FluidBufSelect
+
+DESCRIPTION::
+Pick every N frames and / or channels from a buffer, described in terms of independent hop sizes for frames and channels
+
+CLASSMETHODS::
+
+private::new1
+
+METHOD:: process, processBlocking
+Run the process on the given sever, and perfrom code::action:: when done
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+
+ARGUMENT:: source
+The link::Classes/Buffer:: to select values from
+
+ARGUMENT:: startFrame
+The starting point (in samples) from which to copy in the source buffer.
+
+ARGUMENT:: numFrames
+The duration (in samples) to copy from the source buffer. The default (-1) copies the full lenght of the buffer.
+
+ARGUMENT:: startChan
+The first channel from which to copy in the source buffer.
+
+ARGUMENT:: numChans
+The number of channels from which to copy in the source buffer. This parameter will wrap around the number of channels in the source buffer. The default (-1) copies all of the buffer's channel.
+
+ARGUMENT:: destination
+The link::Classes/Buffer:: to write the selected data to
+
+ARGUMENT:: frameHop
+Take every `framehop` frames. Default = 1 = all frames (where 2 would be every other frame, etc.)
+
+ARGUMENT:: channelHop
+Take every `channelhop` channels. Default = 1 = all channels (where 2 would be every other channel, etc.)
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+Runs when processing is complete
+
+EXAMPLES::
+
+code::
+EXAMPLES::
+Didactic
+code::
+//send a known collection where the value of each frame in each channel is encoded
+//chan
+b = Buffer.sendCollection(s,30.collect{|x| x.mod(6) + (x.div(6) * 0.1)},6)
+//check the ranges (thus showing a plotter error...)
+b.plot(separately: true).plotMode_(\points)
+//you can also check the collection itself if in doubt
+b.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//let's make a destination buffer
+c = Buffer(s);
+
+//using default values, we copy everything:
+FluidBufSelectEvery.process(s,b, destination: c, action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//more powerful copying, resizing the destination accordingly
+FluidBufSelectEvery.process(s,b, destination: c, frameHop: 2, channelHop: 3, action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+
+//source buffer boundaries still apply before the hopping selection
+FluidBufSelectEvery.process(s,b, startFrame: 1, numFrames: 3, startChan: 2, numChans: 3, destination: c, frameHop: 1, channelHop: 2, action: {c.query});
+c.getToFloatArray(action: {|x|x.round(0.1).postln;});
+::::
diff --git a/release-packaging/HelpSource/Classes/FluidBufSines.schelp b/release-packaging/HelpSource/Classes/FluidBufSines.schelp
index 152d651..35d07f1 100644
--- a/release-packaging/HelpSource/Classes/FluidBufSines.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufSines.schelp
@@ -19,7 +19,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the sinusoidal estimation to be calculated on a given source buffer and to be resynthesised.
 
 ARGUMENT:: server
@@ -82,11 +82,13 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the highest of windowSize and (bandwidth - 1) * 2.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [sines, residual] as an argument.
 
-RETURNS::
-	Nothing, as the various destination buffers are declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -102,7 +104,7 @@ d = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufSines.process(s, b, sines: c, residual:d);
+	FluidBufSines.process(s, b, sines: c, residual:d).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -135,7 +137,7 @@ d = Buffer.new(s); e = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufSines.process(s, b, sines: d, residual:e, windowSize: 2048, hopSize: 256, fftSize: 16384);
+    FluidBufSines.process(s, b, sines: d, residual:e, windowSize: 2048, hopSize: 256, fftSize: 16384).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufSpectralShape.schelp b/release-packaging/HelpSource/Classes/FluidBufSpectralShape.schelp
index e85d93f..9561cc6 100644
--- a/release-packaging/HelpSource/Classes/FluidBufSpectralShape.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufSpectralShape.schelp
@@ -31,7 +31,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the spectral shape descriptors to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -64,11 +64,16 @@ ARGUMENT:: hopSize
 ARGUMENT:: fftSize
 	The inner FFT/IFFT size. It should be at least 4 samples long, at least the size of the window, and a power of 2. Making it larger allows an oversampling of the spectral precision. The -1 default value will use the next power of 2 equal or above the windowSize.
 
+ARGUMENT:: padding
+Controls the zero-padding added to either end of the source buffer or segment. Possible values are 0 (no padding), 1 (default, half the window size), or 2 (window size - hop size). Padding ensures that all input samples are completely analysed: with no padding, the first analysis window starts at time 0, and the samples at either end will be tapered by the STFT windowing function. Mode 1 has the effect of centering the first sample in the analysis window and ensuring that the very start and end of the segment are accounted for in the analysis. Mode 2 can be useful when the overlap factor (window size / hop size) is greater than 2, to ensure that the input samples at either end of the segment are covered by the same number of analysis frames as the rest of the analysed material.
+
+ARGUMENT:: freeWhenDone
+    Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [features] as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -83,7 +88,7 @@ c = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufSpectralShape.process(s, b, features: c);
+	FluidBufSpectralShape.process(s, b, features: c).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -113,7 +118,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufSpectralShape.process(s, b, features: c);
+    FluidBufSpectralShape.process(s, b, features: c).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufStats.schelp b/release-packaging/HelpSource/Classes/FluidBufStats.schelp
index ce83e04..39aae16 100644
--- a/release-packaging/HelpSource/Classes/FluidBufStats.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufStats.schelp
@@ -15,7 +15,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -51,11 +51,23 @@ ARGUMENT:: middle
 ARGUMENT:: high
 	The rank requested for the third percentile value. By default, it is percentile 100.0, which is the maximum of the given channel of the source buffer.
 
+ARGUMENT:: outliersCutoff
+	A ratio of the inter quantile range (IQR) that defines a range outside of which data will be rejected. It is run on each channel independently and a single channel being flagged as outlier removes the whole frame (on all channels). The default (-1) bypasses this function, keeping all frames in the statistical measurements. For more information on this statistical process, please refer to the concept of IQR and how the whiskers of a box plot are computed here (https://en.wikipedia.org/wiki/Box_plot)
+
+ARGUMENT:: weights
+	A buffer to provide relative weighting of the source material. Not providing one will not apply weighting and consider all frames equally. The provided buffer has to satisfy all of the following conditions: LIST::
+	## a single-channel, that will be applied to all channels of source
+	## exactly the same amount of frames as ‘source’
+	## weights must be positive (anything lower than 0 will be rejected)
+	::
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 		A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The function will be passed stats as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 EXAMPLES::
 
@@ -63,7 +75,7 @@ STRONG::A didactic example::
 
 CODE::
 
-// make a buffer of known lenght
+// make a buffer of known length
 b = Buffer.alloc(s,101);
 
 // add known values - here, a ramp up
@@ -76,7 +88,7 @@ c = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufStats.process(s, b, stats:c, numDerivs:1);
+    FluidBufStats.process(s, b, stats:c, numDerivs:1).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
@@ -117,41 +129,66 @@ STRONG::A musical example::
 CODE::
 // create some buffers
 (
-b = Buffer.read(s,File.realpath(FluidBufStats.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav");
+// a simple random sliding bell synth
+b = {
+	var trig = Impulse.ar(1.5);
+	SinOsc.ar(
+		Lag.ar(TRand.ar(trig: trig),
+		TRand.ar(0.5, trig: trig)).exprange(333,666),
+		mul: Decay.ar(
+			trig * TRand.ar(0.1,10,trig),
+			TRand.ar(0.5,1.1,trig)
+		)
+	).atan * 0.1;
+}.asBuffer(20);
 c = Buffer.new(s);
 d = Buffer.new(s);
+i = Buffer.new(s);
 )
 
+//play the source
+b.play;
+
 //split in various chunks, collecting the indices in an array
-FluidBufOnsetSlice.process(s,b, minSliceLength: 10, metric: 9, threshold: 0.4, filterSize: 7, indices: c, action:{c.loadToFloatArray(action: {|array| e = array.add(b.numFrames).addFirst(0);e.postln;})});
+FluidBufOnsetSlice.process(s,b, threshold: 0.01, indices: c, action:{c.loadToFloatArray(action: {|array| e = array.add(b.numFrames);e.size.postln;e.postln;})});
 
 //describe the whole input too, here using pitch, and collecting the values in an array, dismissing the (interleaved) confidence.
-FluidBufPitch.process(s,b,features:c, action:{c.loadToFloatArray(action: {|array| f = array.unlace(2)[0]; f.postln;})});
+FluidBufPitch.process(s,b,features:d, windowSize: 4096, hopSize: 512, padding:2, action:{d.loadToFloatArray(action: {|array| f = array.unlace(2)[0]; f.postln;})});
 
 // iterate through each slice, taking the median of the first derivative of the pitch of each
 (
 g= Array.new;
 Routine({
+	var nb = e.size;
 	e.doAdjacentPairs({
 		arg start,end;
-		FluidBufStats.processBlocking(s,c,(start/512).asInt,((end-start)/512).max(2).asInt,0,1,d,1, action: {d.loadToFloatArray(action: {
-			arg array;
-			g = g.add(array[12]);
-			"% % %\n".postf((start/512).asInt,((end-start)/512).max(2).asInt, array[12]);
-		})});
-});
-	"Done".postln;
+		FluidBufStats.processBlocking(s,d,(start/512).asInteger,((end-start)/512).asInteger + 3,0,1,i,1, action: {
+			i.loadToFloatArray( action: {
+				arg array;
+				g = g.add(array[12]);
+				"% % %\n".postf((start/512).asInteger,((end-start)/512).asInteger + 3, array[12]);//adding some of the overlap but not more to not capture too much of the next attack
+				nb = nb - 1;
+				if (nb == 1, {"Done".postln;});//check if we've done all the pairs
+			})
+		}).wait;
+	});
 }).play;
 )
 
-//obtain the order of indices that would sort the stats
-h = g.order;
+//play in loop the slice in order of pitch direction (the median of the slice's pitch variation) - mouse on the left should be descending, in the middle should be more stable, and it should be ascending on the right.
 
-//play in loop the slice in order of pitch direction (the median of the slice's pitch variation)
 (
-var which = h[5];
-{BufRd.ar(1, b, Phasor.ar(0,1,e[which],e[which+1],e[which]))}.play;
+Buffer.sendCollection(s,g.order,action: {|x| {
+	var which = BufRd.kr(1, x, MouseX.kr(0, BufFrames.kr(x) - 1), 0, 1);
+    BufRd.ar(1, b,
+        Phasor.ar(0,1,
+            BufRd.kr(1,c,which,0,1),
+			BufRd.kr(1,c,which + 1,0,1),
+			BufRd.kr(1,c,which,0,1)));
+		}.play;
+	};)
 )
+
 ::
 
 
@@ -165,7 +202,7 @@ b = Buffer.alloc(s,101,2);
 b.setn(0, Array.fill(101,{|i|[i / 100,-1.0.rand]}).flat);
 
 // plot to confirm
-b.plot
+b.plot.plotMode_(\points)
 
 // create a new buffer as destinations
 c = Buffer.new(s);
@@ -175,5 +212,77 @@ FluidBufStats.process(s, b, stats:c, numDerivs:1, action:{c.getn(0,c.numFrames *
 
 //looking at the result is not easy to grasp, since it is interleaved: first number is mean of L, second is mean of R, third is stddev of L, fourth is stddev or R
 //this will make it tidier - the first value of each line is Left, the second is Right
-d.reshape(14,2).do({|x,i|["mean\t\t","stddev\t\t","skew\t\t\t", "kurtosis\t", "min\t\t\t", "median\t\t", "max\t\t\t","d-mean\t","d-stddev\t","d-skew\t\t", "d-kurtosis", "d-min\t\t", "d-median\t", "d-max\t\t"].at(i).post;x.round(0.01).postln})
+d.reshape(14,2).do({|x,i|["mean\t\t","stddev\t\t","skew\t\t", "kurtosis\t\t", "min\t\t\t", "median\t\t", "max\t\t\t","d-mean\t","d-stddev\t","d-skew\t\t", "d-kurtosis", "d-min\t\t", "d-median\t", "d-max\t\t"].at(i).post;x.round(0.01).postln});"".postln;
+::
+
+STRONG::Outliers and Weights::
+
+CODE::
+// example 1a
+// make a buffer of known qualities
+b = Buffer.loadCollection(s,[1, 8, 9, 10, 11, 12, 99]);
+
+// plot to confirm
+b.plot.plotMode = \points;
+
+// create a new buffer as destinations
+c = Buffer.new(s);
+
+// run the stats and send back the values
+FluidBufStats.process(s, b, stats:c, numDerivs:1, action:{c.getn(0,c.numFrames,{|item|item.postln})});
+// run the same array with outliers rejected if outside of 1.5 times the IQR - observe the new minimum and maximum to see
+FluidBufStats.process(s, b, stats:c, numDerivs:1, outliersCutoff: 1.5, action:{c.getn(0,c.numFrames,{|item| item.postln})});
+
+// example 1b (run the stats above, and change the value of some elements in the array too)
+b = Buffer.loadCollection(s,[1, 8, 9, 10, 11, 12, 16, 99].scramble);
+
+// example 1c (multichannel in behaviour is greedy)
+// This mean that an outlier in any channel will dismiss the whole frame.
+// For instance here the outlier is 99 (frame 8) in channel 0, and 1001 in channel 1 (frame 0)
+// The final stats therefore has minima of [2,10002] and maxima of [8,10008]
+e = [(1..8)++99, [1001] ++ 10002.series(10003,10009)].flop.scramble.flat
+b = Buffer.loadCollection(s,e,2);
+FluidBufStats.process(s, b, stats:c, numDerivs:1, outliersCutoff: 1.5, action:{c.getn(0,c.numFrames * c.numChannels,{|item| f =item.postln})});
+
+//More readable format
+f.reshape(14,2).do({|x,i|["mean\t\t","stddev\t\t","skew\t\t\t", "kurtosis\t", "min\t\t\t", "median\t\t", "max\t\t\t","d-mean\t","d-stddev\t","d-skew\t\t", "d-kurtosis", "d-min\t\t", "d-median\t", "d-max\t\t"].at(i).post;x.round(0.01).postln});"".postln;
+
+//////////////
+// example 2a
+
+// make an array of 9 values, with known weigths. Scramble them pairwise for good measure (that should not change any stats)
+e = [(1..9), 1.0.series(0.9,0.2)].flop.scramble.flop;
+b = Buffer.loadCollection(s,e[0]);
+c = Buffer.loadCollection(s,e[1]);
+d = Buffer.new(s);
+// run the stats and send back the values
+FluidBufStats.process(s, b, stats:d, numDerivs:1, action:{d.getn(0,d.numFrames,{|item|item.postln})});
+// run the same array with the weights
+FluidBufStats.process(s, b, stats:d, numDerivs:1, weights: c, action:{d.getn(0,d.numFrames * d.numChannels,{|item|item.postln})});
+
+// example 2b
+e = [(1..9), 0.series(-10,-80)].flop.scramble.flop;
+b = Buffer.loadCollection(s,e[0]);
+c = Buffer.loadCollection(s,e[1]);
+FluidBufStats.process(s, b, stats:d, numDerivs:1, weights: c, action:{d.getn(0,d.numFrames * d.numChannels,{|item|item.postln})});
+// this has only negative weights, so it bails out, outputing all 0s. It also publishes a warning if the server options on verbosity are on.
+// but if we scale them up
+g = Buffer(s)
+FluidBufScale.process(s,c,destination: g,inputLow: -100,inputHigh: 0)
+// look at the new values - because 0->1 and -100->0 we get the same weights as example 2a
+g.getn(0,9,{|x|x.postln})
+// run the stats - same results as example 2a
+FluidBufStats.process(s, b, stats:d, numDerivs:1, weights: g, action:{d.getn(0,d.numFrames * d.numChannels,{|item|item.postln})});
+
+//example 2c (stereo input but mono weigths - works like a charm)
+e = [(1..9), (101..109), 1.0.series(0.9,0.2)].flop.scramble.flop;
+b = Buffer.loadCollection(s,e[0..1].flop.flat,2);
+b.plot(separately: true).plotMode = \points;
+c = Buffer.loadCollection(s,e[2]);
+FluidBufStats.process(s, b, stats:d, numDerivs:1, weights: c, action:{d.getn(0,d.numFrames * d.numChannels,{|item|f = item.postln})});
+
+//More readable format
+f.reshape(14,2).do({|x,i|["mean\t\t","stddev\t\t","skew\t\t\t", "kurtosis\t", "min\t\t\t", "median\t\t", "max\t\t\t","d-mean\t","d-stddev\t","d-skew\t\t", "d-kurtosis", "d-min\t\t", "d-median\t", "d-max\t\t"].at(i).post;x.round(0.01).postln});"".postln;
+
+//see the example folder for 2 musical comparisons: 1) weighted MFCCs providing different nearest neighbours, and 2) pitch manipulations
 ::
diff --git a/release-packaging/HelpSource/Classes/FluidBufThreadDemo.schelp b/release-packaging/HelpSource/Classes/FluidBufThreadDemo.schelp
index 99427b3..da2bcda 100644
--- a/release-packaging/HelpSource/Classes/FluidBufThreadDemo.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufThreadDemo.schelp
@@ -12,7 +12,7 @@ The process will, after waiting for STRONG::time:: millisecond, return its delay
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the job to be done. In this case, simply waiting STRONG::time:: millisecond before writing a value in the destination buffer.
 
 ARGUMENT:: server
@@ -24,11 +24,13 @@ ARGUMENT:: result
 ARGUMENT:: time
 	The duration in milliseconds of the delay that the background thread will wait for before yielding the value to the destination buffer.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A function that will be executed upon completion. It is passed the destination buffer as argument.
 
-RETURNS::
-	The instance of FluidNRTProcess which can be used to cancel the job.
+returns::The instance of FluidNRTProcess which can be used to cancel the job.
 
 
 METHOD:: kr
@@ -43,8 +45,7 @@ ARGUMENT:: time
 ARGUMENT:: doneAction
 	An integer representing an action to be executed when the process is finished. This can be used to free the enclosing synth, etc. See link::Classes/Done::  for more detail.
 
-RETURNS::
-	It report the approximate job progress, from 0 to 1.
+returns::It report the approximate job progress, from 0 to 1.
 
 
 EXAMPLES::
@@ -56,12 +57,12 @@ CODE::
 b=Buffer.alloc(s,1);
 
 // a simple call, where we query the destination buffer upon completion with the action message.
-FluidBufThreadDemo.process(s, b, 1000, {|x|x.get(0,{|y|y.postln});});
+FluidBufThreadDemo.process(s, b, 1000, action:{|x|x.get(0,{|y|y.postln});});
 
-// as the 'process' returns its parent UGen, we can cancel the process easily
-c = FluidBufThreadDemo.process(s, b, 100000, {|x|x.get(0,{|y|y.postln});});
-c.cancel
+// as the 'process' returns its instance, we can cancel the process easily
+c = FluidBufThreadDemo.process(s, b, 100000, action: {|x|x.get(0,{|y|y.postln});});
+c.cancel;
 
-// if a simple call to the UGen is used, the progress can be monitored
+// if a simple call to the UGen is used, the progress can be monitored. The usual cmd-period will cancel the job by freeing the synth.
 {c = FluidBufThreadDemo.kr(b,10000, Done.freeSelf); Poll.kr(Impulse.kr(2),c);}.scope;
 ::
diff --git a/release-packaging/HelpSource/Classes/FluidBufThresh.schelp b/release-packaging/HelpSource/Classes/FluidBufThresh.schelp
new file mode 100644
index 0000000..f905faa
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidBufThresh.schelp
@@ -0,0 +1,81 @@
+TITLE:: FluidBufThresh
+SUMMARY:: A Gate Processor for Buffers
+CATEGORIES:: Libraries>FluidDecomposition
+RELATED:: Guides/FluCoMa, Guides/FluidDecomposition, Guides/FluidBufMultiThreading
+
+DESCRIPTION::
+This class implements a simple Buffer preprocessor, by replacing values under a threshold by 0s. It is part of the LINK:: Guides/FluidDecomposition:: of LINK:: Guides/FluCoMa::. For more explanations, learning material, and discussions on its musicianly uses, visit http://www.flucoma.org/
+
+The process will return a buffer with the same size and shape than the requested range.
+
+STRONG::Threading::
+
+By default, this UGen spawns a new thread to avoid blocking the server command queue, so it is free to go about with its business. For a more detailed discussion of the available threading and monitoring options, including the two undocumented Class Methods below (.processBlocking and .kr) please read the guide LINK::Guides/FluidBufMultiThreading::.
+
+CLASSMETHODS::
+
+METHOD:: process, processBlocking
+	This is the method that calls for the thresholding to be calculated on a given source buffer.
+
+ARGUMENT:: server
+	The server on which the buffer to be processed is allocated.
+
+ARGUMENT:: source
+The index of the buffer to use as the source material to be processed.
+
+ARGUMENT:: startFrame
+	The starting point (in samples) from which to copy in the source buffer.
+
+ARGUMENT:: numFrames
+	The duration (in samples) to copy from the source buffer. The default (-1) copies the full lenght of the buffer.
+
+ARGUMENT:: startChan
+	The first channel from which to copy in the source buffer.
+
+ARGUMENT:: numChans
+	The number of channels from which to copy in the source buffer. This parameter will wrap around the number of channels in the source buffer. The default (-1) copies all of the buffer's channel.
+
+ARGUMENT:: destination
+The index of the buffer to use as the destination for the processed material.
+
+ARGUMENT:: threshold
+The threshold under which values will be zeroed
+
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
+ARGUMENT:: action
+	A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The metric will be passed indices as an argument.
+
+returns:: an instance of the processor
+
+EXAMPLES::
+
+code::
+// make a buffer of know qualities
+b = Buffer.sendCollection(s,0.0.series(0.1,1.0))
+// and a destination buffer
+c = Buffer(s)
+// play with the threshold
+FluidBufThresh.process(s, b, destination: c, threshold: 0.5)
+// retrieve the buffer and enjoy the results.
+c.getn(0,11,{|x|x.round(0.000001).postln;})
+
+// also works in multichannel - explore the following buffer
+b = Buffer.sendCollection(s,0.0.series(0.1,2.0).scramble,2)
+b.plot.plotMode_(\points)
+//process and keep just the top values
+FluidBufThresh.process(s, b, destination: c, threshold: 1.6)
+//enjoy
+c.plot.plotMode_(\points)
+
+//also works with a subset of the input, resizing the output
+b = Buffer.sendCollection(s,0.0.series(0.1,3.0).reshape(3,10).flop.flat,3)
+b.plot(separately: true).plotMode_(\points)
+//process and keep just the top values
+FluidBufThresh.process(s, b,startFrame: 3,numFrames: 4,startChan: 1,numChans: 1,destination: c, threshold: 1.6)
+//enjoy
+c.plot(separately: true).plotMode_(\points)
+c.query
+c.getn(0,4,{|x|x.round(0.000001).postln;})
+::
diff --git a/release-packaging/HelpSource/Classes/FluidBufTransientSlice.schelp b/release-packaging/HelpSource/Classes/FluidBufTransientSlice.schelp
index 709a058..71926c3 100644
--- a/release-packaging/HelpSource/Classes/FluidBufTransientSlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufTransientSlice.schelp
@@ -14,7 +14,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 	This is the method that calls for the slicing to be calculated on a given source buffer.
 
 ARGUMENT:: server
@@ -65,11 +65,13 @@ ARGUMENT:: clumpLength
 ARGUMENT:: minSliceLength
 	The minimum duration of a slice in samples.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 		A Function to be evaluated once the offline process has finished and indices instance variables have been updated on the client side. The function will be passed indices as an argument.
 
-RETURNS::
-	Nothing, as the destination buffer is declared in the function call.
+returns:: an instance of the processor
 
 
 EXAMPLES::
@@ -85,7 +87,7 @@ c = Buffer.new(s);
 (
 	Routine{
 	t = Main.elapsedTime;
-	FluidBufTransientSlice.process(s,b, indices:c);
+	FluidBufTransientSlice.process(s,b, indices:c).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -107,11 +109,11 @@ c.query;
         }.play;
 )
 
-// with everything changed to make it much better, at the cost of computation time (only 10 seconds are processed here, again wait for the (longer) computation time to appear)
+// with everything changed to make it much better, at the cost of computation time (only 5 seconds are processed here, again wait for the (longer) computation time to appear)
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufTransientSlice.process(s,b, 0, 220500, 0, 1, c, 200, 2048, 1024, 1, 3, 1, 15, 30, 4410);
+	FluidBufTransientSlice.process(s,b, 0, 220500, 0, 1, c, 200, 2048, 1024, 1, 3, 1, 15, 30, 4410).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -138,7 +140,7 @@ c = Buffer.new(s);
 // with basic params
 Routine{
     t = Main.elapsedTime;
-    FluidBufTransientSlice.process(s,b, indices: c, threshFwd: 1.2);
+    FluidBufTransientSlice.process(s,b, indices: c, threshFwd: 1.2).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidBufTransients.schelp b/release-packaging/HelpSource/Classes/FluidBufTransients.schelp
index 4f71858..fc427a0 100644
--- a/release-packaging/HelpSource/Classes/FluidBufTransients.schelp
+++ b/release-packaging/HelpSource/Classes/FluidBufTransients.schelp
@@ -18,7 +18,7 @@ By default, this UGen spawns a new thread to avoid blocking the server command q
 
 CLASSMETHODS::
 
-METHOD:: process
+METHOD:: process, processBlocking
 This is the method that calls for the transient extraction to be performed on a given source buffer.
 
 ARGUMENT:: server
@@ -69,11 +69,13 @@ ARGUMENT:: windowSize
 ARGUMENT:: clumpLength
 	The window size in sample within which positive detections will be clumped together to avoid overdetecting in time.
 
+ARGUMENT:: freeWhenDone
+Free the server instance when processing complete. Default true
+
 ARGUMENT:: action
 	A Function to be evaluated once the offline process has finished and all Buffer's instance variables have been updated on the client side. The function will be passed [transients, residual] as an argument.
 
-RETURNS::
-	Nothing, as the various destination buffers are declared in the function call.
+returns:: an instance of the processor
 
 
 EXAMPLES::
@@ -89,7 +91,7 @@ d = Buffer.new(s);
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufTransients.process(s,b, transients:c, residual:d);
+	FluidBufTransients.process(s,b, transients:c, residual:d).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 );
@@ -106,7 +108,7 @@ d.play;
 (
 Routine{
 	t = Main.elapsedTime;
-	FluidBufTransients.process(s,b, 0, 220500, 0, 1, c, d, 200, 2048, 1024, 1, 3, 1, 15, 30);
+	FluidBufTransients.process(s,b, 0, 220500, 0, 1, c, d, 200, 2048, 1024, 1, 3, 1, 15, 30).wait;
 	(Main.elapsedTime - t).postln;
 }.play
 )
@@ -136,7 +138,7 @@ d = Buffer.new(s); e = Buffer.new(s);
 (
 Routine{
     t = Main.elapsedTime;
-    FluidBufTransients.process(s, b, transients: d, residual:e, threshFwd:1.2, clumpLength:40);
+    FluidBufTransients.process(s, b, transients: d, residual:e, threshFwd:1.2, clumpLength:40).wait;
     (Main.elapsedTime - t).postln;
 }.play
 )
diff --git a/release-packaging/HelpSource/Classes/FluidDataSet.schelp b/release-packaging/HelpSource/Classes/FluidDataSet.schelp
new file mode 100644
index 0000000..6643181
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidDataSet.schelp
@@ -0,0 +1,230 @@
+TITLE:: FluidDataSet
+summary:: Container for labelled,  multidimensional data
+categories:: UGens>FluidManipulation
+related:: Classes/FluidLabelSet, Classes/FluidKDTree, Classes/FluidKMeans
+​
+DESCRIPTION::
+A server-side container associating labels with multi-dimensional data. FluidDataSet is identified by its name.
+
+CLASSMETHODS::
+​
+PRIVATE:: asUGenInput
+
+METHOD:: new
+Create a new instance of the DataSet, with the given name. If a DataSet with this name already exists, an exception will be thrown (see link::Classes/FluidDataSet#at:: to access an existant DataSet).
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to create the data set.
+
+​
+returns:: The new instance
+
+INSTANCEMETHODS::
+​
+PRIVATE:: init,id,cache
+
+METHOD:: addPoint
+Add a new point to the data set. The dimensionality of the DataSet is governed by the size of the first point added.
+Will report an error if the label already exists, or if the size of the data does not match the dimensionality of the DataSet.
+ARGUMENT:: label
+A symbol or string with the label for the new point.
+ARGUMENT:: buffer
+A link::Classes/Buffer:: with the new data point.
+ARGUMENT:: action
+A function to run when the point has been added.
+​​
+METHOD:: updatePoint
+Update an existing label's data. Will report an error if the label doesn't exist, or if the size of the data does not match the given dimensionality of the DataSet.
+
+METHOD:: getPoint
+Retrieve a point from the data set into a link::Classes/Buffer::. Will report an error if the label or buffer doesn't exist​.
+
+METHOD:: deletePoint
+Remove a point from the data set. Will report an error if the label doesn't exist.
+
+METHOD:: setPoint
+Set the point: if the label exists, this method behaves like updatePoint; if the label doesn't exist, behaves like addPoint.
+​​
+METHOD:: clear
+Empty the data set.
+
+METHOD:: toBuffer
+Dump the content of the dataset to a link::Classes/Buffer::, with optional transposition, and a map of frames/channels to the original IDs as a link::Classes/FluidLabelSet::.
+
+ARGUMENT:: buffer
+The buffer to write to. It will be resized.
+
+ARGUMENT:: transpose
+If 0, each dataset point becomes a buffer frame, and each dataset dimension becomes a buffer channel. If 1, points become channels, and dimensions become frames.
+
+ARGUMENT:: labelSet
+The link::Classes/FluidLabelSet:: in which to dump the point's IDs associated with their reference frame number (or channel number if transposed).
+
+ARGUMENT:: action
+A function to run when the dump is done.
+
+METHOD:: fromBuffer
+Import to the dataset the content of a link::Classes/Buffer::, with optional transposition, and a map of frames/channels to the original IDs as a link::Classes/FluidLabelSet::.
+
+ARGUMENT:: buffer
+The buffer to read from. The dataset will be resized.
+
+ARGUMENT:: transpose
+If 0, each buffer frame becomes a dataset point, and each buffer channel becomes a dataset dimension. If 1, channels become points, and frames become dimensions.
+
+ARGUMENT:: labelSet
+The link::Classes/FluidLabelSet:: from which to retrieve the point's IDs associated with their reference frame number (or channel number if transposed).
+
+ARGUMENT:: action
+A function to run when the import is done.
+
+METHOD:: getIds
+Export to the dataset IDs to a link::Classes/FluidLabelSet::.
+
+ARGUMENT:: labelSet
+The link::Classes/FluidLabelSet:: to export to. Its content will be replaced.
+​
+ARGUMENT:: action
+A function to run when the export is done.
+
+METHOD:: merge
+Merge sourceDataSet in the current DataSet. It will update the value of points with the same label if overwrite is set to 1. To add columns instead, see the 'transformJoin' method of link::Classes/FluidDataSetQuery::
+
+METHOD:: free
+Destroy the object on the server.
+
+METHOD:: print
+Post an abbreviated content of the DataSet in the window by default, but you can supply a custom action instead.
+
+returns:: A link::Classes/Synth::
+​
+METHOD:: server
+The server instance the object uses
+​
+returns:: A link::Classes/Server::
+
+EXAMPLES::
+
+CODE::
+// Create a simple a one-dimensional data set, three ways
+// Using routine
+s.boot;
+(
+fork{
+	~ds = FluidDataSet.new(s);
+	~point = Buffer.alloc(s,1,1);
+	s.sync;
+	10.do{|i|
+		~point.set(0,i);
+		~ds.addPoint(i.asString,~point,{("addPoint"+i).postln});
+		s.sync;
+	};
+	~ds.dump;
+	s.sync;
+	~ds.free;
+};
+)
+
+//Using Dictionary
+(
+d = Dictionary.new;
+d.add(\cols -> 1);
+d.add(\data -> Dictionary.newFrom(10.collect{|i|[i.asString, [i.asFloat]]}.flatten));
+fork{
+	~ds = FluidDataSet.new(s);
+	~ds.load(d); s.sync;
+	~ds.dump; s.sync; ~ds.free;
+}
+)
+
+// Using a synth
+(
+~ds = FluidDataSet.new(s);
+{
+	var trig = Impulse.kr(20);
+	var count = PulseCount.kr(trig) - 1;
+	var buf = LocalBuf(1);
+	BufWr.kr(count, buf);
+	FluidDataSetWr.kr(~ds.asUGenInput, idNumber: count, buf: buf, trig: trig);
+	FreeSelf.kr(count - 8);
+}.play.onFree{~ds.dump{|o| o.postln;~ds.free}}
+)
+::
+
+STRONG:: Buffer Interface::
+
+As the content of the dataset has a similar structure to buffers, namely arrays of floats in parallel, it is possible to transfer the content between the two. Careful consideration of the rotation of the buffer, as well as the relation of points to channel numbers, are needed.
+
+code::
+(
+//Make a dummy data set
+d = FluidDataSet(s);
+~data = Dictionary.with(*Array.iota(20).reshape(4,5).collect{|a,i| ("row"++i)->a});
+~dsdata = Dictionary.newFrom([\cols,5,\data,~data]);
+d.load(~dsdata);
+d.print;
+)
+
+//convert to separate buffer and labelset
+b = Buffer(s);
+l = FluidLabelSet(s);
+d.toBuffer(b,0,l);
+
+//check the result: by default, dataset points become frames, with their associated data columns as channels
+b.query
+b.getn(0,20,{|x|x.postln})
+l.print
+
+//you can also transpose your query, where dataset points are each a buffer channel, and each data column becomes a buffer frame
+d.toBuffer(b,1,l);
+b.query
+b.getn(0,20,{|x|x.postln})
+//note that the IDs are still one per item, as columns are unamed in datasets
+l.print
+
+//Convert back to DS again
+e = FluidDataSet(s);
+
+//Let's use the transposed data we just got
+e.print;
+e.fromBuffer(b,1,l);
+e.print;
+//if we didn't transpose, we would get an error as the labelset is mismatched with the number of items
+e.clear
+e.print
+e.fromBuffer(b,0,l)
+::
+
+STRONG:: Merging Datasets::
+code::
+//this is how to add items between 2 datasets.
+//create 2 datasets
+(
+~dsA = FluidDataSet.new(s);
+~dsB = FluidDataSet.new(s);
+)
+
+//feed them items with same dimensions but different labels
+~dsA.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\one,1,\two,2])]));
+~dsB.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\three,3,\four,4])]));
+~dsA.print;
+~dsB.print;
+
+// merge and check. it works.
+~dsB.merge(~dsA)
+~dsB.print;
+
+//change the content of the dataset to shared labels
+~dsA.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\three,333,\four,444])]));
+~dsB.load(Dictionary.newFrom([\cols, 1, \data, Dictionary.newFrom([\three,3,\four,4])]));
+~dsA.print;
+~dsB.print;
+
+//try to merge, it does not update
+~dsB.merge(~dsA)
+~dsB.print;
+
+// add the overwrite flag, and it works
+~dsB.merge(~dsA,1)
+~dsB.print;
+::
diff --git a/release-packaging/HelpSource/Classes/FluidDataSetQuery.schelp b/release-packaging/HelpSource/Classes/FluidDataSetQuery.schelp
new file mode 100644
index 0000000..e41bc26
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidDataSetQuery.schelp
@@ -0,0 +1,185 @@
+TITLE:: FluidDataSetQuery
+summary:: Query a FluidDataSet
+categories:: UGens>FluidManipulation
+related:: Classes/FluidDataSet
+
+DESCRIPTION::
+A selection of columns and a set of conditions that match rows of a FluidDataSet.
+Use to filter and search in a database of descriptors.
+
+CLASSMETHODS::
+
+METHOD:: new
+Make a new instance
+ARGUMENT:: server
+The server on which to run this object
+
+INSTANCEMETHODS::
+
+PRIVATE:: init
+
+METHOD:: addColumn
+Add a column to the query
+ARGUMENT:: column
+Column index
+ARGUMENT:: action
+Run when done
+
+METHOD:: addRange
+Add a range of columns to the query
+ARGUMENT:: start
+First index
+ARGUMENT:: count
+Number of columns
+ARGUMENT:: action
+Run when done
+
+METHOD:: filter
+Filter rows according to some condition.
+
+Example: (3, ">", 0.5) filters rows where the value of the 4th column (starting at 0) is larger than 0.5.
+ARGUMENT:: column
+Column index
+ARGUMENT:: condition
+Condition string. Possible values: "==", "!=", "<", "<=", ">", ">="
+ARGUMENT:: value
+Condition value
+ARGUMENT:: action
+Run when done
+
+METHOD:: and
+Add a condition to an existing filter with an "and" connector.
+ARGUMENT:: column
+Column index
+ARGUMENT:: condition
+Condition string. Possible values: "==", "!=", "<", "<=", ">", ">="
+ARGUMENT:: value
+Condition value
+ARGUMENT:: action
+Run when done
+
+
+METHOD:: or
+Add a condition to an existing filter with an "or" connector.
+ARGUMENT:: column
+Column index
+ARGUMENT:: condition
+Condition string. Possible values: "==", "!=", "<", "<=", ">", ">="
+ARGUMENT:: value
+Condition value
+ARGUMENT:: action
+Run when done
+
+METHOD:: limit
+Limit the number of resulting rows.
+ARGUMENT:: rows
+Maximum number of rows
+ARGUMENT:: action
+Run when done
+
+METHOD:: clear
+Clear the query, remove all columns, filters and limit.
+ARGUMENT:: action
+Run when done
+
+METHOD:: transform
+Apply the query to a source link::Classes/FluidDataSet:: and write to a destination. Can be the same.
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done
+
+METHOD:: transformJoin
+Apply the query to a source link::Classes/FluidDataSet:: and join the resulting subset at the end of the items sharing the same labels in a second source. Items unique to a source dataset will be ignored. To add items at the end of a dataset instead, see the 'merge' method of link::Classes/FluidDataSet::
+ARGUMENT:: source1DataSet
+Source data, or the DataSet name
+ARGUMENT:: source2DataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done
+
+
+EXAMPLES::
+
+code::
+
+s.reboot;
+// Create a DataSet with random data
+~dataSet= FluidDataSet(s);
+
+(
+~points = 100.collect{|i|5.collect{|j|j+(i/100)}};
+~dataSet.clear;
+~tmpbuf = Buffer.alloc(s,5);
+
+fork{
+    s.sync;
+    ~points.do{|x,i|
+        ~tmpbuf.setn(0,x);
+        ~dataSet.addPoint(i,~tmpbuf);
+        s.sync;
+    }
+}
+)
+
+//check the source
+~dataSet.print;
+
+// Prepare a FluidDataSetQuery object
+~query = FluidDataSetQuery.new;
+~out = FluidDataSet(s);
+
+// prepare a simple query
+~query.filter(0,"<",0.04);
+~query.addColumn(2);
+~query.transform(~dataSet, ~out);
+
+// check the result
+~out.print;
+
+//prepare a more complex query
+~query.clear;
+~query.filter(0,">",0.03);
+~query.and(1,"<",1.08);
+~query.or(2,">",2.98);
+~query.addRange(2,2);
+~query.transform(~dataSet, ~out);
+
+// Check the results
+~out.print;
+
+::
+
+STRONG:: Joining Datasets::
+
+code::
+//this is how to join 2 datasets, adding columns to items with the same label
+//create 3 datasets
+(
+~dsA =  FluidDataSet(s);
+~dsB =  FluidDataSet(s);
+~dsC =  FluidDataSet(s);
+)
+
+//feed them items with almost overlaping label lists but with different dimensions
+~dsA.load(Dictionary.newFrom([\cols, 2, \data, Dictionary.newFrom([\zero, [0,0], \one,[1,11],\two,[2,22], \three,[3,33],\four,[4,44]])]));
+~dsB.load(Dictionary.newFrom([\cols, 2, \data, Dictionary.newFrom([\one,[111,1111],\two,[222,2222], \three,[333,3333],\four,[444,4444],\five,[555,5555]])]));
+~dsA.print;
+~dsB.print;
+
+// no query/filter defined, copies all items with labels common to both, and all of the defined column of the first input
+~joiner = FluidDataSetQuery.new;
+~joiner.transformJoin(~dsA,~dsB,~dsC)
+~dsC.print
+
+// all the sophisticated conditions applicable to 'transform' can be done on the first dataset too. Selected columns of the first source are appended to matching items in the second source.
+~joiner.filter(0,">",2.1)
+~joiner.and(1,"<", 40)
+~joiner.addColumn(0)
+~joiner.transformJoin(~dsA,~dsB,~dsC)
+~dsC.print
+::
diff --git a/release-packaging/HelpSource/Classes/FluidDataSetWr.schelp b/release-packaging/HelpSource/Classes/FluidDataSetWr.schelp
new file mode 100644
index 0000000..f92de08
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidDataSetWr.schelp
@@ -0,0 +1,149 @@
+TITLE:: FluidDataSetWr
+summary:: Write to FluidDataSet on the server
+categories:: FluidManipulation
+related:: Classes/FLuidDataSet
+
+DESCRIPTION::
+A UGen that adds labelled points to a link::Classes/FluidDataSet:: Internally, this calls code::setPoint::, so IDs that already exist will be overwritten, and new IDs will be added. The actual work is done on the server's command queue, rather than the real-thread.
+
+By default the object takes a control input (code::idNumber::) as a numerical index that gets used for the point labels. This index is used to write each time the Ugen is re-triggered with a zero to non-zero transition. The label is then concatenated with the code::idPrefix:: symbol, which is fixed at instantiation. In this way, one can make custom, incrementing labels, e.g.
+
+code::
+FluidDataSetWr.kr(~somedataset,"my_data",PulseCount.kr(trig),~somebuffer,trig)
+::
+
+would add points like code::my_data0, mydata1, mydata2...:: if successively retriggered.
+
+Alternatively, for one shot use you may not want a numerical suffix at all. Setting code::idNumber:: to code:: nil:: will bypass this and use only the code::idPrefix:: string.
+
+CLASSMETHODS::
+
+private:: *new1
+
+METHOD:: kr
+The equivalent of calling link::Classes/FluidDataSet#-addPoint::, but within a link::Classes/Synth::
+
+ARGUMENT:: dataset
+An instance of link::Classes/FluidDataSet:: or an instance's name.
+
+ARGUMENT:: idPrefix
+A string or symbol with a prefix for generated labels.
+
+ARGUMENT:: idNumber
+ANCHOR::offset::
+An integer with the offset to start labeling from. If the UGen is run in a server-side loop (i.e. repeatedly re-triggered), the generated labels will count upwards from this offset. If nil, then no numerical index will be applied to the generated label (i.e. only the labelPrefix is used).
+
+ARGUMENT:: buf
+The link::Classes/Buffer:: containing the data point.
+
+ARGUMENT:: trig
+
+A kr trigger signal
+
+ARGUMENT:: blocking
+
+If 0 then the job will run in its own thread (not reccomended for this object)
+
+EXAMPLES::
+
+code::
+s.reboot;
+~ds = FluidDataSet(s);
+
+// write a single point, no counting
+(
+{
+	var b = LocalBuf.newFrom([0,1,2,3]);
+	FreeSelfWhenDone.kr(FluidDataSetWr.kr(~ds,"help_data_point", idNumber: nil, buf:b));
+}.play(s);
+)
+
+
+~ds.print;
+~ds.clear
+
+//Write a 100 points quite fast with server-side triggering
+(
+~ds.clear;
+OSCFunc({
+    "FluidDataSetWr help: all points written".postln;
+    ~ds.print
+},'/datasetwrdone').oneShot;
+
+{  |n|
+	var b = LocalBuf.newFrom([0,1,2,3]);
+    var trig = Impulse.kr(ControlRate.ir / 8);
+    var idx = Stepper.kr(trig,min:-1, max:n); //we need to start at -1 to catch the first increment
+	4.collect{|i| BufWr.kr([(4 * idx) + i],b,i)};
+    FluidDataSetWr.kr(~ds,idNumber:idx,buf:b,trig:trig);
+    SendReply.kr(idx >= (n-1), '/datasetwrdone');
+    FreeSelf.kr(idx >= (n-1));
+}.play(s,args:[n:100]);
+)
+
+~ds.print;
+~ds.clear
+
+//Again, but as fast as possible using a feedback of the trigger we are given when the writing is done
+(
+~ds.clear;
+OSCFunc({
+    "FluidDataSetWr help: all points written".postln;
+    ~ds.print
+},'/datasetwrdone').oneShot;
+
+{  |n|
+    var b = LocalBuf.newFrom([0,1,2,3]);
+    var trig = LocalIn.kr(1,1);
+    var idx = Stepper.kr(trig,min:-1, max:n);
+    var wr = FluidDataSetWr.kr(~ds,idNumber:idx,buf:b,trig:trig);
+    4.collect{|i| BufWr.kr([(4 * idx) + i],b,i)};
+    LocalOut.kr(Done.kr(wr));
+    SendReply.kr(idx >= (n-1), '/datasetwrdone');
+    FreeSelf.kr(idx >= (n-1));
+}.play(s,args:[n:100]);
+)
+
+~ds.print;
+~ds.clear
+
+// incremental buffer writing - sky is the limit
+// start the entry maker, trigging twice a second
+(
+{
+	var buf = LocalBuf.newFrom([0,1,2,3]);
+	var noise = 4.collect{WhiteNoise.kr()};
+	var trig = Impulse.kr(2);
+	var count = PulseCount.kr(trig);
+	4.do{|i|
+		BufWr.kr(noise[i], buf, DC.kr(i));
+	};
+	FluidDataSetWr.kr(~ds, idNumber: count, trig: trig, buf:buf);
+}.play(s);
+)
+
+//print a few times
+~ds.print;
+
+//clear before flushing the writing synth
+~ds.clear
+~ds.print;
+
+// circular writing
+(
+{
+	var buf = LocalBuf.newFrom([0,1,2,3]);
+	var noise = 4.collect{WhiteNoise.kr()};
+	var trig = Impulse.kr(2);
+	var count = Stepper.kr(trig, min: 0, max: 9, resetval: -1); //0 to 9, starting at -1 to catch the first entry
+	4.do{|i|
+		BufWr.kr(noise[i], buf, DC.kr(i));
+	};
+	FluidDataSetWr.kr(~ds, idNumber: count, trig: trig, buf:buf);
+}.play(s);
+)
+
+~ds.print;
+~ds.clear
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidGain.schelp b/release-packaging/HelpSource/Classes/FluidGain.schelp
index 2783e26..0933940 100644
--- a/release-packaging/HelpSource/Classes/FluidGain.schelp
+++ b/release-packaging/HelpSource/Classes/FluidGain.schelp
@@ -32,7 +32,7 @@ Varying the gain at audio rate.
 CODE::
 { FluidGain.ar(PinkNoise.ar(0.1), gain:LFTri.ar(1)) }.play
 ::
-Varying the gain at comtrol rate, in beautiful stereo.
+Varying the gain at control rate, in beautiful stereo.
 CODE::
 { FluidGain.ar(SinOsc.ar([222,333],mul:0.1), gain:LFTri.kr([0.5,0.7])) }.play
 ::
diff --git a/release-packaging/HelpSource/Classes/FluidKDTree.schelp b/release-packaging/HelpSource/Classes/FluidKDTree.schelp
new file mode 100644
index 0000000..14100e6
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidKDTree.schelp
@@ -0,0 +1,177 @@
+TITLE:: FluidKDTree
+summary:: KD Tree on the server
+categories:: FluidManipulation
+related:: Classes/FluidDataSet
+
+DESCRIPTION::
+A server-side K-Dimensional tree for efficient neighbourhood searches of multi-dimensional data.
+
+See https://scikit-learn.org/stable/modules/neighbors.html#nearest-neighbor-algorithms for more on KD Trees
+
+CLASSMETHODS::
+
+METHOD:: new
+Make a new KDTree model for the given server.
+ARGUMENT:: server
+The server on which to make the model.
+ARGUMENT:: numNeighbours
+The number of neighbours to return. A 0 will return all points in order of distance. When a radius is defined, numNeighbours is the maximum of items returned.
+ARGUMENT:: radius
+The threshold of acceptable distance for a point to be returned. A 0 will bypass this function, returning numNeighbours points.
+ARGUMENT:: lookupDataSet
+An optional link::Classes/FluidDataSet:: from which data points will be returned for realtime queries. This does not need to be the same DataSet that the tree was fitted against, but does need to have matching labels. Using this mechanism, we have a way to, e.g. associate labels with segments of playback buffers, without needing pass strings around the server. warning::This parameter can not be changed after the instance of FluidKDTree has been created::
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Build the tree by scanning the points of a LINK::Classes/FluidDataSet::
+ARGUMENT:: dataSet
+The LINK::Classes/FluidDataSet:: of interest. This can either be a data set object itself, or the name of one.
+ARGUMENT:: action
+A function to run when indexing is complete.
+
+METHOD:: kNearest
+Returns the IDs of the CODE::k:: points nearest to the one passed.
+ARGUMENT:: buffer
+A LINK::Classes/Buffer:: containing a data point to match against. The number of frames in the buffer must match the dimensionality of the LINK::Classes/FluidDataSet:: the tree was fitted to.
+ARGUMENT:: action
+A function that will run when the query returns, whose argument is an array of point IDs from the tree's LINK::Classes/FluidDataSet::
+
+METHOD:: kNearestDist
+Get the distances of the K nearest neighbours to a point.
+ARGUMENT:: buffer
+A LINK::Classes/Buffer:: containing a data point to match against. The number of frames in the buffer must match the dimensionality of the LINK::Classes/FluidDataSet:: the tree was fitted to.
+ARGUMENT:: action
+A function that will run when the query returns, whose argument is an array of distances.
+
+
+EXAMPLES::
+
+code::
+// Make a DataSet of random 2D points
+s.reboot;
+(
+fork{
+	d = Dictionary.with(
+		*[\cols -> 2,\data -> Dictionary.newFrom(
+			100.collect{|i| [i, [ 1.0.linrand,1.0.linrand]]}.flatten)]);
+	~ds = FluidDataSet(s);
+	~ds.load(d, {~ds.print});
+}
+)
+
+// Make a new tree, and fit it to the DataSet
+~tree = FluidKDTree(s,numNeighbours:5);
+
+//Fit it to the DataSet
+~tree.fit(~ds);
+
+// Should be 100 points, 2 columns
+~tree.size;
+~tree.cols;
+
+//Return the labels of k nearest points to a new point
+(
+~p = [ 1.0.linrand,1.0.linrand ];
+~tmpbuf = Buffer.loadCollection(s, ~p, 1, {
+	~tree.kNearest(~tmpbuf,{ |a|a.postln;~nearest = a;})
+});
+)
+
+// Retrieve values from the DataSet by iterating through the returned labels
+(
+fork{
+	~nearest.do{|n|
+		~ds.getPoint(n, ~tmpbuf, {~tmpbuf.getn(0, 2, {|x|x.postln})});
+		s.sync;
+	}
+}
+)
+// Distances of the nearest points
+~tree.kNearestDist(~tmpbuf, { |a| a.postln });
+
+// Explore changing the number of neighbourgs
+~tree.numNeighbours = 11; // note that this value needs to be sent to the server
+~tree.kNearest(~tmpbuf,{ |a|a.postln;});
+~tree.numNeighbours = 0; // 0 will return all items in order of distance
+~tree.kNearest(~tmpbuf,{ |a|a.postln;});
+
+// Limit the search to an acceptable distance in a radius
+// Define a point, and observe typical distance values
+~p = [ 0.4,0.4];
+(
+~tmpbuf = Buffer.loadCollection(s, ~p, 1, {
+	~tree.kNearest(~tmpbuf,{ |a|a.postln;});
+	~tree.kNearestDist(~tmpbuf,{ |a|a.postln;});
+});
+)
+
+// enter a valid radius.
+~tree.radius = 0.1;
+// FluidKDTree will return only values that are within that radius, up to numNeighbours values
+(
+~tmpbuf = Buffer.loadCollection(s, ~p, 1, {
+	~tree.kNearest(~tmpbuf,{ |a|a.postln;});
+});
+)
+::
+
+subsection:: Queries in a Synth
+
+Input and output is done via buffers, which will need to be preallocated to the correct sizes:
+LIST::
+##Your input buffer should be sized to the input data dimension (2, in this example)
+##Your output buffer should be the number of neighbours * output dimensionality
+::
+
+We can't simply return labels (i.e. strings) from a UGen, so the query returns the actual data points from a DataSet instead. By default, this is the FluidDataSet against which the tree was fitted. However, by passing a different dataset to code::kr::'s code::lookupDataSet:: argument instead, you can return different points, so long as the labels in the two datasets match. In this way, the FluidKDTree can be used to perform nearest neighbour mappings in a synth.
+
+For instance, whilst fitting the tree against some n-dimensional descriptor data, our lookup dataset could use the same labels to map descriptor entries back to buffers, or locations in buffers, so that queries can be used to trigger audio.
+
+code::
+
+(
+Routine{
+    var inputBuffer = Buffer.alloc(s,2);
+    var outputBuffer = Buffer.alloc(s,10);//5 neighbours * 2D data points
+    s.sync;
+    {
+        var trig = Impulse.kr(4); //can go as fast as ControlRate.ir/2
+        var point = 2.collect{TRand.kr(0,1,trig)};
+        point.collect{|p,i| BufWr.kr([p],inputBuffer,i)};
+        ~tree.kr(trig,inputBuffer,outputBuffer,5,nil);
+		Poll.kr(trig, BufRd.kr(1,outputBuffer,Array.iota(10)),10.collect{|i| "Neighbour" + (i/2).asInteger ++ "-" ++ (i.mod(2))});
+        Silent.ar;
+    }.play;
+}.play;
+)
+
+//Using a lookup data set instead:
+//here we populate with numbers that are in effect the indicies, but it could be anything numerical that will be returned on the server-side and would be usable on that side
+(
+fork{
+	d = Dictionary.with(
+		*[\cols -> 1,\data -> Dictionary.newFrom(
+			100.collect{|i| [i, [ i ]]}.flatten)]);
+	~dsL = FluidDataSet.new(s);
+	~dsL.load(d, {~dsL.print});
+}
+)
+
+// Create the buffers, and make a synth, querying our tree with some random points
+(
+Routine{
+    var inputBuffer = Buffer.alloc(s,2);
+    var outputBuffer = Buffer.alloc(s,5);//5 neighbours * 1D points
+    s.sync;
+    {
+        var trig = Impulse.kr(4); //can go as fast as ControlRate.ir/2
+        var point = 2.collect{TRand.kr(0,1,trig)};
+        point.collect{|p,i| BufWr.kr([p],inputBuffer,i)};
+        ~tree.kr(trig,inputBuffer,outputBuffer,5,~dsL);
+		Poll.kr(trig, BufRd.kr(1,outputBuffer,Array.iota(5)),5.collect{|i| "Neighbour" + i});
+        Silent.ar;
+    }.play;
+}.play;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidKMeans.schelp b/release-packaging/HelpSource/Classes/FluidKMeans.schelp
new file mode 100644
index 0000000..1dcf71f
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidKMeans.schelp
@@ -0,0 +1,259 @@
+TITLE:: FluidKMeans
+summary:: Cluster data points with K-Means
+categories:: FluidManipulation
+related:: Classes/FluidDataSet, Classes/FluidLabelSet, Classes/FluidKNNClassifier, Classes/FluidKNNRegressor
+
+DESCRIPTION::
+Uses the K-Means algorithm to learn clusters from a link::Classes/FluidDataSet::
+
+https://scikit-learn.org/stable/tutorial/statistical_inference/unsupervised_learning.html#clustering-grouping-observations-together
+
+CLASSMETHODS::
+
+METHOD:: new
+Construct a new K Means model on the passed server. The parameters code::numClusters:: and code::maxIter:: can be modulated on an existing instance.
+ARGUMENT:: server
+If nil will use Server.default.
+ARGUMENT:: numClusters
+The number of clusters to classify data into.
+ARGUMENT:: maxIter
+The maximum number of iterations the algorithm will use whilst fitting.
+
+
+INSTANCEMETHODS::
+
+PRIVATE::k
+
+METHOD:: fit
+Identify code::numClusters:: clusters in a link::Classes/FluidDataSet::. It will optimise until no improvement is possible, or up to code::maxIter::, whichever comes first. Subsequent calls will continue training from the stopping point with the same conditions.
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: of data points.
+ARGUMENT:: action
+A function to run when fitting is complete, taking as its argument an array with the number of data points for each cluster.
+
+METHOD:: predict
+Given a trained object, return the cluster ID for each data point in a link::Classes/FluidDataSet:: to a  link::Classes/FluidLabelSet::.
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: containing the data to predict.
+ARGUMENT:: labelSet
+A link::Classes/FluidLabelSet:: to retrieve the predicted clusters.
+ARGUMENT:: action
+A function to run when the server responds.
+
+METHOD:: fitPredict
+Run link::Classes/FluidKMeans#*fit:: and link::Classes/FluidKMeans#*predict:: in a single pass: i.e. train the model on the incoming link::Classes/FluidDataSet:: and then return the learned clustering to the passed link::Classes/FluidLabelSet::
+ARGUMENT:: dataSet
+a link::Classes/FluidDataSet:: containing the data to fit and predict.
+ARGUMENT:: labelSet
+a link::Classes/FluidLabelSet:: to retrieve the predicted clusters.
+ARGUMENT:: action
+A function to run when the server responds
+
+METHOD:: predictPoint
+Given a trained object, return the cluster ID for a data point in a link::Classes/Buffer::
+ARGUMENT:: buffer
+A link::Classes/Buffer:: containing a data point.
+ARGUMENT:: action
+A function to run when the server responds, taking the ID of the cluster as its argument.
+
+METHOD:: transform
+Given a trained object, return for each item of a provided link::Classes/FluidDataSet:: its distance to each cluster as an array, often reffered to as the cluster-distance space.
+ARGUMENT:: srcDataSet
+A link::Classes/FluidDataSet:: of data points to transform.
+ARGUMENT:: dstDataSet
+A link::Classes/FluidDataSet:: to contain the new cluster-distance space.
+ARGUMENT:: action
+A function to run when complete.
+
+METHOD:: fitTransform
+Run link::Classes/FluidKMeans#*fit:: and link::Classes/FluidKMeans#*transform:: in a single pass: i.e. train the model on the incoming link::Classes/FluidDataSet:: and then return its cluster-distance space in the destination link::Classes/FluidDataSet::
+ARGUMENT:: srcDataSet
+A link::Classes/FluidDataSet:: containing the data to fit and transform.
+ARGUMENT:: dstDataSet
+A link::Classes/FluidDataSet:: to contain the new cluster-distance space.
+ARGUMENT:: action
+A function to run when complete.
+
+METHOD:: transformPoint
+Given a trained object, return the distance of the provided point to each cluster. Both points are handled as link::Classes/Buffer::
+ARGUMENT:: sourceBuffer
+A link::Classes/Buffer:: containing a data point to query.
+ARGUMENT:: targetBuffer
+A link::Classes/Buffer:: containing a the distance of the source point to each cluster.
+ARGUMENT:: action
+A function to run when complete.
+
+METHOD:: getMeans
+Given a trained object, retrieve the means (centroids) of each cluster as a link::Classes/FluidDataSet::
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: of clusers with a mean per column.
+ARGUMENT:: action
+A function to run when complete.
+
+METHOD:: setMeans
+Overwrites the means (centroids) of each cluster, and declare the object trained.
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: of clusers with a mean per column.
+ARGUMENT:: action
+A function to run when complete.
+
+METHOD:: clear
+Reset the object status to not fitted and untrained.
+ARGUMENT:: action
+A function to run when complete.
+
+EXAMPLES::
+code::
+
+(
+//Make some clumped 2D points and place into a DataSet
+~points = (4.collect{
+		       64.collect{(1.sum3rand) + [1,-1].choose}.clump(2)
+	       }).flatten(1) * 0.5;
+fork{
+    ~dataSet =  FluidDataSet(s);
+    d = Dictionary.with(
+        *[\cols -> 2,\data -> Dictionary.newFrom(
+			~points.collect{|x, i| [i, x]}.flatten)]);
+    s.sync;
+    ~dataSet.load(d, {~dataSet.print});
+}
+)
+
+
+// Create a KMeans instance and a LabelSet for the cluster labels in the server
+~clusters = FluidLabelSet(s);
+~kmeans = FluidKMeans(s);
+
+// Fit into 4 clusters
+(
+~kmeans.fitPredict(~dataSet,~clusters,action: {|c|
+		"Fitted.\n # Points in each cluster:".postln;
+		c.do{|x,i|
+			("Cluster" + i + "->" + x.asInteger + "points").postln;
+		}
+	});
+)
+
+// Cols of kmeans should match DataSet, size is the number of clusters
+
+~kmeans.cols;
+~kmeans.size;
+~kmeans.dump;
+
+// Retrieve labels of clustered points
+(
+~assignments = Array.new(128);
+fork{
+    128.do{ |i|
+        ~clusters.getLabel(i,{|clusterID|
+            (i.asString+clusterID).postln;
+            ~assignments.add(clusterID)
+        });
+        s.sync;
+    }
+}
+)
+
+//or faster by sorting the IDs
+~clusters.dump{|x|~assignments = x.at("data").atAll(x.at("data").keys.asArray.sort{|a,b|a.asInteger < b.asInteger}).flatten.postln;}
+
+//Visualise: we're hoping to see colours neatly mapped to quandrants...
+(
+d = ((~points + 1) * 0.5).flatten(1).unlace;
+w = Window("scatter", Rect(128, 64, 200, 200));
+~colours = [Color.blue,Color.red,Color.green,Color.magenta];
+w.drawFunc = {
+	Pen.use {
+		d[0].size.do{|i|
+			var x = (d[0][i]*200);
+			var y = (d[1][i]*200);
+			var r = Rect(x,y,5,5);
+			Pen.fillColor = ~colours[~assignments[i].asInteger];
+			Pen.fillOval(r);
+		}
+	}
+};
+w.refresh;
+w.front;
+)
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~kmeans.predictPoint(~inbuf,{|x|x.postln;});
+::
+
+subsection:: Accessing the means
+
+We can get and set the means for each cluster, their centroid.
+
+code::
+// with the dataset and kmeans generated and trained in the code above
+~centroids = FluidDataSet(s);
+~kmeans.getMeans(~centroids, {~centroids.print});
+
+// We can also set them to arbitrary values to seed the process
+~centroids.load(Dictionary.newFrom([\cols, 2, \data, Dictionary.newFrom([\0, [0.5,0.5], \1, [-0.5,0.5], \2, [0.5,-0.5], \3, [-0.5,-0.5]])]));
+~centroids.print
+~kmeans.setMeans(~centroids, {~kmeans.predict(~dataSet,~clusters,{~clusters.dump{|x|var count = 0.dup(4); x["data"].keysValuesDo{|k,v|count[v[0].asInteger] = count[v[0].asInteger] + 1;};count.postln}})});
+
+// We can further fit from the seeded means
+~kmeans.fit(~dataSet)
+// then retreive the improved means
+~kmeans.getMeans(~centroids, {~centroids.print});
+//subtle in this case but still.. each quadrant is where we seeded it.
+::
+
+subsection:: Cluster-distance Space
+
+We can get the euclidian distance of a given point to each cluster. This is often referred to as the cluster-distance space as it creates new dimensions for each given point, one distance per cluster.
+
+code::
+// with the dataset and kmeans generated and trained in the code above
+b = Buffer.sendCollection(s,[0.5,0.5])
+c = Buffer(s)
+
+// get the distance of our given point (b) to each cluster, thus giving us 4 dimensions in our cluster-distance space
+~kmeans.transformPoint(b,c,{|x|x.query;x.getn(0,x.numFrames,{|y|y.postln})})
+
+// we can also transform a full dataset
+~srcDS = FluidDataSet(s)
+~cdspace = FluidDataSet(s)
+// make a new dataset with 4 points
+~srcDS.load(Dictionary.newFrom([\cols, 2, \data, Dictionary.newFrom([\pp, [0.5,0.5], \np, [-0.5,0.5], \pn, [0.5,-0.5], \nn, [-0.5,-0.5]])]));
+~kmeans.transform(~srcDS, ~cdspace, {~cdspace.print})
+::
+
+subsection:: Queries in a Synth
+
+This is the equivalent of predictPoint, but wholly on the server
+
+code::
+(
+{
+    var trig = Impulse.kr(5);
+    var point = WhiteNoise.kr(1.dup);
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+    Poll.kr(trig, point, [\pointX,\pointY]);
+    point.collect{ |p,i| BufWr.kr([p],inputPoint,i)};
+    ~kmeans.kr(trig,inputPoint,outputPoint);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,0,interpolation:0),\cluster);
+}.play;
+)
+
+// to sonify the output, here are random values alternating quadrant, generated more quickly as the cursor moves rightwards
+(
+{
+	var trig = Impulse.kr(MouseX.kr(0,1).exprange(0.5,ControlRate.ir / 2));
+	var step = Stepper.kr(trig,max:3);
+	var point = TRand.kr(-0.1, [0.1, 0.1], trig) + [step.mod(2).linlin(0,1,-0.6,0.6),step.div(2).linlin(0,1,-0.6,0.6)] ;
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+	point.collect{|p,i| BufWr.kr([p],inputPoint,i)};
+    ~kmeans.kr(trig,inputPoint,outputPoint);
+    SinOsc.ar((BufRd.kr(1,outputPoint,0,interpolation:0) + 69).midicps,mul: 0.1);
+}.play;
+)
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidKNNClassifier.schelp b/release-packaging/HelpSource/Classes/FluidKNNClassifier.schelp
new file mode 100644
index 0000000..9166851
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidKNNClassifier.schelp
@@ -0,0 +1,181 @@
+TITLE:: FluidKNNClassifier
+summary:: Classify data with K Nearest Neighbours
+categories:: Classification, KNN
+related:: Classes/FluidKNNRegressor, Classes/FluidDataSet, Classes/FluidLabelSet
+
+DESCRIPTION::
+A nearest-neighbour classifier using link::Classes/FluidKDTree:: . Each point is assigned the class that is most common among its nearest neighbours.
+https://scikit-learn.org/stable/modules/neighbors.html#classification
+
+CLASSMETHODS::
+
+METHOD:: new
+Create a new KNNClassifier
+ARGUMENT:: server
+The server to make the model on
+ARGUMENT:: numNeighbours
+the number of neighours to consider
+ARGUMENT:: weight
+true / false: whether the neighbours should be weighted by distance
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Fit the model to a source link::Classes/FluidDataSet:: and a target link::Classes/FluidLabelSet::. These need to be the same size
+ARGUMENT:: dataSet
+Source data
+ARGUMENT:: labelSet
+Labels for the source data
+ARGUMENT:: action
+Run when done
+
+METHOD:: predict
+Given a fitted model, predict labels for a link::Classes/FluidDataSet:: and write these to a link::Classes/FluidLabelSet::
+ARGUMENT:: dataSet
+data to predict labels for
+ARGUMENT:: labelSet
+place to write labels
+ARGUMENT:: action
+Run when done
+
+METHOD:: predictPoint
+Given a fitted model, predict labels for a data point in a link::Classes/Buffer:: and return these to the caller
+ARGUMENT:: buffer
+A data point
+ARGUMENT:: action
+Run when done, passes predicted label as argument
+
+EXAMPLES::
+
+code::
+
+
+// Make:
+// - A KNN Classifier
+// - A DataSet of example points, and a label set of corresponding labels
+// - A DataSet of test data and a LabelSet for predicted labels
+
+(
+~classifier = FluidKNNClassifier(s);
+~source= FluidDataSet(s);
+~labels = FluidLabelSet(s);
+~test = FluidDataSet(s);
+~mapping = FluidLabelSet(s);
+)
+
+//Make some clumped 2D points and place into a DataSet
+(
+~examplepoints = [[0.5,0.5],[-0.5,0.5],[0.5,-0.5],[-0.5,-0.5]];
+~examplelabels = [\red,\orange,\green,\blue];
+d = Dictionary.new;
+d.add(\cols -> 2);
+d.add(\data -> Dictionary.newFrom(~examplepoints.collect{|x, i|[i.asString, x]}.flatten));
+~source.load(d);
+~examplelabels.collect{|x,i| ~labels.addLabel(i, x);};
+)
+
+//Make some random, but clustered test points
+(
+~testpoints = (4.collect{
+               64.collect{(1.sum3rand) + [1,-1].choose}.clump(2)
+           }).flatten(1) * 0.5;
+d = Dictionary.with(
+        *[\cols -> 2,\data -> Dictionary.newFrom(
+            ~testpoints.collect{|x, i| [i, x]}.flatten)]);
+ ~test.load(d);
+
+)
+
+
+//Fit the classifier to the example DataSet and labels, and then run prediction on the test data into our mapping label set
+(
+~classifier.fit(~source,~labels);
+~classifier.predict(~test, ~mapping, 1);
+)
+
+//Return labels of clustered points - wait for the dump to be done
+(
+~assignments = Array.new(~testpoints.size);
+fork{
+    ~testpoints.do{|x,i|
+        ~mapping.getLabel(i, action:{|l|
+            ~assignments.add(l);
+        });
+        s.sync;
+        if(i==(~testpoints.size - 1)){"Got assignments".postln;}
+    };
+    ~assignments.postln;
+}
+)
+
+//Visualise: we're hoping to see colours neatly mapped to quandrants...
+(
+c = IdentityDictionary();
+
+c.add(\red->Color.red);
+c.add(\blue->Color.blue);
+c.add(\green->Color.green);
+c.add(\orange-> Color.new255(255, 127, 0));
+
+e = 200 * ((~examplepoints + 1) * 0.5).flatten(1).unlace;
+d = ((~testpoints + 1) * 0.5).flatten(1).unlace;
+// d = [20.collect{1.0.rand}, 20.collect{1.0.rand}];
+w = Window("scatter", Rect(128, 64, 200, 200));
+~colours = [Color.blue,Color.red,Color.green,Color.magenta];
+w.drawFunc = {
+    Pen.use {
+        e[0].size.do{|i|
+            var r = Rect(e[0][i],e[1][i],10,10);
+            Pen.fillColor = c[~examplelabels[i]];
+            Pen.fillOval(r);
+        };
+        d[0].size.do{|i|
+            var x = (d[0][i]*200);
+            var y = (d[1][i]*200);
+            var r = Rect(x,y,5,5);
+            Pen.fillColor = c[~assignments[i].asSymbol].alpha_(0.3);
+            Pen.fillOval(r);
+        }
+    }
+};
+w.refresh;
+w.front;
+)
+
+// single point prediction on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~classifier.predictPoint(~inbuf,{|x|x.postln;});
+::
+
+subsection::Server Side Queries
+This is the equivalent of predictPoint, but wholly on the server
+code::
+
+//Generate a random point and sends a trigger to query, and return the class that point matches
+(
+{
+	var trig = Impulse.kr(5);
+	var point = WhiteNoise.kr(1.dup);
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+	Poll.kr(trig, point, [\pointX,\pointY]);
+	point.collect{ |p,i| BufWr.kr([p],inputPoint,i)};
+    ~classifier.kr(trig,inputPoint,outputPoint);
+	Poll.kr(trig,BufRd.kr(1,outputPoint,0,interpolation:0),\cluster);
+}.play;
+)
+
+// to sonify the output, here are random values alternating quadrant.
+(
+{
+	var trig = Impulse.kr(MouseX.kr(0,1).exprange(0.5,ControlRate.ir /2).poll(trig:2, label: "Query Frequency"));
+	var step = Stepper.kr(trig,max:3);
+	var point = TRand.kr(-0.1, [0.1, 0.1], trig) + [step.mod(2).linlin(0,1,-0.6,0.6),step.div(2).linlin(0,1,-0.6,0.6)] ;
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+	point.collect{|p,i| BufWr.kr([p],inputPoint,i)};
+    ~classifier.kr(trig,inputPoint,outputPoint);
+    SinOsc.ar((BufRd.kr(1,outputPoint,0,interpolation:0) + 69).midicps, mul: 0.1);
+}.play
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidKNNRegressor.schelp b/release-packaging/HelpSource/Classes/FluidKNNRegressor.schelp
new file mode 100644
index 0000000..b950e07
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidKNNRegressor.schelp
@@ -0,0 +1,131 @@
+TITLE:: FluidKNNRegressor
+summary:: Regression with K Nearest Neighbours
+categories:: Regression
+related:: Classes/FluidKNNClassifier, Classes/FluidDataSet
+
+DESCRIPTION::
+A nearest-neighbour regressor. A continuous value is predicted for each point as the (weighted) average value of its nearest neighbours.
+
+https://scikit-learn.org/stable/modules/neighbors.html#regression
+
+CLASSMETHODS::
+
+METHOD:: new
+Create a new KNN regressor on the server
+ARGUMENT:: server
+The server to run this model on.
+ARGUMENT:: numNeighbours
+number of neigbours to consider in mapping, min 1
+ARGUMENT:: weight
+Whether to weight neighbours by distance when producing new point
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Map a source link::Classes/FluidDataSet:: to a one-dimensional target; both DataSets need to have the same number of points.
+ARGUMENT:: sourceDataSet
+Source data
+ARGUMENT:: targetDataSet
+Target data
+ARGUMENT:: action
+Run when done
+
+
+METHOD:: predict
+Apply learned mapping to a link::Classes/FluidDataSet:: and write to an output DataSet
+ARGUMENT:: sourceDataSet
+data to regress
+ARGUMENT:: targetDataSet
+output data
+ARGUMENT:: action
+Run when done
+
+METHOD:: predictPoint
+Apply learned mapping to a data point in a link::Classes/Buffer::
+ARGUMENT:: buffer
+data point
+ARGUMENT:: action
+Run when done
+
+EXAMPLES::
+
+code::
+
+//Make a simple mapping between a ramp and a sine cycle, test with an exponentional ramp
+(
+~source = FluidDataSet(s);
+~target = FluidDataSet(s);
+~test = FluidDataSet(s);
+~output = FluidDataSet(s);
+~tmpbuf = Buffer.alloc(s,1);
+~regressor = FluidKNNRegressor(s);
+)
+
+//Make source, target and test data
+(
+~sourcedata = 128.collect{|i|i/128};
+~targetdata = 128.collect{|i| sin(2*pi*i/128) };
+~testdata = 128.collect{|i|(i/128)**2};
+
+~source.load(
+	Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+			~sourcedata.collect{|x, i| [i.asString, [x]]}.flatten)])
+);
+
+~target.load(
+d = Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+			~targetdata.collect{|x, i| [i.asString, [x]]}.flatten)]);
+);
+
+~test.load(
+	Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+			~testdata.collect{|x, i| [i.asString, [x]]}.flatten)])
+);
+
+~targetdata.plot;
+~source.print;
+~target.print;
+~test.print;
+
+)
+
+// Now make a regressor and fit it to the source and target, and predict against test
+//grab the output data whilst we're at it, so we can inspect
+(
+~outputdata = Array(128);
+~regressor.fit(~source, ~target);
+~regressor.predict(~test, ~output, 1, action:{
+		~output.dump{|x| 128.do{|i|
+		~outputdata.add(x["data"][i.asString][0])
+	}};
+});
+)
+
+//We should see a single cycle of a chirp
+~outputdata.plot;
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,[0.5]);
+~regressor.predictPoint(~inbuf,{|x|x.postln;});
+::
+
+subsection:: Server Side Queries
+
+code::
+//we are here querying with a saw in control rate, all on the server, via a buffer interface
+(
+{
+	var input = Saw.kr(2).linlin(-1,1,0,1);
+	var trig = Impulse.kr(ControlRate.ir/10);
+    var inputPoint = LocalBuf(1);
+    var outputPoint = LocalBuf(1);
+	BufWr.kr(input,inputPoint,0);
+    ~regressor.kr(trig,inputPoint,outputPoint);
+    BufRd.kr(1,outputPoint,0);
+}.scope
+)
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidLabelSet.schelp b/release-packaging/HelpSource/Classes/FluidLabelSet.schelp
new file mode 100644
index 0000000..91ee776
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidLabelSet.schelp
@@ -0,0 +1,56 @@
+TITLE:: FluidLabelSet
+summary:: A set of labels associated with IDs
+categories:: FluidManipulation
+related:: Classes/FluidDataSet, Classes/FluidKMeans
+
+DESCRIPTION::
+FluidLabelSet is a server-side container of associations between labels (from a link::Classes/FluidDataSet::) and IDs, for instance from some clustering or classification of the points in a data set.
+
+
+CLASSMETHODS::
+
+METHOD:: new
+Make a new instance of a label set, uniquely identified by its name. Creating an instance with a name already in use will throw an exception. Use link::Classes/FluidLabelSet#*at:: or free the existing instance.
+ARGUMENT:: server
+The link::Classes/Server:: on which to create the label set.
+
+
+INSTANCEMETHODS::
+
+PRIVATE:: init, id
+
+METHOD:: addLabel
+Add a label to the label set.
+ARGUMENT:: identifier
+symbol or string with the ID for this label.
+ARGUMENT:: label
+symbol or string with the label to add.
+ARGUMENT:: action
+function to run when the operation completes.
+
+METHOD:: updateLabel
+Change a label in the label set.
+
+METHOD:: getLabel
+Retrieve the label associated with an ID. Will report an error if the ID isn't present in the set.
+
+METHOD:: deleteLabel
+Remove a id-label pair from the label set.
+
+METHOD:: clear
+Empty the label set.
+
+
+METHOD:: print
+Post an abbreviated content of the label set in the window by default, but you can supply a custom action instead.
+
+EXAMPLES::
+
+code::
+~ls = FluidLabelSet.new(s);
+
+["one", "two", "three"].collect{|x,i| ~ls.addLabel(i, x);};
+~ls.print;
+
+~ls.free;
+::
diff --git a/release-packaging/HelpSource/Classes/FluidLoadFolder.schelp b/release-packaging/HelpSource/Classes/FluidLoadFolder.schelp
new file mode 100644
index 0000000..1697203
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidLoadFolder.schelp
@@ -0,0 +1,78 @@
+TITLE:: FluidLoadFolder
+summary:: Load a folder of audio into a single buffer
+categories:: FluidCorpusManipulation
+related:: Classes/FluidSliceCorpus, Classes/FluidProcessSlices
+
+DESCRIPTION::
+Given a path name, load every audio file in the path (using link::Classes/SoundFile#*collect::), allocate a link::Classes/Buffer::, and load the files top to tail into the buffer. Information about start stop points, channel counts and sample rates is then stored in link::Classes/FluidLoadFolder#index:: as a link::Classes/IdentityDictionary::.
+
+
+CLASSMETHODS::
+
+METHOD:: new
+Construct a new instance
+
+ARGUMENT:: path
+A string pointing to a folder on disk
+
+ARGUMENT:: labelFunc
+A function that determines how the chunks in the index are labelled; default is file name without path.
+
+ARGUMENT:: channelFunc
+A funciton that controls what to do with differently wide files. Default behaviour is for loaded buffer to have as many channels as the widest file in the path, and for narrower files to repeat their channels across this buffer. The funciton is passed the channels for the current file, the maximum channel count, and the current index.
+
+INSTANCEMETHODS::
+
+METHOD:: index
+A link::Classes/IdentityDictionary:: containing the metadata on the loaded files
+
+The keys of this dictionary are the labels produced by the code::labelFunc:: passed to link::Classes/FluidLoadFolder#*new:: (or the default of the filename if nil). The value for each key is a further dictionary consisting of:
+
+definitionlist::
+## bounds
+|| A two element array giving the start and end point of this files eventual position in the overall buffer (in samples).
+## sr
+|| The sampling rate of the original file
+## numchans
+|| Number of channels in the original file
+::
+
+METHOD:: files
+The list of files loaded
+
+METHOD:: buffer
+The buffer in which the files are placed, end to end.
+
+METHOD:: play
+Load the files.
+
+ARGUMENT:: server
+The server on which to run
+
+ARGUMENT:: action
+Function to execute on completion
+
+
+EXAMPLES::
+
+code::
+s.reboot;
+
+(
+// We'll load all the Fluid Corpus Manipulation audio example files
+~path = File.realpath(FluidLoadFolder.class.filenameSymbol).dirname +/+ "../AudioFiles";
+
+~loader = FluidLoadFolder(~path);
+
+~loader.play(s,action:{ |dataDictionary|
+	("Done loading into" + ~loader.buffer).postln;
+	//we get passed an IdentityDictionary of slice data, let's look at it
+	dataDictionary.pairsDo{|label,data|
+		//data is also a dictionary
+		(label ++ '(').post;
+		data.pairsDo{|k,v| (k ++ ':' + v + ' ').post };
+		')'.postln;
+	}
+});
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidLoudness.schelp b/release-packaging/HelpSource/Classes/FluidLoudness.schelp
index 9a6ffdc..769b236 100644
--- a/release-packaging/HelpSource/Classes/FluidLoudness.schelp
+++ b/release-packaging/HelpSource/Classes/FluidLoudness.schelp
@@ -32,7 +32,7 @@ ARGUMENT:: maxwindowSize
 	How large can the windowSize be, by allocating memory at instantiation time. This cannot be modulated.
 
 RETURNS::
-	A 2-channel KR signal with the [pitch, confidence] descriptors. The latency is windowSize.
+	A 2-channel KR signal with the [loudness, peak] descriptors. The latency is windowSize.
 
 
 EXAMPLES::
diff --git a/release-packaging/HelpSource/Classes/FluidMDS.schelp b/release-packaging/HelpSource/Classes/FluidMDS.schelp
new file mode 100644
index 0000000..b1f7722
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidMDS.schelp
@@ -0,0 +1,177 @@
+TITLE:: FluidMDS
+summary:: Dimensionality Reduction with Multidimensional Scaling
+categories:: Dimensionality Reduction, Data Processing
+related:: Classes/FluidPCA, Classes/FluidDataSet
+
+DESCRIPTION::
+
+Multidimensional scaling of a link::Classes/FluidDataSet::
+
+https://scikit-learn.org/stable/modules/manifold.html#multi-dimensional-scaling-mds
+
+
+CLASSMETHODS::
+
+
+METHOD:: new
+Make a new instance
+ARGUMENT:: server
+The server on which to run this model
+ARGUMENT:: numDimensions
+The number of dimensions to reduce to
+ARGUMENT:: distanceMetric
+The distance metric to use (integer, 0-6, see utility constants below)
+
+METHOD:: euclidean
+Euclidean distance (default)
+
+METHOD:: sqeuclidean
+Squared Euclidean distance
+
+METHOD:: manhattan
+Manhattan distance
+
+METHOD:: max
+Minkowski max
+
+METHOD:: min
+Minkowski max
+
+METHOD:: kl
+Symmetric Kulback Leiber divergance (only makes sense with non-negative data)
+
+METHOD:: cosine
+Cosine distance
+
+INSTANCEMETHODS::
+
+PRIVATE:: init
+
+METHOD:: fitTransform
+Fit the model to a link::Classes/FluidDataSet:: and write the new projected data to a destination FluidDataSet.
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done
+
+EXAMPLES::
+
+code::
+
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers, a FluidStandardize and a FluidMDS
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s);
+~standardized = FluidDataSet(s);
+~reduced = FluidDataSet(s);
+~audio = Buffer.read(s,~audiofile);
+~mfcc_feature = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 12);
+~standardizer  = FluidStandardize(s);
+~mds = FluidMDS(s);
+)
+
+// Load audio and run an mfcc analysis, which gives us 13 points (we'll throw the 0th away)
+(
+~audio = Buffer.read(s,~audiofile);
+FluidBufMFCC.process(s,~audio, features: ~mfcc_feature);
+)
+
+// Divide the time series in 100, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(12, 1);
+    var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~mfcc_feature.numFrames / 100).asInteger;
+	var stats = FluidBufStats.kr(
+			source: ~mfcc_feature, startFrame: count * chunkLen,
+		    startChan:1, numFrames: chunkLen, stats: ~stats, trig: trig, blocking:1
+	);
+	var rd = BufRd.kr(12, ~stats, DC.kr(0), 0, 1);
+	var bufWr, dsWr;
+	12.do{|i|
+		bufWr = BufWr.kr(rd[i], buf, DC.kr(i));
+	};
+	dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats),blocking:1);
+    LocalOut.kr(Done.kr(dsWr));
+    FreeSelf.kr(count - 99);
+	Poll.kr(trig,(100-count));
+}.play;
+)
+// wait for the count to reaches 0 in the post window.
+
+//First standardize our DataSet, so that the MFCC dimensions are on comensurate scales
+//Then apply the MDS in-place on the standardized data to get 2 dimensions, using a Euclidean distance metric
+//Download the DataSet contents into an array for plotting
+(
+~reducedarray = Array.new(100);
+~standardizer.fitTransform(~raw, ~standardized);
+~mds.fitTransform(~standardized, ~reduced, action:{
+    ~reduced.dump{|x| 100.do{|i|
+        ~reducedarray.add(x["data"][i.asString])
+}}});
+)
+
+//Visualise the 2D projection of our original 12D data
+(
+d = ~reducedarray.flop.deepCollect(1, { |x| x.normalize});
+w = Window("scatter", Rect(128, 64, 200, 200));
+w.drawFunc = {
+    Pen.use {
+        d[0].size.do{|i|
+            var x = (d[0][i]*200);
+            var y = (d[1][i]*200);
+            var r = Rect(x,y,5,5);
+            Pen.fillColor = Color.blue;
+            Pen.fillOval(r);
+        }
+    }
+};
+w.refresh;
+w.front;
+)
+
+//we can change the distance computation
+~mds.distanceMetric = FluidMDS.kl;
+
+//recompute the reduction and recover the points
+(
+~reducedarray2 = Array.new(100);
+~mds.fitTransform(~standardized, ~reduced, action:{
+	~reduced.dump{|x| 100.do{|i|
+		~reducedarray2.add(x["data"][i.asString])
+     }}});
+)
+
+//draw the new projection in red above the other
+//Visualise the 2D projection of our original 12D data
+(
+d = ~reducedarray.flop.deepCollect(1, { |x| x.normalize});
+e = ~reducedarray2.flop.deepCollect(1, { |x| x.normalize});
+w = Window("scatter", Rect(128, 64, 200, 200));
+w.drawFunc = {
+    Pen.use {
+		d[0].size.do{|i|
+            var x = (d[0][i]*200);
+            var y = (d[1][i]*200);
+            var r = Rect(x,y,5,5);
+            Pen.fillColor = Color.blue;
+            Pen.fillOval(r);
+        };
+        e[0].size.do{|i|
+            var x = (e[0][i]*200);
+            var y = (e[1][i]*200);
+            var r = Rect(x,y,5,5);
+            Pen.fillColor = Color.red;
+            Pen.fillOval(r);
+        }
+    }
+};
+w.refresh;
+w.front;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidMFCC.schelp b/release-packaging/HelpSource/Classes/FluidMFCC.schelp
index 4fb62cf..dac7a3f 100644
--- a/release-packaging/HelpSource/Classes/FluidMFCC.schelp
+++ b/release-packaging/HelpSource/Classes/FluidMFCC.schelp
@@ -61,7 +61,7 @@ a.reference_(Array.fill(13,{0.5})); //make a center line to show 0
 
 //run the window updating routine.
 (
-~winRange = 500;
+~winRange = 200;
 
 r = Routine {
 	{
@@ -89,7 +89,7 @@ x = {arg type = 0;
 
 // change the wave types, observe the amplitude invariance of the descriptors, apart from the leftmost coefficient
 x.set(\type, 1)
-~winRange = 100; //adjust the range above and below 0 to zoom in or out on the MFCC
+~winRange = 5; //adjust the range above and below 0 to zoom in or out on the MFCC
 x.set(\type, 2)
 x.set(\type, 0)
 // free this source
@@ -106,6 +106,7 @@ x = {arg bands = 40, low = 20, high = 20000;
 	source.dup;
 }.play;
 )
+~winRange = 10; //adjust the range above and below 0 to zoom in or out on the MFCC
 
 // observe the number of bands. The unused ones at the top are not updated
 x.set(\bands,20)
diff --git a/release-packaging/HelpSource/Classes/FluidMLPClassifier.schelp b/release-packaging/HelpSource/Classes/FluidMLPClassifier.schelp
new file mode 100644
index 0000000..f58b84f
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidMLPClassifier.schelp
@@ -0,0 +1,189 @@
+TITLE:: FluidMLPClassifier
+summary:: Classification with a multi-layer perceptron
+categories:: Machine learning
+related:: Classes/FluidMLPRegressor, Classes/FluidDataSet
+
+Perform classification between a link::Classes/FluidDataSet:: and a link::Classes/FluidLabelSet:: using a Multi-Layer Perception neural network.
+
+CLASSMETHODS::
+
+METHOD:: new
+Creates a new instance on the server.
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run this model.
+
+ARGUMENT:: hidden
+An link::Classes/Array:: that gives the sizes of any hidden layers in the network (default is two hidden layers of three units each).
+
+ARGUMENT:: activation
+The activation function to use for the hidden layer units. Beware of the permitted ranges of each: relu (0->inf), sigmoid (0->1), tanh (-1,1).
+
+ARGUMENT:: maxIter
+The maximum number of iterations to use in training.
+
+ARGUMENT:: learnRate
+The learning rate of the network. Start small, increase slowly.
+
+ARGUMENT:: momentum
+The training momentum, default 0.9
+
+ARGUMENT:: batchSize
+The training batch size.
+
+ARGUMENT:: validation
+The fraction of the DataSet size to hold back during training to validate the network against.
+
+METHOD:: identity, sigmoid, relu, tanh
+A set of convinience constants for the available activation functions.
+
+INSTANCEMETHODS::
+
+PRIVATE:: init, uid
+
+METHOD:: fit
+Train the network to map between a source link::Classes/FluidDataSet:: and a target link::Classes/FluidLabelSet::
+
+ARGUMENT:: sourceDataSet
+Source data
+
+ARGUMENT:: targetLabelSet
+Target data
+
+ARGUMENT:: action
+Function to run when training is complete
+
+returns:: The training loss, or -1 if training failed
+
+METHOD:: predict
+Apply the learned mapping to a DataSet (given a trained network)
+
+ARGUMENT:: sourceDataSet
+Input data
+
+ARGUMENT:: targetLabelSet
+Output data
+
+ARGUMENT:: action
+Function to run when complete
+
+METHOD:: predictPoint
+Apply the learned mapping to a single data point in a link::Classes/Buffer::
+
+ARGUMENT:: sourceBuffer
+Input point
+
+ARGUMENT:: action
+A function to run when complete
+
+METHOD:: clear
+This will erase all the learning done in the neural network.
+
+ARGUMENT:: action
+A function to run when complete
+
+EXAMPLES::
+
+code::
+(
+~classifier=FluidMLPClassifier(s).hidden_([6]).activation_(FluidMLPClassifier.tanh).maxIter_(1000).learnRate_(0.1).momentum_(0.1).batchSize_(50).validation_(0);
+~sourcedata= FluidDataSet(s);
+~labels = FluidLabelSet(s);
+~testdata = FluidDataSet(s);
+~predictedlabels = FluidLabelSet(s);
+)
+//Make some clumped 2D points and place into a DataSet
+(
+~centroids = [[0.5,0.5],[-0.5,0.5],[0.5,-0.5],[-0.5,-0.5]];
+~categories = [\red,\orange,\green,\blue];
+~trainingset = Dictionary();
+~labeldata = Dictionary();
+4.do{ |i|
+	64.do{ |j|
+		~trainingset.put("mlpclass"++i++\_++j, ~centroids[i].collect{|x| x.gauss(0.5/3)});
+		~labeldata.put("mlpclass"++i++\_++j,[~categories[i]]);
+	}
+};
+~sourcedata.load(Dictionary.with(*[\cols->2,\data->~trainingset]),action:{~sourcedata.print});
+~labels.load(Dictionary.with(*[\cols->1,\data->~labeldata]),action:{~labels.print});
+)
+
+//Fit the classifier to the example DataSet and labels, and then run prediction on the test data into our mapping label set
+~classifier.fit(~sourcedata,~labels,action:{|loss| ("Trained"+loss).postln});
+
+//make some test data
+(
+~testset = Dictionary();
+4.do{ |i|
+	64.do{ |j|
+		~testset.put("mlpclass_test"++i++\_++j, ~centroids[i].collect{|x| x.gauss(0.5/3)});
+	}
+};
+~testdata.load(Dictionary.with(*[\cols->2,\data->~testset]),action:{~testdata.print});
+)
+
+//Run the test data through the network, into the predicted labelset
+~classifier.predict(~testdata,~predictedlabels,action:{"Test complete".postln});
+
+//get labels from server
+~predictedlabels.dump(action:{|d| ~labelsdict = d["data"]; ~labelsdict.postln});
+
+//Visualise: we're hoping to see colours neatly mapped to quandrants...
+(
+c = Dictionary();
+c.add("red"->Color.red);
+c.add("blue"->Color.blue);
+c.add("green"->Color.green);
+c.add("orange"->Color.new255(255, 127, 0));
+e = 200 * ((~centroids + 1) * 0.5).flatten(1).unlace;
+w = Window("scatter", Rect(128, 64, 200, 200));
+w.drawFunc = {
+    Pen.use {
+		~testset.keysValuesDo{|k,v|
+			var x = v[0].linlin(-1,1,200,0).asInteger;
+			var y = v[1].linlin(-1,1,200,0).asInteger;
+			var r = Rect(x,y,5,5);
+			Pen.fillColor = c.at(~labelsdict[k][0]);
+			Pen.fillOval(r);
+		}
+    }
+};
+w.refresh;
+w.front;
+)
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~classifier.predictPoint(~inbuf,{|x|x.postln;});
+::
+subsection::Querying in a Synth
+This is the equivalent of code::predictPoint::, but wholly on the server
+code::
+(
+{
+	var trig = Impulse.kr(5);
+	var point = WhiteNoise.kr(1.dup);
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+	Poll.kr(trig, point, [\pointX,\pointY]);
+	point.collect{ |p,i| BufWr.kr([p],inputPoint,i)};
+    ~classifier.kr(trig,inputPoint,outputPoint);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,0,interpolation:0),\cluster);
+    Silent.ar;
+}.play;
+)
+
+// to sonify the output, here are random values alternating quadrant.
+(
+{
+	var trig = Impulse.kr(MouseX.kr(0,1).exprange(0.5,ControlRate.ir /2).poll(trig: 2,label: "Query Frequency"));
+	var step = Stepper.kr(trig,max:3);
+	var point = TRand.kr(-0.1, [0.1, 0.1], trig) + [step.mod(2).linlin(0,1,-0.6,0.6),step.div(2).linlin(0,1,-0.6,0.6)] ;
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(1);
+	point.collect{|p,i| BufWr.kr([p],inputPoint,i)};
+    ~classifier.kr(trig,inputPoint,outputPoint);
+    SinOsc.ar((BufRd.kr(1,outputPoint,0,interpolation:0) + 69).midicps,mul: 0.1)
+}.play;
+)
+::
\ No newline at end of file
diff --git a/release-packaging/HelpSource/Classes/FluidMLPRegressor.schelp b/release-packaging/HelpSource/Classes/FluidMLPRegressor.schelp
new file mode 100644
index 0000000..2b8a8c0
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidMLPRegressor.schelp
@@ -0,0 +1,191 @@
+TITLE:: FluidMLPRegressor
+summary:: Regression with a multi-layer perceptron
+categories:: Machine learning
+related:: Classes/FluidMLPClassifier, Classes/FluidDataSet
+
+DESCRIPTION::
+Perform regression between link::Classes/FluidDataSet::s using a Multi-Layer Perception neural network.
+
+CLASSMETHODS::
+
+METHOD:: new
+Creates a new instance on the server.
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to run this model.
+
+ARGUMENT:: hidden
+An link::Classes/Array:: that gives the sizes of any hidden layers in the network (default is two hidden layers of three units each).
+
+ARGUMENT:: activation
+The activation function to use for the hidden layer units. Beware of the permitted ranges of each: relu (0->inf), sigmoid (0->1), tanh (-1,1).
+
+ARGUMENT:: outputActivation
+The activation function to use for the final layer units. Beware of the permitted ranges of each: relu (0->inf), sigmoid (0->1), tanh (-1,1).
+
+ARGUMENT:: tapIn
+The layer whose input is used to predict and predictPoint. It is 0 counting, where the default of 0 is the input layer, and 1 would be the first hidden layer, and so on.
+
+ARGUMENT:: tapOut
+The layer whose output to return. It is counting from 0 as the input layer, and 1 would be the first hidden layer, and so on. The default of -1 is the last layer of the whole network.
+
+ARGUMENT:: maxIter
+The maximum number of iterations to use in training.
+
+ARGUMENT:: learnRate
+The learning rate of the network. Start small, increase slowly.
+
+ARGUMENT:: momentum
+The training momentum, default 0.9
+
+ARGUMENT:: batchSize
+The training batch size.
+
+ARGUMENT:: validation
+The fraction of the DataSet size to hold back during training to validate the network against.
+
+METHOD:: identity, sigmoid, relu, tanh
+A set of convinience constants for the available activation functions.
+
+INSTANCEMETHODS::
+
+PRIVATE:: init, uid
+
+METHOD:: fit
+Train the network to map between a source and target link::Classes/FluidDataSet::
+
+ARGUMENT:: sourceDataSet
+Source data
+
+ARGUMENT:: targetDataSet
+Target data
+
+ARGUMENT:: action
+Function to run when training is complete
+
+returns:: The training loss, or -1 if training failed
+
+METHOD:: predict
+Apply the learned mapping to a link::Classes/FluidDataSet:: (given a trained network)
+
+ARGUMENT:: sourceDataSet
+Input data
+
+ARGUMENT:: targetDataSet
+Output data
+
+ARGUMENT:: action
+Function to run when complete
+
+METHOD:: predictPoint
+Apply the learned mapping to a single data point in a link::Classes/Buffer::
+
+ARGUMENT:: sourceBuffer
+Input point
+
+ARGUMENT:: targetBuffer
+Output point
+
+ARGUMENT:: action
+A function to run when complete
+
+METHOD:: clear
+This will erase all the learning done in the neural network.
+
+ARGUMENT:: action
+A function to run when complete
+
+EXAMPLES::
+
+code::
+
+//Make a simple mapping between a ramp and a sine cycle, test with an exponentional ramp
+(
+~source = FluidDataSet(s);
+~target = FluidDataSet(s);
+~test = FluidDataSet(s);
+~output = FluidDataSet(s);
+~tmpbuf = Buffer.alloc(s,1);
+~regressor=FluidMLPRegressor(s).hidden_([2]).activation_(FluidMLPRegressor.tanh).outputActivation_(FluidMLPRegressor.tanh).maxIter_(1000).learnRate_(0.1).momentum_(0.1).batchSize_(1).validation_(0);
+)
+
+//Make source, target and test data
+(
+~sourcedata = 128.collect{|i|i/128};
+~targetdata = 128.collect{|i| sin(2*pi*i/128) };
+~testdata = 128.collect{|i|(i/128)**2};
+
+~source.load(
+    Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+            ~sourcedata.collect{|x, i| [i.asString, [x]]}.flatten)]);
+);
+
+~target.load(
+d = Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+            ~targetdata.collect{|x, i| [i.asString, [x]]}.flatten)]);
+);
+
+~test.load(
+    Dictionary.with(
+        *[\cols -> 1,\data -> Dictionary.newFrom(
+            ~testdata.collect{|x, i| [i.asString, [x]]}.flatten)]);
+);
+
+~targetdata.plot;
+~source.print;
+~target.print;
+~test.print;
+)
+
+// Now make a regressor and fit it to the source and target, and predict against test
+//grab the output data whilst we're at it, so we can inspect
+
+// run this to train the network for up to 1000(max epochs to map source to target. fit() returns loss. If this is -1, then training has failed. Run until the printed error is satisfactory to you
+~regressor.fit(~source, ~target, {|x|x.postln;});
+
+//you can change parameters of the MLPregressor with setters
+~regressor.learnRate = 0.01;
+~regressor.momentum = 0;
+~regressor.validation= 0.2;
+
+(
+~outputdata = Array(128);
+~regressor.predict(~test, ~output, action:{
+    ~output.dump{|x| 128.do{|i|
+        ~outputdata.add(x["data"][i.asString][0])
+    }};
+}
+);
+)
+
+//We should see a single cycle of a chirp. If not, fit a little more epochs
+~outputdata.plot;
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,[0.5]);
+~outbuf = Buffer.new(s);
+~regressor.predictPoint(~inbuf,~outbuf,{|x|x.postln;x.getn(0,1,{|y|y.postln;};)});
+::
+
+subsection:: Querying in a Synth
+
+This is the equivalent of calling code::predictPoint::, except wholly on the server
+
+code::
+(
+{
+	var input = Saw.kr(2).linlin(-1,1,0,1);
+	var trig = Impulse.kr(ControlRate.ir/10);
+    var inputPoint = LocalBuf(1);
+    var outputPoint = LocalBuf(1);
+	BufWr.kr(input,inputPoint,0);
+    ~regressor.kr(trig,inputPoint,outputPoint,0,-1);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,0),"mapped value");
+}.scope;
+)
+
+
+
+::
diff --git a/release-packaging/HelpSource/Classes/FluidManipulationClient.schelp b/release-packaging/HelpSource/Classes/FluidManipulationClient.schelp
new file mode 100644
index 0000000..5bb3dca
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidManipulationClient.schelp
@@ -0,0 +1,55 @@
+TITLE:: FluidManipulationClient
+summary:: A base case for FluidManipulation classes
+categories:: FluidManipulation
+
+DESCRIPTION::
+A utility base class for FluidManipulation classes, that deals with common functionality (wrapping a link::Classes/Synth:: in the instance, etc.)
+
+Not intended to be used directly.
+
+CLASSMETHODS::
+
+PRIVATE:: nonBlocking
+
+METHOD:: new
+Language-side constructor. Internally, this creates a new synth around an instance of the sub-class being constructed, and maintains a variable pointing to the synth, so that it can be communicated with.
+
+ARGUMENT:: server
+The link::Classes/Server:: this instance is running on
+
+ARGUMENT::  ... args
+Arguments specific to the sub-class at hand
+
+returns:: A new instance
+
+INSTANCEMETHODS::
+
+private:: pr_sendMsg
+
+METHOD:: synth
+Fluid Manipulation client objects are server-side entities, wrapped in a Node to manage communication between language and object. For this, a link::Classes/Synth:: is needed, as the representation of a server node.
+
+returns:: the instance's link::Classes/Synth::
+
+METHOD:: server
+The link::Classes/Server:: that our instance's object is running on
+
+returns:: a link::Classes/Server::
+
+METHOD:: read
+Read the object's data from a JSON file on disk, replacing the current contents.
+​
+METHOD:: write
+Write the object's data to disk as a JSON file.
+
+METHOD:: size
+Report the number of items currently in the object's data.
+
+METHOD:: cols
+Report the dimensionality of the object's data. If action is nil, will default to posting result.
+
+METHOD:: dump
+Get the contents of the object's data as a Dictionary (note: uses a temporary file under the hood);
+
+METHOD:: load
+Fill the object with the contents of a dictionary, replacing its current contents (note: uses a temporary file under the hood).
diff --git a/release-packaging/HelpSource/Classes/FluidNMFFilter.schelp b/release-packaging/HelpSource/Classes/FluidNMFFilter.schelp
index a5efa31..db9c268 100644
--- a/release-packaging/HelpSource/Classes/FluidNMFFilter.schelp
+++ b/release-packaging/HelpSource/Classes/FluidNMFFilter.schelp
@@ -79,8 +79,7 @@ d.play //////(beware !!!! loud!!!)
 (
 // separate them in 2 components
 Routine {
-	FluidBufNMF.process(s, d, bases: e, components:2);
-	s.sync;
+	FluidBufNMF.process(s, d, bases: e, components:2).wait;
 	e.query;
 }.play
 )
@@ -89,11 +88,11 @@ Routine {
 e.plot
 
 //listen how the filter isolates each component and places them in each channel separately.
-{FluidNMFFilter.ar(SinOsc.ar(500),e,2)}.play
+{FluidNMFFilter.ar(SinOsc.ar(500, mul: 0.1),e,2)}.play
 
-{FluidNMFFilter.ar(SinOsc.ar(5000),e,2)}.play
+{FluidNMFFilter.ar(SinOsc.ar(5000, mul: 0.1),e,2)}.play
 
-{FluidNMFFilter.ar(SinOsc.ar([500,5000]).sum,e,2)}.play
+{FluidNMFFilter.ar(SinOsc.ar([500,5000], mul: 0.1).sum,e,2)}.play
 ::
 
 STRONG::A guitar processor::
@@ -112,7 +111,7 @@ c = Buffer.new(s);
 // train only 2 seconds
 (
 Routine {
-    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:10,fftSize:2048);
+    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:10,fftSize:2048).wait;
     c.query;
 }.play;
 )
@@ -120,14 +119,15 @@ Routine {
 // wait for the query to print
 // find the component that has the picking sound checking the median spectral centroid
 (
-FluidBufSpectralShape.process(s, c, features: ~spectralshapes, action:{
-	|shapes|FluidBufStats.process(s,shapes,stats:~stats, action:{
-		|stats|stats.getn(0, (stats.numChannels * stats.numFrames) ,{
-			|x| ~centroids = x.select({
-				|item, index| (index.mod(7) == 0) && (index.div(70) == 5);
-			})
-		})
-	})
+FluidBufSpectralShape.process(s, c, features: ~spectralshapes, action:{ |shapes|
+    FluidBufStats.process(s,shapes,stats:~stats, action:{|stats|
+        stats.getn(0, (stats.numChannels * stats.numFrames), {|x|
+            ~centroids = x.select({
+                |item, index| (index.mod(7) == 0) && (index.div(70) == 5);
+            });
+            ~centroids.postln;
+        })
+    })
 });
 )
 
diff --git a/release-packaging/HelpSource/Classes/FluidNMFMatch.schelp b/release-packaging/HelpSource/Classes/FluidNMFMatch.schelp
index d4202e2..a98d2bd 100644
--- a/release-packaging/HelpSource/Classes/FluidNMFMatch.schelp
+++ b/release-packaging/HelpSource/Classes/FluidNMFMatch.schelp
@@ -112,7 +112,7 @@ c = Buffer.new(s);
 // train only 2 seconds
 (
 Routine {
-    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:10,fftSize:2048);
+    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:10,fftSize:2048).wait;
     c.query;
 }.play;
 )
@@ -197,7 +197,7 @@ c = Buffer.new(s);
 // train only 2 seconds
 (
 Routine {
-    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:8, hopSize:256, fftSize:2048);
+    FluidBufNMF.process(s,b,0,88200,0,1, c, ~bases, components:8, hopSize:256, fftSize:2048).wait;
     c.query;
 }.play;
 )
@@ -216,7 +216,7 @@ FluidBufSpectralShape.process(s, c, features: ~spectralshapes, action:{
 });
 )
 
-//7 shapes (track) x 8 components (tracks) x 7 stats(frames)
+//the interleave format is 7 stats(frames) x 8 components in the source as tracks x 7 shapes (tracks)
 ~stats.query
 ~centroids.size()
 
@@ -230,8 +230,8 @@ x = {
 	var sound = PlayBuf.ar(1,b,loop:1);
 	var  harm, perc;
 	# harm, perc = FluidHPSS.ar(sound, maskingMode:1, harmThreshFreq1: 0.005869, harmThreshAmp1: -9.6875, harmThreshFreq2: 0.006609, harmThreshAmp2: -4.375, hopSize:256);
-	Out.ar(~splitaudio, harm);
-	Out.kr(~nmfenvs, FluidNMFMatch.kr(sound, ~bases, maxComponents:8, hopSize:256, fftSize:2048));
+	Out.ar(~splitaudio, (harm / 4) + perc);
+	Out.kr(~nmfenvs, FluidNMFMatch.kr(DelayN.ar(sound,delaytime: ((17-1)*256)/44100), ~bases, maxComponents:8, hopSize:256, fftSize:2048));
 	Out.ar(0,perc.dup)
 }.play;
 )
@@ -241,7 +241,7 @@ x = {
 8.do({
 	arg i;
 	{
-		var audio = BPF.ar(In.ar(~splitaudio,1), ~centroids[i],0.01,LagUD.kr(In.kr(~nmfenvs,8)[i],0.001,0.01,0.1));
+		var audio = BPF.ar(In.ar(~splitaudio,1), ~centroids[i],0.0015,Lag.kr(In.kr(~nmfenvs,8)[i] * 2,0.022));
 		Out.ar(0,Pan2.ar(audio, (i / 14) - 0.25));
 	}.play(x,addAction: \addAfter);
 });
diff --git a/release-packaging/HelpSource/Classes/FluidNMFMorph.schelp b/release-packaging/HelpSource/Classes/FluidNMFMorph.schelp
new file mode 100644
index 0000000..c594fd3
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidNMFMorph.schelp
@@ -0,0 +1,94 @@
+TITLE:: FluidNMFMorph
+summary:: Morph between sounds
+categories:: FluidCorpusManipulation
+related:: Classes/FluidAudioTransport,Classes/FluidBufNMFCross
+
+
+DESCRIPTION::
+Perform cross-synthesis using Nonnegative Matrix Factorization (NMF) and Optimal Transport
+(OT). NMF analyses of code::source:: and code::target:: sounds decompose their material in to a selectable number of components, which are in turn represented by their emphasis::bases:: (spectrum) and emphasis::activations:: (temporal pattern of each component).
+
+code::FluidNMFMorph:: provides the ability to interpolate between code::source:: and code::target:: spectra using a technique called Optimal Transport, that provides richer results than a simple linear interpolation between spectral shapes. The resulting sound is built up using a buffer of temporal activations, then resynthesised using a phase estimate.
+
+CLASSMETHODS::
+
+METHOD:: ar
+Given buffers of spectral and temporal data from a NMF anlaysis such as produced by link::Classes/FluidBufNMF::, cross-synthesise a hybrid sound.
+
+ARGUMENT:: source
+A link::Classes/Buffer:: with the spectral bases for the source sound.
+
+ARGUMENT:: target
+A link::Classes/Buffer:: with the spectral bases for the target sound.
+
+ARGUMENT:: activations
+A link::Classes/Buffer:: with the temporal activations for the target sound.
+
+ARGUMENT:: autoassign
+If set to code::1:: the algorithm will attempt to optimally match which NMF basis components from source and target best match each other, and will use this mapping as its basis for interpolation. warning::changing this value re-initalizes the process::
+
+ARGUMENT:: interp
+Set the relative contributions of code::source:: and code::target:: between 0 and 1.
+
+ARGUMENT:: windowSize
+The analysis window size in samples. Needs to match that of the seeding NMF analyses
+
+ARGUMENT:: hopSize
+The analysis hop size in samples. Needs to match that of the seeding NMF analyses
+
+ARGUMENT:: fftSize
+The analysis FFT size in samples. Needs to match that of the seeding NMF analyses
+
+ARGUMENT:: maxFFTSize
+The maximum FFT size to allocate memory for
+
+INSTANCEMETHODS::
+
+private:: checkInputs, init
+
+EXAMPLES::
+
+code::FluidNMFMorph:: relies on preexisting NMF analyses to generate variations between sounds. We can produce these using link::Classes/FluidBufNMF::
+
+code::
+//read some audio
+(
+~audiopath = File.realpath(FluidMelBands.class.filenameSymbol).dirname;
+~src1 = Buffer.readChannel(s,~audiopath +/+ "../AudioFiles/Nicol-LoopE-M.wav",channels:[0]); //some drums
+~src2 = Buffer.readChannel(s,~audiopath +/+ "../AudioFiles/Tremblay-SA-UprightPianoPedalWide.wav",channels:[0]);//some piano
+
+~src1Bases = Buffer.new;
+~src2Bases = Buffer.new;
+~src1Activations = Buffer.new;
+~src2Activations = Buffer.new;
+)
+//nmf analyses
+(
+FluidBufNMF.process(s,~src1,bases:~src1Bases,activations:~src1Activations,components:5, action:{"Analysed Source 1".postln});
+FluidBufNMF.process(s,~src2,bases:~src2Bases,activations:~src2Activations, components:5, action:{"Analysed Source 2".postln});
+)
+
+(
+~morph = { |source, target, activations, interp, autoassign|
+	FluidNMFMorph.ar(source,target,activations,autoassign,interp) * 80
+};
+)
+
+~synth = ~morph.play(s,args:[\source,~src1Bases,\target,~src2Bases,\activations,~src2Activations,\interp,0.5,\autoassign,1]);
+
+//Play with different interpolation values
+~synth.set(\interp,0.0);
+~synth.set(\interp,1.0);
+::
+warning::The following parameters current require one to change the 'autoassign' control to update the process::
+code::
+//Change the actvations
+~synth.set(\activations, ~src1Activations, \autoassign,0);
+~synth.set(\autoassign,1);
+~synth.set(\activations, ~src2Activations, \autoassign,0);
+~synth.set(\autoassign,1);
+
+//Swap source and target
+~synth.set(\source,~src2Bases,\target,~src1Bases, \autoassign,0);
+~synth.set(\autoassign,1);
+::
\ No newline at end of file
diff --git a/release-packaging/HelpSource/Classes/FluidNormalize.schelp b/release-packaging/HelpSource/Classes/FluidNormalize.schelp
new file mode 100644
index 0000000..5718cd6
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidNormalize.schelp
@@ -0,0 +1,156 @@
+TITLE:: FluidNormalize
+summary:: Normalize a FluidDataSet
+categories:: FluidManipulation
+related:: Classes/FluidStandardize, Classes/FluidRobustScale, Classes/FluidDataSet
+
+DESCRIPTION::
+Normalize the entries of a link::Classes/FluidDataSet::, or normalize a data point according to the learned bounds of a data set. On the server.
+
+See http://www.faqs.org/faqs/ai-faq/neural-nets/part2/section-16.html
+
+CLASSMETHODS::
+
+private:: kr
+
+METHOD:: new
+Create a new instance
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+ARGUMENT:: min
+Minimum output value, default 0
+ARGUMENT:: max
+Maximum output value, default 1
+ARGUMENT:: invert
+The direction in which the normalization will occur for transform and transformpoint. The default 0 is taking in the range of the input used to fit and transforms it towards the normalised range. A value of 1 will expect an input of the normalized range to transform back to the original range.
+
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Compute the normalization factors from a link::Classes/FluidDataSet:: for later.
+ARGUMENT:: dataSet
+The link::Classes/FluidDataSet:: to normalize
+ARGUMENT:: action
+A function to run when processing is complete
+
+METHOD:: transform
+Normalize a link::Classes/FluidDataSet:: into another link::Classes/FluidDataSet::, using the learned extrema from a previous call to link::Classes/FluidNormalize#fit::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to normalize
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with normalized data
+ARGUMENT:: action
+A function to run when processing is complete
+
+
+METHOD:: fitTransform
+Normalize a link::Classes/FluidDataSet::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to normalize
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with normalized data
+ARGUMENT:: action
+A function to run when processing is complete
+
+
+METHOD:: transformPoint
+Normalize a new data point, using the learned extrema from a previous call to link::Classes/FluidNormalize#fit::
+ARGUMENT:: sourceBuffer
+A link::Classes/Buffer:: with the new data point
+ARGUMENT:: destBuffer
+A link::Classes/Buffer:: to contain the normalized value
+ARGUMENT:: action
+A function to run when processing is complete
+
+EXAMPLES::
+code::
+s.boot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers and a FluidNormalize
+// FluidNormalize.dumpAllMethods
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s);
+~norm = FluidDataSet(s);
+~pitch_feature = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 2);
+~normalizer = FluidNormalize(s);
+)
+
+// Load audio and run a pitch analysis, which gives us pitch and pitch confidence (so a 2D datum)
+(
+~audio = Buffer.read(s,~audiofile);
+FluidBufPitch.process(s,~audio, features: ~pitch_feature);
+)
+
+// Divide the time series in to 10, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(2, 1);
+    var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~pitch_feature.numFrames / 10).asInteger;
+	var stats = FluidBufStats.kr(
+			source: ~pitch_feature, startFrame: count * chunkLen,
+        numFrames: chunkLen, stats: ~stats, trig: (trig * (count <=9)), blocking:1
+	);
+	var rd = BufRd.kr(2, ~stats, DC.kr(0), 0, 1);// pick only mean pitch and confidence
+	var wr1 = BufWr.kr(rd[0], buf, DC.kr(0));
+	var wr2 = BufWr.kr(rd[1], buf, DC.kr(1));
+	var dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats));
+	LocalOut.kr( Done.kr(dsWr));
+    Poll.kr(trig,count,\count);
+	FreeSelf.kr(count - 9);
+}.play;
+)
+
+// Normalize and load to language-side array
+(
+~rawarray = Array.new(10);
+~normedarray= Array.new(10);
+~normalizer.fitTransform(~raw,~norm, {
+	~raw.dump{|x| 10.do{|i|
+		~rawarray.add(x["data"][i.asString])
+	}};
+	~norm.dump{|x| 10.do{|i|
+		~normedarray.add(x["data"][i.asString])
+	}};
+});
+)
+
+//Plot side by side. Before normalization the two dimensions have radically different scales
+//which can be unhelpful in many cases
+
+(
+(~rawarray ++ 0).flop.plot("Unnormalized",Rect(0,0,400,400),minval:0,maxval:[5000,1]).plotMode=\bars;
+(~normedarray  ++ 0).flop.plot("Normalized",Rect(410,0,400,400)).plotMode=\bars;
+)
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~outbuf = Buffer.new(s);
+~normalizer.transformPoint(~inbuf,~outbuf,{|x|x.postln;x.getn(0,2,{|y|y.postln;};)});
+
+//Server side queries
+(
+{
+	var audio = BufRd.ar(1,~audio,LFSaw.ar(BufDur.ir(~audio).reciprocal).range(0, BufFrames.ir(~audio)));
+	var counter = Stepper.ar(Impulse.ar(ControlRate.ir),max:99);
+    var trig = A2K.kr(HPZ1.ar(counter) < 0);
+	//average 100 frames: one could use the MovingAverage extension here
+	var avg;
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(2);
+    var avgBuf = LocalBuf(100,2);
+    //running average of pitch features
+	BufWr.kr(FluidPitch.kr(audio),avgBuf,phase:counter);
+	avg = Mix.new(BufRd.kr(2, avgBuf, phase:100.collect{|x|x})) * 0.01;
+	//assemble data point
+	BufWr.kr(avg[0],inputPoint,0);
+	BufWr.kr(avg[1],inputPoint,1);
+    ~normalizer.kr(trig,inputPoint,outputPoint);
+	Poll.kr(trig,BufRd.kr(1,inputPoint,[0,1]),["pitch (raw)", "confidence (raw)"]);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,[0,1]),["pitch (normalized)", "confidence (normalized)"])
+}.play;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidNoveltySlice.schelp b/release-packaging/HelpSource/Classes/FluidNoveltySlice.schelp
index e5f8ec3..89edceb 100644
--- a/release-packaging/HelpSource/Classes/FluidNoveltySlice.schelp
+++ b/release-packaging/HelpSource/Classes/FluidNoveltySlice.schelp
@@ -56,7 +56,7 @@ ARGUMENT:: maxFilterSize
 	This cannot be modulated.
 
 RETURNS::
-	An audio stream with impulses at detected transients. The latency between the input and the output is STRONG::windowSize + (hopSize * (((kernelSize+1)/2) + (filterSize / 2))):: samples at minimum.
+An audio stream with impulses at detected transients. The latency between the input and the output is STRONG::hopSize * (((kernelSize+1)/2).asInteger + ((filterSize + 1) / 2).asInteger + 1):: samples at minimum.
 
 EXAMPLES::
 
@@ -65,10 +65,10 @@ code::
 b = Buffer.read(s,File.realpath(FluidNoveltySlice.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
 
 // basic param (the process add a latency of windowSize samples
-{var sig = PlayBuf.ar(1,b,loop:1); [FluidNoveltySlice.ar(sig,0,11,0.33) * 0.5, DelayN.ar(sig, 1, (1024 + (512 * (((11+1)/2) + (1 / 2))))/ s.sampleRate, 0.2)]}.play
+{var sig = PlayBuf.ar(1,b,loop:1); [FluidNoveltySlice.ar(sig,0,11,0.33) * 0.5, DelayN.ar(sig, 1, (512 * (((11 + 1) / 2).asInteger + ((1 + 1) / 2).asInteger + 1)) / s.sampleRate, 0.2)]}.play
 
 // other parameters
-{var sig = PlayBuf.ar(1,b,loop:1); [FluidNoveltySlice.ar(sig, 1, 31, 0.0035, 4, 100, 128, 32) * 0.5, DelayN.ar(sig, 1, (128 + (32 * (((31+1)/2) + (4 / 2))))/ s.sampleRate,0.2)]}.play
+{var sig = PlayBuf.ar(1,b,loop:1); [FluidNoveltySlice.ar(sig, 1, 31, 0.0035, 4, 100, 128, 32) * 0.5, DelayN.ar(sig, 1, (32 * (((31 + 1)/2).asInteger + ((4 + 1) / 2).asInteger + 1))/ s.sampleRate,0.2)]}.play
 
 // More musical, novelty-trigged autopan
 (
@@ -76,7 +76,7 @@ b = Buffer.read(s,File.realpath(FluidNoveltySlice.class.filenameSymbol).dirname.
     var sig, trig, syncd, pan;
     sig = PlayBuf.ar(1,b,loop:1);
     trig = FluidNoveltySlice.ar(sig, 0, 11, 0.25, 5, 1, 128, 32);
-    syncd = DelayN.ar(sig, 1, (128 + (32 * (((11+1)/2) + (5 / 2))))/ s.sampleRate);
+    syncd = DelayN.ar(sig, 1, (32 * (((11 + 1)/2).asInteger + ((5 + 1) / 2).asInteger + 1))/ s.sampleRate);
     pan = TRand.ar(-1,1,trig);
     Pan2.ar(syncd,pan);
 }.play
diff --git a/release-packaging/HelpSource/Classes/FluidPCA.schelp b/release-packaging/HelpSource/Classes/FluidPCA.schelp
new file mode 100644
index 0000000..d271202
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidPCA.schelp
@@ -0,0 +1,169 @@
+TITLE:: FluidPCA
+summary:: Dimensionality Reduction with Principal Component Analysis
+categories:: Dimensionality Reduction, Data Processing
+related:: Classes/FluidMDS, Classes/FluidDataSet
+
+DESCRIPTION::
+
+Principal Components Analysis of a link::Classes/FluidDataSet::
+
+https://scikit-learn.org/stable/modules/decomposition.html#principal-component-analysis-pca
+
+CLASSMETHODS::
+
+METHOD:: new
+Make a new instance
+ARGUMENT:: server
+The server on which to run this model
+ARGUMENT:: numDimensions
+The number of dimensions to reduce to
+
+INSTANCEMETHODS::
+
+PRIVATE:: init
+
+METHOD:: fit
+Train this model on a link::Classes/FluidDataSet:: but don't transform the data
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: to analyse
+ARGUMENT:: action
+Run when done
+
+METHOD:: transform
+Given a trained model, apply the reduction to a source link::Classes/FluidDataSet:: and write to a destination. Can be the same for both (in-place)
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done. The fraction of accounted variance is passed as an argument, aka the fidelity of the new representation: a value near 1.0 means a higher fidelity to the original.
+
+METHOD:: fitTransform
+link::Classes/FluidPCA#fit:: and link::Classes/FluidPCA#transform:: in a single pass
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done. The fraction of accounted variance is passed as an argument, aka the fidelity of the new representation: a value near 1.0 means a higher fidelity to the original.
+
+METHOD:: transformPoint
+Given a trained model, transform the data point in a link::Classes/Buffer:: and write to an output
+ARGUMENT:: sourceBuffer
+Input data
+ARGUMENT:: destBuffer
+Output data
+ARGUMENT:: action
+Run when done. The function is passed code::destBuffer:: as argument.
+
+EXAMPLES::
+
+code::
+s.reboot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers, a FluidStandardize and a FluidPCA
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s);
+~standardized = FluidDataSet(s);
+~reduced = FluidDataSet(s);
+~audio = Buffer.read(s,~audiofile);
+~mfcc_feature = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 12);
+~datapoint = Buffer.alloc(s, 12);
+~standardizer  = FluidStandardize(s);
+~pca = FluidPCA(s,2);
+)
+
+
+// Load audio and run an mfcc analysis, which gives us 13 points (we'll throw the 0th away)
+(
+~audio = Buffer.read(s,~audiofile);
+FluidBufMFCC.process(s,~audio, features: ~mfcc_feature,action:{"Done MFCCs".postln});
+)
+
+// Divide the time series in 100, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(12, 1);
+    var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~mfcc_feature.numFrames / 100).asInteger;
+	var stats = FluidBufStats.kr(
+        source: ~mfcc_feature, startFrame: count * chunkLen,
+        startChan:1, numFrames: chunkLen, stats: ~stats,
+        trig: trig * (count < 100), blocking: 1
+	);
+	var rd = BufRd.kr(12, ~stats, DC.kr(0), 0, 1);
+	var bufWr, dsWr;
+	12.do{|i|
+		bufWr = BufWr.kr(rd[i], buf, DC.kr(i));
+	};
+	dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats));
+	LocalOut.kr( Done.kr(dsWr));
+	FreeSelf.kr(count - 99);
+	Poll.kr(trig,(100 - count));
+}.play;
+)
+// wait for the count to reaches 0 in the post window.
+
+//First standardize our DataSet, so that the MFCC dimensions are on comensurate scales
+//Then apply the PCA in-place on the standardized data
+//Download the DataSet contents into an array for plotting
+(
+~reducedarray = Array.new(100);
+~standardizer.fitTransform(~raw, ~standardized);
+~pca.fitTransform(~standardized, ~reduced, action:{|x|
+	x.postln; //pass on the variance
+	~reduced.dump{|x| 100.do{|i|
+		~reducedarray.add(x["data"][i.asString])
+	}};
+});
+)
+
+//Visualise the 2D projection of our original 12D data
+(
+d = ~reducedarray.flop.deepCollect(1, { |x| x.normalize});
+w = Window("scatter", Rect(128, 64, 200, 200));
+w.drawFunc = {
+    Pen.use {
+        d[0].size.do{|i|
+            var x = (d[0][i]*200);
+            var y = (d[1][i]*200);
+            var r = Rect(x,y,5,5);
+            Pen.fillColor = Color.blue;
+            Pen.fillOval(r);
+        }
+    }
+};
+w.refresh;
+w.front;
+)
+
+// transform a single point with arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup(12));
+~outbuf = Buffer.new(s);
+~pca.transformPoint(~inbuf,~outbuf,{|x|x.postln;x.getn(0,1,{|y|y.postln;};)});
+::
+
+subsection:: Server Side Queries
+
+Let's map our learned PCA dimensions to the controls of a processor
+
+code::
+(
+{
+	var mapped;
+	var audio = BufRd.ar(1,~audio,LFSaw.ar(BufDur.ir(~audio).reciprocal).range(0, BufFrames.ir(~audio)));
+	var mfcc = FluidMFCC.kr(audio)[1..12];
+	var smoothed = LagUD.kr(mfcc,1*ControlDur.ir,500*ControlDur.ir);
+	var trig = Impulse.kr(ControlRate.ir / 2);
+    var inputPoint = LocalBuf(12);
+    var outputPoint = LocalBuf(2);
+	smoothed.collect{|coeff,i| BufWr.kr([coeff],inputPoint,i)};
+    ~pca.kr(trig, inputPoint, outputPoint, 2);
+	mapped = BufRd.kr(1,outputPoint, phase:[0,1]).linlin(-3,3,0,3);
+	CombC.ar(audio,3,mapped[0],mapped[1]*3)
+}.play;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidProcessSlices.schelp b/release-packaging/HelpSource/Classes/FluidProcessSlices.schelp
new file mode 100644
index 0000000..5de64ec
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidProcessSlices.schelp
@@ -0,0 +1,123 @@
+TITLE:: FluidProcessSlices
+summary:: Utility for batch processing slices
+categories:: FluidManipulation
+related:: Classes/FluidLoadFolder, Classes/FluidSliceCorpus,Guides/FluidDecomposition
+
+DESCRIPTION::
+This class abstracts some of the boilerplate involved in batch processing a sequence of segments in a link::Classes/Buffer:: on the server. It does this by iteratively running a user supplied function and using slice point information passed as an link::Classes/IdentityDictionary:: (see link::Classes/FluidLoadFolder#-index:: for details on the format of this).
+
+CLASSMETHODS::
+
+METHOD:: new
+Creates a new instance
+
+ARGUMENT:: featureFunc
+ANCHOR::featureFunction::
+A function that will perform some processing on a section of a buffer.
+warning::
+This function strong::must:: return a link::Classes/UGen:: that sets a code::done:: flag (see link::Classes/Done::), in order for the iteration and housekeeping to work. All code::FluidBuf*:: objects do this.
+::
+The functions is passed the following arguments
+definitionlist::
+##src
+|| The source link::Classes/Buffer:: containing the audio to process
+##start
+|| The start frame of the section to process, in samples
+##num
+|| The number of frames to process, in samples
+##data
+|| anchor::datadict:: An link::Classes/Association:: of the label for this segment, with an link::Classes/IdentityDictionary:: of useful extra data:
+definitionlist::
+## sr
+|| The original sample rate of the segment
+## numchans
+|| The original channel count of the segment
+## voice
+|| By default link::#-play:: will run multiple jobs in parallel dependning on the link::#ntasks#tasks:: argument. This contains the task number, which allows you to maintain separate set of resources (e.g. temporary link::Classes/Buffer::s) for each task.
+## index
+|| The absolute count of slices processed.
+::
+::
+
+An example function that records statistics about the pitch of a segment in to a link::Classes/FluidDataSet:: could look like
+
+code::
+
+~featureBuffers = 4.do{Buffer.new};
+
+~avgPitch = { |src,start,num,data|
+	var pitch, stats,statsbuf,label,voice;
+	label = data.key;
+	voice = data.value[\voice];
+	statsbuf = LocalBuf(7);
+	pitch = FluidBufPitch.kr(src,start,num,numChans:1,features:~featurebuffers[voice]);
+	stats = FluidBufStats.kr(~featurebuffers[voice],numChans:1, stats:statsbuf,trig:Done.kr(pitch));
+	FluidDataSetWr.kr(~mydataset, label, nil, statsbuf,Done.kr(stats))
+};
+::
+
+INSTANCEMETHODS::
+
+METHOD:: play
+Run the link::#featureFunction:: iteratively over segments of a link::Classes/Buffer::, specified by an link::Classes/IdentityDictionary::
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to process
+
+ARGUMENT:: sourceBuffer
+ The source link::Classes/Buffer:: containing the audio to process
+
+ARGUMENT:: bufIdx
+An link::Classes/IdentityDictionary:: specifying labels, boundaries, sample rate and channel count for the segment. See link::Classes/FluidLoadFolder#-index:: for details.
+
+ARGUMENT:: action
+A function to run when processing is complete. This gets passed the same link::Classes/Association:: as link::#datadict#the processing function::
+
+ARGUMENT:: tasks
+ANCHOR::ntasks::
+The number of parallel processing tasks to run on the server. Default 4. This should probably never be greater than the number of available CPU cores.
+
+METHOD:: featureFunc
+Return the function uses by this instance.
+
+EXAMPLES::
+
+code::
+s.reboot;
+//Load all the Fluid Corpus Manipulation audio files
+
+(
+~path = File.realpath(FluidLoadFolder.class.filenameSymbol).dirname +/+ "../AudioFiles";
+~loader = FluidLoadFolder(~path);
+~loader.play(s,action:{ |dataDictionary| "Done loading".postln});
+~slicer = FluidSliceCorpus({ |src,start,num,dest|
+		FluidBufOnsetSlice.kr(src,start,num,indices:dest, threshold:2)
+});
+~pitchdata = FluidDataSet(s);
+~pitchbufs = 4.collect{Buffer.new};
+~statsbufs = 4.collect{Buffer.new};
+)
+
+//segment
+~slicer.play(s,~loader.buffer,~loader.index,{|dataDictionary| "Slicing done".postln;});
+
+//In the interests of brevity, let's just take a subset of the slices and process these
+~subset = IdentityDictionary.newFrom(~slicer.index.asSortedArray[0..7].flatten(1));
+
+//write pitch statistics into a dataset
+(
+~extractor = FluidProcessSlices({|src,start,num,data|
+    var pitch, stats, label,i;
+    i = data.value[\voice];
+    label = data.key;
+    pitch = FluidBufPitch.kr(src,start,num,features:~pitchbufs[i]);
+    stats = FluidBufStats.kr(~pitchbufs[i],stats:~statsbufs[i],trig:Done.kr(pitch));
+    FluidDataSetWr.kr(~pitchdata,label,nil,buf:~statsbufs[i],trig:Done.kr(stats))
+});
+)
+
+~extractor.play(s,~loader.buffer,~subset,{"Feature extraction done".postln});
+
+//view the data
+~pitchdata.print
+::
diff --git a/release-packaging/HelpSource/Classes/FluidRobustScale.schelp b/release-packaging/HelpSource/Classes/FluidRobustScale.schelp
new file mode 100644
index 0000000..5237e55
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidRobustScale.schelp
@@ -0,0 +1,158 @@
+TITLE:: FluidRobustScale
+summary:: Apply Robust Scaling to FluidDataSet
+categories:: FluidManipulation
+related:: Classes/FluidStandardize, Classes/FluidNormalize, Classes/FluidDataSet
+
+DESCRIPTION::
+Scales the entries of a link::Classes/FluidDataSet::, or scales a data point according to the learned values of a data set. It will centre the median of each dimension to 0, and will scale the data to +/- the provided centiles, by default providing the first and third qartile (25 and 75).All happens on the server.
+
+See https://scikit-learn.org/stable/auto_examples/preprocessing/plot_all_scaling.html#robustscaler
+
+CLASSMETHODS::
+
+private:: kr
+
+METHOD:: new
+Create a new instance
+ARGUMENT:: server
+The link::Classes/Server:: on which to run
+ARGUMENT:: low
+The low centile boundary, default 25.
+ARGUMENT:: high
+The high centile boundary, default 75.
+ARGUMENT:: invert
+The direction in which the scaling will occur for transform and transformpoint. The default 0 is taking in the range of the input used to fit and transforms it towards the robust scaling range. A value of 1 will expect an input of the scaling range to transform back to the original range.
+
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Compute the scaling factors from a link::Classes/FluidDataSet:: for later.
+ARGUMENT:: dataSet
+The link::Classes/FluidDataSet:: to scale
+ARGUMENT:: action
+A function to run when processing is complete
+
+METHOD:: transform
+Scale a link::Classes/FluidDataSet:: into another link::Classes/FluidDataSet::, using the learned range from a previous call to link::Classes/FluidRobustScale#fit::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to scale
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with scaled data
+ARGUMENT:: action
+A function to run when processing is complete
+
+
+METHOD:: fitTransform
+Scale a link::Classes/FluidDataSet::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to scale
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with scaled data
+ARGUMENT:: action
+A function to run when processing is complete
+
+
+METHOD:: transformPoint
+Scale a new data point, using the learned scaling from a previous call to link::Classes/FluidRobustScale#fit::
+ARGUMENT:: sourceBuffer
+A link::Classes/Buffer:: with the new data point
+ARGUMENT:: destBuffer
+A link::Classes/Buffer:: to contain the scaled value
+ARGUMENT:: action
+A function to run when processing is complete
+
+EXAMPLES::
+code::
+s.boot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers and a FluidRobustScale
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s);
+~scaled = FluidDataSet(s);
+~pitch_feature = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 2);
+~robust = FluidRobustScale(s);
+)
+
+// Load audio and run a pitch analysis, which gives us pitch and pitch confidence (so a 2D datum)
+(
+~audio = Buffer.read(s,~audiofile);
+FluidBufPitch.process(s,~audio, features: ~pitch_feature);
+)
+
+// Divide the time series in to 10, and take the mean of each segment and add this as a point to
+// the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(2, 1);
+    var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~pitch_feature.numFrames / 10).asInteger;
+	var stats = FluidBufStats.kr(
+		source: ~pitch_feature, startFrame: count * chunkLen,
+        numFrames: chunkLen, stats: ~stats, trig: (trig * (count <=9)), blocking:1
+	);
+	var rd = BufRd.kr(2, ~stats, DC.kr(0), 0, 1);// pick only mean pitch and confidence
+	var wr1 = BufWr.kr(rd[0], buf, DC.kr(0));
+	var wr2 = BufWr.kr(rd[1], buf, DC.kr(1));
+	var dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats));
+	LocalOut.kr( Done.kr(dsWr));
+    Poll.kr(trig,count,\count);
+	FreeSelf.kr(count - 9);
+}.play;
+)
+
+//check the dataset
+~raw.print;
+
+// Scale and load to language-side array
+(
+~rawarray = Array.new(10);
+~scaledarray= Array.new(10);
+~robust.fitTransform(~raw,~scaled, {
+	~raw.dump{|x| 10.do{|i|
+		~rawarray.add(x["data"][i.asString])
+	}};
+	~scaled.dump{|x| 10.do{|i|
+		~scaledarray.add(x["data"][i.asString])
+	}};
+});
+)
+
+//Plot side by side. Before normalization the two dimensions have radically different scales
+//which can be unhelpful in many cases
+
+(
+(~rawarray ++ 0).flop.plot("Raw Data",Rect(0,0,400,400),minval:0,maxval:[5000,1]).plotMode=\bars;
+(~scaledarray  ++ 0).flop.plot("Scaled",Rect(410,0,400,400), minval:-2,maxval:2).plotMode=\bars;
+)
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~outbuf = Buffer.new(s);
+~robust.transformPoint(~inbuf,~outbuf,{|x|x.postln;x.getn(0,2,{|y|y.postln;};)});
+
+//Server side queries
+(
+{
+	var audio = BufRd.ar(1,~audio,LFSaw.ar(BufDur.ir(~audio).reciprocal).range(0, BufFrames.ir(~audio)));
+	var counter = Stepper.ar(Impulse.ar(ControlRate.ir),max:99);
+    var trig = A2K.kr(HPZ1.ar(counter) < 0);
+	//average 100 frames: one could use the MovingAverage extension here
+	var avg;
+    var inputPoint = LocalBuf(2);
+    var outputPoint = LocalBuf(2);
+    var avgBuf = LocalBuf(100,2);
+    //running average of pitch features
+	BufWr.kr(FluidPitch.kr(audio),avgBuf,phase:counter);
+	avg = Mix.new(BufRd.kr(2, avgBuf, phase:100.collect{|x|x})) * 0.01;
+	//assemble data point
+	BufWr.kr(avg[0],inputPoint,0);
+	BufWr.kr(avg[1],inputPoint,1);
+    ~robust.kr(trig,inputPoint,outputPoint);
+	Poll.kr(trig,BufRd.kr(1,inputPoint,[0,1]),["pitch (raw)", "confidence (raw)"]);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,[0,1]),["pitch (scaled)", "confidence (scaled)"])
+}.play;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidSines.schelp b/release-packaging/HelpSource/Classes/FluidSines.schelp
index f419a7c..c34d207 100644
--- a/release-packaging/HelpSource/Classes/FluidSines.schelp
+++ b/release-packaging/HelpSource/Classes/FluidSines.schelp
@@ -82,6 +82,12 @@ b = Buffer.read(s,File.realpath(FluidSines.class.filenameSymbol).dirname.withTra
 // as the algorithm resynthesize the sinusoidal peaks, we would expect to get it to work almost perfectly on a sine wave, with these settings that tell the process to tolerate everything as a sinusoid, even short and quiet peaks
 {FluidSines.ar(SinOsc.ar(mul: 0.1),detectionThreshold: -144,birthLowThreshold: -144,birthHighThreshold: -144,minTrackLen: 1,trackMagRange: 200,trackFreqRange: 1000,trackProb: 0)}.play;
 
+// we can listen to the artefact in solo, amplifying it by 30dB, to hear the 'lobes' - not bad at all!
+{FluidSines.ar(SinOsc.ar(mul: 0.1),detectionThreshold: -144,birthLowThreshold: -144,birthHighThreshold: -144,minTrackLen: 1,trackMagRange: 200,trackFreqRange: 1000,trackProb: 0)[1].dup * Line.ar(0,30,1).dbamp}.play;
+
 // as this is a windowed process, the frequency of the peak is good for that full window, and therefore interesting artefacts appear when the pitch is changing.
 {FluidSines.ar(SinOsc.ar(LFTri.kr(0.1).exprange(220,880),mul: 0.1),detectionThreshold: -144,birthLowThreshold: -144,birthHighThreshold: -144,minTrackLen: 1,trackMagRange: 300,trackFreqRange: 1000,trackProb: 0)}.play;
+
+// if we solo and amplify the artefacts, they are much more apparent (and interesting)
+{FluidSines.ar(SinOsc.ar(LFTri.kr(0.1).exprange(220,880),mul: 0.1),detectionThreshold: -144,birthLowThreshold: -144,birthHighThreshold: -144,minTrackLen: 1,trackMagRange: 300,trackFreqRange: 1000,trackProb: 0)[1].dup * Line.ar(0,30,1).dbamp}.play;
 ::
diff --git a/release-packaging/HelpSource/Classes/FluidSliceCorpus.schelp b/release-packaging/HelpSource/Classes/FluidSliceCorpus.schelp
new file mode 100644
index 0000000..2abeec4
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidSliceCorpus.schelp
@@ -0,0 +1,113 @@
+TITLE:: FluidSliceCorpus
+summary:: A utility for batch slicing of a corpus
+categories:: FluidManipulation
+related:: Classes/FluidLoadFolder, Classes/FluidProcessSlices, Classes/FluidBufOnsetSlice, Classes/FluidBufNoveltySlice, Classes/FluidBufTransientSlice
+
+DESCRIPTION::
+A utility class that abstracts the boiler plate code involved with batch slicing a buffer containing distinct chunks of audio (a 'corpus' for these purposes).
+
+Whilst this class is designed to be used most easily in conjunction with link::Classes/FluidLoadFolder::, it doesn't have to be. However, it does expect to be passed an link::Classes/IdentityDictionary:: of a particular format (see link::#indexFormat#description below::).
+
+The actual mechanism for doing the slicing is provided by the user, in the form of a function that will form part of a larger link::Classes/Synth:: (see link::#sliceFuncDescription#below::).
+
+CLASSMETHODS::
+
+METHOD:: new
+Create a new instance with the specified slicing and labelling behaviour.
+
+ARGUMENT:: sliceFunc
+ANCHOR::sliceFuncDescription::
+A function that does the slicing, returning a link::Classes/UGen::. This function is passed the following arguments:
+definitionlist::
+## src
+|| The source link::Classes/Buffer:: for slicing
+## start
+|| The frame to start slicing from, in samples
+## num
+|| The number of frames to slice, in samples
+## dst
+|| The destination link::Classes/Buffer:: into which to write slice indices
+::
+
+This configuration assumes that you are using one of the link::Guides/FluidDecomposition:: buffer-based slicing objects, or at least following their conventions, notably:
+list::
+## slice points are written into a buffer as sample positions.
+## If no slices are found, then a single value of -1 is written instead
+::
+
+warning::
+This function strong::must:: return a link::Classes/UGen:: that sets a code::done:: flag (see link::Classes/Done::), in order for the iteration and housekeeping to work. All code::FluidBuf*:: objects do this.
+::
+
+A concrete example of a code::sliceFunc:: could be:
+code::
+~sliceFn = { |src,start,num,dest|
+	FluidBufOnsetSlice.kr(src,start,num,indices:dest)
+});
+::
+
+ARGUMENT:: labelFunc
+ANCHOR::labelling::
+warning::Not yet implemented::
+
+Override the default labelling behaviour for slices. The default is to append the original label with code::-<slice number>:: counting from 1.
+
+INSTANCEMETHODS::
+
+METHOD:: sliceFunc
+Retreive the link::#sliceFuncDescription#slicing function:: used by this instance.
+
+METHOD:: play
+Run the slicing function over each entry in the supplied link::#indexformat#index dictionary::
+
+ARGUMENT:: server
+The link::Classes/Server:: on which to execute
+
+ARGUMENT:: sourceBuffer
+The link::Classes/Buffer:: containing the audio to slice
+
+ARGUMENT:: bufIdx
+ANCHOR::indexformat::
+An link::Classes/IdentityDictionary:: that details labels and start-end positions for each chunk in the source buffer. See link::Classes/FluidLoadFolder#index::
+
+ARGUMENT:: action
+A function that runs on complettion, will be passed the link::Classes/IdentityDictionary:: from link::#index:: as an argument.
+
+ARGUMENT:: tasks
+ANCHOR::ntasks::
+The number of parallel processing tasks to run on the server. Default 4. This should probably never be greater than the number of available CPU cores.
+
+METHOD:: index
+A link::Classes/IdentityDictionary:: containing information about the position of each discovered slice, using labels based on those passed into link::#play:: (see link::#labelling::). This dictionary copies all other entries from the source dictionary on a per-key basis (so you can store arbitary stuff in there should you wish, and it will remain oassciated with its original source chunk).
+
+
+EXAMPLES::
+
+code::
+s.reboot
+
+(
+~path = File.realpath(FluidLoadFolder.class.filenameSymbol).dirname +/+ "../AudioFiles";
+~loader = FluidLoadFolder(~path);
+~loader.play(s,action:{ |dataDictionary| "Done loading".postln});
+)
+
+(
+~slicer = FluidSliceCorpus({ |src,start,num,dest|
+	FluidBufOnsetSlice.kr(src,start,num,indices:dest, threshold:0.7)
+});
+)
+
+(
+~slicer.play(s,~loader.buffer,~loader.index,{|dataDictionary|
+	"Slicing done".postln;
+	//we get passed an IdentityDictionary of slice data, let's look at it
+	dataDictionary.pairsDo{|label,data|
+		//data is also a dictionary
+		(label ++ '(').post;
+		data.pairsDo{|k,v| (k ++ ':' + v + ' ').post };
+		')'.postln;
+	}
+});
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidStandardize.schelp b/release-packaging/HelpSource/Classes/FluidStandardize.schelp
new file mode 100644
index 0000000..a10ceab
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidStandardize.schelp
@@ -0,0 +1,150 @@
+TITLE:: FluidStandardize
+summary:: Standardize a FluidDataSet
+categories:: FluidManipulation
+related:: Classes/FluidDataSet, Classes/FluidNormalize, Classes/FluidRobustScale
+
+DESCRIPTION::
+Standardize a link::Classes/FluidDataSet::, i.e. rescale using its mean(s) and standard deviation(s) in each dimension.
+
+See http://www.faqs.org/faqs/ai-faq/neural-nets/part2/section-16.html
+
+CLASSMETHODS::
+
+METHOD:: new
+Create a new instance
+ARGUMENT:: server
+The server for this model
+ARGUMENT:: invert
+The direction in which the standardization will occur for transform and transformpoint. The default 0 is taking in the range of the input used to fit and transforms it towards the standardized range. A value of 1 will expect an input of the standardized range to transform back to the original range.
+
+INSTANCEMETHODS::
+
+METHOD:: fit
+Fit model to a DataSet without applying scaling
+ARGUMENT:: dataSet
+The link::Classes/FluidDataSet:: to standardize
+ARGUMENT:: action
+A function to run when processing is complete
+
+METHOD:: transform
+Standardize a link::Classes/FluidDataSet::, using the learned statistics from a previous call to link::Classes/FluidStandardize#fit::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to standardize
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with standardized data
+ARGUMENT:: action
+A function to run when processing is complete
+
+METHOD:: fitTransform
+Standardize a link::Classes/FluidDataSet:: into another link::Classes/FluidDataSet::
+ARGUMENT:: sourceDataSet
+The link::Classes/FluidDataSet:: to standardize
+ARGUMENT:: destDataSet
+The link::Classes/FluidDataSet:: to populate with standardized data
+ARGUMENT:: action
+A function to run when processing is complete
+
+METHOD:: transformPoint
+Standardize a new data point, using the learned statistics from a previous call to link::Classes/FluidStandardize#fit::
+ARGUMENT:: sourceBuffer
+A link::Classes/Buffer:: with the new data point
+ARGUMENT:: destBuffer
+A link::Classes/Buffer:: to contain the standardize value
+ARGUMENT:: action
+A function to run when processing is complete
+
+EXAMPLES::
+code::
+s.boot;
+//Preliminaries: we want some audio, a couple of FluidDataSets, some Buffers and a FluidStandardize
+(
+~audiofile = File.realpath(FluidBufPitch.class.filenameSymbol).dirname +/+ "../AudioFiles/Tremblay-ASWINE-ScratchySynth-M.wav";
+~raw = FluidDataSet(s);
+~stand = FluidDataSet(s);
+~audio = Buffer.read(s,~audiofile);
+~pitch_feature = Buffer.new(s);
+~stats = Buffer.alloc(s, 7, 2);
+~standardizer = FluidStandardize(s);
+)
+
+
+// Load audio and run a pitch analysis, which gives us pitch and pitch confidence (so a 2D datum)
+(
+~audio = Buffer.read(s,~audiofile);
+FluidBufPitch.process(s,~audio, features: ~pitch_feature,action:{"Analysed Pitch".postln});
+)
+
+// Divide the time series in to 10, and take the mean of each s"egment and add this as a point to
+// the 'raw' FluidDataSet
+(
+{
+	var trig = LocalIn.kr(1, 1);
+	var buf =  LocalBuf(2, 1);
+    var count = PulseCount.kr(trig) - 1;
+	var chunkLen = (~pitch_feature.numFrames / 10).asInteger;
+	var stats = FluidBufStats.kr(
+        source: ~pitch_feature, startFrame: count * chunkLen,
+        numFrames: chunkLen, stats: ~stats,
+        trig: trig * (count < 10), blocking: 1
+	);
+	var rd = BufRd.kr(2, ~stats, DC.kr(0), 0, 1);// pick only mean pitch and confidence
+	var wr1 = BufWr.kr(rd[0], buf, DC.kr(0));
+	var wr2 = BufWr.kr(rd[1], buf, DC.kr(1));
+	var dsWr = FluidDataSetWr.kr(~raw, buf: buf, idNumber: count, trig: Done.kr(stats));
+	LocalOut.kr( Done.kr(dsWr));
+	FreeSelf.kr(count - 9);
+    Poll.kr(trig,count, \count);
+}.play;
+)
+
+// Standardize and load to language-side array
+(
+~rawarray = Array.new(10);
+~stdarray= Array.new(10);
+~standardizer.fitTransform(~raw,~stand, {
+	~raw.dump{|x| 10.do{|i|
+		~rawarray.add(x["data"][i.asString])
+	}};
+	~stand.dump{|x| 10.do{|i|
+		~stdarray.add(x["data"][i.asString])
+	}};
+});
+)
+
+(
+(~rawarray ++ 0).flop.plot("Unstandardized",Rect(0,0,400,400),minval:0,maxval:[5000,1]).plotMode=\bars;
+(~stdarray  ++ 0).flop.plot("Standardized",Rect(410,0,400,400), minval:-2,maxval:2).plotMode=\bars;
+)
+
+// single point transform on arbitrary value
+~inbuf = Buffer.loadCollection(s,0.5.dup);
+~outbuf = Buffer.new(s);
+~standardizer.transformPoint(~inbuf,~outbuf,{|x|x.postln;x.getn(0,2,{|y|y.postln;};)});
+
+::
+
+subsection::Server Side Querying
+code::
+(
+// read frames out of buffer and pass to standardize
+{
+	var audio = BufRd.ar(1,~audio,LFSaw.ar(BufDur.ir(~audio).reciprocal).range(0, BufFrames.ir(~audio)));
+	var counter = Stepper.ar(Impulse.ar(ControlRate.ir),max:99);
+    var trig = A2K.kr(HPZ1.ar(counter) < 0);
+	//average 10 frames: one could use the MovingAverage extension here
+	var avg;
+    var inputPoint= LocalBuf(2);
+    var outputPoint = LocalBuf(2);
+    var avgBuf = LocalBuf(100,2);
+    //average of pitch features
+	BufWr.kr(FluidPitch.kr(audio),avgBuf,phase:counter);
+	avg = Mix.new(BufRd.kr(2, avgBuf, phase:100.collect{|x|x})) * 0.01;
+	//assemble data point
+	BufWr.kr(avg[0],inputPoint,0);
+	BufWr.kr(avg[1],inputPoint,1);
+	Poll.kr(trig,BufRd.kr(1,inputPoint,[0,1]),["pitch (raw)", "confidence (raw)"]);
+    ~standardizer.kr(trig,inputPoint,outputPoint);
+    Poll.kr(trig,BufRd.kr(1,outputPoint,[0,1]),["pitch (standardized)", "confidence (standardized)"]);
+}.play;
+)
+::
diff --git a/release-packaging/HelpSource/Classes/FluidTransients.schelp b/release-packaging/HelpSource/Classes/FluidTransients.schelp
index 475f080..1fdafbc 100644
--- a/release-packaging/HelpSource/Classes/FluidTransients.schelp
+++ b/release-packaging/HelpSource/Classes/FluidTransients.schelp
@@ -57,7 +57,7 @@ b = Buffer.read(s,File.realpath(FluidTransients.class.filenameSymbol).dirname.wi
 // basic parameters
 {FluidTransients.ar(PlayBuf.ar(1, b, loop:1))}.play
 
-// tweaked parameterss
+// tweaked parameters
 {FluidTransients.ar(PlayBuf.ar(1, b, loop:1), 80, threshFwd:MouseX.kr(0,5), threshBack:MouseY.kr(0,2))}.play
 
 // null test (the process add a latency of (blockSize + padding - order) samples
diff --git a/release-packaging/HelpSource/Classes/FluidUMAP.schelp b/release-packaging/HelpSource/Classes/FluidUMAP.schelp
new file mode 100644
index 0000000..ab1be2b
--- /dev/null
+++ b/release-packaging/HelpSource/Classes/FluidUMAP.schelp
@@ -0,0 +1,247 @@
+TITLE:: FluidUMAP
+summary:: Dimensionality Reduction with Uniform Manifold Approximation and Projection
+categories:: Dimensionality Reduction, Data Processing
+related:: Classes/FluidMDS, Classes/FluidPCA, Classes/FluidDataSet
+
+DESCRIPTION::
+
+Multidimensional scaling of a link::Classes/FluidDataSet:: using Uniform Manifold Approximation and Projection (UMAP)
+
+Please refer to https://umap-learn.readthedocs.io/ for more information on the algorithm.
+
+CLASSMETHODS::
+
+METHOD:: new
+Make a new instance
+ARGUMENT:: server
+The server on which to run this model
+ARGUMENT:: numDimensions
+The number of dimensions to reduce to
+ARGUMENT:: numNeighbours
+The number of neighbours considered by the algorithm to balance local vs global structures to conserve. Low values will prioritise preserving local structure, high values will help preserving the global structure.
+ARGUMENT:: minDist
+The minimum distance each point is allowed to be from the others in the low dimension space. Low values will make tighter clumps, and higher will spread the points more.
+ARGUMENT:: iterations
+The number of iterations that the algorithm will go through to optimise the new representation
+ARGUMENT:: learnRate
+The learning rate of the algorithm, aka how much of the error it uses to estimate the next iteration.
+
+INSTANCEMETHODS::
+
+PRIVATE:: init
+
+METHOD:: fit
+Train this model on a link::Classes/FluidDataSet:: but don't transform the data
+ARGUMENT:: dataSet
+A link::Classes/FluidDataSet:: to analyse
+ARGUMENT:: action
+Run when done
+
+METHOD:: transform
+Given a trained model, apply the reduction to a source link::Classes/FluidDataSet:: and write to a destination. Can be the same for both (in-place)
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done.
+
+METHOD:: fitTransform
+Fit the model to a link::Classes/FluidDataSet:: and write the new projected data to a destination FluidDataSet.
+ARGUMENT:: sourceDataSet
+Source data, or the DataSet name
+ARGUMENT:: destDataSet
+Destination data, or the DataSet name
+ARGUMENT:: action
+Run when done
+
+EXAMPLES::
+
+code::
+
+//Preliminaries: we want some points, a couple of FluidDataSets, a FluidStandardize and a FluidUMAP
+(
+~raw = FluidDataSet(s);
+~standardized = FluidDataSet(s);
+~reduced = FluidDataSet(s);
+~normalized = FluidDataSet(s);
+~standardizer  = FluidStandardize(s);
+~normalizer = FluidNormalize(s, 0.05, 0.95);
+~umap = FluidUMAP(s).numDimensions_(2).numNeighbours_(5).minDist_(0.2).iterations_(50).learnRate_(0.2);
+)
+
+
+// build a dataset of 400 points in 3D (colour in RGB)
+~colours = Dictionary.newFrom(400.collect{|i|[("entry"++i).asSymbol, 3.collect{1.0.rand}]}.flatten(1));
+~raw.load(Dictionary.newFrom([\cols, 3, \data, ~colours]));
+
+// check the entries
+~raw.print;
+
+//First standardize our DataSet, then apply the UMAP to get 2 dimensions, then normalise these 2 for drawing in the full window size
+(
+~standardizer.fitTransform(~raw,~standardized,action:{"Standardized".postln});
+~umap.fitTransform(~standardized,~reduced,action:{"Finished UMAP".postln});
+~normalizer.fitTransform(~reduced,~normalized,action:{"Normalized Output".postln});
+)
+//we recover the reduced dataset
+~normalized.dump{|x| ~normalizedDict = x["data"]};
+
+~normalized.print
+~normalizedDict.postln
+
+//Visualise the 2D projection of our original 4D data
+(
+w = Window("a perspective", Rect(128, 64, 200, 200));
+w.drawFunc = {
+	Pen.use {
+		~normalizedDict.keysValuesDo{|key, val|
+			Pen.fillColor = Color.new(~colours[key.asSymbol][0], ~colours[key.asSymbol][1],~colours[key.asSymbol][2]);
+			Pen.fillOval(Rect((val[0] * 200), (val[1] * 200), 5, 5));
+			~colours[key.asSymbol].flat;
+		}
+	}
+};
+w.refresh;
+w.front;
+)
+
+//play with parameters
+~umap.numNeighbours_(10).minDist_(0.5).iterations_(100).learnRate_(0.1);
+
+//rerun the UMAP
+~umap.fitTransform(~standardized,~reduced,action:{"Finished UMAP".postln});
+
+//draw to compare
+(
+~normalizer.fitTransform(~reduced,~normalized,action:{
+	"Normalized Output".postln;
+	~normalized.dump{|x|
+		~normalizedDict = x["data"];
+
+		{
+			u = Window("another perspective", Rect(328, 64, 200, 200));
+			u.drawFunc = {
+				Pen.use {
+					~normalizedDict.keysValuesDo{|key, val|
+						Pen.fillColor = Color.new(~colours[key.asSymbol][0], ~colours[key.asSymbol][1],~colours[key.asSymbol][2]);
+						Pen.fillOval(Rect((val[0] * 200), (val[1] * 200), 5, 5));
+						~colours[key.asSymbol].flat;
+					};
+				};
+			};
+			u.refresh;
+			u.front;
+
+		}.defer;
+
+	};
+});
+)
+
+// now run new random points on the same training material. Colours should be scattered around the same space
+
+~newDS = FluidDataSet(s);
+~colours2 = Dictionary.newFrom(400.collect{|i|[("entry"++i).asSymbol, 3.collect{1.0.rand}]}.flatten(1));
+~newDS.load(Dictionary.newFrom([\cols, 3, \data, ~colours2]));
+
+//we need to standardize to the same space
+~newDSstan = FluidDataSet(s);
+~standardizer.transform(~newDS, ~newDSstan);
+
+//then we can run the umap
+~newDSmap = FluidDataSet(s);
+~umap.transform(~newDSstan, ~newDSmap);
+
+//then we can draw and look
+(
+~normalizer.transform(~newDSmap,~normalized,action:{
+	"Normalized Output".postln;
+	~normalized.dump{|x|
+		~normalizedDict = x["data"];
+		{
+			t = Window("new material", Rect(528, 64, 200, 200));
+			t.drawFunc = {
+				Pen.use {
+					~normalizedDict.keysValuesDo{|key, val|
+						Pen.fillColor = Color.new(~colours2[key.asSymbol][0], ~colours2[key.asSymbol][1],~colours2[key.asSymbol][2]);
+						Pen.fillOval(Rect((val[0] * 200), (val[1] * 200), 5, 5));
+						~colours2[key.asSymbol].flat;
+					};
+				};
+			};
+			t.refresh;
+			t.front;
+		}.defer;
+	};
+});
+)
+
+//if we process the original dataset, we will see small differences in positions
+~reduced2 = FluidDataSet(s);
+~umap.transform(~standardized, ~reduced2, action: {\done.postln;});
+
+//then we can draw and look
+(
+~normalizer.transform(~reduced2,~normalized,action:{
+	"Normalized Output".postln;
+	~normalized.dump{|x|
+		~normalizedDict = x["data"];
+		{
+			z = Window("old material", Rect(728, 64, 200, 200));
+			z.drawFunc = {
+				Pen.use {
+					~normalizedDict.keysValuesDo{|key, val|
+						Pen.fillColor = Color.new(~colours[key.asSymbol][0], ~colours[key.asSymbol][1],~colours[key.asSymbol][2]);
+						Pen.fillOval(Rect((val[0] * 200), (val[1] * 200), 5, 5));
+						~colours[key.asSymbol].flat;
+					};
+				};
+			};
+			z.refresh;
+			z.front;
+		}.defer;
+	};
+});
+)
+
+//this is because the fitTransform method has the advantage of being certain that the data it transforms is the one that has been used to fit the model. This allows for more accurate distance measurement.
+
+//to check, let's retrieve a single point and predict its position
+(
+~sourcePoint = Buffer(s);
+~original = Buffer(s);
+~standed = Buffer(s);
+~umaped = Buffer(s);
+)
+
+//retrieve the 3D original
+~raw.getPoint("entry49",~sourcePoint)
+//retrieve the fitTransformed point as the most accurate point
+~reduced.getPoint("entry49",~original, {~original.getn(0,2,{|x|x.postln})})
+//retreive the transformed point, via the standardizer
+~standardizer.transformPoint(~sourcePoint,~standed);
+~umap.transformPoint(~standed, ~umaped, {~umaped.getn(0,2,{|x|x.postln})})
+
+// one can also retrieve in control rate with Server Side Queries
+// Let's map our learned UMAP dimensions to the controls of a processor
+
+(
+{
+    var trig = Impulse.kr(1);
+	var point = WhiteNoise.kr(1.dup(3));
+    var inputPoint = LocalBuf(3);
+    var standPoint = LocalBuf(3);
+	var outputPoint = LocalBuf(2);
+	var cue1, cue2;
+	Poll.kr(trig, point, [\pointX,\pointY,\pointZ]);
+	point.collect{ |p,i| BufWr.kr([p],inputPoint,i)};
+	cue1 = ~standardizer.kr(trig,inputPoint,standPoint);
+	Poll.kr(cue1,BufRd.kr(1,standPoint,(0..2),interpolation:0),[\stdX,\stdY, \stdZ]);
+	cue2 = ~umap.kr(cue1, standPoint, outputPoint);
+	Poll.kr(cue2,BufRd.kr(1,outputPoint,[0,1],interpolation:0),[\newDimA,\newDimB]);
+    Silent.ar;
+}.play;
+)
+
+::
diff --git a/release-packaging/HelpSource/Classes/QuickStart.md b/release-packaging/HelpSource/Classes/QuickStart.md
deleted file mode 100644
index 80d9288..0000000
--- a/release-packaging/HelpSource/Classes/QuickStart.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Instructions for the PureData version of the fluid.* toolbox
-
-## How to start:
-
-1) move the following items to their respective relevant pd search path
-- externals are in /pd_objects
-- help files are in /help
-- audio used in the help files are in /media, which is expected to be parallel to /help
-- detailed help is provided as a website in /docs
-
-2) The PureData document 'Fluid_Decomposition_Overview.pd' shows the toolbox at a glance.
-
-5) Parameters can be set by message (as in max with the same names) OR by option in the object box which work similarly to the [sigmund~] options.
-
-6) Most objects working on arrays/buffers are multichannel. The toolbox uses the following convention: a named array is expected to have a name, followed by -x where x is the 'channel' number, 0-indexed. For instance, a stereo source buffer defined as 'mybuf' will expect an array named 'mybuf-0' for the left channel, and an array named 'mybuf-1' for the right channel. A utility [multiarray.pd] is used throughout the helpfiles in conjonction with the [clone] to programmatically generate such 'multichannel' buffers.
-
-#### Enjoy!
-
-
-## Known issues:
-- pd is single threaded so doing buffer ops will do bad things to realtime audio.
-- providing 'multichannel' arrays not enough in numbers (aka channels) will crash Pd.
diff --git a/release-packaging/HelpSource/Guides/FluCoMa.schelp b/release-packaging/HelpSource/Guides/FluCoMa.schelp
index 0f16dc3..bd55234 100644
--- a/release-packaging/HelpSource/Guides/FluCoMa.schelp
+++ b/release-packaging/HelpSource/Guides/FluCoMa.schelp
@@ -1,11 +1,11 @@
 title:: The Fluid Corpus Manipulation Project
 summary:: This section gives an overview of the Fluid Corpus Manipulation Project
 categories:: Libraries>FluidDecomposition
-related:: Classes/FluidBufNMF
+related:: Classes/FluidBufNMF, Guides/FluidDecomposition
 
 description::
 The Fluid Corpus Manipulation project (FluCoMA) instigates new musical ways of exploiting ever-growing banks of sound and gestures within the digital composition process, by bringing breakthroughs of signal decomposition DSP and machine learning to the toolset of techno-fluent computer composers, creative coders and digital artists. The first set of tools  released is the LINK:: Guides/FluidDecomposition::
 
 This was made possible thanks to a grant by the European Research Council ( https://erc.europa.eu/ ) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899).
 
-For more information, including a forum and learning material, please visit the FluCoMa project website at http://www.flucoma.org/
\ No newline at end of file
+For more information, including a forum and learning material, please visit the FluCoMa project website at http://www.flucoma.org/
diff --git a/release-packaging/HelpSource/Guides/FluidBufMultiThreading.schelp b/release-packaging/HelpSource/Guides/FluidBufMultiThreading.schelp
index f1f1e49..5ec317f 100644
--- a/release-packaging/HelpSource/Guides/FluidBufMultiThreading.schelp
+++ b/release-packaging/HelpSource/Guides/FluidBufMultiThreading.schelp
@@ -1,6 +1,6 @@
 TITLE:: FluidBuf* Multithreading Behaviour
 SUMMARY:: A tutorial on the multithreading behaviour of offline processes of the Fluid Decomposition toolbox for signal decomposition
-CATEGORIES:: Libraries>FluidDecomposition
+CATEGORIES:: Libraries>FluidDecomposition, Guides>FluCoMa
 RELATED:: Guides/FluCoMa, Guides/FluidDecomposition
 
 DESCRIPTION::
diff --git a/release-packaging/HelpSource/Guides/FluidDataTools.schelp b/release-packaging/HelpSource/Guides/FluidDataTools.schelp
new file mode 100644
index 0000000..672d922
--- /dev/null
+++ b/release-packaging/HelpSource/Guides/FluidDataTools.schelp
@@ -0,0 +1,67 @@
+title:: The Fluid Corpus Manipulation Data Tools
+summary:: Tools for organising, exploring and querying corpora
+categories:: Libraries>FluidDecomposition,Guides>FluCoMa
+related:: Guides/FluCoMa, Guides/FluidDecomposition, Classes/FluidDataSet,Classes/FluidLabelSet
+
+The suite of Fluid Corpus Manipulation data tools offer facilities for building, exploring, transforming and playing with corpora. The tools are built around two container classes, link::Classes/FluidDataSet:: and link::Classes/FluidLabelSet::, which provides a way to build up and stored collections of labelled data, and a suite of objects that act on these containers.
+
+The design and interface of many of these objects is heavily based on the Python library link::https://scikit-learn.org/stable/##scikit-learn::, a mature and well developed machine learning toolkit that is comparatively quick to get going with. As our documentation continues to develop, we will also lean quite heavily on sci-learn's!
+
+section:: Containers
+
+Map id labels to data points, or to other labels
+
+link::Classes/FluidDataSet::
+
+link::Classes/FluidLabelSet::
+
+
+section:: DataSet Filtering
+
+Select and filter items from FluidDataSet by building queries
+
+link::Classes/FluidDataSetQuery::
+
+section:: Data Structure
+
+Perform nearest neighbour searches
+
+link::Classes/FluidKDTree::
+
+section:: Data Conditioning
+
+Pre-process data
+
+link::Classes/FluidNormalize::
+
+link::Classes/FluidStandardize::
+
+link::Classes/FluidRobustScale::
+
+section:: Dimension Reduction
+
+Compress data to fewer dimensions for visualisation / efficiency / preprocessing
+
+link::Classes/FluidPCA::
+
+link::Classes/FluidMDS::
+
+section:: Supervised Learning
+
+Train supervised learning models using either K nearest neighbours or a simple neural network
+
+subsection:: Classification
+
+Map input data points to categories
+
+link::Classes/FluidKNNClassifier::
+
+link::Classes/FluidMLPClassifier::
+
+subsection:: Regression
+
+Map input data points to continuous output
+
+link::Classes/FluidKNNRegressor::
+
+link::Classes/FluidMLPRegressor::
diff --git a/release-packaging/HelpSource/Guides/FluidDecomposition.schelp b/release-packaging/HelpSource/Guides/FluidDecomposition.schelp
index bfe55a0..2f5f49d 100644
--- a/release-packaging/HelpSource/Guides/FluidDecomposition.schelp
+++ b/release-packaging/HelpSource/Guides/FluidDecomposition.schelp
@@ -1,6 +1,6 @@
 TITLE:: Fluid Decomposition Toolbox
 SUMMARY:: An overview of the FluCoMa toolbox for signal decomposition
-CATEGORIES:: Libraries>FluidDecomposition
+CATEGORIES:: Libraries>FluidDecomposition, Guides>FluCoMa
 
 DESCRIPTION::
 The Fluid Decomposition toolbox provides an open-ended, loosely coupled set of objects to break up and analyse sound in terms of slices (segments in time), layers (superpositions in time and frequency) and objects (configurable or discoverable patterns in sound). Almost all objects have audio-rate and buffer-based versions. footnote::
diff --git a/scripts/target_post.cmake b/scripts/target_post.cmake
index e70c088..cce9658 100644
--- a/scripts/target_post.cmake
+++ b/scripts/target_post.cmake
@@ -7,23 +7,18 @@
 
 target_compile_features(${PLUGIN} PRIVATE cxx_std_14)
 
-if(MSVC)
-  foreach(flag_var
-      CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-      CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-    if(${flag_var} MATCHES "/MD")
-      string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-    endif()
-  endforeach()
-endif()
-
 if(MSVC)
   target_compile_options(${PLUGIN} PRIVATE /W3)
 else()
   target_compile_options(${PLUGIN} PRIVATE 
-    -Wall -Wextra -Wpedantic -Wreturn-type -Wconversion -Wno-c++11-narrowing
+    -Wall -Wextra -Wpedantic -Wreturn-type -Wconversion
   )
-endif()
+  
+  #GCC doesn't have Wno-c++11-narrowing
+  if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    target_compile_options(${PLUGIN} PRIVATE  -Wno-c++11-narrowing)
+  endif()
+endif() 
 
 set_target_properties(${PLUGIN} PROPERTIES
     CXX_STANDARD 14
@@ -41,9 +36,8 @@ endif()
 
 target_link_libraries(
   ${PLUGIN}
-  PRIVATE
+  PRIVATE  
   FLUID_DECOMPOSITION
-  # FLUID_MANIP
   FLUID_SC_WRAPPER  
   HISSTools_FFT
 )
@@ -51,10 +45,16 @@ target_link_libraries(
 target_include_directories(
   ${PLUGIN}
   PRIVATE
-  ${LOCAL_INCLUDES}
+  "${LOCAL_INCLUDES}"
   "${FLUID_VERSION_PATH}"
 )
 
+file(GLOB_RECURSE FLUID_SC_HEADERS CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/include/wrapper/*.hpp")
+
+target_sources(
+  ${PLUGIN} PUBLIC ${FLUID_SC_HEADERS}
+)
+
 target_include_directories(
   ${PLUGIN}
   SYSTEM PRIVATE
@@ -66,10 +66,9 @@ target_include_directories(
 
 get_property(HEADERS TARGET FLUID_DECOMPOSITION PROPERTY INTERFACE_SOURCES)
 source_group(TREE "${flucoma-core_SOURCE_DIR}/include" FILES ${HEADERS})
+source_group(TREE "${CMAKE_SOURCE_DIR}/include/wrapper" PREFIX wrapper FILES ${FLUID_SC_HEADERS})
+
 
-# get_property(HEADERS TARGET FLUID_MANIP PROPERTY INTERFACE_SOURCES)
-# source_group(TREE "${fluid_manipulation_SOURCE_DIR}/include" FILES ${HEADERS})
-# 
 # if (SUPERNOVA)
 #     target_include_directories(
 #       ${PLUGIN}
diff --git a/src/FluidAmpGate/FluidAmpGate.cpp b/src/FluidAmpGate/FluidAmpGate.cpp
index 3b696e2..d8a0c9b 100644
--- a/src/FluidAmpGate/FluidAmpGate.cpp
+++ b/src/FluidAmpGate/FluidAmpGate.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<AmpGateClient>("FluidAmpGate", ft);
+  makeSCWrapper<RTAmpGateClient>("FluidAmpGate", ft);
 }
diff --git a/src/FluidAmpSlice/FluidAmpSlice.cpp b/src/FluidAmpSlice/FluidAmpSlice.cpp
index 3ac71fd..c5ceaa0 100644
--- a/src/FluidAmpSlice/FluidAmpSlice.cpp
+++ b/src/FluidAmpSlice/FluidAmpSlice.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<AmpSliceClient>("FluidAmpSlice", ft);
+  makeSCWrapper<RTAmpSliceClient>("FluidAmpSlice", ft);
 }
diff --git a/src/FluidAudioTransport/CMakeLists.txt b/src/FluidAudioTransport/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidAudioTransport/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidAudioTransport/FluidAudioTransport.cpp b/src/FluidAudioTransport/FluidAudioTransport.cpp
new file mode 100644
index 0000000..1815e8b
--- /dev/null
+++ b/src/FluidAudioTransport/FluidAudioTransport.cpp
@@ -0,0 +1,21 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/rt/AudioTransportClient.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<RTAudioTransportClient>("FluidAudioTransport",ft);
+}
diff --git a/src/FluidBufAudioTransport/CMakeLists.txt b/src/FluidBufAudioTransport/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufAudioTransport/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufAudioTransport/FluidBufAudioTransport.cpp b/src/FluidBufAudioTransport/FluidBufAudioTransport.cpp
new file mode 100644
index 0000000..2d1476e
--- /dev/null
+++ b/src/FluidBufAudioTransport/FluidBufAudioTransport.cpp
@@ -0,0 +1,21 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/rt/AudioTransportClient.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedAudioTransportClient>("FluidBufAudioTransp",ft);
+}
diff --git a/src/FluidBufFlatten/CMakeLists.txt b/src/FluidBufFlatten/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufFlatten/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufFlatten/FluidBufFlatten.cpp b/src/FluidBufFlatten/FluidBufFlatten.cpp
new file mode 100644
index 0000000..0a6746c
--- /dev/null
+++ b/src/FluidBufFlatten/FluidBufFlatten.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufFlattenClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedBufFlattenClient>("FluidBufFlatten", ft);
+}
diff --git a/src/FluidBufNNDSVD/CMakeLists.txt b/src/FluidBufNNDSVD/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufNNDSVD/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufNNDSVD/FluidBufNNDSVD.cpp b/src/FluidBufNNDSVD/FluidBufNNDSVD.cpp
new file mode 100644
index 0000000..2f4e47f
--- /dev/null
+++ b/src/FluidBufNNDSVD/FluidBufNNDSVD.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/NNDSVDClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedNNDSVDClient>("FluidBufNNDSVD", ft);
+}
diff --git a/src/FluidBufSTFT/CMakeLists.txt b/src/FluidBufSTFT/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufSTFT/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufSTFT/FluidBufSTFT.cpp b/src/FluidBufSTFT/FluidBufSTFT.cpp
new file mode 100644
index 0000000..ecd1001
--- /dev/null
+++ b/src/FluidBufSTFT/FluidBufSTFT.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufSTFTClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedBufferSTFTClient>("FluidBufSTFT", ft);
+}
diff --git a/src/FluidBufScale/CMakeLists.txt b/src/FluidBufScale/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufScale/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufScale/FluidBufScale.cpp b/src/FluidBufScale/FluidBufScale.cpp
new file mode 100644
index 0000000..12ffeba
--- /dev/null
+++ b/src/FluidBufScale/FluidBufScale.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufScaleClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedBufferScaleClient>("FluidBufScale", ft);
+}
diff --git a/src/FluidBufSelect/CMakeLists.txt b/src/FluidBufSelect/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufSelect/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufSelect/FluidBufSelect.cpp b/src/FluidBufSelect/FluidBufSelect.cpp
new file mode 100644
index 0000000..43fc58a
--- /dev/null
+++ b/src/FluidBufSelect/FluidBufSelect.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufSelectClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadingSelectClient>("FluidBufSelect", ft);
+}
diff --git a/src/FluidBufSelectEvery/CMakeLists.txt b/src/FluidBufSelectEvery/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufSelectEvery/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufSelectEvery/FluidBufSelectEvery.cpp b/src/FluidBufSelectEvery/FluidBufSelectEvery.cpp
new file mode 100644
index 0000000..87c1d9b
--- /dev/null
+++ b/src/FluidBufSelectEvery/FluidBufSelectEvery.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufSelectEveryClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadingSelectEveryClient>("FluidBufSelectEvery", ft);
+}
diff --git a/src/FluidBufSpectralShape/FluidBufSpectralShape.cpp b/src/FluidBufSpectralShape/FluidBufSpectralShape.cpp
index adda5b1..09685d8 100644
--- a/src/FluidBufSpectralShape/FluidBufSpectralShape.cpp
+++ b/src/FluidBufSpectralShape/FluidBufSpectralShape.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(OfflineFluidDecompositionUGens) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NRTThreadedSpectralShapeClient>("FluidBufSpectralShape", ft);
+  makeSCWrapper<NRTThreadedSpectralShapeClient>("FluidBufSpecShp", ft);
 }
diff --git a/src/FluidBufStats/FluidBufStats.cpp b/src/FluidBufStats/FluidBufStats.cpp
index c81c117..b5f902c 100644
--- a/src/FluidBufStats/FluidBufStats.cpp
+++ b/src/FluidBufStats/FluidBufStats.cpp
@@ -18,5 +18,5 @@ PluginLoad(OfflineFluidDecompositionUGens)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NRTThreadedBufStatsClient>("FluidBufStats", ft);
+  makeSCWrapper<NRTThreadedBufferStatsClient>("FluidBufStats", ft);
 }
diff --git a/src/FluidBufThresh/CMakeLists.txt b/src/FluidBufThresh/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidBufThresh/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidBufThresh/FluidBufThresh.cpp b/src/FluidBufThresh/FluidBufThresh.cpp
new file mode 100644
index 0000000..bd6c0a2
--- /dev/null
+++ b/src/FluidBufThresh/FluidBufThresh.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/nrt/BufThreshClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedBufferThreshClient>("FluidBufThresh", ft);
+}
diff --git a/src/FluidBufTransientSlice/FluidBufTransientSlice.cpp b/src/FluidBufTransientSlice/FluidBufTransientSlice.cpp
index 520b066..7354e08 100644
--- a/src/FluidBufTransientSlice/FluidBufTransientSlice.cpp
+++ b/src/FluidBufTransientSlice/FluidBufTransientSlice.cpp
@@ -17,5 +17,5 @@ static InterfaceTable* ft;
 PluginLoad(OfflineFluidDecompositionUGens) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NRTThreadedTransientSliceClient>("FluidBufTransientSlice", ft);
+  makeSCWrapper<NRTThreadedTransientSliceClient>("FluidBufTrSlice", ft);
 }
diff --git a/src/FluidGain/FluidGain.cpp b/src/FluidGain/FluidGain.cpp
index acb105f..0dcb164 100644
--- a/src/FluidGain/FluidGain.cpp
+++ b/src/FluidGain/FluidGain.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidGainUgen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<GainClient>("FluidGain", ft);
+  makeSCWrapper<RTGainClient>("FluidGain", ft);
 }
diff --git a/src/FluidHPSS/FluidHPSS.cpp b/src/FluidHPSS/FluidHPSS.cpp
index 7003c44..d6c8288 100644
--- a/src/FluidHPSS/FluidHPSS.cpp
+++ b/src/FluidHPSS/FluidHPSS.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<HPSSClient>("FluidHPSS", ft);
+  makeSCWrapper<RTHPSSClient>("FluidHPSS", ft);
 }
diff --git a/src/FluidLoudness/FluidLoudness.cpp b/src/FluidLoudness/FluidLoudness.cpp
index c938917..ccf0300 100644
--- a/src/FluidLoudness/FluidLoudness.cpp
+++ b/src/FluidLoudness/FluidLoudness.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<LoudnessClient>("FluidLoudness", ft);
+  makeSCWrapper<RTLoudnessClient>("FluidLoudness", ft);
 }
diff --git a/src/FluidMFCC/FluidMFCC.cpp b/src/FluidMFCC/FluidMFCC.cpp
index a6652e9..79cc90f 100644
--- a/src/FluidMFCC/FluidMFCC.cpp
+++ b/src/FluidMFCC/FluidMFCC.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<MFCCClient>("FluidMFCC", ft);
+  makeSCWrapper<RTMFCCClient>("FluidMFCC", ft);
 }
diff --git a/src/FluidManipulation/CMakeLists.txt b/src/FluidManipulation/CMakeLists.txt
new file mode 100644
index 0000000..cd88c0a
--- /dev/null
+++ b/src/FluidManipulation/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.3)
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+target_include_directories(
+  ${PLUGIN} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../include
+)
+
+target_link_libraries(
+  ${PLUGIN} PRIVATE FLUID_DECOMPOSITION
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
+
+if(MSVC)
+  target_compile_options(${PLUGIN} PRIVATE /bigobj)
+endif()
diff --git a/src/FluidManipulation/FluidManipulation.cpp b/src/FluidManipulation/FluidManipulation.cpp
new file mode 100644
index 0000000..9de5f6e
--- /dev/null
+++ b/src/FluidManipulation/FluidManipulation.cpp
@@ -0,0 +1,44 @@
+
+// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
+
+#include <clients/nrt/DataSetClient.hpp>
+#include <clients/nrt/DataSetQueryClient.hpp>
+#include <clients/nrt/LabelSetClient.hpp>
+#include <clients/nrt/KDTreeClient.hpp>
+#include <clients/nrt/KMeansClient.hpp>
+#include <clients/nrt/KNNClassifierClient.hpp>
+#include <clients/nrt/KNNRegressorClient.hpp>
+#include <clients/nrt/NormalizeClient.hpp>
+#include <clients/nrt/RobustScaleClient.hpp>
+#include <clients/nrt/StandardizeClient.hpp>
+#include <clients/nrt/PCAClient.hpp>
+#include <clients/nrt/MDSClient.hpp>
+#include <clients/nrt/UMAPClient.hpp>
+#include <clients/nrt/MLPRegressorClient.hpp>
+#include <clients/nrt/MLPClassifierClient.hpp>
+#include <clients/rt/FluidDataSetWr.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedDataSetClient>("FluidDataSet",ft);
+  makeSCWrapper<NRTThreadedDataSetQueryClient>("FluidDataSetQuery",ft);
+  makeSCWrapper<NRTThreadedLabelSetClient>("FluidLabelSet",ft);
+  makeSCWrapper<RTKDTreeClient>("FluidKDTree",ft);
+  makeSCWrapper<RTKMeansClient>("FluidKMeans",ft);
+  makeSCWrapper<RTKNNClassifierClient>("FluidKNNClassifier",ft);
+  makeSCWrapper<RTKNNRegressorClient>("FluidKNNRegressor",ft);
+  makeSCWrapper<RTNormalizeClient>("FluidNormalize",ft);
+  makeSCWrapper<RTRobustScaleClient>("FluidRobustScale",ft);
+  makeSCWrapper<RTStandardizeClient>("FluidStandardize",ft);
+  makeSCWrapper<RTPCAClient>("FluidPCA",ft);
+  makeSCWrapper<NRTThreadedMDSClient>("FluidMDS",ft);
+  makeSCWrapper<RTUMAPClient>("FluidUMAP",ft);
+  makeSCWrapper<NRTThreadedDataSetWriter>("FluidDataSetWr", ft);
+  makeSCWrapper<RTMLPRegressorClient>("FluidMLPRegressor",ft);
+  makeSCWrapper<RTMLPClassifierClient>("FluidMLPClassifier",ft);
+}
diff --git a/src/FluidMelBands/FluidMelBands.cpp b/src/FluidMelBands/FluidMelBands.cpp
index 586462a..01aeff1 100644
--- a/src/FluidMelBands/FluidMelBands.cpp
+++ b/src/FluidMelBands/FluidMelBands.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<MelBandsClient>("FluidMelBands", ft);
+  makeSCWrapper<RTMelBandsClient>("FluidMelBands", ft);
 }
diff --git a/src/FluidMessageTest/CMakeLists.txt b/src/FluidMessageTest/CMakeLists.txt
new file mode 100644
index 0000000..3693881
--- /dev/null
+++ b/src/FluidMessageTest/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.3)
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+target_include_directories(
+  ${PLUGIN} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../include
+)
+
+target_link_libraries(
+  ${PLUGIN} PRIVATE FLUID_DECOMPOSITION
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidMessageTest/FluidMessageTest.cpp b/src/FluidMessageTest/FluidMessageTest.cpp
new file mode 100644
index 0000000..778df9c
--- /dev/null
+++ b/src/FluidMessageTest/FluidMessageTest.cpp
@@ -0,0 +1,13 @@
+
+// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
+
+#include <clients/nrt/MessageTest.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen) {
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadingMessageTest>("FluidMessageTest", ft);
+}
diff --git a/src/FluidNMFCross/CMakeLists.txt b/src/FluidNMFCross/CMakeLists.txt
new file mode 100644
index 0000000..3693881
--- /dev/null
+++ b/src/FluidNMFCross/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.3)
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+target_include_directories(
+  ${PLUGIN} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../include
+)
+
+target_link_libraries(
+  ${PLUGIN} PRIVATE FLUID_DECOMPOSITION
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidNMFCross/FluidNMFCross.cpp b/src/FluidNMFCross/FluidNMFCross.cpp
new file mode 100644
index 0000000..5749fa5
--- /dev/null
+++ b/src/FluidNMFCross/FluidNMFCross.cpp
@@ -0,0 +1,12 @@
+
+#include <clients/nrt/NMFCrossClient.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(OfflineFluidDecompositionUGens)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTNMFCrossClient>("FluidBufNMFCross", ft);
+}
diff --git a/src/FluidNMFFilter/FluidNMFFilter.cpp b/src/FluidNMFFilter/FluidNMFFilter.cpp
index bca77d5..9324f20 100644
--- a/src/FluidNMFFilter/FluidNMFFilter.cpp
+++ b/src/FluidNMFFilter/FluidNMFFilter.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NMFFilterClient>("FluidNMFFilter", ft);
+  makeSCWrapper<RTNMFFilterClient>("FluidNMFFilter", ft);
 }
diff --git a/src/FluidNMFMatch/FluidNMFMatch.cpp b/src/FluidNMFMatch/FluidNMFMatch.cpp
index fbb3ceb..e84b0e8 100644
--- a/src/FluidNMFMatch/FluidNMFMatch.cpp
+++ b/src/FluidNMFMatch/FluidNMFMatch.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NMFMatchClient>("FluidNMFMatch", ft);
+  makeSCWrapper<RTNMFMatchClient>("FluidNMFMatch", ft);
 }
diff --git a/src/FluidNMFMorph/CMakeLists.txt b/src/FluidNMFMorph/CMakeLists.txt
new file mode 100644
index 0000000..9646a4e
--- /dev/null
+++ b/src/FluidNMFMorph/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+# Copyright 2017-2019 University of Huddersfield.
+# Licensed under the BSD-3 License.
+# See license.md file in the project root for full license information.
+# This project has received funding from the European Research Council (ERC)
+# under the European Union’s Horizon 2020 research and innovation programme
+# (grant agreement No 725899).
+
+cmake_minimum_required(VERSION 3.11)
+
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidNMFMorph/FluidNMFMorph.cpp b/src/FluidNMFMorph/FluidNMFMorph.cpp
new file mode 100644
index 0000000..fa38d8f
--- /dev/null
+++ b/src/FluidNMFMorph/FluidNMFMorph.cpp
@@ -0,0 +1,22 @@
+/*
+Part of the Fluid Corpus Manipulation Project (http://www.flucoma.org/)
+Copyright 2017-2019 University of Huddersfield.
+Licensed under the BSD-3 License.
+See license.md file in the project root for full license information.
+This project has received funding from the European Research Council (ERC)
+under the European Union’s Horizon 2020 research and innovation programme
+(grant agreement No 725899).
+*/
+
+#include <clients/rt/NMFMorphClient.hpp>
+
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<RTNMFMorphClient>("FluidNMFMorph", ft);
+}
diff --git a/src/FluidNoveltySlice/FluidNoveltySlice.cpp b/src/FluidNoveltySlice/FluidNoveltySlice.cpp
index e64ea80..4044310 100644
--- a/src/FluidNoveltySlice/FluidNoveltySlice.cpp
+++ b/src/FluidNoveltySlice/FluidNoveltySlice.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<NoveltySliceClient>("FluidNoveltySlice", ft);
+  makeSCWrapper<RTNoveltySliceClient>("FluidNoveltySlice", ft);
 }
diff --git a/src/FluidOnsetSlice/FluidOnsetSlice.cpp b/src/FluidOnsetSlice/FluidOnsetSlice.cpp
index 8db8146..aec600f 100644
--- a/src/FluidOnsetSlice/FluidOnsetSlice.cpp
+++ b/src/FluidOnsetSlice/FluidOnsetSlice.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<OnsetSliceClient>("FluidOnsetSlice", ft);
+  makeSCWrapper<RTOnsetSliceClient>("FluidOnsetSlice", ft);
 }
diff --git a/src/FluidPitch/FluidPitch.cpp b/src/FluidPitch/FluidPitch.cpp
index 6b473c7..b1d8a87 100644
--- a/src/FluidPitch/FluidPitch.cpp
+++ b/src/FluidPitch/FluidPitch.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<PitchClient>("FluidPitch", ft);
+  makeSCWrapper<RTPitchClient>("FluidPitch", ft);
 }
diff --git a/src/FluidSTFTPass/FluidSTFTPass.cpp b/src/FluidSTFTPass/FluidSTFTPass.cpp
index 4f7ac01..9fff5e4 100644
--- a/src/FluidSTFTPass/FluidSTFTPass.cpp
+++ b/src/FluidSTFTPass/FluidSTFTPass.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<BaseSTFTClient>("FluidSTFTPass", ft);
+  makeSCWrapper<RTSTFTPassClient>("FluidSTFTPass", ft);
 }
diff --git a/src/FluidSines/FluidSines.cpp b/src/FluidSines/FluidSines.cpp
index 2cc18f5..93ac2a7 100644
--- a/src/FluidSines/FluidSines.cpp
+++ b/src/FluidSines/FluidSines.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<SinesClient>("FluidSines", ft);
+  makeSCWrapper<RTSinesClient>("FluidSines", ft);
 }
diff --git a/src/FluidSpectralShape/FluidSpectralShape.cpp b/src/FluidSpectralShape/FluidSpectralShape.cpp
index f00982d..7c6b19b 100644
--- a/src/FluidSpectralShape/FluidSpectralShape.cpp
+++ b/src/FluidSpectralShape/FluidSpectralShape.cpp
@@ -17,5 +17,5 @@ static InterfaceTable *ft;
 PluginLoad(FluidSTFTUGen) {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<SpectralShapeClient>("FluidSpectralShape", ft);
+  makeSCWrapper<RTSpectralShapeClient>("FluidSpectralShape", ft);
 }
diff --git a/src/FluidSubscriberProviderTest/CMakeLists.txt b/src/FluidSubscriberProviderTest/CMakeLists.txt
new file mode 100644
index 0000000..3693881
--- /dev/null
+++ b/src/FluidSubscriberProviderTest/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.3)
+get_filename_component(PLUGIN ${CMAKE_CURRENT_LIST_DIR} NAME_WE)
+message("Configuring ${PLUGIN}")
+set(FILENAME ${PLUGIN}.cpp)
+
+add_library(
+  ${PLUGIN}
+  MODULE
+  ${FILENAME}
+)
+
+target_include_directories(
+  ${PLUGIN} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../include
+)
+
+target_link_libraries(
+  ${PLUGIN} PRIVATE FLUID_DECOMPOSITION
+)
+
+include(${CMAKE_CURRENT_LIST_DIR}/../../scripts/target_post.cmake)
diff --git a/src/FluidSubscriberProviderTest/FluidSubscriberProviderTest.cpp b/src/FluidSubscriberProviderTest/FluidSubscriberProviderTest.cpp
new file mode 100644
index 0000000..224dadf
--- /dev/null
+++ b/src/FluidSubscriberProviderTest/FluidSubscriberProviderTest.cpp
@@ -0,0 +1,17 @@
+
+// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
+
+#include <clients/nrt/ProviderTest.hpp>
+#include <clients/nrt/SubscriberTest.hpp>
+#include <FluidSCWrapper.hpp>
+
+static InterfaceTable *ft;
+
+PluginLoad(FluidSTFTUGen)
+{
+  ft = inTable;
+  using namespace fluid::client;
+  makeSCWrapper<NRTThreadedProviderTest>("FluidProviderTest", ft);
+  makeSCWrapper<NRTThreadedSubscriberTest>("FluidSubscriberTest", ft);
+
+}
diff --git a/src/FluidTransientSlice/FluidTransientSlice.cpp b/src/FluidTransientSlice/FluidTransientSlice.cpp
index 6eff3fa..987097d 100644
--- a/src/FluidTransientSlice/FluidTransientSlice.cpp
+++ b/src/FluidTransientSlice/FluidTransientSlice.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<TransientsSliceClient>("FluidTransientSlice", ft);
+  makeSCWrapper<RTTransientSliceClient>("FluidTransientSlice", ft);
 }
diff --git a/src/FluidTransients/FluidTransients.cpp b/src/FluidTransients/FluidTransients.cpp
index f3c91cb..be7816f 100644
--- a/src/FluidTransients/FluidTransients.cpp
+++ b/src/FluidTransients/FluidTransients.cpp
@@ -18,5 +18,5 @@ PluginLoad(FluidSTFTUGen)
 {
   ft = inTable;
   using namespace fluid::client;
-  makeSCWrapper<TransientClient>("FluidTransients", ft);
+  makeSCWrapper<RTTransientClient>("FluidTransients", ft);
 }
diff --git a/test/TestFluidManipulationLifecyle.sc b/test/TestFluidManipulationLifecyle.sc
new file mode 100644
index 0000000..796673a
--- /dev/null
+++ b/test/TestFluidManipulationLifecyle.sc
@@ -0,0 +1,101 @@
+
+TestFluidCorpusManipulationServer : UnitTest
+{
+	var waitForCounts, countsListener;
+
+	setUp{
+		waitForCounts = Condition.new(false);
+		countsListener = { |s,changed|
+			if(changed == \counts) {
+				waitForCounts.test = true;
+				waitForCounts.signal;
+			}
+		};
+		Server.default.addDependant(countsListener);
+	}
+
+	tearDown{
+		Server.default.removeDependant(countsListener);
+		Server.default.quit;
+	}
+
+	test_DataSetPersistence{
+		var foo, bar, tree, testPoint;
+		//No server on? You get nothing
+		this.assertEquals(nil,FluidDataSet(Server.default,\foo));
+
+		this.bootServer(Server.default);
+		// while {Server.default.serverRunning.not}{0.2.wait};
+
+		waitForCounts.test = false;
+		Server.default.doWhenBooted{foo=FluidDataSet(Server.default,\foo)};
+		waitForCounts.wait;
+		this.assertEquals(Server.default.numSynths,1,"Dataset: One Synth present after deferred boot");
+		waitForCounts.test = false;
+		foo.free;
+		waitForCounts.wait;
+		this.assertEquals(Server.default.numSynths,0,"Dataset: No synth present via cretation after free");
+		foo=FluidDataSet(Server.default,\foo);
+		//Uniqueness test (difficult to run with previous instance of foo, because
+		//UnitTest.bootServer messes with Server alloctors and screws up the ID cache
+		this.assertException({
+			bar = FluidDataSet(Server.default,\foo);
+		},FluidDataSetExistsError,"DataSetDuplicateError on reused name", onFailure:{
+			"Exception fail".postln;
+		});
+
+		waitForCounts.test = false;
+		bar = FluidDataSet(Server.default,\bar);
+		waitForCounts.wait;
+		this.assertEquals(Server.default.numSynths,2,"Dataset: Two Synths present after new valid Dataset added");
+
+		testPoint = Buffer.alloc(Server.default,8);
+		Server.default.sync;
+		testPoint.setn(0,[1,2,3,4,5,6,7,8]);
+		Server.default.sync;
+		foo.addPoint(\one,testPoint);
+		Server.default.sync;
+		foo.size({|size|
+			this.assertEquals(size,1,"Dataset size is 1");
+		});
+		Server.default.sync;
+		foo.cols({|cols|
+			this.assertEquals(cols,8,"Dataset cols is 8");
+		});
+
+		Server.default.sync;
+		waitForCounts.test = false;
+
+		tree = FluidKDTree(Server.default);
+		waitForCounts.wait;
+
+		this.assert(tree.synth.notNil,"Tree should have a valid synth");
+		this.assertEquals(Server.default.numSynths,3,"Dataset: Three Synths remain after cmd-.");
+
+		tree.fit(foo);
+		Server.default.sync;
+		tree.cols({|cols|
+			this.assertEquals(cols,8,"KDTree correct dims after fit")
+		});
+		Server.default.sync;
+
+		//Test cmd-period resistance
+		waitForCounts.test = false;
+		Server.default.freeAll;
+		Server.default.sync;
+		Server.default.sync;
+		waitForCounts.wait;
+
+		this.assertEquals(Server.default.numSynths,3,"Dataset: Three Synths remain after cmd-.");
+		foo.size({|size|
+			this.assertEquals(size,1,"Dataset size is still 1 after Cmd-.");
+		});
+		Server.default.sync;
+		foo.cols({|cols|
+			this.assertEquals(cols,8,"Dataset cols is still 8 after Cmd-.");
+		});
+		Server.default.sync;
+		tree.cols({|cols| this.assertEquals(cols,8,"KDTree correct dims after Cmd-.")});
+		Server.default.sync;
+	}
+}
\ No newline at end of file
diff --git a/tests/TestFluiSubscriberProvider.scd b/tests/TestFluiSubscriberProvider.scd
new file mode 100644
index 0000000..b8f1652
--- /dev/null
+++ b/tests/TestFluiSubscriberProvider.scd
@@ -0,0 +1,12 @@
+
+~provider
+~subscriber
+a = {~subscriber = FluidSubscriberTest.kr(\bollocks)}.play
+b = {~provider = FluidProviderTest.kr(\bollocks)}.play
+~provider.addPoint(Server.default,b,['foo', 1,2],{'Added'.postln})
+~subscriber.providerLookup(Server.default,a,['foo'],{|msg| msg.postln})
+~provider.updatePoint(Server.default,b,['foo', 3,4],{'Upadted'.postln})
+~subscriber.providerLookup(Server.default,a,['foo'],{|msg| msg.postln})
+~provider.deletePoint(Server.default,b,['foo'],{'Deleted'.postln})
+~subscriber.providerLookup(Server.default,a,['foo'],{|msg| msg.postln})
+
diff --git a/tests/TestFluidMessageTest..scd b/tests/TestFluidMessageTest..scd
new file mode 100644
index 0000000..54f4a14
--- /dev/null
+++ b/tests/TestFluidMessageTest..scd
@@ -0,0 +1,16 @@
+~messageTest
+a = {~messageTest = FluidMessageTest.kr}.play
+~messageTest.testReturnStrings(nil,a.nodeID,{|msg| msg.postln});
+~messageTest.testReturnNumbers(nil,a.nodeID,{|msg| msg.postln});
+~messageTest.testReturnOneString(nil,a.nodeID,{|msg| msg.postln});
+~messageTest.testReturnOneNumber(nil,a.nodeID,{|msg| msg.postln});
+b = Buffer.read(s,File.realpath(FluidMessageTest.class.filenameSymbol).dirname.withTrailingSlash ++ "../AudioFiles/Nicol-LoopE-M.wav");
+~messageTest.testAccessBuffer(nil,a.nodeID,b,{|msg| msg.postln});
+b.numFrames
+~messageTest.testPassString(nil,a.nodeID,'hello, you big lovely server',1,2,3,{'testPassString Done'.postln});
+~messageTest.testReturnBuffer(nil,a.nodeID,b,{|buffer| b.numFrames.postln});
+~messageTest.testReturnHetero(nil,a.nodeID,{|x|x.postln});
+
+a.free
+// OSCFunc.trace(true)
+// OSCFunc.trace(false)
\ No newline at end of file