diff --git a/config.h b/config.h
index a43f15c..e8ae781 100644
--- a/config.h
+++ b/config.h
@@ -105,14 +105,6 @@
 #define CMD_CYCLE_START '~'
 #define CMD_RESET 0x18 // ctrl-x
 
-// The temporal resolution of the acceleration management subsystem. Higher number give smoother
-// acceleration but may impact performance. If you run at very high feedrates (>15kHz or so) and 
-// very high accelerations, this will reduce the error between how the planner plans the velocity
-// profiles and how the stepper program actually performs them. The correct value for this parameter
-// is machine dependent, so it's advised to set this only as high as needed. Approximate successful
-// values can widely range from 50 to 200 or more. Cannot be greater than ISR_TICKS_PER_SECOND/2.
-#define ACCELERATION_TICKS_PER_SECOND 100L 
-
 // The "Stepper Driver Interrupt" employs the Pramod Ranade inverse time algorithm to manage the
 // Bresenham line stepping algorithm. The value ISR_TICKS_PER_SECOND is the frequency(Hz) at which
 // the Ranade algorithm ticks at. Maximum step frequencies are limited by the Ranade frequency by
@@ -124,6 +116,17 @@
 // 20kHz by performing two steps per step event, rather than just one.
 #define ISR_TICKS_PER_SECOND 20000L  // Integer (Hz)
 
+// The temporal resolution of the acceleration management subsystem. Higher number give smoother
+// acceleration but may impact performance. If you run at very high feedrates (>15kHz or so) and 
+// very high accelerations, this will reduce the error between how the planner plans the velocity
+// profiles and how the stepper program actually performs them. The correct value for this parameter
+// is machine dependent, so it's advised to set this only as high as needed. Approximate successful
+// values can widely range from 50 to 200 or more. Cannot be greater than ISR_TICKS_PER_SECOND/2.
+#define ACCELERATION_TICKS_PER_SECOND 100L 
+
+// NOTE: Make sure this value is less than 256, when adjusting both dependent parameters.
+#define INTERRUPTS_PER_ACCELERATION_TICK (ISR_TICKS_PER_SECOND/ACCELERATION_TICKS_PER_SECOND)
+
 // The Ranade algorithm can use either floating point or long integers for its counters, but for 
 // integers the counter values must be scaled since these values can be very small (10^-6). This
 // multiplier value scales the floating point counter values for use in a long integer. Long integers
@@ -193,6 +196,13 @@
 // parser state depending on user preferences.
 #define N_STARTUP_LINE 2 // Integer (1-5)
 
+// Number of arc generation iterations by small angle approximation before exact arc trajectory 
+// correction. This parameter maybe decreased if there are issues with the accuracy of the arc
+// generations. In general, the default value is more than enough for the intended CNC applications
+// of grbl, and should be on the order or greater than the size of the buffer to help with the 
+// computational efficiency of generating arcs.
+#define N_ARC_CORRECTION 20 // Integer (1-255)
+
 // ---------------------------------------------------------------------------------------
 // FOR ADVANCED USERS ONLY: 
 
diff --git a/defaults.h b/defaults.h
index 30cc71d..293e934 100644
--- a/defaults.h
+++ b/defaults.h
@@ -33,7 +33,7 @@
   #define DEFAULT_Y_STEPS_PER_MM 250.0
   #define DEFAULT_Z_STEPS_PER_MM 250.0
   #define DEFAULT_STEP_PULSE_MICROSECONDS 10
-  #define DEFAULT_MM_PER_ARC_SEGMENT 0.1
+  #define DEFAULT_ARC_TOLERANCE 0.005 // mm
   #define DEFAULT_RAPID_FEEDRATE 500.0 // mm/min
   #define DEFAULT_FEEDRATE 250.0
   #define DEFAULT_ACCELERATION (10.0*60*60) // 10 mm/min^2
@@ -51,7 +51,6 @@
   #define DEFAULT_HOMING_PULLOFF 1.0 // mm
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 25 // msec (0-255)
   #define DEFAULT_DECIMAL_PLACES 3
