diff --git a/client/app/components/word-cloud/component.js b/client/app/components/word-cloud/component.js
new file mode 100644
index 000000000..bb59df459
--- /dev/null
+++ b/client/app/components/word-cloud/component.js
@@ -0,0 +1,98 @@
+import Ember from 'ember';
+//import d3.layout.cloud from '../d3.layout.cloud.js' ;
+
+export default Ember.Component.extend({
+  //from list-widget
+      data : [],
+
+      init(){
+          this._super(...arguments);
+          //this.processData(this.get('aggregations.listWidgetData.buckets'));
+
+      },
+
+      processData (data) {
+          this.set('data', data.map((item) => {
+              return {
+                  number: item.doc_count,
+                  name: item.key,
+              };
+          }));
+      },
+
+      actions: {
+
+          transitionToFacet(parameter) {
+              let queryParams = {};
+              queryParams[this.get("item.facetDashParameter")] = parameter.name;
+              this.attrs.transitionToFacet(this.get('item.facetDash'), queryParams);
+          }
+
+      },
+
+      didRender() {
+
+        Ember.$.getScript( "d3.layout.cloud.js")
+          .done(function( script, textStatus ) {
+            console.log( textStatus );
+          })
+          .fail(function( jqxhr, settings, exception ) {
+            $( "div.log" ).text( "Triggered ajaxError handler." );
+          });
+
+
+        d3.select($("#test").get(0)).append("span")
+          .text("Hello World") ;
+
+        //word cloud
+        var fill = d3.scale.category20();
+
+        d3.layout.cloud()
+            .size([300, 300])
+            .words([
+              "Hello", "world", "normally", "you", "want", "more", "words",
+              "than", "this"].map(function(d) {
+              return {text: d, size: 10 + Math.random() * 90};
+            }))
+            .rotate(function() { return ~~(Math.random() * 2) * 90; })
+            .font("Impact")
+            .fontSize(function(d) { return d.size; })
+            .on("end", draw)
+            .start();
+
+        function draw(words) {
+          d3.select($("#wordcloud").get(0)).append("svg")
+              .attr("width", 300)
+              .attr("height", 300)
+            .append("g")
+              .attr("transform", "translate(150,150)")
+            .selectAll("text")
+              .data(words)
+            .enter().append("text")
+              .style("font-size", function(d) { return d.size + "px"; })
+              .style("font-family", "Impact")
+              .style("fill", function(d, i) { return fill(i); })
+              .attr("text-anchor", "middle")
+              .attr("transform", function(d) {
+                return "translate(" + [d.x, d.y] + ")rotate(" + d.rotate + ")";
+              })
+              .text(function(d) { return d.text; });
+        }
+
+    }
+});
+
+/*
+var data = [4, 8, 15, 16, 23, 42];
+
+var x = d3.scale.linear()
+    .domain([0, d3.max(data)])
+    .range([0, 420]);
+
+d3.select($("#wordcloud").get(0))
+  .selectAll("div")
+    .data(data)
+  .enter().append("div")
+    .style("width", function(d) { return x(d) + "px"; })
+    .text(function(d) { return d; });
+    */
diff --git a/client/app/components/word-cloud/d3.layout.cloud.js b/client/app/components/word-cloud/d3.layout.cloud.js
new file mode 100644
index 000000000..a73f5f8ea
--- /dev/null
+++ b/client/app/components/word-cloud/d3.layout.cloud.js
@@ -0,0 +1,385 @@
+// Word cloud layout by Jason Davies, http://www.jasondavies.com/word-cloud/
+// Algorithm due to Jonathan Feinberg, http://static.mrfeinberg.com/bv_ch03.pdf
+(function(exports) {
+  function cloud() {
+    var size = [256, 256],
+        text = cloudText,
+        font = cloudFont,
+        fontSize = cloudFontSize,
+        rotate = cloudRotate,
+        padding = cloudPadding,
+        spiral = archimedeanSpiral,
+        words = [],
+        timeInterval = Infinity,
+        event = d3.dispatch("word", "end"),
+        timer = null,
+        cloud = {};
+
+    cloud.start = function() {
+      var board = zeroArray((size[0] >> 5) * size[1]),
+          bounds = null,
+          n = words.length,
+          i = -1,
+          tags = [],
+          data = words.map(function(d, i) {
+        return {
+          text: text.call(this, d, i),
+          font: font.call(this, d, i),
+          rotate: rotate.call(this, d, i),
+          size: ~~fontSize.call(this, d, i),
+          padding: cloudPadding.call(this, d, i)
+        };
+      }).sort(function(a, b) { return b.size - a.size; });
+
+      if (timer) clearInterval(timer);
+      timer = setInterval(step, 0);
+      step();
+
+      return cloud;
+
+      function step() {
+        var start = +new Date,
+            d;
+        while (+new Date - start < timeInterval && ++i < n && timer) {
+          d = data[i];
+          d.x = (size[0] * (Math.random() + .5)) >> 1;
+          d.y = (size[1] * (Math.random() + .5)) >> 1;
+          cloudSprite(d, data, i);
+          if (place(board, d, bounds)) {
+            tags.push(d);
+            event.word(d);
+            if (bounds) cloudBounds(bounds, d);
+            else bounds = [{x: d.x + d.x0, y: d.y + d.y0}, {x: d.x + d.x1, y: d.y + d.y1}];
+            // Temporary hack
+            d.x -= size[0] >> 1;
+            d.y -= size[1] >> 1;
+          }
+        }
+        if (i >= n) {
+          cloud.stop();
+          event.end(tags, bounds);
+        }
+      }
+    }
+
+    cloud.stop = function() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      return cloud;
+    };
+
+    cloud.timeInterval = function(x) {
+      if (!arguments.length) return timeInterval;
+      timeInterval = x == null ? Infinity : x;
+      return cloud;
+    };
+
+    function place(board, tag, bounds) {
+      var perimeter = [{x: 0, y: 0}, {x: size[0], y: size[1]}],
+          startX = tag.x,
+          startY = tag.y,
+          maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]),
+          s = spiral(size),
+          dt = Math.random() < .5 ? 1 : -1,
+          t = -dt,
+          dxdy,
+          dx,
+          dy;
+
+      while (dxdy = s(t += dt)) {
+        dx = ~~dxdy[0];
+        dy = ~~dxdy[1];
+
+        if (Math.min(dx, dy) > maxDelta) break;
+
+        tag.x = startX + dx;
+        tag.y = startY + dy;
+
+        if (tag.x + tag.x0 < 0 || tag.y + tag.y0 < 0 ||
+            tag.x + tag.x1 > size[0] || tag.y + tag.y1 > size[1]) continue;
+        // TODO only check for collisions within current bounds.
+        if (!bounds || !cloudCollide(tag, board, size[0])) {
+          if (!bounds || collideRects(tag, bounds)) {
+            var sprite = tag.sprite,
+                w = tag.width >> 5,
+                sw = size[0] >> 5,
+                lx = tag.x - (w << 4),
+                sx = lx & 0x7f,
+                msx = 32 - sx,
+                h = tag.y1 - tag.y0,
+                x = (tag.y + tag.y0) * sw + (lx >> 5),
+                last;
+            for (var j = 0; j < h; j++) {
+              last = 0;
+              for (var i = 0; i <= w; i++) {
+                board[x + i] |= (last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);
+              }
+              x += sw;
+            }
+            delete tag.sprite;
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    cloud.words = function(x) {
+      if (!arguments.length) return words;
+      words = x;
+      return cloud;
+    };
+
+    cloud.size = function(x) {
+      if (!arguments.length) return size;
+      size = [+x[0], +x[1]];
+      return cloud;
+    };
+
+    cloud.font = function(x) {
+      if (!arguments.length) return font;
+      font = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.rotate = function(x) {
+      if (!arguments.length) return rotate;
+      rotate = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.text = function(x) {
+      if (!arguments.length) return text;
+      text = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.spiral = function(x) {
+      if (!arguments.length) return spiral;
+      spiral = spirals[x + ""] || x;
+      return cloud;
+    };
+
+    cloud.fontSize = function(x) {
+      if (!arguments.length) return fontSize;
+      fontSize = d3.functor(x);
+      return cloud;
+    };
+
+    cloud.padding = function(x) {
+      if (!arguments.length) return padding;
+      padding = d3.functor(x);
+      return cloud;
+    };
+
+    return d3.rebind(cloud, event, "on");
+  }
+
+  function cloudText(d) {
+    return d.text;
+  }
+
+  function cloudFont() {
+    return "serif";
+  }
+
+  function cloudFontSize(d) {
+    return Math.sqrt(d.value);
+  }
+
+  function cloudRotate() {
+    return (~~(Math.random() * 6) - 3) * 30;
+  }
+
+  function cloudPadding() {
+    return 1;
+  }
+
+  // Fetches a monochrome sprite bitmap for the specified text.
+  // Load in batches for speed.
+  function cloudSprite(d, data, di) {
+    if (d.sprite) return;
+    c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);
+    var x = 0,
+        y = 0,
+        maxh = 0,
+        n = data.length;
+    di--;
+    while (++di < n) {
+      d = data[di];
+      c.save();
+      c.font = ~~((d.size + 1) / ratio) + "px " + d.font;
+      var w = c.measureText(d.text + "m").width * ratio,
+          h = d.size << 1;
+      if (d.rotate) {
+        var sr = Math.sin(d.rotate * cloudRadians),
+            cr = Math.cos(d.rotate * cloudRadians),
+            wcr = w * cr,
+            wsr = w * sr,
+            hcr = h * cr,
+            hsr = h * sr;
+        w = (Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f) >> 5 << 5;
+        h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));
+      } else {
+        w = (w + 0x1f) >> 5 << 5;
+      }
+      if (h > maxh) maxh = h;
+      if (x + w >= (cw << 5)) {
+        x = 0;
+        y += maxh;
+        maxh = 0;
+      }
+      if (y + h >= ch) break;
+      c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);
+      if (d.rotate) c.rotate(d.rotate * cloudRadians);
+      c.fillText(d.text, 0, 0);
+      c.restore();
+      d.width = w;
+      d.height = h;
+      d.xoff = x;
+      d.yoff = y;
+      d.x1 = w >> 1;
+      d.y1 = h >> 1;
+      d.x0 = -d.x1;
+      d.y0 = -d.y1;
+      x += w;
+    }
+    var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,
+        sprite = [];
+    while (--di >= 0) {
+      d = data[di];
+      var w = d.width,
+          w32 = w >> 5,
+          h = d.y1 - d.y0,
+          p = d.padding;
+      // Zero the buffer
+      for (var i = 0; i < h * w32; i++) sprite[i] = 0;
+      x = d.xoff;
+      if (x == null) return;
+      y = d.yoff;
+      var seen = 0,
+          seenRow = -1;
+      for (var j = 0; j < h; j++) {
+        for (var i = 0; i < w; i++) {
+          var k = w32 * j + (i >> 5),
+              m = pixels[((y + j) * (cw << 5) + (x + i)) << 2] ? 1 << (31 - (i % 32)) : 0;
+          if (p) {
+            if (j) sprite[k - w32] |= m;
+            if (j < w - 1) sprite[k + w32] |= m;
+            m |= (m << 1) | (m >> 1);
+          }
+          sprite[k] |= m;
+          seen |= m;
+        }
+        if (seen) seenRow = j;
+        else {
+          d.y0++;
+          h--;
+          j--;
+          y++;
+        }
+      }
+      d.y1 = d.y0 + seenRow;
+      d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32);
+    }
+  }
+
+  // Use mask-based collision detection.
+  function cloudCollide(tag, board, sw) {
+    sw >>= 5;
+    var sprite = tag.sprite,
+        w = tag.width >> 5,
+        lx = tag.x - (w << 4),
+        sx = lx & 0x7f,
+        msx = 32 - sx,
+        h = tag.y1 - tag.y0,
+        x = (tag.y + tag.y0) * sw + (lx >> 5),
+        last;
+    for (var j = 0; j < h; j++) {
+      last = 0;
+      for (var i = 0; i <= w; i++) {
+        if (((last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0))
+            & board[x + i]) return true;
+      }
+      x += sw;
+    }
+    return false;
+  }
+
+  function cloudBounds(bounds, d) {
+    var b0 = bounds[0],
+        b1 = bounds[1];
+    if (d.x + d.x0 < b0.x) b0.x = d.x + d.x0;
+    if (d.y + d.y0 < b0.y) b0.y = d.y + d.y0;
+    if (d.x + d.x1 > b1.x) b1.x = d.x + d.x1;
+    if (d.y + d.y1 > b1.y) b1.y = d.y + d.y1;
+  }
+
+  function collideRects(a, b) {
+    return a.x + a.x1 > b[0].x && a.x + a.x0 < b[1].x && a.y + a.y1 > b[0].y && a.y + a.y0 < b[1].y;
+  }
+
+  function archimedeanSpiral(size) {
+    var e = size[0] / size[1];
+    return function(t) {
+      return [e * (t *= .1) * Math.cos(t), t * Math.sin(t)];
+    };
+  }
+
+  function rectangularSpiral(size) {
+    var dy = 4,
+        dx = dy * size[0] / size[1],
+        x = 0,
+        y = 0;
+    return function(t) {
+      var sign = t < 0 ? -1 : 1;
+      // See triangular numbers: T_n = n * (n + 1) / 2.
+      switch ((Math.sqrt(1 + 4 * sign * t) - sign) & 3) {
+        case 0:  x += dx; break;
+        case 1:  y += dy; break;
+        case 2:  x -= dx; break;
+        default: y -= dy; break;
+      }
+      return [x, y];
+    };
+  }
+
+  // TODO reuse arrays?
+  function zeroArray(n) {
+    var a = [],
+        i = -1;
+    while (++i < n) a[i] = 0;
+    return a;
+  }
+
+  var cloudRadians = Math.PI / 180,
+      cw = 1 << 11 >> 5,
+      ch = 1 << 11,
+      canvas,
+      ratio = 1;
+
+  if (typeof document !== "undefined") {
+    canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = 1;
+    ratio = Math.sqrt(canvas.getContext("2d").getImageData(0, 0, 1, 1).data.length >> 2);
+    canvas.width = (cw << 5) / ratio;
+    canvas.height = ch / ratio;
+  } else {
+    // node-canvas support
+    var Canvas = require("canvas");
+    canvas = new Canvas(cw << 5, ch);
+  }
+
+  var c = canvas.getContext("2d"),
+      spirals = {
+        archimedean: archimedeanSpiral,
+        rectangular: rectangularSpiral
+      };
+  c.fillStyle = "red";
+  c.textAlign = "center";
+
+  exports.cloud = cloud;
+})(typeof exports === "undefined" ? d3.layout || (d3.layout = {}) : exports);
diff --git a/client/app/components/word-cloud/template.hbs b/client/app/components/word-cloud/template.hbs
new file mode 100644
index 000000000..ec93513f0
--- /dev/null
+++ b/client/app/components/word-cloud/template.hbs
@@ -0,0 +1,18 @@
+<style>
+
+.chart div {
+  font: 10px sans-serif;
+  background-color: steelblue;
+  text-align: right;
+  padding: 3px;
+  margin: 1px;
+  color: white;
+
+  .x.axis path {
+    display: none;
+
+}
+
+</style>
+<div class="chart" id="test"></div>
+<div class="chart" id="wordcloud"></div>
diff --git a/client/app/index.html b/client/app/index.html
index ac0baeb16..de4ad616c 100644
--- a/client/app/index.html
+++ b/client/app/index.html
@@ -19,6 +19,7 @@
 
     <script src="{{rootURL}}assets/vendor.js"></script>
     <script src="{{rootURL}}assets/analytics-dashboard.js"></script>
+    <script src="https://d3js.org/d3.v4.min.js"></script>
 
     {{content-for "body-footer"}}
   </body>
diff --git a/client/app/routes/dashboards/dashboard.js b/client/app/routes/dashboards/dashboard.js
index bf16b8c49..79d70fce9 100644
--- a/client/app/routes/dashboards/dashboard.js
+++ b/client/app/routes/dashboards/dashboard.js
@@ -288,6 +288,47 @@ export default Ember.Route.extend({
                     },
                 ]
             },
