Index: src/Common/GC.cc
===================================================================
--- src/Common/GC.cc	(revision 3205495dd343c9711c6a408c413f19481e797e4a)
+++ src/Common/GC.cc	(revision 04570c75d205118d854a3167b93c28cd2c63f51d)
@@ -28,15 +28,13 @@
 }
 
-GC::GC() : mark(false), using_young(false), old(), young(), static_roots() {
-	old.reserve(70000);
+GC::GC() : gens(1), static_roots(), mark(false), g(0) {
+	gens[0].reserve(70000);
 }
 
 GC::~GC() {
-	for ( GC_Object* o : young ) {
-		delete o;
-	}
-
-	for ( GC_Object* o : old ) {
-		delete o;
+	for ( unsigned i = 0; i <= g; ++i ) {
+		for ( GC_Object* o : gens[i] ) {
+			delete o;
+		}
 	}
 }
@@ -54,5 +52,5 @@
 
 void GC::register_object(GC_Object* obj) {
-	(using_young ? young : old).push_back(obj);
+	gens[g].push_back(obj);
 	obj->mark = !this->mark;  // initialize as un-marked
 }
@@ -63,8 +61,6 @@
 
 void GC::new_generation() {
-	assert(!using_young && "Cannot start new generation when young generation already in use");
-	
-	using_young = true;  // mark young generation as in-use
-	mark = !mark;        // switch mark so aged young objects will still be unmarked in old
+	if ( ++g == gens.size() ) { gens.emplace_back(); }  // ensure new generation available
+	mark = !mark;  // switch mark so aged young objects will still be unmarked in old
 }
 
@@ -77,4 +73,9 @@
 
 void GC::collect_young() {
+	// get generations and decrement generation
+	assert(g > 0 && "Cannot collect_young without young generation");
+	Generation& young = gens[g];
+	Generation& old = gens[--g];
+
 	// collect young gen
 	for ( GC_Object*& obj : young ) {
@@ -89,9 +90,6 @@
 	old.insert( old.end(), young.begin(), end_live );
 	
-	// clear young gen
-	using_young = false;
+	// clear young gen and reset mark to return to old generation mark
 	young.clear();
-
-	// reset mark to return to old generation mark
 	mark = !mark;
 }
@@ -99,5 +97,6 @@
 void GC::collect() {
 	// ensure not called when young gen is active
-	assert(!using_young && "Cannot do old collection when young generation is active");
+	assert(g == 0 && "Cannot do old collection when young generation is active");
+	Generation& old = gens[0];
 
 	// collect old gen
Index: src/Common/GC.h
===================================================================
--- src/Common/GC.h	(revision 3205495dd343c9711c6a408c413f19481e797e4a)
+++ src/Common/GC.h	(revision 04570c75d205118d854a3167b93c28cd2c63f51d)
@@ -38,5 +38,5 @@
 	void register_static_root(BaseSyntaxNode*);
 
-	/// Use young generation for subsequent new objects
+	/// Start new generation for subsequent new objects
 	void new_generation();
 
@@ -44,10 +44,11 @@
 	void trace_static_roots();
 
-	/// Collects the young generation, placing survivors in old generation.
-	/// Old generation is used for subsequent new objects.
+	/// Collects the youngest generation, placing survivors in previous generation.
+	/// Young generation objects cannot be kept alive by pointers from older generation.
+	/// Older generation is used for subsequent new objects.
 	void collect_young();
 
-	/// Collects old generation; use old generation afterward.
-	/// Error if currently using young generation
+	/// Collects oldest generation; use oldest generation afterward.
+	/// Error if currently using younger generation
 	void collect();
 
@@ -58,13 +59,12 @@
 	GC();
 
-	bool mark;                 ///< The current collection's mark bit
-	bool using_young;          ///< Is the young generation in use?
-
 	using Generation = std::vector<GC_Object*>;
-	Generation old;            ///< Old generation
-	Generation young;          ///< Young generation
+	std::vector<Generation> gens;  ///< Set of generations; always at least one
 
 	using StaticRoots = std::vector<BaseSyntaxNode*>;
-	StaticRoots static_roots;  ///< Set of static-lifetime roots
+	StaticRoots static_roots;      ///< Set of static-lifetime roots
+
+	bool mark;                     ///< The current collection's mark bit
+	unsigned g;                    ///< The current number generation in use
 };