-  #define DEFAULT_N_ARC_CORRECTION 25
 #endif
 
 #ifdef DEFAULTS_SHERLINE_5400
@@ -64,7 +63,7 @@
   #define DEFAULT_Y_STEPS_PER_MM (STEPS_PER_REV*MICROSTEPS/MM_PER_REV)
   #define DEFAULT_Z_STEPS_PER_MM (STEPS_PER_REV*MICROSTEPS/MM_PER_REV)
   #define DEFAULT_STEP_PULSE_MICROSECONDS 10
-  #define DEFAULT_MM_PER_ARC_SEGMENT 0.1
+  #define DEFAULT_ARC_TOLERANCE 0.005 // mm
   #define DEFAULT_RAPID_FEEDRATE 635.0 // mm/min (25ipm)
   #define DEFAULT_FEEDRATE 254.0 // mm/min (10ipm)
   #define DEFAULT_ACCELERATION 50.0*60*60 // 50 mm/min^2
@@ -82,7 +81,6 @@
   #define DEFAULT_HOMING_PULLOFF 1.0 // mm
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 25 // msec (0-255)
   #define DEFAULT_DECIMAL_PLACES 3
-  #define DEFAULT_N_ARC_CORRECTION 25
 #endif
 
 #ifdef DEFAULTS_SHAPEOKO
@@ -98,7 +96,7 @@
   #define DEFAULT_Y_STEPS_PER_MM (MICROSTEPS_XY*STEP_REVS_XY/MM_PER_REV_XY)
   #define DEFAULT_Z_STEPS_PER_MM (MICROSTEPS_Z*STEP_REVS_Z/MM_PER_REV_Z)
   #define DEFAULT_STEP_PULSE_MICROSECONDS 10
-  #define DEFAULT_MM_PER_ARC_SEGMENT 0.1
+  #define DEFAULT_ARC_TOLERANCE 0.005 // mm
   #define DEFAULT_RAPID_FEEDRATE 1000.0 // mm/min
   #define DEFAULT_FEEDRATE 250.0
   #define DEFAULT_ACCELERATION (15.0*60*60) // 15 mm/min^2
@@ -116,7 +114,6 @@
   #define DEFAULT_HOMING_PULLOFF 1.0 // mm
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 255 // msec (0-255)
   #define DEFAULT_DECIMAL_PLACES 3
-  #define DEFAULT_N_ARC_CORRECTION 25
 #endif
 
 #ifdef DEFAULTS_ZEN_TOOLWORKS_7x7
@@ -130,7 +127,7 @@
   #define DEFAULT_Y_STEPS_PER_MM (STEPS_PER_REV*MICROSTEPS/MM_PER_REV)
   #define DEFAULT_Z_STEPS_PER_MM (STEPS_PER_REV*MICROSTEPS/MM_PER_REV)
   #define DEFAULT_STEP_PULSE_MICROSECONDS 10
-  #define DEFAULT_MM_PER_ARC_SEGMENT 0.1
+  #define DEFAULT_ARC_TOLERANCE 0.005 // mm
   #define DEFAULT_RAPID_FEEDRATE 2500.0 // mm/min
   #define DEFAULT_FEEDRATE 1000.0 // mm/min
   #define DEFAULT_ACCELERATION 150.0*60*60 // 150 mm/min^2
@@ -148,7 +145,6 @@
   #define DEFAULT_HOMING_PULLOFF 1.0 // mm
   #define DEFAULT_STEPPER_IDLE_LOCK_TIME 25 // msec (0-255)
   #define DEFAULT_DECIMAL_PLACES 3
-  #define DEFAULT_N_ARC_CORRECTION 25
 #endif
 
 #endif
