diff --git a/src/projectM-engine/BuiltinFuncs.cpp b/src/projectM-engine/BuiltinFuncs.cpp
index 3e81e66d8..d2cec2c62 100644
--- a/src/projectM-engine/BuiltinFuncs.cpp
+++ b/src/projectM-engine/BuiltinFuncs.cpp
@@ -16,7 +16,7 @@
 /* Loads a builtin function */
 #include "BuiltinFuncs.hpp"
 
-SplayTree<Func>  * BuiltinFuncs::builtin_func_tree  = 0;
+std::map<std::string, Func*>  * BuiltinFuncs::builtin_func_tree  = 0;
 
 int BuiltinFuncs::load_builtin_func(char * name,  float (*func_ptr)(float*), int num_args) {
 
@@ -129,7 +129,7 @@ int BuiltinFuncs::init_builtin_func_db() {
   int retval;
 
   builtin_func_tree = 
-    SplayTree<Func>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string, (void(*)(void*))SplayKeyFunctions::free_string);
+    std::map<std::string, Func*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string, (void(*)(void*))SplayKeyFunctions::free_string);
 
   if (builtin_func_tree == NULL)
     return PROJECTM_OUTOFMEM_ERROR;
diff --git a/src/projectM-engine/BuiltinFuncs.hpp b/src/projectM-engine/BuiltinFuncs.hpp
index eb82e3fa7..fa369fa10 100644
--- a/src/projectM-engine/BuiltinFuncs.hpp
+++ b/src/projectM-engine/BuiltinFuncs.hpp
@@ -206,7 +206,7 @@ return (float)result;
 }
 };
 
-
+#include <map>
 class BuiltinFuncs {
 
 public:
@@ -220,7 +220,7 @@ public:
     static int remove_func( Func *func );
     static Func *find_func( char *name );
 private:
-     static SplayTree<Func>  * builtin_func_tree;
+     static std::map<std::string, Func*>  * builtin_func_tree;
 };
 
 #endif
diff --git a/src/projectM-engine/BuiltinParams.cpp b/src/projectM-engine/BuiltinParams.cpp
index 96abd48d1..84c878456 100644
--- a/src/projectM-engine/BuiltinParams.cpp
+++ b/src/projectM-engine/BuiltinParams.cpp
@@ -6,212 +6,251 @@
 
 BuiltinParams::BuiltinParams() {}
 
