diff --git a/panda/src/dxgsg9/config_dxgsg9.cxx b/panda/src/dxgsg9/config_dxgsg9.cxx
index e5635abac9..c349332035 100755
--- a/panda/src/dxgsg9/config_dxgsg9.cxx
+++ b/panda/src/dxgsg9/config_dxgsg9.cxx
@@ -129,6 +129,38 @@ ConfigVariableBool dx_force_anisotropic_filtering
 ConfigVariableBool link_tristrips
 ("link-tristrips", false);
 
+// true = use DirectX management of video memory
+// false = use LRU management of video memory or no management at all
+ConfigVariableBool dx_management
+("dx-management", false);
+
+// dx_management must be true or this is ignored
+// true = enable LRU management of video memory
+// false = no video memory management
+ConfigVariableBool dx_lru_management
+("dx-lru-management", true);
+
+// number of LRU pages to pre-allocate
+// if the maximum is reached, then LRU pages will be dynamically allocated/freed
+ConfigVariableInt dx_lru_maximum_pages
+("dx-lru-maximum-pages", 20000);
+
+// this is the amount of video memory the LRU will not use
+// this will allow DirectX some space in case of memory fragmentation, ...
+// this does not apply if dx_lru_minimum_memory_requirement is not met
+ConfigVariableInt dx_lru_free_memory_requirement
+("dx-lru-free-memory-requirement", 5000000);
+
+// this is like the minimum recommended amount of video memory
+ConfigVariableInt dx_lru_minimum_memory_requirement
+("dx-lru-minimum-memory-requirement", 64000000);
+
+// this is used to cap the amount of memory used
+// 0 = use all available DirectX video memory
+ConfigVariableInt dx_lru_maximum_memory_requirement
+("dx-lru-maximum-memory-requirement", 128000000);
+
+
 ConfigureFn(config_dxgsg9) {
   init_libdxgsg9();
 }
diff --git a/panda/src/dxgsg9/config_dxgsg9.h b/panda/src/dxgsg9/config_dxgsg9.h
index b6b7363643..c33232599a 100755
--- a/panda/src/dxgsg9/config_dxgsg9.h
+++ b/panda/src/dxgsg9/config_dxgsg9.h
@@ -38,7 +38,6 @@ extern ConfigVariableInt dx_multisample_antialiasing_level;
 extern ConfigVariableBool dx_use_triangle_mipgen_filter;
 extern ConfigVariableBool dx_broken_max_index;
 
-
 // debug flags we might want to use in full optimized build
 extern ConfigVariableBool dx_ignore_mipmaps;
 extern ConfigVariableBool dx_mipmap_everything;
@@ -61,6 +60,14 @@ extern ConfigVariableDouble dx_global_miplevel_bias;
 extern ConfigVariableBool dx_debug_view_mipmaps;
 #endif
 
+// LRU configuration variables
+extern ConfigVariableBool dx_management;
+extern ConfigVariableBool dx_lru_management;
+extern ConfigVariableInt dx_lru_maximum_pages;
+extern ConfigVariableInt dx_lru_free_memory_requirement;
+extern ConfigVariableInt dx_lru_minimum_memory_requirement;
+extern ConfigVariableInt dx_lru_maximum_memory_requirement;
+
 extern EXPCL_PANDADX void init_libdxgsg9();
 
 #endif
diff --git a/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx b/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
index e510f13592..b71ddcc48a 100755
--- a/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
+++ b/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
@@ -124,11 +124,11 @@ DXGraphicsStateGuardian9(const FrameBufferProperties &properties) :
     Geom::GR_triangle_strip | Geom::GR_triangle_fan |
     Geom::GR_flat_first_vertex;
 
-  _gsg_managed_textures = DEFAULT_ENABLE_DX_MANAGED;
-  _gsg_managed_vertex_buffers = DEFAULT_ENABLE_DX_MANAGED;
-  _gsg_managed_index_buffers = DEFAULT_ENABLE_DX_MANAGED;
+  _gsg_managed_textures = dx_management;
+  _gsg_managed_vertex_buffers = dx_management;
+  _gsg_managed_index_buffers = dx_management;
 
-  _enable_lru = DEFAULT_ENABLE_LRU;
+  _enable_lru = dx_lru_management;
 
   _lru = 0;
 }