diff --git a/motion_control.c b/motion_control.c
index 2fe7872..1daa46a 100644
--- a/motion_control.c
+++ b/motion_control.c
@@ -91,8 +91,9 @@ void mc_line(float x, float y, float z, float feed_rate, uint8_t invert_feed_rat
 // offset == offset from current xyz, axis_XXX defines circle plane in tool space, axis_linear is
 // the direction of helical travel, radius == circle radius, isclockwise boolean. Used
 // for vector transformation direction.
-// The arc is approximated by generating a huge number of tiny, linear segments. The length of each 
-// segment is configured in settings.mm_per_arc_segment.  
+// The arc is approximated by generating a huge number of tiny, linear segments. The chordal tolerance
+// of each segment is configured in settings.arc_tolerance, which is defined to be the maximum normal
+// distance from segment to the circle when the end points both lie on the circle.
 void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8_t axis_1, 
   uint8_t axis_linear, float feed_rate, uint8_t invert_feed_rate, float radius, uint8_t isclockwise)
 {      
@@ -111,83 +112,90 @@ void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8
   } else {
     if (angular_travel <= 0) { angular_travel += 2*M_PI; }
   }
-  
+
+  // NOTE: Segment end points are on the arc, which can lead to the arc diameter being smaller by up to
+  // (2x) settings.arc_tolerance. For 99% of users, this is just fine. If a different arc segment fit
+  // is desired, i.e. least-squares, midpoint on arc, just change the mm_per_arc_segment calculation.
+  // Computes: mm_per_arc_segment = sqrt(4*arc_tolerance*(2*radius-arc_tolerance)),
+  //           segments = millimeters_of_travel/mm_per_arc_segment
   float millimeters_of_travel = hypot(angular_travel*radius, fabs(linear_travel));
-  if (millimeters_of_travel == 0.0) { return; }
-  uint16_t segments = floor(millimeters_of_travel/settings.mm_per_arc_segment);
-  // Multiply inverse feed_rate to compensate for the fact that this movement is approximated
-  // by a number of discrete segments. The inverse feed_rate should be correct for the sum of 
-  // all segments.
-  if (invert_feed_rate) { feed_rate *= segments; }
- 
-  float theta_per_segment = angular_travel/segments;
-  float linear_per_segment = linear_travel/segments;
+  uint16_t segments = floor(millimeters_of_travel/
+                          sqrt(4*settings.arc_tolerance*(2*radius - settings.arc_tolerance)) );
   
