diff --git a/src/main.c b/src/main.c
index 044570e..0ae4710 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,4 +1,3 @@
-// vim: ts=4 sw=4 sts=4
 /* ----------------------------------------------------------------------------
  * main()
  * ----------------------------------------------------------------------------
@@ -20,7 +19,8 @@
 
 // ----------------------------------------------------------------------------
 
-#define  MAX_ACTIVE_LAYERS  20
+// TODO remove this; for now we'll just limit it to the number of layers
+#define MAX_ACTIVE_LAYERS KB_LAYERS
 
 // ----------------------------------------------------------------------------
 
@@ -34,9 +34,6 @@ static bool main_kb_was_transparent[KB_ROWS][KB_COLUMNS];
 
 uint8_t main_layers_pressed[KB_ROWS][KB_COLUMNS];
 
-uint8_t main_loop_row;
-uint8_t main_loop_col;
-
 uint8_t main_arg_layer;
 uint8_t main_arg_layer_offset;
 uint8_t main_arg_row;
@@ -52,78 +49,73 @@ bool    main_arg_trans_key_pressed;
  * main()
  */
 int main(void) {
-	kb_init();  // does controller initialization too
+  kb_init(); // does controller initialization too
 
-	kb_led_state_power_on();
+  kb_led_state_power_on();
 
-	usb_init();
-	while (!usb_configured());
-	kb_led_delay_usb_init();  // give the OS time to load drivers, etc.
+  usb_init();
+  while (!usb_configured());
+  kb_led_delay_usb_init();  // give the OS time to load drivers, etc.
 
-	kb_led_state_ready();
+  kb_led_state_ready();
 
-	for (;;) {
-		// swap `main_kb_is_pressed` and `main_kb_was_pressed`, then update
-		bool (*temp)[KB_ROWS][KB_COLUMNS] = main_kb_was_pressed;
-		main_kb_was_pressed = main_kb_is_pressed;
-		main_kb_is_pressed = temp;
+  for (;;) {
+    // swap `main_kb_is_pressed` and `main_kb_was_pressed`, then update
+    bool (*temp)[KB_ROWS][KB_COLUMNS]	= main_kb_was_pressed;
+    main_kb_was_pressed              	= main_kb_is_pressed;
+    main_kb_is_pressed               	= temp;
 
-		kb_update_matrix(*main_kb_is_pressed);
+    kb_update_matrix(*main_kb_is_pressed);
 
-		// this loop is responsible to
-		// - "execute" keys when they change state
-		// - keep track of which layers the keys were on when they were pressed
-		//   (so they can be released using the function from that layer)
-		//
-		// note
-		// - everything else is the key function's responsibility
-		//   - see the keyboard layout file ("keyboard/ergodox/layout/*.c") for
-		//     which key is assigned which function (per layer)
-		//   - see "lib/key-functions/public/*.c" for the function definitions
-		for (int row=0; row<KB_ROWS; row++) {
-			for (int col=0; col<KB_COLUMNS; col++) {
-				main_arg_is_pressed 	= (*main_kb_is_pressed)[row][col];
-				main_arg_was_pressed	= (*main_kb_was_pressed)[row][col];
+    // this loop is responsible to
+    // - "execute" keys when they change state
+    // - keep track of which layers the keys were on when they were pressed
+    //   (so they can be released using the function from that layer)
+    //
+    // note
+    // - everything else is the key function's responsibility
+    //   - see the keyboard layout file ("keyboard/ergodox/layout/*.c") for
+    //     which key is assigned which function (per layer)
+    //   - see "lib/key-functions/public/*.c" for the function definitions
+    for (uint8_t row=0; row<KB_ROWS; row++) {
+      for (uint8_t col=0; col<KB_COLUMNS; col++) {
+        main_arg_is_pressed 	= (*main_kb_is_pressed)[row][col];
+        main_arg_was_pressed	= (*main_kb_was_pressed)[row][col];
 
-				if (main_arg_is_pressed != main_arg_was_pressed) {
-					if (main_arg_is_pressed) {
-						main_arg_layer               	= main_layers_peek(0);
-						main_layers_pressed[row][col]	= main_arg_layer;
-						main_arg_trans_key_pressed   	= false;
-					} else {
-						main_arg_layer            	= main_layers_pressed[row][col];
-						main_arg_trans_key_pressed	= main_kb_was_transparent[row][col];
-					}
+        if (main_arg_is_pressed != main_arg_was_pressed) {
+          if (main_arg_is_pressed) {
+            main_arg_layer               	= main_layers_peek(0);
+            main_layers_pressed[row][col]	= main_arg_layer;
+            main_arg_trans_key_pressed   	= false;
+          } else {
+            main_arg_layer            	= main_layers_pressed[row][col];
+            main_arg_trans_key_pressed	= main_kb_was_transparent[row][col];
+          }
 
-					// set remaining vars, and "execute" key
-					main_arg_row         	= row;
-					main_arg_col         	= col;
-					main_arg_layer_offset	= 0;
-					main_exec_key();
-					main_kb_was_transparent[row][col] = main_arg_trans_key_pressed;
-				}
-			}
-		}
+          // set remaining vars, and "execute" key
+          main_arg_row         	= row;
+          main_arg_col         	= col;
+          main_arg_layer_offset	= 0;
+          main_exec_key();
+          main_kb_was_transparent[row][col] = main_arg_trans_key_pressed;
+        }
+      }
+    }
 
-		// send the USB report (even if nothing's changed)
-		usb_keyboard_send();
-		usb_extra_consumer_send();
-		_delay_ms(MAKEFILE_DEBOUNCE_TIME);
+    // send the USB report (even if nothing's changed)
+    usb_keyboard_send();
+    usb_extra_consumer_send();
+    _delay_ms(MAKEFILE_DEBOUNCE_TIME);
 
-		// update LEDs
-		if (keyboard_leds & (1<<0)) { kb_led_num_on(); }
-		else { kb_led_num_off(); }
-		if (keyboard_leds & (1<<1)) { kb_led_caps_on(); }
-		else { kb_led_caps_off(); }
-		if (keyboard_leds & (1<<2)) { kb_led_scroll_on(); }
-		else { kb_led_scroll_off(); }
-		if (keyboard_leds & (1<<3)) { kb_led_compose_on(); }
-		else { kb_led_compose_off(); }
-		if (keyboard_leds & (1<<4)) { kb_led_kana_on(); }
-		else { kb_led_kana_off(); }
-	}
+    // update LEDs
+    if (keyboard_leds & (1<<0))	{ kb_led_num_on();    	} else { kb_led_num_off();    	}
+    if (keyboard_leds & (1<<1))	{ kb_led_caps_on();   	} else { kb_led_caps_off();   	}
+    if (keyboard_leds & (1<<2))	{ kb_led_scroll_on(); 	} else { kb_led_scroll_off(); 	}
+    if (keyboard_leds & (1<<3))	{ kb_led_compose_on();	} else { kb_led_compose_off();	}
+    if (keyboard_leds & (1<<4))	{ kb_led_kana_on();   	} else { kb_led_kana_off();   	}
+  }
 
-	return 0;
+  return 0;
 }
 
 // ----------------------------------------------------------------------------