+
+//word cloud test section
+
+            wordcloud: {
+                dasboardName: 'Word Cloud Dashboard',
+                query: 'UC San Diego',
+                widgets: [
+                    {
+                      chartType: 'topContributors',
+                      widgetType: 'word-cloud',
+                      name: 'Top Tags',
+                      width: 4,
+                      post_body : {
+                          query: {
+                              bool: {
+                                  must: {
+                                      query_string: {query: query}
+                                  }
+                              }
+                          },
+                          from: 0,
+                          aggregations: {
+                              listWidgetData : {
+                                  terms : {
+                                      field: 'tags',
+                                      size: 10
+                                  }
+                              }
+                          }
+                      },
+                      postBodyParams: [
+                          {
+                              parameterName: "query",
+                              parameterPath: ["query", "bool", "must", "query_string", "query"]
+                          }
+                      ],
+                  }]
+            },
+
+//end word cloud test section
+
             institution: {
                 dasboardName: 'Institution Overview Dashboard',
                 widgets: [
@@ -879,6 +920,7 @@ export default Ember.Route.extend({
 
                     nested_object[parameter_key] = parameter_value;
 
+                    return //??
                 });
             }
 
diff --git a/client/app/styles/app.css b/client/app/styles/app.css
index 52404afff..d2d0aac9d 100644
--- a/client/app/styles/app.css
+++ b/client/app/styles/app.css
@@ -401,6 +401,7 @@ nav.navbar {
     font-size: 16px;
     color: #2a7ec1;
 }
+<<<<<<< Updated upstream
 .query-widget {
     color: #fff;
     background-color: rgba(0,0,0,0.65);
@@ -463,4 +464,31 @@ nav.navbar {
     -moz-box-shadow: 0px 10px 25px -2px rgba(0,0,0,0.3);
     box-shadow: 0px 10px 25px -2px rgba(0,0,0,0.3);
 
+=======
+
+
+
+.word-cloud-widget {
+    padding-bottom: 20px;
+}
+.word-cloud-widget-item {
+    padding: 4px 10px;
+    border-bottom: 1px solid #ddd;
+    border-radius: 2px;
+}
+.word-cloud-widget-item{
+    display: block;
+    cursor: pointer;
+}
+.word-cloud-widget-item:hover {
+    background: #e3ecf3;
+}
+.word-cloud-widget .item-number {
+    font-size: 18px;
+    color: #F44336;
+}
+.word-cloud-widget .item-name {
+    font-size: 16px;
+    color: #2a7ec1;
+>>>>>>> Stashed changes
 }
diff --git a/client/tests/integration/components/word-cloud-test.js b/client/tests/integration/components/word-cloud-test.js
new file mode 100644
index 000000000..2b69b0731
--- /dev/null
+++ b/client/tests/integration/components/word-cloud-test.js
@@ -0,0 +1,24 @@
+import { moduleForComponent, test } from 'ember-qunit';
+import hbs from 'htmlbars-inline-precompile';
+
+moduleForComponent('word-cloud', 'Integration | Component | word cloud', {
+  integration: true
+});
+
+test('it renders', function(assert) {
+  // Set any properties with this.set('myProperty', 'value');
+  // Handle any actions with this.on('myAction', function(val) { ... });
+
+  this.render(hbs`{{word-cloud}}`);
+
+  assert.equal(this.$().text().trim(), '');
+
+  // Template block usage:
+  this.render(hbs`
+    {{#word-cloud}}
+      template block text
+    {{/word-cloud}}
+  `);
+
+  assert.equal(this.$().text().trim(), 'template block text');
+});
diff --git a/client/tests/integration/components/word-cloud/component-test.js b/client/tests/integration/components/word-cloud/component-test.js
new file mode 100644
index 000000000..2b69b0731
--- /dev/null
+++ b/client/tests/integration/components/word-cloud/component-test.js
@@ -0,0 +1,24 @@
+import { moduleForComponent, test } from 'ember-qunit';
+import hbs from 'htmlbars-inline-precompile';
+
+moduleForComponent('word-cloud', 'Integration | Component | word cloud', {
+  integration: true
+});
+
+test('it renders', function(assert) {
+  // Set any properties with this.set('myProperty', 'value');
+  // Handle any actions with this.on('myAction', function(val) { ... });
+
+  this.render(hbs`{{word-cloud}}`);
+
+  assert.equal(this.$().text().trim(), '');
+
+  // Template block usage:
+  this.render(hbs`
+    {{#word-cloud}}
+      template block text
+    {{/word-cloud}}
+  `);
+
+  assert.equal(this.$().text().trim(), 'template block text');
+});