-  /* Vector rotation by transformation matrix: r is the original vector, r_T is the rotated vector,
-     and phi is the angle of rotation. Solution approach by Jens Geisler.
-         r_T = [cos(phi) -sin(phi);
-                sin(phi)  cos(phi] * r ;
-     
-     For arc generation, the center of the circle is the axis of rotation and the radius vector is 
-     defined from the circle center to the initial position. Each line segment is formed by successive
-     vector rotations. This requires only two cos() and sin() computations to form the rotation
-     matrix for the duration of the entire arc. Error may accumulate from numerical round-off, since
-     all double numbers are single precision on the Arduino. (True double precision will not have
-     round off issues for CNC applications.) Single precision error can accumulate to be greater than
-     tool precision in some cases. Therefore, arc path correction is implemented. 
-
-     Small angle approximation may be used to reduce computation overhead further. This approximation
-     holds for everything, but very small circles and large mm_per_arc_segment values. In other words,
-     theta_per_segment would need to be greater than 0.1 rad and N_ARC_CORRECTION would need to be large
-     to cause an appreciable drift error. N_ARC_CORRECTION~=25 is more than small enough to correct for 
-     numerical drift error. N_ARC_CORRECTION may be on the order a hundred(s) before error becomes an
-     issue for CNC machines with the single precision Arduino calculations.
-     
-     This approximation also allows mc_arc to immediately insert a line segment into the planner 
-     without the initial overhead of computing cos() or sin(). By the time the arc needs to be applied
-     a correction, the planner should have caught up to the lag caused by the initial mc_arc overhead. 
-     This is important when there are successive arc motions. 
-  */
-  // Vector rotation matrix values
-  float cos_T = 1-0.5*theta_per_segment*theta_per_segment; // Small angle approximation
-  float sin_T = theta_per_segment;
-  
-  float arc_target[3];
-  float sin_Ti;
-  float cos_Ti;
-  float r_axisi;
-  uint16_t i;
-  int8_t count = 0;
-
-  // Initialize the linear axis
-  arc_target[axis_linear] = position[axis_linear];
-
-  for (i = 1; i<segments; i++) { // Increment (segments-1)
+  if (segments) { 
+    // Multiply inverse feed_rate to compensate for the fact that this movement is approximated
+    // by a number of discrete segments. The inverse feed_rate should be correct for the sum of 
+    // all segments.
+    if (invert_feed_rate) { feed_rate *= segments; }
+   
+    float theta_per_segment = angular_travel/segments;
+    float linear_per_segment = linear_travel/segments;
     
-    if (count < settings.n_arc_correction) {
-      // Apply vector rotation matrix 
-      r_axisi = r_axis0*sin_T + r_axis1*cos_T;
-      r_axis0 = r_axis0*cos_T - r_axis1*sin_T;
-      r_axis1 = r_axisi;
-      count++;
-    } else {
-      // Arc correction to radius vector. Computed only every n_arc_correction increments.
-      // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
-      cos_Ti = cos(i*theta_per_segment);
-      sin_Ti = sin(i*theta_per_segment);
-      r_axis0 = -offset[axis_0]*cos_Ti + offset[axis_1]*sin_Ti;
-      r_axis1 = -offset[axis_0]*sin_Ti - offset[axis_1]*cos_Ti;
-      count = 0;
+    /* Vector rotation by transformation matrix: r is the original vector, r_T is the rotated vector,
+       and phi is the angle of rotation. Solution approach by Jens Geisler.
+           r_T = [cos(phi) -sin(phi);
+                  sin(phi)  cos(phi] * r ;
+       
+       For arc generation, the center of the circle is the axis of rotation and the radius vector is 
+       defined from the circle center to the initial position. Each line segment is formed by successive
+       vector rotations. Single precision values can accumulate error greater than tool precision in some
+       cases. So, exact arc path correction is implemented. This approach avoids the problem of too many very
+       expensive trig operations [sin(),cos(),tan()] which can take 100-200 usec each to compute.
+  
+       Small angle approximation may be used to reduce computation overhead further. A third-order approximation
+       (second order sin() has too much error) holds for nearly all CNC applications, except for possibly very
+       small radii (~0.5mm). In other words, theta_per_segment would need to be greater than 0.25 rad(14 deg) 
+       and N_ARC_CORRECTION would need to be large to cause an appreciable drift error (>5% of radius, for very
+       small radii this is very, very small). N_ARC_CORRECTION~=20 should be more than small enough to correct 
+       for numerical drift error.
+       
+       This approximation also allows mc_arc to immediately insert a line segment into the planner 
+       without the initial overhead of computing cos() or sin(). By the time the arc needs to be applied
+       a correction, the planner should have caught up to the lag caused by the initial mc_arc overhead. 
+       This is important when there are successive arc motions. 
+    */
+    // Computes: cos_T = 1 - theta_per_segment^2/2, sin_T = theta_per_segment - theta_per_segment^3/6) in ~52usec
+    float cos_T = 2 - theta_per_segment*theta_per_segment;
+    float sin_T = theta_per_segment*0.1666667*(cos_T + 4);
+    cos_T *= 0.5;
+
+    float arc_target[N_AXIS];
+    float sin_Ti;
+    float cos_Ti;
+    float r_axisi;
+    uint16_t i;
+    int8_t count = 0;
+  
+    // Initialize the linear axis
+    arc_target[axis_linear] = position[axis_linear];
+  
+    for (i = 1; i<segments; i++) { // Increment (segments-1)
+      
+      if (count < N_ARC_CORRECTION) {
+        // Apply vector rotation matrix. ~40 usec
+        r_axisi = r_axis0*sin_T + r_axis1*cos_T;
+        r_axis0 = r_axis0*cos_T - r_axis1*sin_T;
+        r_axis1 = r_axisi;
+        count++;
+      } else {
+        // Arc correction to radius vector. Computed only every N_ARC_CORRECTION increments. ~375 usec
+        // Compute exact location by applying transformation matrix from initial radius vector(=-offset).
+        cos_Ti = cos(i*theta_per_segment);
+        sin_Ti = sin(i*theta_per_segment);
+        r_axis0 = -offset[axis_0]*cos_Ti + offset[axis_1]*sin_Ti;
+        r_axis1 = -offset[axis_0]*sin_Ti - offset[axis_1]*cos_Ti;
+        count = 0;
+      }
+  
+      // Update arc_target location
+      arc_target[axis_0] = center_axis0 + r_axis0;
+      arc_target[axis_1] = center_axis1 + r_axis1;
+      arc_target[axis_linear] += linear_per_segment;
+      mc_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], feed_rate, invert_feed_rate);
+      
+      // Bail mid-circle on system abort. Runtime command check already performed by mc_line.
+      if (sys.abort) { return; }
     }
-
-    // Update arc_target location
-    arc_target[axis_0] = center_axis0 + r_axis0;
-    arc_target[axis_1] = center_axis1 + r_axis1;
-    arc_target[axis_linear] += linear_per_segment;
-    mc_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], feed_rate, invert_feed_rate);
-    
-    // Bail mid-circle on system abort. Runtime command check already performed by mc_line.
-    if (sys.abort) { return; }
   }
   // Ensure last segment arrives at target location.
   mc_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], feed_rate, invert_feed_rate);