@@ -833,11 +833,11 @@ end_frame() {
 
         available_texture_memory = _d3d_device->GetAvailableTextureMem ( );
 
-        dxgsg9_cat.debug() << "* LRU: total_pages " << _lru -> _m.total_pages << "\n";
+        dxgsg9_cat.debug() << "* LRU: total_pages " << _lru -> _m.total_pages << "/" << _lru -> _m.maximum_pages << "\n";
         dxgsg9_cat.debug() << "*  DX available_texture_memory = " << available_texture_memory << "\n";
 //        dxgsg9_cat.debug() << "*  DX delta_memory " << available_texture_memory - _lru -> _m.available_memory << "\n";
         dxgsg9_cat.debug() << "*  delta_memory " << _available_texture_memory - (available_texture_memory + (_lru -> _m.maximum_memory - _lru -> _m.available_memory)) << "\n";
-        dxgsg9_cat.debug() << "*  available_memory " << _lru -> _m.available_memory << "\n";
+        dxgsg9_cat.debug() << "*  available_memory " << _lru -> _m.available_memory << "/" << _lru -> _m.maximum_memory << "\n";
         dxgsg9_cat.debug() << "*  total lifetime pages created " << _lru -> _m.identifier << "\n";
         dxgsg9_cat.debug() << "*  total_lifetime_page_ins " << _lru -> _m.total_lifetime_page_ins << "\n";
         dxgsg9_cat.debug() << "*  total_lifetime_page_outs " << _lru -> _m.total_lifetime_page_outs << "\n";
@@ -1972,69 +1972,79 @@ reset() {
   }
   _available_texture_memory = available_texture_memory;
 
-  if (_lru)
-  {
+  if (_lru) {
     delete _lru;
     _lru = 0;
   }
 
-  if (_enable_lru)
-  {
+  if (dx_management == false && _enable_lru) {
+    int error;
     int maximum_memory;
     int maximum_pages;
-    int maximum_page_types;
     Lru *lru;
 
-int minimum_memory_requirement;
-int optimum_memory_requirement;
-int free_memory_requirement;
+    int absolute_minimum_memory_requirement;
+    int minimum_memory_requirement;
+    int maximum_memory_requirement;
+    int free_memory_requirement;
 
-// THESE NEED TO SPECIFIED SOMEHOW
-minimum_memory_requirement = 64000000;
-optimum_memory_requirement = 128000000;
-free_memory_requirement = 5000000; // allow DirectX some space in case of fragmentation, ...
-maximum_pages = 20000;
+    maximum_pages = dx_lru_maximum_pages;
 
-maximum_memory = available_texture_memory - free_memory_requirement;
-if (!false)
+    absolute_minimum_memory_requirement = 5000000;
+    minimum_memory_requirement = dx_lru_minimum_memory_requirement;
+    maximum_memory_requirement = dx_lru_maximum_memory_requirement;
+    free_memory_requirement = dx_lru_free_memory_requirement;
+
+
+    error = false;
+    maximum_memory = available_texture_memory - free_memory_requirement;
+    if (maximum_memory < minimum_memory_requirement) {
+       if (maximum_memory < absolute_minimum_memory_requirement) {
+         // video memory size is too small
+          error = true;
+       }
+       else {
+         // video memory is way too low, so take all of it
+         maximum_memory = available_texture_memory;
+
+         // need to warn user about low video memory
+// *****
 {
-  if (maximum_memory < minimum_memory_requirement)
-  {
-     // video memory is way too low, so take all of it
-     maximum_memory = available_texture_memory;
 
-     // should warn user about low video memory
-
-  }
-  else
-  {
-     if (maximum_memory >= optimum_memory_requirement)
-     {
-        // cap video memory used
-        maximum_memory = optimum_memory_requirement;
-     }
-  }
 }
-else
-{
-  // TEST LRU *****
-  maximum_memory = 55000000;
-  maximum_pages = 20000;
-}
-
-    maximum_page_types = GPT_TotalPageTypes;
-
-    lru = new Lru (maximum_memory, maximum_pages, maximum_page_types);
-    if (lru)
-    {
-      lru -> register_lru_page_type (GPT_VertexBuffer, vertex_buffer_page_in_function, vertex_buffer_page_out_function);
-      lru -> register_lru_page_type (GPT_IndexBuffer, index_buffer_page_in_function, index_buffer_page_out_function);
-      lru -> register_lru_page_type (GPT_Texture, texture_page_in_function, texture_page_out_function);
-
-      lru -> _m.context = (void *) this;
+      }
+    }
+    else {
+      if (maximum_memory_requirement != 0) {
+        if (maximum_memory >= maximum_memory_requirement) {
+          // cap video memory used
+          maximum_memory = maximum_memory_requirement;
+        }
+      }
     }
 
-    _lru = lru;
+    // no LRU if there is an error, go back to DirectX managed
+    if (error) {
+      _gsg_managed_textures = true;
+      _gsg_managed_vertex_buffers = true;
+      _gsg_managed_index_buffers = true;
+    } else {
+
+      int maximum_page_types;
+
+      maximum_page_types = GPT_TotalPageTypes;
+
+      lru = new Lru (maximum_memory, maximum_pages, maximum_page_types);
+      if (lru) {
+        lru -> register_lru_page_type (GPT_VertexBuffer, vertex_buffer_page_in_function, vertex_buffer_page_out_function);
+        lru -> register_lru_page_type (GPT_IndexBuffer, index_buffer_page_in_function, index_buffer_page_out_function);
+        lru -> register_lru_page_type (GPT_Texture, texture_page_in_function, texture_page_out_function);
+
+        lru -> _m.context = (void *) this;
+      }
+
+      _lru = lru;
+    }
   }
 
   // check for render to texture support