@@ -141,9 +133,9 @@ int main(void) {
 // ----------------------------------------------------------------------------
 
 struct layers {
-	uint8_t layer;
-	uint8_t id;
-	uint8_t sticky;
+  uint8_t layer;
+  uint8_t id;
+  uint8_t sticky;
 };
 
 // ----------------------------------------------------------------------------
@@ -158,18 +150,18 @@ uint8_t       layers_ids_in_use[MAX_ACTIVE_LAYERS] = {true};
  *   the current possition.
  */
 void main_exec_key(void) {
-	void (*key_function)(void) =
-		( (main_arg_is_pressed)
-		  ? kb_layout_press_get(main_arg_layer, main_arg_row, main_arg_col)
-		  : kb_layout_release_get(main_arg_layer, main_arg_row, main_arg_col) );
+  void (*key_function)(void) =
+    ( (main_arg_is_pressed)
+      ? kb_layout_press_get(main_arg_layer, main_arg_row, main_arg_col)
+      : kb_layout_release_get(main_arg_layer, main_arg_row, main_arg_col) );
 
-	if (key_function)
-		(*key_function)();
+  if (key_function)
+    (*key_function)();
 
-	// If the current layer is in the sticky once up state and a key defined
-	//  for this layer (a non-transparent key) was pressed, pop the layer
-	if (layers[layers_head].sticky == eStickyOnceUp && main_arg_any_non_trans_key_pressed)
-		main_layers_pop_id(layers_head);
+  // If the current layer is in the sticky once up state and a key defined
+  //  for this layer (a non-transparent key) was pressed, pop the layer
+  if (layers[layers_head].sticky == eStickyOnceUp && main_arg_any_non_trans_key_pressed)
+    main_layers_pop_id(layers_head);
 }
 
 /*
@@ -183,17 +175,19 @@ void main_exec_key(void) {
  * - failure: 0 (default) (out of bounds)
  */
 uint8_t main_layers_peek(uint8_t offset) {
-	if (offset <= layers_head)
-		return layers[layers_head - offset].layer;
+  if (offset <= layers_head) {
+    return layers[layers_head - offset].layer;
+  }
 
-	return 0;  // default, or error
+  return 0; // default, or error
 }
 
 uint8_t main_layers_peek_sticky(uint8_t offset) {
-	if (offset <= layers_head)
-		return layers[layers_head - offset].sticky;
+  if (offset <= layers_head) {
+    return layers[layers_head - offset].sticky;
+  }
 
-	return 0;  // default, or error
+  return 0; // default, or error
 }
 
 /*
@@ -207,20 +201,20 @@ uint8_t main_layers_peek_sticky(uint8_t offset) {
  * - failure: 0 (the stack was already full)
  */
 uint8_t main_layers_push(uint8_t layer, uint8_t sticky) {
-	// look for an available id
-	for (uint8_t id=1; id<MAX_ACTIVE_LAYERS; id++) {
-		// if one is found
-		if (layers_ids_in_use[id] == false) {
-			layers_ids_in_use[id] = true;
-			layers_head++;
-			layers[layers_head].layer = layer;
-			layers[layers_head].id = id;
-			layers[layers_head].sticky = sticky;
-			return id;
-		}
-	}
+  // look for an available id
+  for (uint8_t id=1; id<MAX_ACTIVE_LAYERS; id++) {
+    // if one is found
+    if (layers_ids_in_use[id] == false) {
+      layers_ids_in_use[id]     	= true;
+      layers_head++;            	
+      layers[layers_head].layer 	= layer;
+      layers[layers_head].id    	= id;
+      layers[layers_head].sticky	= sticky;
+      return id;
+    }
+  }
 
-	return 0;  // default, or error
+  return 0; // default, or error
 }
 
 /*
@@ -230,22 +224,23 @@ uint8_t main_layers_push(uint8_t layer, uint8_t sticky) {
  * - 'id': the id of the element to pop from the stack
  */
 void main_layers_pop_id(uint8_t id) {
-	// look for the element with the id we want to pop
-	for (uint8_t element=1; element<=layers_head; element++)
-		// if we find it
-		if (layers[element].id == id) {
-			// move all layers above it down one
-			for (; element<layers_head; element++) {
-				layers[element].layer = layers[element+1].layer;
-				layers[element].id = layers[element+1].id;
-			}
-			// reinitialize the topmost (now unused) slot
-			layers[layers_head].layer = 0;
-			layers[layers_head].id = 0;
-			// record keeping
-			layers_ids_in_use[id] = false;
-			layers_head--;
-		}
+  // look for the element with the id we want to pop
+  for (uint8_t element=1; element<=layers_head; element++) {
+    // if we find it
+    if (layers[element].id == id) {
+      // move all layers above it down one
+      for (; element<layers_head; element++) {
+        layers[element].layer	= layers[element+1].layer;
+        layers[element].id   	= layers[element+1].id;
+      }
+      // reinitialize the topmost (now unused) slot
+      layers[layers_head].layer	= 0;
+      layers[layers_head].id   	= 0;
+      // record keeping
+      layers_ids_in_use[id] = false;
+      layers_head--;
+    }
+  }
 }
 
 /*
@@ -260,14 +255,15 @@ void main_layers_pop_id(uint8_t id) {
  * - failure: 0 (default) (id unassigned)
  */
 uint8_t main_layers_get_offset_id(uint8_t id) {
-	// look for the element with the id we want to get the offset of
-	for (uint8_t element=1; element<=layers_head; element++)
-		// if we find it
-		if (layers[element].id == id)
-			return (layers_head - element);
-
-	return 0;  // default, or error
+  // look for the element with the id we want to get the offset of
+  for (uint8_t element=1; element<=layers_head; element++) {
+    // if we find it
+    if (layers[element].id == id) {
+      return (layers_head - element);
+    }
+  }
 
+  return 0; // default, or error
 }
 
 /* ----------------------------------------------------------------------------