diff --git a/planner.c b/planner.c
index 7a3b303..dad99c9 100644
--- a/planner.c
+++ b/planner.c
@@ -38,6 +38,7 @@ static block_t block_buffer[BLOCK_BUFFER_SIZE];  // A ring buffer for motion ins
 static volatile uint8_t block_buffer_head;       // Index of the next block to be pushed
 static volatile uint8_t block_buffer_tail;       // Index of the block to process now
 static uint8_t next_buffer_head;                 // Index of the next buffer head
+// static *block_t block_buffer_planned;
 
 // Define planner variables
 typedef struct {
@@ -190,12 +191,82 @@ static void calculate_trapezoid_for_block(block_t *block, float entry_speed_sqr,
 */
 static void planner_recalculate() 
 {     
+
+//   float entry_speed_sqr;
+//   uint8_t block_index = block_buffer_head;
+//   block_t *previous = NULL;
+//   block_t *current = NULL;
+//   block_t *next;
+//   while (block_index != block_buffer_tail) {
+//     block_index = prev_block_index( block_index );
+//     next = current;
+//     current = previous;
+//     previous = &block_buffer[block_index];
+//     
+//     if (next && current) {
+//       if (next != block_buffer_planned) {
+//         if (previous == block_buffer_tail) { block_buffer_planned = next; }
+//         else {
+//         
+//           if (current->entry_speed_sqr != current->max_entry_speed_sqr) {
+//             current->recalculate_flag = true; // Almost always changes. So force recalculate.       
+//             entry_speed_sqr = next->entry_speed_sqr + 2*current->acceleration*current->millimeters;
+//             if (entry_speed_sqr < current->max_entry_speed_sqr) {
+//               current->entry_speed_sqr = entry_speed_sqr;
+//             } else {
+//               current->entry_speed_sqr = current->max_entry_speed_sqr;
+//             }
+//           } else {  
+//             block_buffer_planned = current;
+//           }
+//         }
+//       } else { 
+//         break;
+//       }
+//     }
+//   } 
+// 
+//   block_index = block_buffer_planned;
+//   next = &block_buffer[block_index];
+//   current = prev_block_index(block_index);
+//   while (block_index != block_buffer_head) {
+// 
+//       // If the current block is an acceleration block, but it is not long enough to complete the
+//       // full speed change within the block, we need to adjust the exit speed accordingly. Entry
+//       // speeds have already been reset, maximized, and reverse planned by reverse planner.
+//       if (current->entry_speed_sqr < next->entry_speed_sqr) {
+//         // Compute block exit speed based on the current block speed and distance
+//         // Computes: v_exit^2 = v_entry^2 + 2*acceleration*distance
+//         entry_speed_sqr = current->entry_speed_sqr + 2*current->acceleration*current->millimeters;
+//         
+//         // If it's less than the stored value, update the exit speed and set recalculate flag.
+//         if (entry_speed_sqr < next->entry_speed_sqr) {
+//           next->entry_speed_sqr = entry_speed_sqr;
+//           next->recalculate_flag = true;
+//         }
+//       }
+// 
+//       // Recalculate if current block entry or exit junction speed has changed.
+//       if (current->recalculate_flag || next->recalculate_flag) {
+//         // NOTE: Entry and exit factors always > 0 by all previous logic operations.     
+//         calculate_trapezoid_for_block(current, current->entry_speed_sqr, next->entry_speed_sqr);      
+//         current->recalculate_flag = false; // Reset current only to ensure next trapezoid is computed
+//       }
+//       
+//     current = next;
+//     next = &block_buffer[block_index];
+//     block_index = next_block_index( block_index );
+//   }
+//   
+//   // Last/newest block in buffer. Exit speed is set with MINIMUM_PLANNER_SPEED. Always recalculated.
+//   calculate_trapezoid_for_block(next, next->entry_speed_sqr, MINIMUM_PLANNER_SPEED*MINIMUM_PLANNER_SPEED);
+//   next->recalculate_flag = false;
+  
   // TODO: No over-write protection exists for the executing block. For most cases this has proven to be ok, but 
   // for feed-rate overrides, something like this is essential. Place a request here to the stepper driver to
   // find out where in the planner buffer is the a safe place to begin re-planning from.
 
-//   if (block_buffer_head != block_buffer_tail) { 
-
+//   if (block_buffer_head != block_buffer_tail) {   
   float entry_speed_sqr;
 
   // Perform reverse planner pass. Skip the head(end) block since it is already initialized, and skip the
@@ -268,7 +339,6 @@ static void planner_recalculate()
   // Last/newest block in buffer. Exit speed is set with MINIMUM_PLANNER_SPEED. Always recalculated.
   calculate_trapezoid_for_block(next, next->entry_speed_sqr, MINIMUM_PLANNER_SPEED*MINIMUM_PLANNER_SPEED);
   next->recalculate_flag = false;
-  
 //   }
 }
 
@@ -276,6 +346,7 @@ void plan_reset_buffer()
 {
   block_buffer_tail = block_buffer_head;
   next_buffer_head = next_block_index(block_buffer_head);
+//   block_buffer_planned = block_buffer_head;
 }
 
 inline void plan_discard_current_block() 
diff --git a/report.c b/report.c
index a27f8c1..2953393 100644
--- a/report.c
+++ b/report.c
@@ -158,20 +158,19 @@ void report_grbl_settings() {
   printPgmString(PSTR(" (step port invert mask, int:")); print_uint8_base2(settings.invert_mask);  
   printPgmString(PSTR(")\r\n$12=")); printInteger(settings.stepper_idle_lock_time);
   printPgmString(PSTR(" (step idle delay, msec)\r\n$13=")); printFloat(settings.junction_deviation);
-  printPgmString(PSTR(" (junction deviation, mm)\r\n$14=")); printFloat(settings.mm_per_arc_segment);
-  printPgmString(PSTR(" (arc, mm/segment)\r\n$15=")); printInteger(settings.n_arc_correction);
-  printPgmString(PSTR(" (n-arc correction, int)\r\n$16=")); printInteger(settings.decimal_places);
-  printPgmString(PSTR(" (n-decimals, int)\r\n$17=")); printInteger(bit_istrue(settings.flags,BITFLAG_REPORT_INCHES));
-  printPgmString(PSTR(" (report inches, bool)\r\n$18=")); printInteger(bit_istrue(settings.flags,BITFLAG_AUTO_START));
-  printPgmString(PSTR(" (auto start, bool)\r\n$19=")); printInteger(bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE));
-  printPgmString(PSTR(" (invert step enable, bool)\r\n$20=")); printInteger(bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE));
-  printPgmString(PSTR(" (hard limits, bool)\r\n$21=")); printInteger(bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE));
-  printPgmString(PSTR(" (homing cycle, bool)\r\n$22=")); printInteger(settings.homing_dir_mask);
+  printPgmString(PSTR(" (junction deviation, mm)\r\n$14=")); printFloat(settings.arc_tolerance);
+  printPgmString(PSTR(" (arc tolerance, mm)\r\n$15=")); printInteger(settings.decimal_places);
+  printPgmString(PSTR(" (n-decimals, int)\r\n$16=")); printInteger(bit_istrue(settings.flags,BITFLAG_REPORT_INCHES));
+  printPgmString(PSTR(" (report inches, bool)\r\n$17=")); printInteger(bit_istrue(settings.flags,BITFLAG_AUTO_START));
+  printPgmString(PSTR(" (auto start, bool)\r\n$18=")); printInteger(bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE));
+  printPgmString(PSTR(" (invert step enable, bool)\r\n$19=")); printInteger(bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE));
+  printPgmString(PSTR(" (hard limits, bool)\r\n$20=")); printInteger(bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE));
+  printPgmString(PSTR(" (homing cycle, bool)\r\n$21=")); printInteger(settings.homing_dir_mask);
   printPgmString(PSTR(" (homing dir invert mask, int:")); print_uint8_base2(settings.homing_dir_mask);  
