diff --git a/gc.c b/gc.c
index 1bbff959..031cfa0f 100644
--- a/gc.c
+++ b/gc.c
@@ -433,7 +433,7 @@ int gc_grow_heap(gc_heap * h, int heap_type, size_t size, size_t chunk_size)
   pthread_mutex_lock(&heap_lock);
   // Compute size of new heap page
   if (heap_type == HEAP_HUGE) {
-    new_size = size;
+    new_size = gc_heap_align(size);
   } else {
     // Grow heap gradually using fibonnaci sequence.
     size_t prev_size = GROW_HEAP_BY_SIZE;
diff --git a/include/cyclone/types.h b/include/cyclone/types.h
index bd9a9c67..f18aa1c6 100644
--- a/include/cyclone/types.h
+++ b/include/cyclone/types.h
@@ -54,7 +54,7 @@
 #define DEBUG_SHOW_DIAG 0
 
 // Show diagnostic information before/after sweeping
-#define GC_DEBUG_SHOW_SWEEP_DIAG 1
+#define GC_DEBUG_SHOW_SWEEP_DIAG 0
 
 // GC debugging flags
 #define GC_DEBUG_TRACE 0
diff --git a/runtime.c b/runtime.c
index 4f6aad11..427a5372 100644
--- a/runtime.c
+++ b/runtime.c
@@ -1687,6 +1687,7 @@ object Cyc_make_vector(void *data, object cont, int argc, object len, ...)
   object v = NULL;
   object fill = boolean_f;
   int i, ulen;
+  size_t element_vec_size;
   va_list ap;
   va_start(ap, len);
   if (argc > 1) {
@@ -1695,35 +1696,41 @@ object Cyc_make_vector(void *data, object cont, int argc, object len, ...)
   va_end(ap);
   Cyc_check_num(data, len);
   ulen = unbox_number(len);
+  element_vec_size = sizeof(object) * ulen;
+
+  if (element_vec_size >= MAX_STACK_OBJ) {
+    // If vector is too large to allocate on the stack, allocate on heap
+    //
+    // TODO: mark this thread as potentially blocking before doing
+    //       the allocation????
+    int heap_grown;
+    v = gc_alloc(Cyc_heap, 
+                 sizeof(vector_type) + element_vec_size,
+                 boolean_f, // OK to populate manually over here
+                 (gc_thread_data *)data, 
+                 &heap_grown);
+    ((vector) v)->hdr.mark = ((gc_thread_data *)data)->gc_alloc_color;
+    ((vector) v)->hdr.grayed = 0;
+    ((vector) v)->tag = vector_tag;
+    ((vector) v)->num_elements = ulen;
+    ((vector) v)->elements = (object *)(((char *)v) + sizeof(vector_type));
+  } else {
+    v = alloca(sizeof(vector_type));
+    ((vector) v)->hdr.mark = gc_color_red;
+    ((vector) v)->hdr.grayed = 0;
+    ((vector) v)->tag = vector_tag;
+    ((vector) v)->num_elements = ulen;
+    ((vector) v)->elements = NULL;
+
+    if (ulen > 0) {
+      ((vector) v)->elements = 
+        (object *) alloca(sizeof(object) * ((vector) v)->num_elements);
+    }
+  }
 
-// TODO: if vector is too big, would need to alloc directly on the heap
-//  if (ulen < 10000) {
-  v = alloca(sizeof(vector_type));
-  ((vector) v)->hdr.mark = gc_color_red;
-  ((vector) v)->hdr.grayed = 0;
-  ((vector) v)->tag = vector_tag;
-  ((vector) v)->num_elements = ulen;
-  ((vector) v)->elements =
-      (((vector) v)->num_elements > 0) ?
-      (object *) alloca(sizeof(object) * ((vector) v)->num_elements) : NULL;
   for (i = 0; i < ((vector) v)->num_elements; i++) {
     ((vector) v)->elements[i] = fill;
   }
-//  } else {
-//    // Experimenting with heap allocation if vector is too large
-//    int heap_grown;
-//    vector_type *vt = gc_alloc(Cyc_heap,
-//                               sizeof(vector_type) + sizeof(object) * ulen,
-//                               boolean_f, (gc_thread_data *)data, &heap_grown);
-//    mark(vt) = ((gc_thread_data *)data)->gc_alloc_color;
-//    type_of(vt) = vector_tag;
-//    vt->num_elements = ulen;
-//    vt->elements = (object *)((char *)vt) + sizeof(vector_type);
-//    for (i = 0; i < ulen; i++) {
-//      vt->elements[i] = fill;
-//    }
-//    v = vt;
-//  }
   return_closcall1(data, cont, v);
 }