-BuiltinParams::BuiltinParams(const PresetInputs & presetInputs, PresetOutputs & presetOutputs) {
+BuiltinParams::BuiltinParams(const PresetInputs & presetInputs, PresetOutputs & presetOutputs)
+{
 
-    int ret;
-    if ((ret = init_builtin_param_db(presetInputs, presetOutputs)) != PROJECTM_SUCCESS) {
-        throw ret;
-    }
+  int ret;
+  if ((ret = init_builtin_param_db(presetInputs, presetOutputs)) != PROJECTM_SUCCESS)
+  {
+    throw ret;
+  }
 
 }
 
-BuiltinParams::~BuiltinParams() {
-   destroy_builtin_param_db();
+BuiltinParams::~BuiltinParams()
+{
+  destroy_builtin_param_db();
 }
 
 /* Loads a float parameter into the builtin database */
 int BuiltinParams::load_builtin_param_float(char * name, void * engine_val, void * matrix, short int flags,
-        float init_val, float upper_bound, float lower_bound, char * alt_name) {
+    float init_val, float upper_bound, float lower_bound, char * alt_name)
+{
 
-    Param * param = NULL;
-    CValue iv, ub, lb;
+  Param * param = NULL;
+  CValue iv, ub, lb;
 
-    iv.float_val = init_val;
-    ub.float_val = upper_bound;
-    lb.float_val = lower_bound;
+  iv.float_val = init_val;
+  ub.float_val = upper_bound;
+  lb.float_val = lower_bound;
 
-    /* Create new parameter of type float */
-    if (BUILTIN_PARAMS_DEBUG == 2) {
-        printf("load_builtin_param_float: (name \"%s\") (alt_name = \"%s\") ", name, alt_name);
-        fflush(stdout);
+  /* Create new parameter of type float */
+  if (BUILTIN_PARAMS_DEBUG == 2)
+  {
+    printf("load_builtin_param_float: (name \"%s\") (alt_name = \"%s\") ", name, alt_name);
+    fflush(stdout);
+  }
+
+  if ((param = new Param(name, P_TYPE_DOUBLE, flags, engine_val, matrix, iv, ub, lb)) == NULL)
+  {
+    return PROJECTM_OUTOFMEM_ERROR;
+  }
+
+  if (BUILTIN_PARAMS_DEBUG == 2)
+  {
+    printf("created...");
+    fflush(stdout);
+  }
+
+  /* Insert the paremeter into the database */
+
+  if (insert_builtin_param( param ) < 0)
+  {
+    delete param;
+    return PROJECTM_ERROR;
+  }
+
+  if (BUILTIN_PARAMS_DEBUG == 2)
+  {
+    printf("inserted...");
+    fflush(stdout);
+  }
+
+  /* If this parameter has an alternate name, insert it into the database as link */
+
+  if (alt_name != NULL)
+  {
+    insert_param_alt_name(param,alt_name);
+
+    if (BUILTIN_PARAMS_DEBUG == 2)
+    {
+      printf("alt_name inserted...");
+      fflush(stdout);
     }
 
-    if ((param = new Param(name, P_TYPE_DOUBLE, flags, engine_val, matrix, iv, ub, lb)) == NULL) {
-        return PROJECTM_OUTOFMEM_ERROR;
-    }
 
-    if (BUILTIN_PARAMS_DEBUG == 2) {
-        printf("created...");
-        fflush(stdout);
-    }
+  }
 
-    /* Insert the paremeter into the database */
+  if (BUILTIN_PARAMS_DEBUG == 2) printf("finished\n");
 
-    if (insert_builtin_param( param ) < 0) {
-        delete param;
-        return PROJECTM_ERROR;
-    }
-
-    if (BUILTIN_PARAMS_DEBUG == 2) {
-        printf("inserted...");
-        fflush(stdout);
-    }
-
-    /* If this parameter has an alternate name, insert it into the database as link */
-
-    if (alt_name != NULL) {
-        insert_param_alt_name(param,alt_name);
-
-        if (BUILTIN_PARAMS_DEBUG == 2) {
-            printf("alt_name inserted...");
-            fflush(stdout);
-        }
-
-
-    }
-
-    if (BUILTIN_PARAMS_DEBUG == 2) printf("finished\n");
-
-    /* Finished, return success */
-    return PROJECTM_SUCCESS;
+  /* Finished, return success */
+  return PROJECTM_SUCCESS;
 }
 
 
 
 /* Destroy the builtin parameter database.
    Generally, do this on projectm exit */
-int BuiltinParams::destroy_builtin_param_db() {
+int BuiltinParams::destroy_builtin_param_db()
+{
 
-    builtin_param_tree->traverse
-	<SplayTreeFunctors::Delete<Param> >();
-    delete builtin_param_tree;
-    builtin_param_tree = NULL;
-    return PROJECTM_SUCCESS;
+  builtin_param_tree->traverse
+  <SplayTreeFunctors::Delete<Param> >();
+  delete builtin_param_tree;
+  builtin_param_tree = NULL;
+  return PROJECTM_SUCCESS;
 }
 
 
 /* Insert a parameter into the database with an alternate name */
-int BuiltinParams::insert_param_alt_name(Param *param, char * alt_name) {
+int BuiltinParams::insert_param_alt_name(Param *param, char * alt_name)
+{
 
-    assert(alt_name);
+  assert(alt_name);
 
-    aliasMap.insert(std::make_pair(std::string(alt_name), std::string(param->name)));
+  aliasMap.insert(std::make_pair(std::string(alt_name), std::string(param->name)));
 
-    return PROJECTM_SUCCESS;
+  return PROJECTM_SUCCESS;
 }
 
-Param * BuiltinParams::find_builtin_param(char * name) {
+Param * BuiltinParams::find_builtin_param(const std::string & name)
+{
 
-    assert(name);
+  AliasMap::iterator pos = aliasMap.find(name);
+  Param * param = 0;
 
-    AliasMap::iterator pos = aliasMap.find(std::string(name));
+  if (pos == aliasMap.end())
+  {
+    std::map<std::string, Param*>::iterator builtinPos = builtin_param_tree->find(name);
 
-    if (pos == aliasMap.end())
-    	return builtin_param_tree->splay_find(name);
-    else
-	return builtin_param_tree->splay_find(pos->second.c_str());
+    if (builtinPos != builtin_param_tree->end())
+      param = builtinPos->second;
+  }
+  else
+  {
+
+    std::map<std::string, Param*>::iterator builtinPos = builtin_param_tree->find(pos->second);
+
+    if (builtinPos != builtin_param_tree->end())
+      param = builtinPos->second;
+  }
+  return param;
 }
 
 
 /* Loads a integer parameter into the builtin database */
 int BuiltinParams::load_builtin_param_int(char * name, void * engine_val, short int flags,
-        int init_val, int upper_bound, int lower_bound, char * alt_name) {
+    int init_val, int upper_bound, int lower_bound, char * alt_name)
+{
 
-    Param * param;
-    CValue iv, ub, lb;
+  Param * param;
+  CValue iv, ub, lb;
 
-    iv.int_val = init_val;
-    ub.int_val = upper_bound;
-    lb.int_val = lower_bound;
+  iv.int_val = init_val;
+  ub.int_val = upper_bound;
+  lb.int_val = lower_bound;
 
-    param = new Param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb);
+  param = new Param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb);
 
-    if (param == NULL) {
-        return PROJECTM_OUTOFMEM_ERROR;
-    }
+  if (param == NULL)
+  {
+    return PROJECTM_OUTOFMEM_ERROR;
+  }
 
-    if (insert_builtin_param( param ) < 0) {
-        delete param;
-        return PROJECTM_ERROR;
-    }
+  if (insert_builtin_param( param ) < 0)
+  {
+    delete param;
+    return PROJECTM_ERROR;
+  }
 
-    if (alt_name != NULL) {
-        insert_param_alt_name(param,alt_name);
-    }
+  if (alt_name != NULL)
+  {
+    insert_param_alt_name(param,alt_name);
+  }
 
-    return PROJECTM_SUCCESS;
+  return PROJECTM_SUCCESS;
 
 }
 
 /* Loads a boolean parameter */
 int BuiltinParams::load_builtin_param_bool(char * name, void * engine_val, short int flags,
-        int init_val, char * alt_name) {
+    int init_val, char * alt_name)
+{
 
-    Param * param;
-    CValue iv, ub, lb;
+  Param * param;
+  CValue iv, ub, lb;
 
-    iv.int_val = init_val;
-    ub.int_val = TRUE;
-    lb.int_val = FALSE;
+  iv.int_val = init_val;
+  ub.int_val = TRUE;
+  lb.int_val = FALSE;
 
-    param = new Param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb);
+  param = new Param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb);
 
-    if (param == NULL) {
-        return PROJECTM_OUTOFMEM_ERROR;
-    }
+  if (param == NULL)
+  {
+    return PROJECTM_OUTOFMEM_ERROR;
+  }
 
-    if (insert_builtin_param(param) < 0) {
-        delete param;
-        return PROJECTM_ERROR;
-    }
+  if (insert_builtin_param(param) < 0)
+  {
+    delete param;
+    return PROJECTM_ERROR;
+  }
 
-    if (alt_name != NULL) {
-        insert_param_alt_name(param,alt_name);
-    }
+  if (alt_name != NULL)
+  {
+    insert_param_alt_name(param,alt_name);
+  }
 
-    return PROJECTM_SUCCESS;
+  return PROJECTM_SUCCESS;
 
 }
 
 /* Inserts a parameter into the builtin database */
-int BuiltinParams::insert_builtin_param( Param *param ) {
+int BuiltinParams::insert_builtin_param( Param *param )
+{
 
-    return builtin_param_tree->splay_insert(param, param->name);
+  return builtin_param_tree->splay_insert(param, param->name);
 }
 
 
 
 /* Initialize the builtin parameter database.
    Should only be necessary once */
-int BuiltinParams::init_builtin_param_db(const PresetInputs & presetInputs, PresetOutputs & presetOutputs) {
+int BuiltinParams::init_builtin_param_db(const PresetInputs & presetInputs, PresetOutputs & presetOutputs)
+{
 
-    /* Create the builtin parameter splay tree (go Sleator...) */
-    if ((this->builtin_param_tree = SplayTree<Param>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL) {
-        if (BUILTIN_PARAMS_DEBUG) printf("init_builtin_param_db: failed to initialize database (FATAL)\n");
-        return PROJECTM_OUTOFMEM_ERROR;
-    }
+  /* Create the builtin parameter splay tree (go Sleator...) */
+  if ((this->builtin_param_tree = std::map<std::string,Param*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL)
+  {
+    if (BUILTIN_PARAMS_DEBUG) printf("init_builtin_param_db: failed to initialize database (FATAL)\n");
+    return PROJECTM_OUTOFMEM_ERROR;
+  }
 
-    if (BUILTIN_PARAMS_DEBUG) {
-        printf("init_builtin_param: loading database...");
-        fflush(stdout);
-    }
+  if (BUILTIN_PARAMS_DEBUG)
+  {
+    printf("init_builtin_param: loading database...");
+    fflush(stdout);
+  }
 
-    /* Loads all builtin parameters into the database */
-    if (load_all_builtin_param(presetInputs, presetOutputs) < 0) {
-        if (BUILTIN_PARAMS_DEBUG) printf("failed loading builtin parameters (FATAL)\n");
-        return PROJECTM_ERROR;
-    }
+  /* Loads all builtin parameters into the database */
+  if (load_all_builtin_param(presetInputs, presetOutputs) < 0)
+  {
+    if (BUILTIN_PARAMS_DEBUG) printf("failed loading builtin parameters (FATAL)\n");
+    return PROJECTM_ERROR;
+  }
 
-    if (BUILTIN_PARAMS_DEBUG) printf("success!\n");
+  if (BUILTIN_PARAMS_DEBUG) printf("success!\n");
 
-    /* Finished, no errors */
-    return PROJECTM_SUCCESS;
+  /* Finished, no errors */
+  return PROJECTM_SUCCESS;
 }
 
 
 
 /* Loads all builtin parameters, limits are also defined here */
-int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, PresetOutputs & presetOutputs) {
+int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, PresetOutputs & presetOutputs)
+{
 
   load_builtin_param_float("fRating", (void*)&presetOutputs.fRating, NULL, P_FLAG_NONE, 0.0 , 5.0, 0.0, NULL);
   load_builtin_param_float("fWaveScale", (void*)&presetOutputs.fWaveScale, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
@@ -219,18 +258,18 @@ int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, Pre
   load_builtin_param_float("echo_zoom", (void*)&presetOutputs.fVideoEchoZoom, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoZoom");
   load_builtin_param_float("echo_alpha", (void*)&presetOutputs.fVideoEchoAlpha, NULL, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fVideoEchoAlpha");
   load_builtin_param_float("wave_a", (void*)&presetOutputs.fWaveAlpha, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fWaveAlpha");
-  load_builtin_param_float("fWaveSmoothing", (void*)&presetOutputs.fWaveSmoothing, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);  
+  load_builtin_param_float("fWaveSmoothing", (void*)&presetOutputs.fWaveSmoothing, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
   load_builtin_param_float("fModWaveAlphaStart", (void*)&presetOutputs.fModWaveAlphaStart, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
   load_builtin_param_float("fModWaveAlphaEnd", (void*)&presetOutputs.fModWaveAlphaEnd, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
   load_builtin_param_float("fWarpAnimSpeed",  (void*)&presetOutputs.fWarpAnimSpeed, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
   //  load_builtin_param_float("warp", (void*)&presetOutputs.warp, warp_mesh, P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
-	
+
   load_builtin_param_float("fShader", (void*)&presetOutputs.fShader, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, NULL);
   load_builtin_param_float("decay", (void*)&presetOutputs.decay, NULL, P_FLAG_NONE, 0.0, 1.0, 0, "fDecay");
 
   load_builtin_param_int("echo_orient", (void*)&presetOutputs.nVideoEchoOrientation, P_FLAG_NONE, 0, 3, 0, "nVideoEchoOrientation");
   load_builtin_param_int("wave_mode", (void*)&presetOutputs.nWaveMode, P_FLAG_NONE, 0, 7, 0, "nWaveMode");
-  
+
   load_builtin_param_bool("wave_additive", (void*)&presetOutputs.bAdditiveWaves, P_FLAG_NONE, FALSE, "bAdditiveWaves");
   load_builtin_param_bool("bModWaveAlphaByVolume", (void*)&presetOutputs.bModWaveAlphaByVolume, P_FLAG_NONE, FALSE, NULL);
   load_builtin_param_bool("wave_brighten", (void*)&presetOutputs.bMaximizeWaveColor, P_FLAG_NONE, FALSE, "bMaximizeWaveColor");
@@ -248,7 +287,7 @@ int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, Pre
   load_builtin_param_float("zoom", (void*)&presetOutputs.zoom, presetOutputs.zoom_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, 0, NULL);
   load_builtin_param_float("rot", (void*)&presetOutputs.rot, presetOutputs.rot_mesh,  P_FLAG_PER_PIXEL |P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
   load_builtin_param_float("zoomexp", (void*)&presetOutputs.zoomexp, presetOutputs.zoomexp_mesh,  P_FLAG_PER_PIXEL |P_FLAG_NONE, 0.0, MAX_DOUBLE_SIZE, 0, "fZoomExponent");
- 
+
   load_builtin_param_float("cx", (void*)&presetOutputs.cx, presetOutputs.cx_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
   load_builtin_param_float("cy", (void*)&presetOutputs.cy, presetOutputs.cy_mesh, P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, 1.0, 0, NULL);
   load_builtin_param_float("dx", (void*)&presetOutputs.dx, presetOutputs.dx_mesh,  P_FLAG_PER_PIXEL | P_FLAG_DONT_FREE_MATRIX, 0.0, MAX_DOUBLE_SIZE, MIN_DOUBLE_SIZE, NULL);
@@ -262,7 +301,7 @@ int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, Pre
   load_builtin_param_float("wave_x", (void*)&presetOutputs.wave_x, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
   load_builtin_param_float("wave_y", (void*)&presetOutputs.wave_y, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
   load_builtin_param_float("wave_mystery", (void*)&presetOutputs.wave_mystery, NULL, P_FLAG_NONE, 0.0, 1.0, -1.0, "fWaveParam");
-  
+
   load_builtin_param_float("ob_size", (void*)&presetOutputs.ob_size, NULL, P_FLAG_NONE, 0.0, 0.5, 0, NULL);
   load_builtin_param_float("ob_r", (void*)&presetOutputs.ob_r, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
   load_builtin_param_float("ob_g", (void*)&presetOutputs.ob_g, NULL, P_FLAG_NONE, 0.0, 1.0, 0.0, NULL);
@@ -295,14 +334,14 @@ int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, Pre
   load_builtin_param_float("progress", (void*)&presetInputs.progress,  NULL,P_FLAG_READONLY, 0.0, 1, 0, NULL);
   load_builtin_param_int("fps", (void*)&presetInputs.fps, P_FLAG_READONLY, 15, MAX_INT_SIZE, 0, NULL);
 
-  load_builtin_param_float("x", (void*)&presetInputs.x_per_pixel, presetInputs.x_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
-			    0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
-  load_builtin_param_float("y", (void*)&presetInputs.y_per_pixel, presetInputs.y_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX |P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
-			    0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
-  load_builtin_param_float("ang", (void*)&presetInputs.ang_per_pixel, presetInputs.theta_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX, 
-			    0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_float("x", (void*)&presetInputs.x_per_pixel, presetInputs.x_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_float("y", (void*)&presetInputs.y_per_pixel, presetInputs.y_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX |P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+  load_builtin_param_float("ang", (void*)&presetInputs.ang_per_pixel, presetInputs.theta_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
   load_builtin_param_float("rad", (void*)&presetInputs.rad_per_pixel, presetInputs.rad_mesh,  P_FLAG_PER_PIXEL |P_FLAG_ALWAYS_MATRIX | P_FLAG_READONLY | P_FLAG_DONT_FREE_MATRIX,
-			    0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
+                           0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
 
   load_builtin_param_float("q1", (void*)&presetOutputs.q1,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
   load_builtin_param_float("q2", (void*)&presetOutputs.q2,  NULL, P_FLAG_PER_PIXEL |P_FLAG_QVAR, 0, MAX_DOUBLE_SIZE, -MAX_DOUBLE_SIZE, NULL);
@@ -319,4 +358,4 @@ int BuiltinParams::load_all_builtin_param(const PresetInputs & presetInputs, Pre
 
   return PROJECTM_SUCCESS;
 
-}
+}
\ No newline at end of file
diff --git a/src/projectM-engine/BuiltinParams.hpp b/src/projectM-engine/BuiltinParams.hpp
index 102699d89..3be853972 100644
--- a/src/projectM-engine/BuiltinParams.hpp
+++ b/src/projectM-engine/BuiltinParams.hpp
@@ -31,6 +31,7 @@
 #include "PresetFrameIO.hpp"
 #include "Param.hpp"
 #include <map>
+#include "Algorithms.hpp"
 
 class BuiltinParams {
 
@@ -52,7 +53,7 @@ public:
     int destroy_builtin_param_db();
 
     int insert_param_alt_name( Param *param, char *alt_name );
-    Param *find_builtin_param( char *name );
+    Param *find_builtin_param( const std::string & name );
     int load_builtin_param_float( char *name, void *engine_val, void *matrix,
                                   short int flags,
                                   float init_val, float upper_bound,
@@ -66,7 +67,7 @@ public:
 
     template <class Fun>
     void traverse(Fun & fun) {
-	builtin_param_tree->traverse(fun);
+	Algorithms::traverse(builtin_param_tree, fun);
     }
 
 
@@ -79,6 +80,6 @@ private:
     AliasMap aliasMap;
 
     // Internal datastructure to store the parameters
-    SplayTree<Param> * builtin_param_tree;
+    std::map<std::string,Param*> * builtin_param_tree;
 };
 #endif
diff --git a/src/projectM-engine/CustomShape.cpp b/src/projectM-engine/CustomShape.cpp
index ab27088fe..771884ae7 100755
--- a/src/projectM-engine/CustomShape.cpp
+++ b/src/projectM-engine/CustomShape.cpp
@@ -33,7 +33,7 @@
 #include "Param.hpp"
 #include "PerFrameEqn.hpp"
 #include "Preset.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include "ParamUtils.hpp"
 #include "InitCondUtils.hpp"
 #include "wipemalloc.h"
@@ -55,16 +55,16 @@ CustomShape::CustomShape( int id ) {
 
   /* Initialize tree data structures */
   this->param_tree = 
-       SplayTree<Param>::create_splaytree( (int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*)) SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string);
+       std::map<std::string,Param*>::create_splaytree( (int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*)) SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string);
   
   this->per_frame_eqn_tree = 
-       SplayTree<PerFrameEqn>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int,(void (*)(void*))SplayKeyFunctions::free_int);
+       std::map<int, PerFrameEqn*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int,(void (*)(void*))SplayKeyFunctions::free_int);
 
   this->init_cond_tree = 
-       SplayTree<InitCond>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*)) SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string);
+       std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*)) SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string);
   
   this->per_frame_init_eqn_tree = 
-       SplayTree<InitCond>::create_splaytree((int (*)(const void*, const void*)) SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string);
+       std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*, const void*)) SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string);
 
   /* Start: Load custom shape parameters */
   param = Param::new_param_float("r", P_FLAG_NONE, &this->r, NULL, 1.0, 0.0, 0.5);
diff --git a/src/projectM-engine/CustomShape.hpp b/src/projectM-engine/CustomShape.hpp
index d0e37b3d2..36bc955d2 100755
--- a/src/projectM-engine/CustomShape.hpp
+++ b/src/projectM-engine/CustomShape.hpp
@@ -30,7 +30,7 @@
 #define _CUSTOM_SHAPE_H
 
 #define CUSTOM_SHAPE_DEBUG 0
-#include "SplayTree.hpp"
+#include <map>
 #include "Param.hpp"
 #include "PerFrameEqn.hpp"
 #include "InitCond.hpp"
@@ -45,7 +45,7 @@ public:
     int per_frame_count;
 
     /* Parameter tree associated with this custom shape */
-    SplayTree<Param> * param_tree;
+    std::map<std::string,Param*> * param_tree;
 
     /* Engine variables */
     int sides;
@@ -88,19 +88,20 @@ public:
     float t8;
     
     /* Data structure to hold per frame  / per frame init equations */
-    SplayTree<InitCond> * init_cond_tree;
-    SplayTree<PerFrameEqn> * per_frame_eqn_tree;
-    SplayTree<InitCond> * per_frame_init_eqn_tree;
+    std::map<std::string,InitCond*> * init_cond_tree;
+    std::map<int, PerFrameEqn*> * per_frame_eqn_tree;
+    std::map<std::string,InitCond*> * per_frame_init_eqn_tree;
     
     /* Denotes the index of the last character for each stdring buffer */
     int per_frame_eqn_string_index;
     int per_frame_init_eqn_string_index;
     
+
     /* String buffers for per frame / per frame init equations */
     char per_frame_eqn_string_buffer[STRING_BUFFER_SIZE];
     char per_frame_init_eqn_string_buffer[STRING_BUFFER_SIZE];
+
     /* Per point equation array */
-      
     CustomShape( int id );
     ~CustomShape();
 
diff --git a/src/projectM-engine/CustomWave.cpp b/src/projectM-engine/CustomWave.cpp
index cb0e98023..f97fd9b13 100755
--- a/src/projectM-engine/CustomWave.cpp
+++ b/src/projectM-engine/CustomWave.cpp
@@ -36,7 +36,7 @@
 #include "PerFrameEqn.hpp"
 #include "PerPointEqn.hpp"
 #include "Preset.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include "ParamUtils.hpp"
 #include "InitCondUtils.hpp"
 #include "wipemalloc.h"
@@ -80,32 +80,32 @@ CustomWave::CustomWave(int id):id(id)
   /* Initialize tree data structures */
   
   if ((this->param_tree = 
-       SplayTree<Param>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL) {
+       std::map<std::string,Param*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL) {
     delete(this);
   abort();
   }
 
   if ((this->per_point_eqn_tree = 
-       SplayTree<PerPointEqn>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int)) == NULL) {
+       std::map<int, PerPointEqn*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int)) == NULL) {
     delete(this);
     abort();
   }
 
   if ((this->per_frame_eqn_tree = 
-       SplayTree<PerFrameEqn>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int,(void (*)(void*)) SplayKeyFunctions::free_int)) == NULL) {
+       std::map<int, PerFrameEqn*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int,(void (*)(void*)) SplayKeyFunctions::free_int)) == NULL) {
     delete(this);
     abort();
   }
 
   if ((this->init_cond_tree = 
-       SplayTree<InitCond>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string)) == NULL) {
+       std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string,(void (*)(void*)) SplayKeyFunctions::free_string)) == NULL) {
     delete(this);
     /// @bug make exception
     abort();
   }
   
   if ((this->per_frame_init_eqn_tree = 
-       SplayTree<InitCond>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL) {
+       std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*, const void*))SplayKeyFunctions::compare_string, (void*(*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string)) == NULL) {
     delete(this);
     /// @bug make exception
     abort();
diff --git a/src/projectM-engine/CustomWave.hpp b/src/projectM-engine/CustomWave.hpp
index 999451666..868cde50f 100755
--- a/src/projectM-engine/CustomWave.hpp
+++ b/src/projectM-engine/CustomWave.hpp
@@ -48,7 +48,7 @@ class Preset;
 #include "Param.hpp"
 #include "PerFrameEqn.hpp"
 
-#include "SplayTree.hpp"
+#include <map>
 
 class CustomWave {
 public:
@@ -67,7 +67,7 @@ public:
     int per_frame_count;
 
     /* Parameter tree associated with this custom wave */
-    SplayTree<Param> * param_tree;
+    std::map<std::string,Param*> * param_tree;
 
     /* Engine variables */
     float x; /* x position for per point equations */
@@ -110,10 +110,10 @@ public:
     float v1,v2;
 
     /* Data structures to hold per frame and per point equations */
-    SplayTree<InitCond> * init_cond_tree;
-    SplayTree<PerFrameEqn> * per_frame_eqn_tree;
-    SplayTree <PerPointEqn> * per_point_eqn_tree;
-    SplayTree<InitCond> *  per_frame_init_eqn_tree;
+    std::map<std::string,InitCond*> * init_cond_tree;
+    std::map<int, PerFrameEqn*> * per_frame_eqn_tree;
+    std::map<int, PerPointEqn*> * per_point_eqn_tree;
+    std::map<std::string,InitCond*> *  per_frame_init_eqn_tree;
 
     /* Denotes the index of the last character for each string buffer */
     int per_point_eqn_string_index;
diff --git a/src/projectM-engine/Func.cpp b/src/projectM-engine/Func.cpp
index 3568f0ea8..febc81d76 100755
--- a/src/projectM-engine/Func.cpp
+++ b/src/projectM-engine/Func.cpp
@@ -28,7 +28,7 @@
 #include "fatal.h"
 
 #include "Func.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "wipemalloc.h"
 
diff --git a/src/projectM-engine/Func.hpp b/src/projectM-engine/Func.hpp
index 6aacd763c..2d07e7215 100755
--- a/src/projectM-engine/Func.hpp
+++ b/src/projectM-engine/Func.hpp
@@ -32,7 +32,7 @@
 #include "Common.hpp"
 
 class Func;
-#include "SplayTree.hpp"
+//#include <map>
 
 /* Function Type */
 class Func {
diff --git a/src/projectM-engine/InitCond.cpp b/src/projectM-engine/InitCond.cpp
index 51ffd67ab..6b0846b22 100755
--- a/src/projectM-engine/InitCond.cpp
+++ b/src/projectM-engine/InitCond.cpp
@@ -30,7 +30,7 @@
 #include "Expr.hpp"
 #include "InitCond.hpp"
 #include "Param.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "wipemalloc.h"
 
@@ -45,7 +45,7 @@ InitCond::InitCond( Param * param, CValue init_val ) {
 
   if ( INIT_COND_DEBUG ) {
     DWRITE( "InitCond::InitCond: %s -> %X -> %X\n", 
-             this->param->name, this->param, this->param->engine_val );
+             this->param->name.c_str(), this->param, this->param->engine_val );
   }
 }
 
@@ -63,7 +63,7 @@ void InitCond::eval_init_cond() {
   param->matrix_flag = 0;
   if (param->type == P_TYPE_BOOL) {
 	 if (INIT_COND_DEBUG) {
-        DWRITE( "init_cond: %s = %d (TYPE BOOL)\n", param->name, init_val.bool_val); 
+        DWRITE( "init_cond: %s = %d (TYPE BOOL)\n", param->name.c_str(), init_val.bool_val); 
       }
 	 *((int*)param->engine_val) = init_val.bool_val;
      return;
@@ -72,10 +72,10 @@ void InitCond::eval_init_cond() {
   /* Parameter is an integer type, just like C */
   
   if ( param->type == P_TYPE_INT) {
-    if (strcmp( param->name, "wave_mode" ) == 0 ) {
+    if ((param->name == "wave_mode") == 0 ) {
       }
 	 if (INIT_COND_DEBUG) {
-        DWRITE( "init_cond: %s = %d (TYPE INT)\n", param->name, init_val.int_val);
+        DWRITE( "init_cond: %s = %d (TYPE INT)\n", param->name.c_str(), init_val.int_val);
      }
 	 *((int*)param->engine_val) = init_val.int_val;
      return;
@@ -85,7 +85,7 @@ void InitCond::eval_init_cond() {
 
   if (param->type == P_TYPE_DOUBLE) {
 	if (INIT_COND_DEBUG) {
-	    DWRITE( "init_cond: %s = %f (TYPE DOUBLE) -> %f -> %X -> %X\n", param->name, 
+	    DWRITE( "init_cond: %s = %f (TYPE DOUBLE) -> %f -> %X -> %X\n", param->name.c_str(), 
 	            init_val.float_val, *((float *)param->engine_val),
 	            param, param->engine_val );
 	  }
@@ -107,13 +107,13 @@ void InitCond::init_cond_to_string() {
 	switch (param->type) {
 		
 		case P_TYPE_BOOL:
-			sprintf(string, "%s=%d\n", param->name, init_val.bool_val);
+			sprintf(string, "%s=%d\n", param->name.c_str(), init_val.bool_val);
 			break; 
 		case P_TYPE_INT:
-			sprintf(string, "%s=%d\n", param->name, init_val.int_val);
+			sprintf(string, "%s=%d\n", param->name.c_str(), init_val.int_val);
 			break;
 		case P_TYPE_DOUBLE:
-			sprintf(string, "%s=%f\n", param->name, init_val.float_val);
+			sprintf(string, "%s=%f\n", param->name.c_str(), init_val.float_val);
 			break;
 		default:
 			return;
diff --git a/src/projectM-engine/InitCond.hpp b/src/projectM-engine/InitCond.hpp
index 80688b66c..2fcfb5f94 100755
--- a/src/projectM-engine/InitCond.hpp
+++ b/src/projectM-engine/InitCond.hpp
@@ -37,7 +37,7 @@
 
 class InitCond;
 class Param;
-#include "SplayTree.hpp"
+#include <map>
 
 class InitCond {
 public:
@@ -60,10 +60,6 @@ inline void eval_init_cond_helper( void *init_cond ) {
     ((InitCond *)init_cond)->eval_init_cond();
   }
 
-inline void free_init_cond_helper( void *init_cond ) {
-    delete ((InitCond *)init_cond);
-  }
-
 inline void write_init_helper( void *init_cond ) {
     ((InitCond *)init_cond)->write_init();
   }
diff --git a/src/projectM-engine/InitCondUtils.hpp b/src/projectM-engine/InitCondUtils.hpp
index 8c832922b..a5d9f1b30 100644
--- a/src/projectM-engine/InitCondUtils.hpp
+++ b/src/projectM-engine/InitCondUtils.hpp
@@ -1,20 +1,20 @@
 #ifndef _INIT_COND_UTILS_HPP
 #define _INIT_COND_UTILS_HPP
-#include "SplayTree.hpp"
+#include <map>
 #include "InitCond.hpp"
 
 namespace InitCondUtils {
 class LoadUnspecInitCond {
 	public:
 	
-	LoadUnspecInitCond(SplayTree<InitCond> & initCondTree, SplayTree<InitCond> & perFrameInitEqnTree):
+	LoadUnspecInitCond(std::map<std::string,InitCond*> & initCondTree, std::map<std::string,InitCond*> & perFrameInitEqnTree):
 		 m_initCondTree(initCondTree), m_perFrameInitEqnTree(perFrameInitEqnTree) {}
 
 	void operator()(Param * param);
 
 	private:
-		SplayTree<InitCond> & m_initCondTree;
-		SplayTree<InitCond> & m_perFrameInitEqnTree;
+		std::map<std::string,InitCond*> & m_initCondTree;
+		std::map<std::string,InitCond*> & m_perFrameInitEqnTree;
 };
 
 
diff --git a/src/projectM-engine/Param.cpp b/src/projectM-engine/Param.cpp
index b2bf4e4b7..ce059e170 100755
--- a/src/projectM-engine/Param.cpp
+++ b/src/projectM-engine/Param.cpp
@@ -36,13 +36,14 @@
 #include "InitCond.hpp"
 #include "Param.hpp"
 #include "Preset.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "wipemalloc.h"
 
 /** Constructor */
-Param::Param( char * name, short int type, short int flags, void * engine_val, void * matrix,
+Param::Param( std::string name, short int type, short int flags, void * engine_val, void * matrix,
               CValue default_init_val, CValue upper_bound, CValue lower_bound):
+	m_name(name),
         type(type),
         flags (flags),
         matrix_flag (0),
@@ -53,8 +54,6 @@ Param::Param( char * name, short int type, short int flags, void * engine_val, v
         lower_bound (lower_bound)
     {
 
-    strncpy(this->name, name, MAX_TOKEN_SIZE-1);
-
     /** @@FIX THIS */
     //this->gx = projectM::currentEngine->gx;
     //this->gy = projectM::currentEngine->gy;
@@ -123,7 +122,7 @@ int Param::compare_param( char * name, char * name2 ) {
 }
 
 /* Returns nonzero if the string is valid parameter name */
-int Param::is_valid_param_string( char * string ) {
+int Param::is_valid_param_string( const char * string ) {
 
     if (string == NULL)
         return FALSE;
diff --git a/src/projectM-engine/Param.hpp b/src/projectM-engine/Param.hpp
index b831c873b..d8f2dfea9 100755
--- a/src/projectM-engine/Param.hpp
+++ b/src/projectM-engine/Param.hpp
@@ -51,16 +51,16 @@
 
 #include "Expr.hpp"
 #include "Common.hpp"
-
+#include <string>
 class InitCond;
 class Param;
 class Preset;
-#include "SplayTree.hpp"
+//#include <map>
 
 /* Parameter Type */
 class Param {
 public:
-    char name[MAX_TOKEN_SIZE]; /* name of the parameter, not necessary but useful neverthless */
+    std::string name; /* name of the parameter, not necessary but useful neverthless */
     short int type; /* parameter number type (int, bool, or float) */	
     short int flags; /* read, write, user defined, etc */	
     short int matrix_flag; /* for optimization purposes */
@@ -80,7 +80,7 @@ public:
     ~Param();
 
     /** Create a user defined parameter **/ 
-    Param( char *name );
+    Param( std::string name );
     static int init_user_param_db();
     static int destroy_user_param_db();
 
@@ -91,7 +91,7 @@ public:
 
     
     int compare_param( char *name, char *name2 );
-    static int is_valid_param_string( char *string );
+    static int is_valid_param_string( const char *string );
     void set_param( float val );
 
     static Param *new_param_float( char *name, short int flags, void *engine_val,
diff --git a/src/projectM-engine/ParamUtils.hpp b/src/projectM-engine/ParamUtils.hpp
index 08d922593..391f54138 100644
--- a/src/projectM-engine/ParamUtils.hpp
+++ b/src/projectM-engine/ParamUtils.hpp
@@ -6,124 +6,133 @@
 #define _PARAM_UTILS_HPP
 
 #include "Param.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include <cassert>
 
 
 class BuiltinParams;
 
-class ParamUtils {
+class ParamUtils
+{
 public:
-    static int insert(Param * param, SplayTree<Param> * paramTree) {
+  static void insert(Param * param, std::map<std::string,Param*> * paramTree)
+  {
 
-	assert(param);
-	assert(paramTree);
+    assert(param);
+    assert(paramTree);
 
 
-	return paramTree->splay_insert(param, param->name);
+    paramTree->insert(std::make_pair(param->name,param))
+    ;
+
+  }
+
+  static const int AUTO_CREATE = 1;
+  static const int NO_CREATE = 0;
+
+  template <int FLAGS>
+  static Param * find(std::string name, std::map<std::string,Param*> * paramTree)
+  {
+
+    Param * param = NULL;
+
+
+    /* First look in the builtin database */
+    std::map<std::string,Param*>::iterator pos = paramTree->find(name);
+		
+
+    if ((FLAGS == AUTO_CREATE) && ((pos == paramTree->end())))
+    {
+	param = pos->second;
+      /* Check if string is valid */
+      if (!Param::is_valid_param_string(name.c_str()))
+        return NULL;
+
+      /* Now, create the user defined parameter given the passed name */
+      if ((param = new Param(name)) == NULL)
+        return NULL;
+
+      /* Finally, insert the new parameter into this preset's proper splaytree */
+      std::pair<std::map<std::string,Param*>::iterator, bool>  insertRetPair = 
+		paramTree->insert(std::make_pair(param->name, param));
+
+	if (insertRetPair.second)
+		param = insertRetPair.first->second;
+	
+    } else 
+	param = pos->second;
 	
-}
 
-    static const int AUTO_CREATE = 1;
-    static const int NO_CREATE = 0;
-
-    template <int FLAGS>
-    static Param * find(char * name, SplayTree<Param> * paramTree) {
-
-        assert(name);
-
-        Param * param = NULL;
+    /* Return the found (or created) parameter. Note that this could be null */
+    return param;
 
 
-        /* First look in the builtin database */
-        param = paramTree->splay_find(name);
+  }
 
+  /// Checks attempt
+  static Param * find(const std::string & name, BuiltinParams * builtinParams, std::map<std::string,Param*> * insertionTree)
+  {
 
-        if (((FLAGS == AUTO_CREATE) && ((param = paramTree->splay_find(name)) == NULL))) {
+    Param * param;
 
-            /* Check if string is valid */
-            if (!param->is_valid_param_string(name))
-                return NULL;
+    // Check first db
+    if ((param = builtinParams->find_builtin_param(name)) != 0)
+      return param;
 
-            /* Now, create the user defined parameter given the passed name */
-            if ((param = new Param(name)) == NULL)
-                return NULL;
+    // Check second db, create if necessary
+    return find<AUTO_CREATE>(name, insertionTree);
 
-            /* Finally, insert the new parameter into this preset's proper splaytree */
-            if (paramTree->splay_insert(param, param->name) < 0) {
-                delete param;
-                return NULL;
-            }
+  }
 
-        }
-
-        /* Return the found (or created) parameter. Note that this could be null */
-        return param;
-
-
-    }
-
-/// Checks attempt
-static Param * find(char * name, BuiltinParams * builtinParams , SplayTree<Param> * insertionTree) {
-
-Param * param;
-
-// Check first db
-if ((param = builtinParams->find_builtin_param(name)) != 0)
-	return param;
-
-// Check second db, create if necessary
-return find<AUTO_CREATE>(name, insertionTree);
-
-}
-
-class LoadInitCondFunctor {
-public:
+  class LoadInitCondFunctor
+  {
+  public:
     LoadInitCondFunctor(Preset * preset) :m_preset(preset) {}
 
-    void operator() (Param * param) {
+    void operator() (Param * param)
+    {
 
-        InitCond * init_cond;
-        CValue init_val;
+      InitCond * init_cond;
+      CValue init_val;
 
-        /* Don't count read only parameters as initial conditions */
-        if (param->flags & P_FLAG_READONLY)
-            return;
+      /* Don't count read only parameters as initial conditions */
+      if (param->flags & P_FLAG_READONLY)
+        return;
 
-        /* If initial condition was not defined by the preset file, force a default one
-           with the following code */
-        if ((init_cond = (InitCond*)(m_preset->init_cond_tree->splay_find(param->name))) == NULL) {
+      /* If initial condition was not defined by the preset file, force a default one
+         with the following code */
+      std::map<std::string,InitCond*>::iterator pos;
+      if ((pos = (m_preset->init_cond_tree->find(param->name))) == m_preset->init_cond_tree->end())
+      {
 
-            /* Make sure initial condition does not exist in the set of per frame initial equations */
-            if ((init_cond = (InitCond*)(m_preset->per_frame_init_eqn_tree->splay_find(param->name))) != NULL)
-                return;
+        std::map<std::string,InitCond*>::iterator per_frame_init_pos;
+        /* Make sure initial condition does not exist in the set of per frame initial equations */
+        if ((per_frame_init_pos = (m_preset->per_frame_init_eqn_tree->find(param->name))) != m_preset->per_frame_init_eqn_tree->end())
+          return;
 
-            if (param->type == P_TYPE_BOOL)
-                init_val.bool_val = 0;
+        if (param->type == P_TYPE_BOOL)
+          init_val.bool_val = 0;
 
-            else if (param->type == P_TYPE_INT)
-                init_val.int_val = *(int*)param->engine_val;
+        else if (param->type == P_TYPE_INT)
+          init_val.int_val = *(int*)param->engine_val;
 
-            else if (param->type == P_TYPE_DOUBLE)
-                init_val.float_val = *(float*)param->engine_val;
+        else if (param->type == P_TYPE_DOUBLE)
+          init_val.float_val = *(float*)param->engine_val;
 
-            /* Create new initial condition */
-            if ((init_cond = new InitCond(param, init_val)) == NULL)
-                return;
+        /* Create new initial condition */
+        if ((init_cond = new InitCond(param, init_val)) == NULL)
+          return;
 
-            /* Insert the initial condition into this presets tree */
-            if (m_preset->init_cond_tree->splay_insert(init_cond, init_cond->param->name) < 0) {
-                delete init_cond;
-                return;
-            }
-
-        }
+        /* Insert the initial condition into this presets tree */
+        /// @bug not error checking
+        m_preset->init_cond_tree->insert(std::make_pair(init_cond->param->name,init_cond));
+      }
 
     }
 
-private :
+  private :
     Preset * m_preset;
-};
+  };
 
 };
 
diff --git a/src/projectM-engine/Parser.cpp b/src/projectM-engine/Parser.cpp
index 92f6c3a58..f24b85f21 100755
--- a/src/projectM-engine/Parser.cpp
+++ b/src/projectM-engine/Parser.cpp
@@ -39,7 +39,7 @@
 #include "Parser.hpp"
 #include "PerFrameEqn.hpp"
 #include "PerPixelEqn.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include "ParamUtils.hpp"
 
 #include "wipemalloc.h"
@@ -335,13 +335,8 @@ int Parser::parse_line(FILE * fs, Preset * preset) {
       }	
       
       /* Insert the equation in the per frame equation tree */
-      if (preset->per_frame_init_eqn_tree->splay_insert(init_cond, init_cond->param->name) < 0) {
-	//if (PARSE_DEBUG) printf("parse_line: failed to add a perframe equation (ERROR)\n");
-	delete init_cond; /* will free the gen expr too */		
-	return PROJECTM_PARSE_ERROR;
-      }
-      
-     
+      preset->per_frame_init_eqn_tree->insert(std::make_pair(init_cond->param->name, init_cond));
+	
       if (update_string_buffer(preset->per_frame_init_eqn_string_buffer, 
 			       &preset->per_frame_init_eqn_string_index) < 0)
 	{	return PROJECTM_FAILURE;}
@@ -365,11 +360,7 @@ int Parser::parse_line(FILE * fs, Preset * preset) {
       }	
       
       /* Insert the equation in the per frame equation tree */
-      if (preset->per_frame_eqn_tree->splay_insert(per_frame_eqn, &per_frame_eqn_count) < 0) {
-	if (PARSE_DEBUG) printf("parse_line: failed to add a perframe equation (ERROR)\n");
-	delete per_frame_eqn; /* will free the gen expr too */		
-	return PROJECTM_PARSE_ERROR;
-      }
+      preset->per_frame_eqn_tree->insert(std::make_pair(per_frame_eqn_count, per_frame_eqn));
     
       if (update_string_buffer(preset->per_frame_eqn_string_buffer, 
 			       &preset->per_frame_eqn_string_index) < 0)
@@ -465,12 +456,8 @@ int Parser::parse_line(FILE * fs, Preset * preset) {
 	return PROJECTM_PARSE_ERROR;
 
       /* Insert the equation in the per frame equation tree */
-      if (preset->per_frame_eqn_tree->splay_insert(per_frame_eqn, &per_frame_eqn_count) < 0) {
-	if (PARSE_DEBUG) printf("parse_line: failed to add a perframe equation (ERROR)\n");
-	delete per_frame_eqn;       /* will free the gen expr too */		
-	return PROJECTM_PARSE_ERROR;
-      }
-
+      preset->per_frame_eqn_tree->insert(std::make_pair(per_frame_eqn_count, per_frame_eqn));
+	
       if (update_string_buffer(preset->per_frame_eqn_string_buffer, 
 			       &preset->per_frame_eqn_string_index) < 0)
 	return PROJECTM_FAILURE;
@@ -485,11 +472,8 @@ int Parser::parse_line(FILE * fs, Preset * preset) {
     ++per_frame_init_eqn_count;
 
       /* Insert the equation in the per frame equation tree */
-      if (preset->per_frame_init_eqn_tree->splay_insert(init_cond, &per_frame_init_eqn_count) < 0) {
-	if (PARSE_DEBUG) printf("parse_line: failed to add a per frame init equation (ERROR)\n");
-	delete init_cond; /* will free the gen expr too */		
-	return PROJECTM_PARSE_ERROR;
-      }
+      preset->per_frame_init_eqn_tree->insert(std::make_pair(init_cond->param->name, init_cond));
+	
 
       if (update_string_buffer(preset->per_frame_init_eqn_string_buffer, 
 			       &preset->per_frame_init_eqn_string_index) < 0)
@@ -558,12 +542,7 @@ int Parser::parse_line(FILE * fs, Preset * preset) {
     }
 
     /* Add equation to initial condition tree */
-    if (preset->init_cond_tree->splay_insert(init_cond, init_cond->param->name) < 0) {
-      if (PARSE_DEBUG) printf("parse_line: failed to add initial condition \"%s\" to equation tree (LINE %d)\n", 
-      		      init_cond->param->name, line_count);
-      delete init_cond;
-      return PROJECTM_FAILURE;
-    }
+    preset->init_cond_tree->insert(std::make_pair(init_cond->param->name, init_cond));
 
     /* Finished with initial condition line */
     //    if (PARSE_DEBUG) printf("parse_line: initial condition parsed successfully\n");
@@ -738,7 +717,7 @@ GenExpr * Parser::parse_gen_expr ( FILE * fs, TreeExpr * tree_expr, Preset * pre
       }
       
       if (PARSE_DEBUG) {
-	    DWRITE( "parse_gen_expr: custom shape parameter (name = %s)... \n", param->name);
+	    DWRITE( "parse_gen_expr: custom shape parameter (name = %s)... \n", param->name.c_str());
 	    
       }  
       
@@ -765,7 +744,7 @@ GenExpr * Parser::parse_gen_expr ( FILE * fs, TreeExpr * tree_expr, Preset * pre
       }
 
       if (PARSE_DEBUG) {
-	    DWRITE("parse_gen_expr: custom wave parameter (name = %s)... \n", param->name);
+	    DWRITE("parse_gen_expr: custom wave parameter (name = %s)... \n", param->name.c_str());
 
       }
 	
@@ -786,7 +765,7 @@ GenExpr * Parser::parse_gen_expr ( FILE * fs, TreeExpr * tree_expr, Preset * pre
     if ((param = ParamUtils::find(string, &preset->builtinParams, preset->user_param_tree)) != NULL) {
 
       if (PARSE_DEBUG) {
-	    DWRITE("parse_gen_expr: parameter (name = %s)...\n", param->name);
+	    DWRITE("parse_gen_expr: parameter (name = %s)...\n", param->name.c_str());
 	    
       }  
     
@@ -1310,7 +1289,7 @@ InitCond * Parser::parse_init_cond(FILE * fs, char * name, Preset * preset) {
 }
 
 /* Parses a per frame init equation, not sure if this works right now */
-InitCond * Parser::parse_per_frame_init_eqn(FILE * fs, Preset * preset, SplayTree<Param> * database) {
+InitCond * Parser::parse_per_frame_init_eqn(FILE * fs, Preset * preset, std::map<std::string,Param*> * database) {
 
   char name[MAX_TOKEN_SIZE];
   Param * param = NULL;
@@ -1340,7 +1319,7 @@ InitCond * Parser::parse_per_frame_init_eqn(FILE * fs, Preset * preset, SplayTre
     return NULL;
   }
   
-  if (PARSE_DEBUG) printf("parse_per_frame_init_eqn: parameter = \"%s\" (LINE %d)\n", param->name, line_count);
+  if (PARSE_DEBUG) printf("parse_per_frame_init_eqn: parameter = \"%s\" (LINE %d)\n", param->name.c_str(), line_count);
   
   if (param->flags & P_FLAG_READONLY) {
     //if (PARSE_DEBUG) printf("pars_per_frame_init_eqn: builtin parameter \"%s\" marked as read only!\n", param->name);
@@ -1458,11 +1437,8 @@ int Parser::parse_wavecode(char * token, FILE * fs, Preset * preset) {
       return PROJECTM_FAILURE;
   }
   
-  if (custom_wave->init_cond_tree->splay_insert(init_cond, param->name) < 0) {
-    delete init_cond;
-    return PROJECTM_PARSE_ERROR;
-  }
-
+  custom_wave->init_cond_tree->insert(std::make_pair(param->name, init_cond));
+  
   line_mode = CUSTOM_WAVE_WAVECODE_LINE_MODE;
 
   //if (PARSE_DEBUG) printf("parse_wavecode: [success]\n");
@@ -1542,11 +1518,7 @@ int Parser::parse_shapecode(char * token, FILE * fs, Preset * preset) {
       return PROJECTM_FAILURE;
   }
  
-  if (custom_shape->init_cond_tree->splay_insert(init_cond, param->name) < 0) {
-    delete init_cond;
-    //if (PARSE_DEBUG) printf("parse_shapecode: initial condition already set, not reinserting it (param = \"%s\")\n", param->name);
-    return PROJECTM_PARSE_ERROR;
-  }
+  custom_shape->init_cond_tree->insert(std::make_pair(param->name,init_cond));
   line_mode = CUSTOM_SHAPE_SHAPECODE_LINE_MODE;
 
   //if (PARSE_DEBUG) printf("parse_shapecode: [success]\n");
@@ -1775,12 +1747,8 @@ int Parser::parse_wave_helper(FILE * fs, Preset  * preset, int id, char * eqn_ty
     }	
 
     /* Insert the equation in the per frame equation tree */
-    if (custom_wave->per_frame_init_eqn_tree->splay_insert(init_cond, init_cond->param->name) < 0) {
-      if (PARSE_DEBUG) printf("parse_wave_helper (per frame init): failed to add equation (ERROR)\n");
-       delete init_cond; /* will free the gen expr too */		
-      return PROJECTM_FAILURE;
-    }
-   
+    custom_wave->per_frame_init_eqn_tree->insert(std::make_pair(init_cond->param->name,init_cond));
+
     if (update_string_buffer(custom_wave->per_frame_init_eqn_string_buffer, 
 			     &custom_wave->per_frame_init_eqn_string_index) < 0) {
 	if (PARSE_DEBUG) printf("parse_wave_helper: failed to update string buffer (LINE %d)\n", line_count);
@@ -1836,11 +1804,7 @@ int Parser::parse_wave_helper(FILE * fs, Preset  * preset, int id, char * eqn_ty
       return PROJECTM_FAILURE;
     }
  
-    if (custom_wave->per_frame_eqn_tree->splay_insert(per_frame_eqn, &per_frame_eqn->index) < 0) {
-      delete per_frame_eqn;
-      return PROJECTM_FAILURE;
-    }
-       
+    custom_wave->per_frame_eqn_tree->insert(std::make_pair(per_frame_eqn->index, per_frame_eqn)); 
     //if (PARSE_DEBUG) printf("parse_wave (per_frame): equation %d associated with custom wave %d [success]\n", 
     //			    per_frame_eqn->index, custom_wave->id);
 
@@ -2045,12 +2009,7 @@ int Parser::parse_shape_per_frame_init_eqn(FILE * fs, CustomShape * custom_shape
     }
 
     /* Insert the equation in the per frame equation tree */
-    if (custom_shape->per_frame_init_eqn_tree->splay_insert(init_cond, init_cond->param->name) < 0) {
-      //if (PARSE_DEBUG) printf("parse_shape (per frame init): failed to add equation (ERROR)\n");
-      delete init_cond; /* will free the gen expr too */		
-      return PROJECTM_PARSE_ERROR;
-    }
-
+    custom_shape->per_frame_init_eqn_tree->insert(std::make_pair(init_cond->param->name,init_cond));
     if (update_string_buffer(custom_shape->per_frame_init_eqn_string_buffer, 
 			     &custom_shape->per_frame_init_eqn_string_index) < 0)
       return PROJECTM_FAILURE;
@@ -2107,14 +2066,7 @@ char string[MAX_TOKEN_SIZE];
       return PROJECTM_FAILURE;
     }
  
-    if (custom_shape->per_frame_eqn_tree->splay_insert(per_frame_eqn, &per_frame_eqn->index) < 0) {
-      delete per_frame_eqn;
-      return PROJECTM_FAILURE;
-    }
-
-    //if (PARSE_DEBUG) printf("parse_shape (per_frame): equation %d associated with custom shape %d [success]\n", 
-    //			    per_frame_eqn->index, custom_shape->id);
-
+    custom_shape->per_frame_eqn_tree->insert(std::make_pair(per_frame_eqn->index, per_frame_eqn));
 
     /* Need to add stuff to string buffer so the editor can read the equations.
        Why not make a nice little helper function for this? - here it is: */
@@ -2174,11 +2126,7 @@ char string[MAX_TOKEN_SIZE];
       return PROJECTM_FAILURE;
     }
  
-    if (custom_wave->per_frame_eqn_tree->splay_insert(per_frame_eqn, &per_frame_eqn->index) < 0) {
-      delete per_frame_eqn;
-      return PROJECTM_FAILURE;
-    }
-       
+    custom_wave->per_frame_eqn_tree->insert(std::make_pair(per_frame_eqn->index, per_frame_eqn));
     //if (PARSE_DEBUG) printf("parse_shape (per_frame): equation %d associated with custom shape %d [success]\n", 
     //			    per_frame_eqn->index, custom_shape->id);
 
diff --git a/src/projectM-engine/Parser.hpp b/src/projectM-engine/Parser.hpp
index e70e0ac8b..144df0289 100755
--- a/src/projectM-engine/Parser.hpp
+++ b/src/projectM-engine/Parser.hpp
@@ -157,7 +157,7 @@ public:
     static int insert_infix_rec(InfixOp * infix_op, TreeExpr * root);
     static GenExpr * parse_gen_expr(FILE * fs, TreeExpr * tree_expr, Preset * preset);
     static PerFrameEqn * parse_implicit_per_frame_eqn(FILE * fs, char * param_string, int index, Preset * preset);
-    static InitCond * parse_per_frame_init_eqn(FILE * fs, Preset * preset, SplayTree<Param> * database);
+    static InitCond * parse_per_frame_init_eqn(FILE * fs, Preset * preset, std::map<std::string,Param*> * database);
     static int parse_wavecode_prefix(char * token, int * id, char ** var_string);
     static int parse_wavecode(char * token, FILE * fs, Preset * preset);
     static int parse_wave_prefix(char * token, int * id, char ** eqn_string);
diff --git a/src/projectM-engine/PerPixelEqn.cpp b/src/projectM-engine/PerPixelEqn.cpp
index 03abcac64..b55aabb70 100755
--- a/src/projectM-engine/PerPixelEqn.cpp
+++ b/src/projectM-engine/PerPixelEqn.cpp
@@ -32,7 +32,7 @@
 #include "Eval.hpp"
 #include "Param.hpp"
 #include "PerPixelEqn.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "wipemalloc.h"
 
diff --git a/src/projectM-engine/PerPointEqn.cpp b/src/projectM-engine/PerPointEqn.cpp
index 8d27c01a1..89e40e122 100755
--- a/src/projectM-engine/PerPointEqn.cpp
+++ b/src/projectM-engine/PerPointEqn.cpp
@@ -34,7 +34,7 @@
 #include "Param.hpp"
 #include "PerPixelEqn.hpp"
 #include "PerPointEqn.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "wipemalloc.h"
 
diff --git a/src/projectM-engine/Preset.cpp b/src/projectM-engine/Preset.cpp
index c6273d6e5..8f734589b 100755
--- a/src/projectM-engine/Preset.cpp
+++ b/src/projectM-engine/Preset.cpp
@@ -32,7 +32,7 @@
 #include "Preset.hpp"
 #include "Parser.hpp"
 #include "ParamUtils.hpp"
-
+#include "fatal.h"
 
 
 Preset::Preset(const std::string & filename, const PresetInputs & presetInputs, PresetOutputs & presetOutputs):
@@ -57,25 +57,25 @@ Preset::~Preset() {
 
 
 
-  init_cond_tree->splay_traverse((void (*)(void*))free_init_cond_helper);
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<InitCond> >(*init_cond_tree);
   delete init_cond_tree;
 
-  per_frame_init_eqn_tree->splay_traverse((void (*)(void*))free_init_cond_helper);
+ Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<InitCond> >(*per_frame_init_eqn_tree);
   delete per_frame_init_eqn_tree;
 
-  per_pixel_eqn_tree->splay_traverse((void (*)(void*))free_per_pixel_eqn_helper);
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<PerPixelEqn> >(*per_pixel_eqn_tree);
   delete per_pixel_eqn_tree;
 
-  per_frame_eqn_tree->splay_traverse((void (*)(void*))free_per_frame_eqn_helper);
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<PerFrameEqn> >(*per_frame_eqn_tree);
   delete per_frame_eqn_tree;
-   
-  user_param_tree->traverse<SplayTreeFunctors::Delete<Param> >();
+ 
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<Param> >(user_param_tree);
   delete user_param_tree;
 
-  custom_wave_tree->splay_traverse((void (*)(void*))free_custom_wave_helper);
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<CustomWave> >(custom_wave_tree);
   delete custom_wave_tree;
 
-  custom_shape_tree->splay_traverse((void (*)(void*))free_custom_shape_helper);
+  Algorithms::traverse<Algorithms::TraverseFunctors::DeleteFunctor<CustomShape> >(custom_shape_tree);
   delete custom_shape_tree;
  
 #if defined(PRESET_DEBUG) && defined(DEBUG)
@@ -137,6 +137,9 @@ int Preset::add_per_pixel_eqn(char * name, GenExpr * gen_expr) {
 
  /* Find most largest index in the splaytree */
  if ((per_pixel_eqn = (PerPixelEqn *)per_pixel_eqn_tree->splay_find_max()) == NULL)
+  std::map<int, per_pixel_eqn*>::iterator pos = --(per_pixel_eqn_tree->end());
+
+ if ((pos = per_pixel_eqn_tree->splay_find_max()) == NULL)
   index = 0;
   else
  index = per_pixel_eqn_tree->splay_size();
@@ -208,7 +211,7 @@ void Preset::reloadPerPixel(char *s) {
   /* Clear previous per pixel equations */
   per_pixel_eqn_tree->splay_traverse((void (*)(void*))free_per_pixel_eqn_helper);
   delete per_pixel_eqn_tree;
-  per_pixel_eqn_tree = SplayTree<PerPixelEqn>::create_splaytree
+  per_pixel_eqn_tree = std::map<int, PerPixelEqn*>::create_splaytree
 	((int (*)(const void*,const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
 
   /* Convert string to a stream */
@@ -261,7 +264,7 @@ void Preset::reloadPerFrame(char * s) {
   /* Clear previous per frame equations */
   per_frame_eqn_tree->splay_traverse((void (*)(void*))free_per_frame_eqn_helper );
   delete per_frame_eqn_tree;
-  per_frame_eqn_tree = SplayTree<PerFrameEqn>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
+  per_frame_eqn_tree = std::map<int, PerFrameEqn*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
 
   /* Convert string to a stream */
   //FIXME
@@ -306,13 +309,13 @@ printf( "reloadPerFrame()\n" );
 void Preset::initialize(const std::string & pathname) {
 
   /* Initialize equation trees */
-  init_cond_tree = SplayTree<InitCond>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string);
-  this->user_param_tree = SplayTree<Param>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string,  (void (*)(void*))SplayKeyFunctions::free_string);
-  this->per_frame_eqn_tree = SplayTree<PerFrameEqn>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*)) SplayKeyFunctions::free_int);
-  this->per_pixel_eqn_tree = SplayTree<PerPixelEqn>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
-  this->per_frame_init_eqn_tree = SplayTree<InitCond>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string, (void (*)(void*)) SplayKeyFunctions::free_string);
-  this->custom_wave_tree = SplayTree<CustomWave>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*)) SplayKeyFunctions::free_int);
-  this->custom_shape_tree = SplayTree<CustomShape>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
+  init_cond_tree = std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string, (void* (*)(void*))SplayKeyFunctions::copy_string, (void (*)(void*))SplayKeyFunctions::free_string);
+  this->user_param_tree = std::map<std::string,Param*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string,  (void (*)(void*))SplayKeyFunctions::free_string);
+  this->per_frame_eqn_tree = std::map<int, PerFrameEqn*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*)) SplayKeyFunctions::free_int);
+  this->per_pixel_eqn_tree = std::map<int, PerPixelEqn*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int,(void* (*)(void*)) SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
+  this->per_frame_init_eqn_tree = std::map<std::string,InitCond*>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_string,(void* (*)(void*)) SplayKeyFunctions::copy_string, (void (*)(void*)) SplayKeyFunctions::free_string);
+  this->custom_wave_tree = std::map<int, CustomWave *>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*)) SplayKeyFunctions::free_int);
+  this->custom_shape_tree = std::map<int, CustomShape *>::create_splaytree((int (*)(const void*,const void*))SplayKeyFunctions::compare_int, (void* (*)(void*))SplayKeyFunctions::copy_int, (void (*)(void*))SplayKeyFunctions::free_int);
 
   memset(this->per_pixel_flag, 0, sizeof(int)*NUM_OPS);
 
diff --git a/src/projectM-engine/Preset.hpp b/src/projectM-engine/Preset.hpp
index ea06fb64c..b7bab090e 100644
--- a/src/projectM-engine/Preset.hpp
+++ b/src/projectM-engine/Preset.hpp
@@ -40,7 +40,7 @@
 #include "PerFrameEqn.hpp"
 #include "BuiltinParams.hpp"
 #include "PresetFrameIO.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include "InitCond.hpp"
 #include <vector>
 
@@ -49,7 +49,7 @@ class CustomWave;
 class CustomShape;
 class InitCond;
 
-//#include "SplayTree.hpp"
+//#include <map>
 
 
 class Preset {
@@ -90,14 +90,14 @@ public:
     char per_frame_init_eqn_string_buffer[STRING_BUFFER_SIZE];
 
     /* Data structures that contain equation and initial condition information */
-    SplayTree<PerFrameEqn> * per_frame_eqn_tree;   /* per frame equations */
-    SplayTree<PerPixelEqn> * per_pixel_eqn_tree; /* per pixel equation tree */
+    std::map<int, PerFrameEqn*> * per_frame_eqn_tree;   /* per frame equations */
+    std::map<int, PerPixelEqn*> * per_pixel_eqn_tree; /* per pixel equation tree */
     GenExpr * per_pixel_eqn_array[NUM_OPS]; /* per pixel equation array */
-    SplayTree<InitCond> * per_frame_init_eqn_tree; /* per frame initial equations */
-    SplayTree<InitCond> * init_cond_tree; /* initial conditions */
-    SplayTree<Param> * user_param_tree; /* user parameter splay tree */
-    SplayTree<CustomWave> * custom_wave_tree; /* custom wave forms for this preset */
-    SplayTree<CustomShape> * custom_shape_tree; /* custom shapes for this preset */
+    std::map<std::string,InitCond*> * per_frame_init_eqn_tree; /* per frame initial equations */
+    std::map<std::string,InitCond*> * init_cond_tree; /* initial conditions */
+    std::map<std::string,Param*> * user_param_tree; /* user parameter splay tree */
+    std::map<int, CustomWave *> * custom_wave_tree; /* custom wave forms for this preset */
+    std::map<int, CustomShape *> * custom_shape_tree; /* custom shapes for this preset */
 
     int add_per_pixel_eqn( char *name, GenExpr *gen_expr );
     int isPerPixelEqn( int op );
diff --git a/src/projectM-engine/PresetChooser.hpp b/src/projectM-engine/PresetChooser.hpp
index 4cd7cb5d3..0bb76c508 100644
--- a/src/projectM-engine/PresetChooser.hpp
+++ b/src/projectM-engine/PresetChooser.hpp
@@ -56,7 +56,7 @@ class PresetChooser {
 public:
     typedef PresetIterator iterator;
     /// Initializes a chooser with an established preset loader.
-    /// \param presetLoader an initalized preset loader to choose presets from
+    /// \param presetLoader an initialized preset loader to choose presets from
     /// \note The preset loader is refreshed via events or otherwise outside this class's scope
     PresetChooser(const PresetLoader & presetLoader);
 
@@ -68,7 +68,7 @@ public:
     /// Gets the number of presets last believed to exist in the preset loader's filename collection
     std::size_t getNumPresets() const;
 
-    /// \brief A functor, for all preset indices, returns probability 1 / (number of presets in directory)
+    /// A functor, for all preset indices, returns probability 1 / (number of presets in directory)
     class UniformRandomFunctor {
 
     public:
@@ -89,7 +89,7 @@ public:
     PresetIterator begin();
 
     /// \brief An STL-esque iterator to retrieve an end position from a directory
-    PresetIterator end();
+    PresetIterator end() const;
 
     /// \brief Do a weighted sample given a weight functor.
     template <class WeightFunctor>
@@ -153,7 +153,7 @@ inline PresetIterator PresetChooser::begin() {
     return pos;
 }
 
-inline PresetIterator PresetChooser::end() {
+inline PresetIterator PresetChooser::end() const {
     PresetIterator pos(m_presetLoader->getNumPresets());
     return pos;
 }
@@ -180,7 +180,7 @@ inline std::auto_ptr<Preset> PresetChooser::directoryIndex(std::size_t index, co
 template <class WeightFunctor>
 inline std::auto_ptr<Preset> PresetChooser::doWeightedSample(WeightFunctor & weightFunctor, const PresetInputs & presetInputs, PresetOutputs & presetOutputs) {
 
-    // Choose a random mass bounded mass between 0 and 1
+    // Choose a random bounded mass between 0 and 1
     float cutoff = ((float)(random())) / RAND_MAX;
 
     // Sum up mass, stopping when cutoff is reached. This is the typical
diff --git a/src/projectM-engine/SplayTree.hpp b/src/projectM-engine/SplayTree.hpp
index 196432bdc..0a1659892 100755
--- a/src/projectM-engine/SplayTree.hpp
+++ b/src/projectM-engine/SplayTree.hpp
@@ -635,15 +635,5 @@ int SplayTree<Data>::splay_rec_size(SplayNode<Data> * splaynode) {
 
 }
 
-namespace SplayTreeFunctors {
-template <class Data>
-class Delete {
-public:
-void operator() (Data * data) {
-	delete(data);
-}
-
-};
-}
 
 #endif /** !_SPLAYTREE_HPP */
diff --git a/src/projectM-engine/menu.cpp b/src/projectM-engine/menu.cpp
index 205b4e92c..26c3f7930 100755
--- a/src/projectM-engine/menu.cpp
+++ b/src/projectM-engine/menu.cpp
@@ -33,7 +33,7 @@
 #include "Common.hpp"
 #include "fatal.h"
 #include "Param.hpp"
-#include "SplayTree.hpp"
+#include <map>
 
 #include "InitCond.hpp"
 
diff --git a/src/projectM-engine/projectM.cpp b/src/projectM-engine/projectM.cpp
index c1160caa6..2d3275cf1 100755
--- a/src/projectM-engine/projectM.cpp
+++ b/src/projectM-engine/projectM.cpp
@@ -45,7 +45,7 @@
 #include "PCM.hpp"                    //Sound data handler (buffering, FFT, etc.)
 #include "CustomWave.hpp"
 #include "CustomShape.hpp"
-#include "SplayTree.hpp"
+#include <map>
 #include "Renderer.hpp"
 #include "PresetChooser.hpp"