-  printPgmString(PSTR(")\r\n$23=")); printFloat(settings.homing_feed_rate);
-  printPgmString(PSTR(" (homing feed, mm/min)\r\n$24=")); printFloat(settings.homing_seek_rate);
-  printPgmString(PSTR(" (homing seek, mm/min)\r\n$25=")); printInteger(settings.homing_debounce_delay);
-  printPgmString(PSTR(" (homing debounce, msec)\r\n$26=")); printFloat(settings.homing_pulloff);
+  printPgmString(PSTR(")\r\n$22=")); printFloat(settings.homing_feed_rate);
+  printPgmString(PSTR(" (homing feed, mm/min)\r\n$23=")); printFloat(settings.homing_seek_rate);
+  printPgmString(PSTR(" (homing seek, mm/min)\r\n$24=")); printInteger(settings.homing_debounce_delay);
+  printPgmString(PSTR(" (homing debounce, msec)\r\n$25=")); printFloat(settings.homing_pulloff);
   printPgmString(PSTR(" (homing pull-off, mm)\r\n")); 
 }
 
diff --git a/settings.c b/settings.c
index 6f7d30a..a781409 100644
--- a/settings.c
+++ b/settings.c
@@ -79,7 +79,7 @@ void settings_reset(bool reset_all) {
     settings.acceleration[X_AXIS] = DEFAULT_ACCELERATION;
     settings.acceleration[Y_AXIS] = DEFAULT_ACCELERATION;
     settings.acceleration[Z_AXIS] = DEFAULT_ACCELERATION;
-    settings.mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT;
+    settings.arc_tolerance = DEFAULT_ARC_TOLERANCE;
     settings.invert_mask = DEFAULT_STEPPING_INVERT_MASK;
     settings.junction_deviation = DEFAULT_JUNCTION_DEVIATION;
   }
