diff --git a/index.html b/index.html
index 667dc79..71cc102 100644
--- a/index.html
+++ b/index.html
@@ -59,27 +59,35 @@
     </style>
 </head>
 <body>
-    <h1>Quicksort discussion</h1>
+    for each one: in place? adaptive? stable? swaps. comparisons. random example. best case example. worst case example.
+
 
+    <h1>Quicksort discussion</h1>
+    used by chrome
     <div class="sorter"></div>
 
 
     <h1>Mergesort discussion</h1>
+    used by firefox and safari
 
     <div class="sorter"></div>
 
 
-    <!-- <h1>Shellsort discussion</h1>
+    <h1>Shellsort discussion</h1>
+    several ways to pick gap width, but dependence on input data makes gap selection trivial
 
     <div class="sorter"></div>
 
+    <h1>Selection sort discussion</h1>
+    http://stackoverflow.com/questions/15799034/insertion-sort-vs-selection-sort
 
+<!--
     <h1>Heapsort discussion</h1>
 
     <div class="sorter"></div>
 
     <h1>Bubblesort discussion</h1>
-
+    NOTE http://stackoverflow.com/questions/17270628/insertion-sort-vs-bubble-sort-algorithms
     <div class="sorter"></div>
 
     <h1>Radixsort discussion</h1>
@@ -93,34 +101,32 @@
     <script type='text/javascript' src='js/sorter.js'></script>
     <script type='text/javascript' src='js/quicksort.js'></script>
     <script type='text/javascript' src='js/mergesort.js'></script>
+    <script type='text/javascript' src='js/insertionsort.js'></script>
+    <script type='text/javascript' src='js/shellsort.js'></script>
+    <script type='text/javascript' src='js/selectionsort.js'></script>
+    <script type='text/javascript' src='js/bubblesort.js'></script>
 
     <script type='text/javascript'>
-        // var QS = new Quicksort();
-        // QS.addInstruction();
+        var dump = function(arr) {
+            var d = [];
+            arr.forEach(function(obj) {
+                d.push(obj.value);
+            })
+
+            return d.join(',');
+        }
 
-        var MS = new Mergesort();
+        var SS = new Bubblesort();
 
-        var data = MS.generate(15);
-        var a = []
-        data.forEach(function(obj0) {
-            a.push(obj0.value);
-        })
-        console.log('DATA: ' + a.join(','));
+        var data = SS.generate(15);
+        console.log('DATA: ' + dump(data));
 
-        var shuffled = MS.shuffle(data);
-        var b = []
-        shuffled.forEach(function(obj0) {
-            b.push(obj0.value);
-        });
-        console.log('SHUFFLED: ' + b.join(','));
+        var shuffled = SS.shuffle(data);
+        console.log('SHUFFLED: ' + dump(shuffled));
 
         var ordered = Object.create(shuffled);
-        var ordered = MS.sort(ordered, 0, ordered.length - 1);
-        var c = []
-        ordered.forEach(function(obj0) {
-            c.push(obj0.value);
-        });
-        console.log('ORDERED: ' + c.join(','));
+        SS.sort(ordered, 0, ordered.length - 1);
+        console.log('ORDERED: ' + dump(ordered));
 
 
     // Wrap anonymous function to avoid polluting global namespace.
diff --git a/js/bubblesort.js b/js/bubblesort.js
new file mode 100644
index 0000000..230c34e
--- /dev/null
+++ b/js/bubblesort.js
@@ -0,0 +1,29 @@
+/**
+ *
+ */
+var Bubblesort = function() {
+    this.instructions = [];
+};
+
+Bubblesort.prototype = Object.create(Sorter.prototype);
+
+/**
+ *
+ */
+Bubblesort.prototype.sort = function(arr) {
+    var i;
+    var swapped = false;
+    var len = arr.length;
+
+    for (i = 1; i < len; i++) {
+        if (arr[i - 1].value > arr[i].value) {
+            this.swap(arr, i, i - 1);
+            swapped = true;
+            console.log(dump(arr));
+        }
+    }
+
+    if (swapped === true) {
+        this.sort(arr);
+    }
+};
diff --git a/js/insertionsort.js b/js/insertionsort.js
new file mode 100644
index 0000000..f2b5d65
--- /dev/null
+++ b/js/insertionsort.js
@@ -0,0 +1,36 @@
+/**
+ *
+ */
+var Insertionsort = function() {
+    this.instructions = [];
+};
+
+Insertionsort.prototype = Object.create(Sorter.prototype);
+
+/**
+ *
+ */
+Insertionsort.prototype.sort = function(arr) {
+    var len = arr.length;
+    var i;
+    var j;
+    var tmp;
+    var swaps = 0;
+    var comparisons = 0;
+
+    for (i = 0; i < len; i++) {
+        for (j = i; j > 0; j--) {
+            comparisons++;
+
+            if (arr[j - 1].value > arr[j].value) {
+                swaps++;
+                tmp = arr[j - 1];
+                arr[j - 1] = arr[j];
+                arr[j] = tmp;
+            }
+            else {
+                break;
+            }
+        }
+    }
+};
diff --git a/js/mergesort.js b/js/mergesort.js
index 9c98aef..e6c4447 100644
--- a/js/mergesort.js
+++ b/js/mergesort.js
@@ -25,19 +25,14 @@ Mergesort.prototype.addInstruction = function(operation, left, right, mid) {
     });
 };
 