@@ -97,7 +97,6 @@ void settings_reset(bool reset_all) {
   settings.homing_pulloff = DEFAULT_HOMING_PULLOFF;
   settings.stepper_idle_lock_time = DEFAULT_STEPPER_IDLE_LOCK_TIME;
   settings.decimal_places = DEFAULT_DECIMAL_PLACES;
-  settings.n_arc_correction = DEFAULT_N_ARC_CORRECTION;
   write_global_settings();
 }
 
@@ -173,35 +172,34 @@ uint8_t settings_store_global_setting(int parameter, float value) {
     case 11: settings.invert_mask = trunc(value); break;
     case 12: settings.stepper_idle_lock_time = round(value); break;
     case 13: settings.junction_deviation = fabs(value); break;
-    case 14: settings.mm_per_arc_segment = value; break;
-    case 15: settings.n_arc_correction = round(value); break;
-    case 16: settings.decimal_places = round(value); break;
-    case 17:
+    case 14: settings.arc_tolerance = value; break;
+    case 15: settings.decimal_places = round(value); break;
+    case 16:
       if (value) { settings.flags |= BITFLAG_REPORT_INCHES; }
       else { settings.flags &= ~BITFLAG_REPORT_INCHES; }
       break;
-    case 18: // Reset to ensure change. Immediate re-init may cause problems.
+    case 17: // Reset to ensure change. Immediate re-init may cause problems.
       if (value) { settings.flags |= BITFLAG_AUTO_START; }
       else { settings.flags &= ~BITFLAG_AUTO_START; }
       break;
-    case 19: // Reset to ensure change. Immediate re-init may cause problems.
+    case 18: // Reset to ensure change. Immediate re-init may cause problems.
       if (value) { settings.flags |= BITFLAG_INVERT_ST_ENABLE; }
       else { settings.flags &= ~BITFLAG_INVERT_ST_ENABLE; }
       break;
-    case 20:
+    case 19:
       if (value) { settings.flags |= BITFLAG_HARD_LIMIT_ENABLE; }
       else { settings.flags &= ~BITFLAG_HARD_LIMIT_ENABLE; }
       limits_init(); // Re-init to immediately change. NOTE: Nice to have but could be problematic later.
       break;
-    case 21:
+    case 20:
       if (value) { settings.flags |= BITFLAG_HOMING_ENABLE; }
       else { settings.flags &= ~BITFLAG_HOMING_ENABLE; }
       break;
-    case 22: settings.homing_dir_mask = trunc(value); break;
-    case 23: settings.homing_feed_rate = value; break;
-    case 24: settings.homing_seek_rate = value; break;
-    case 25: settings.homing_debounce_delay = round(value); break;
-    case 26: settings.homing_pulloff = value; break;
+    case 21: settings.homing_dir_mask = trunc(value); break;
+    case 22: settings.homing_feed_rate = value; break;
+    case 23: settings.homing_seek_rate = value; break;
+    case 24: settings.homing_debounce_delay = round(value); break;
+    case 25: settings.homing_pulloff = value; break;
     default: 
       return(STATUS_INVALID_STATEMENT);
   }
diff --git a/settings.h b/settings.h
index 1b7e32e..221c4fb 100644
--- a/settings.h
+++ b/settings.h
@@ -29,7 +29,7 @@
 
 // Version of the EEPROM data. Will be used to migrate existing data from older versions of Grbl
 // when firmware is upgraded. Always stored in byte 0 of eeprom
-#define SETTINGS_VERSION 51
+#define SETTINGS_VERSION 52
 
 // Define bit flag masks for the boolean settings in settings.flag.
 #define BITFLAG_REPORT_INCHES      bit(0)
@@ -62,7 +62,7 @@ typedef struct {
   float default_feed_rate;
   float default_seek_rate;
   uint8_t invert_mask;
-  float mm_per_arc_segment;
+  float arc_tolerance;
   float acceleration[N_AXIS];
   float junction_deviation;
   uint8_t flags;  // Contains default boolean settings
@@ -73,9 +73,8 @@ typedef struct {
   float homing_pulloff;
   uint8_t stepper_idle_lock_time; // If max value 255, steppers do not disable.
   uint8_t decimal_places;
-  uint8_t n_arc_correction;
   float max_velocity[N_AXIS];
-//   float mm_soft_limit[N_AXIS];
+//  float mm_soft_limit[N_AXIS];
 //  uint8_t status_report_mask; // Mask to indicate desired report data.
 } settings_t;
 extern settings_t settings;
diff --git a/stepper.c b/stepper.c
index 4dcae3b..9d43430 100644
--- a/stepper.c
+++ b/stepper.c
@@ -30,7 +30,6 @@
 
 // Some useful constants
 #define TICKS_PER_MICROSECOND (F_CPU/1000000)
-#define INTERRUPTS_PER_ACCELERATION_TICK (ISR_TICKS_PER_SECOND/ACCELERATION_TICKS_PER_SECOND)
 #define CRUISE_RAMP 0
 #define ACCEL_RAMP 1
 #define DECEL_RAMP 2
@@ -47,7 +46,7 @@ typedef struct {
   // Used by Pramod Ranade inverse time algorithm
   int32_t delta_d;     // Ranade distance traveled per interrupt tick
   int32_t d_counter;   // Ranade distance traveled since last step event
-  uint32_t ramp_count; // Acceleration interrupt tick counter. 
+  uint8_t ramp_count; // Acceleration interrupt tick counter. 
   uint8_t ramp_type; // Ramp type variable.
   uint8_t execute_step; // Flags step execution for each interrupt.