-var dump = function(arr) {
-    var d = [];
-    arr.forEach(function(obj) {
-        d.push(obj.value);
-    })
-
-    return d.join(',');
-}
-
 /**
  *
  */
 Mergesort.prototype.sort = function(arr, start, end) {
+    if (arr.length === 0) {
+        return arr;
+    }
+
     if (start === end) {
         this.addInstruction('single', start);
         return new Array(arr[start]);
diff --git a/js/quicksort.js b/js/quicksort.js
index 2ec869d..3a062e7 100644
--- a/js/quicksort.js
+++ b/js/quicksort.js
@@ -24,6 +24,8 @@ Quicksort.prototype.addInstruction = function(operation, left, right, pivot) {
  *
  */
 Quicksort.prototype.sort = function(arr, start, end) {
+
+
     if (end - start <= 0) {
         this.addInstruction('single', start, end, null);
         return this.visualizer;
diff --git a/js/selectionsort.js b/js/selectionsort.js
new file mode 100644
index 0000000..bf4eaab
--- /dev/null
+++ b/js/selectionsort.js
@@ -0,0 +1,40 @@
+/**
+ *
+ */
+var Selectionsort = function() {
+    this.instructions = [];
+};
+
+Selectionsort.prototype = Object.create(Sorter.prototype);
+
+/**
+ *
+ */
+Selectionsort.prototype.sort = function(arr) {
+    var len = arr.length;
+    var i;
+    var j;
+    var tmp;
+    var swaps = 0;
+    var comparisons = 0;
+    var min;
+
+    for (i = 0; i < len; i++) {
+        min = i;
+        for (j = i + 1; j < len; j++) {
+            comparisons++;
+            if (arr[j].value < arr[i].value) {
+                min = j;
+            }
+        }
+
+        if (min !== i) {
+            swaps++;
+            tmp = arr[i];
+            arr[i] = arr[min];
+            arr[min] = tmp;
+        }
+    }
+
+    console.info(`swaps: ${swaps}, comparisons: ${comparisons} `);
+};
diff --git a/js/shellsort.js b/js/shellsort.js
new file mode 100644
index 0000000..d6a1137
--- /dev/null
+++ b/js/shellsort.js
@@ -0,0 +1,55 @@
+/**
+ *
+ */
+var Shellsort = function() {
+    this.instructions = [];
+};
+
+Shellsort.prototype = Object.create(Sorter.prototype);
+
+/**
+ *
+ */
+Shellsort.prototype.sort = function(arr) {
+    var len = arr.length;
+    var gap = Math.floor(len / 3);
+    var i, j;
+
+    for (i = 0; i < gap; i++) {
+        this.gapSort(arr, i, gap);
+    }
+
+    var IS = new Insertionsort();
+    IS.sort(arr);
+};
+
+/**
+ *
+ */
+Shellsort.prototype.gapSort = function(arr, start, gap) {
+    var i, j;
+    var len = arr.length;
+
+    console.log(`start ${start}, gap ${gap}`)
+
+    for (i = start; i < len; i += gap) {
+        console.log(`i: ${i}`)
+        for (j = i; j > start; j -= gap) {
+            console.log(`j: ${j}`)
+            console.log(`checking if ${arr[j - gap].value} > ${arr[j].value}`)
+
+            if (arr[j - gap].value > arr[j].value) {
+                console.log(`swapping ${arr[j - gap].value} and ${arr[j].value}`)
+                tmp = arr[j - gap];
+                arr[j - gap] = arr[j];
+                arr[j] = tmp;
+                console.log(dump(arr));
+            }
+            else {
+                break;
+            }
+        }
+    }
+
+    console.log(dump(arr));
+};
diff --git a/js/sorter.js b/js/sorter.js
index 2277632..5020681 100644
--- a/js/sorter.js
+++ b/js/sorter.js
@@ -33,6 +33,16 @@ Sorter.prototype.generate = function(n) {
     return arr;
 };
 
+/**
+ *
+ */
+Sorter.prototype.swap = function(arr, i, j) {
+    console.info(`swapping ${arr[i].value} and ${arr[j].value}`)
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+};
+
 /**
  *
  */
