diff --git a/spec/runner.html b/spec/runner.html
index 7ce2e7f..8f71893 100644
--- a/spec/runner.html
+++ b/spec/runner.html
@@ -29,6 +29,7 @@
   <script type="text/javascript" src="../src/WaitsForBlock.js"></script>
 
   <script type="text/javascript" src="../src/html/TrivialReporter.js"></script>
+  <script type="text/javascript" src="../src/console/TrivialConsoleReporter.js"></script>
 
 
 
@@ -50,6 +51,7 @@
   <script type="text/javascript" src="suites/SpySpec.js"></script>
   <script type="text/javascript" src="suites/SuiteSpec.js"></script>
   <script type="text/javascript" src="suites/TrivialReporterSpec.js"></script>
+  <script type="text/javascript" src="suites/TrivialConsoleReporterSpec.js"></script>
   <script type="text/javascript" src="suites/WaitsForBlockSpec.js"></script>
 
 
diff --git a/spec/suites/TrivialConsoleReporterSpec.js b/spec/suites/TrivialConsoleReporterSpec.js
new file mode 100644
index 0000000..c1ada66
--- /dev/null
+++ b/spec/suites/TrivialConsoleReporterSpec.js
@@ -0,0 +1,429 @@
+describe("TrivialConsoleReporter", function() {
+  
+
+  //keep these literal.  otherwise the test loses value as a test.
+  function green(str)  { return '\033[32m' + str + '\033[0m'; }
+  function red(str)    { return '\033[31m' + str + '\033[0m'; }
+  function yellow(str) { return '\033[33m' + str + '\033[0m'; }
+  
+  function prefixGreen(str)  { return '\033[32m' + str; }
+  function prefixRed(str)    { return '\033[31m' + str; }
+  
+  var newline = "\n";
+  
+  var passingSpec = { results: function(){ return {passed: function(){return true;}}; } },
+      failingSpec = { results: function(){ return {passed: function(){return false;}}; } },
+      skippedSpec = { results: function(){ return {skipped: true}; } },
+      passingRun =  { results: function(){ return {failedCount: 0, items_: [null, null, null]}; } },
+      failingRun =  { results: function(){ return {failedCount: 7, items_: [null, null, null]}; } };
+  
+  function repeatedlyInvoke(f, times) { for(var i=0; i<times; i++) f(times+1); }
+  
+  function repeat(thing, times) {
+    var arr = [];
+    for(var i=0; i<times; i++) arr.push(thing);
+    return arr;
+  }
+  
+  var fiftyRedFs = repeat(red("F"), 50).join(""),
+      fiftyGreenDots = repeat(green("."), 50).join("");
+  
+  function simulateRun(reporter, specResults, suiteResults, finalRunner, startTime, endTime) {
+    reporter.reportRunnerStarting();
+    for(var i=0; i<specResults.length; i++) reporter.reportSpecResults(specResults[i]);
+    for(i=0; i<suiteResults.length; i++) reporter.reportSuiteResults(suiteResults[i]);
+    reporter.runnerStartTime = startTime;
+    reporter.now = function(){return endTime;};
+    reporter.reportRunnerResults(finalRunner);
+  }
+  
+  beforeEach(function() {
+    this.out = (function(){
+      var output = "";
+      return {
+        print:function(str) {output += str;},
+        getOutput:function(){return output;},
+        clear: function(){output = "";}
+      };
+    })();
+
+    this.done = false
+    var self = this
+    this.reporter = new jasmine.TrivialConsoleReporter(this.out.print, function(runner){
+      self.done = true
+    });
+  });
+  
+  
+  describe('Integration', function(){
+    it("prints the proper output under a pass scenario.  small numbers.", function(){
+      simulateRun(this.reporter,
+                  repeat(passingSpec, 3),
+                  [],
+                  { 
+                    results:function(){
+                      return {
+                        items_: [null, null, null], 
+                        totalCount: 7, 
+                        failedCount: 0
+                      };
+                    }
+                  },
+                  1000,
+                  1777);
+                  
+      expect(this.out.getOutput()).toEqual(
+        [
+         "Started",
+         green(".") + green(".") + green("."),
+         "",
+         "Finished in 0.777 seconds",
+         green("3 specs, 7 assertions, 0 failures"),
+         ""
+        ].join("\n") + "\n"
+      );      
+    });
+
+    it("prints the proper output under a pass scenario.  large numbers.", function(){
+      simulateRun(this.reporter,
+                  repeat(passingSpec, 57),
+                  [],
+                  { 
+                    results:function(){
+                      return {
+                        items_: [null, null, null], 
+                        totalCount: 7, 
+                        failedCount: 0
+                      };
+                    }
+                  },
+                  1000,
+                  1777);
+                       
+      expect(this.out.getOutput()).toEqual(
+        [
+         "Started",
+         
+         green(".") + green(".") + green(".") + green(".") + green(".") + //50 green dots
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + 
+         green(".") + green(".") + green(".") + green(".") + green(".") + newline +
+         
+         green(".") + green(".") + green(".") + green(".") + green(".") + //7 green dots
+         green(".") + green("."),
+         
+         "",
+         "Finished in 0.777 seconds",
+         green("3 specs, 7 assertions, 0 failures"),
+         ""
+        ].join("\n") + "\n"
+      );      
+    });
+    
+    
+    it("prints the proper output under a failure scenario.", function(){
+      simulateRun(this.reporter,
+                  [failingSpec, passingSpec, failingSpec],
+                  [{description:"The oven", 
+                    results:function(){
+                      return {
+                        items_:[
+                          {failedCount:2, 
+                           description:"heats up",
+                           items_:[
+                             {trace:{stack:"stack trace one\n  second line"}},
+                             {trace:{stack:"stack trace two"}}
+                           ]}
+                        ]
+                      };
+                    }},
+                    {description:"The washing machine", 
+                     results:function(){
+                       return {
+                         items_:[
+                           {failedCount:2, 
+                            description:"washes clothes",
+                            items_:[
+                              {trace:{stack:"stack trace one"}}
+                            ]}
+                         ]
+                       };
+                    }}
+                  ],
+                  { 
+                    results:function(){
+                      return {
+                        items_: [null, null, null], 
+                        totalCount: 7, 
+                        failedCount: 2
+                      };
+                    }
+                  },
+                  1000,
+                  1777);
+
+      expect(this.out.getOutput()).toEqual(
+        [
+         "Started",
+         red("F") + green(".") + red("F"),
+         "",
+         "The oven heats up",
+         "  stack trace one",
+         "    second line",
+         "  stack trace two",
+         "",
+         "The washing machine washes clothes",
+         "  stack trace one",
+         "",
+         "Finished in 0.777 seconds",
+         red("3 specs, 7 assertions, 2 failures"),
+         ""
+        ].join("\n") + "\n"
+      );      
+    });
+    
+    
+  });
+  
+  describe('A Test Run', function(){
+
+    describe('Starts', function(){
+      it("prints Started", function(){
+        this.reporter.reportRunnerStarting();
+
+        expect(this.out.getOutput()).toEqual(
+          "Started" + newline
+        );
+      });
+    });
+    
+    describe('A spec runs', function(){
+      it("prints a green dot if the spec passes", function(){
+        this.reporter.reportSpecResults(passingSpec);
+
+        expect(this.out.getOutput()).toEqual(
+          green(".")
+        );
+      });
+    
+      it("prints a red dot if the spec fails", function(){
+        this.reporter.reportSpecResults(failingSpec);
+
+        expect(this.out.getOutput()).toEqual(
+          red("F")
+        );
+      });
+
+      it("prints a yellow star if the spec was skipped", function(){
+        this.reporter.reportSpecResults(skippedSpec);
+
+        expect(this.out.getOutput()).toEqual(
+          yellow("*")
+        );
+      });
+    });
+    
+    
+    describe('Many specs run', function(){
+      it("starts a new line every 50 specs", function(){
+        var self = this;
+        repeatedlyInvoke(function(){self.reporter.reportSpecResults(failingSpec);}, 49);
+
+        expect(this.out.getOutput()).
+          toEqual(repeat(red("F"), 49).join(""));
+        
+        repeatedlyInvoke(function(){self.reporter.reportSpecResults(failingSpec);}, 3);
+        
+        expect(this.out.getOutput()).
+          toEqual(fiftyRedFs + newline + 
+                  red("F") + red("F"));
+          
+        repeatedlyInvoke(function(){self.reporter.reportSpecResults(failingSpec);}, 48);
+        repeatedlyInvoke(function(){self.reporter.reportSpecResults(passingSpec);}, 2);
+        
+        expect(this.out.getOutput()).
+          toEqual(fiftyRedFs + newline + 
+                  fiftyRedFs + newline + 
+                  green(".") + green("."));
+      });      
+    });
+    
+    describe('A suite runs', function(){
+      it("remembers suite results", function(){
+        var emptyResults = function(){return {items_:[]};};
+        this.reporter.reportSuiteResults({description:"Oven", results:emptyResults});
+        this.reporter.reportSuiteResults({description:"Mixer", results:emptyResults});
+        
+        var self = this;
+        var descriptions = [];
+        for(var i=0; i<self.reporter.suiteResults.length; i++) 
+          descriptions.push(self.reporter.suiteResults[i].description);
+        
+        expect(descriptions).toEqual(["Oven", "Mixer"]);
+      });      
+
+      it("creates a description out of the current suite and any parent suites", function(){
+        var emptyResults = function(){return {items_:[]};};
+        var grandparentSuite = {description:"My house", results:emptyResults};
+        var parentSuite = {description:"kitchen", parentSuite: grandparentSuite, results:emptyResults};
+        this.reporter.reportSuiteResults({description:"oven", parentSuite: parentSuite, results:emptyResults});
+        
+        expect(this.reporter.suiteResults[0].description).toEqual("My house kitchen oven");
+      });
+
+      it("gathers failing spec results from the suite.  the spec must have a description.", function(){
+        this.reporter.reportSuiteResults({description:"Oven", 
+                                          results:function(){
+                                            return {
+                                              items_:[
+                                                {failedCount:0, description:"specOne"},
+                                                {failedCount:99, description:"specTwo"},
+                                                {failedCount:0, description:"specThree"},
+                                                {failedCount:88, description:"specFour"},
+                                                {failedCount:3}
+                                              ]
+                                            };
+                                          }});
+
+        expect(this.reporter.suiteResults[0].failedSpecResults).
+          toEqual([
+            {failedCount:99, description:"specTwo"},
+            {failedCount:88, description:"specFour"}
+          ]);
+      });      
+      
+    });
+    
+    describe('Finishes', function(){
+
+      describe('Spec failure information', function(){
+
+        it("prints suite and spec descriptions together as a sentence", function(){
+          this.reporter.suiteResults = [
+            {description:"The oven", failedSpecResults:[
+                                       {description:"heats up", items_:[]},
+                                       {description:"cleans itself", items_:[]}
+                                     ]},
+            {description:"The mixer", failedSpecResults:[
+                                        {description:"blends things together", items_:[]}
+                                      ]}
+          ];
+          
+          this.reporter.reportRunnerResults(failingRun);
+
+          expect(this.out.getOutput()).toContain("The oven heats up");
+          expect(this.out.getOutput()).toContain("The oven cleans itself");
+          expect(this.out.getOutput()).toContain("The mixer blends things together");
+        });
+
+        it("prints stack trace of spec failure", function(){
+          this.reporter.suiteResults = [
+            {description:"The oven", failedSpecResults:[
+                                       {description:"heats up",
+                                        items_:[
+                                          {trace:{stack:"stack trace one"}},
+                                          {trace:{stack:"stack trace two"}}
+                                        ]}
+                                     ]}
+          ];
+          
+          this.reporter.reportRunnerResults(failingRun);
+
+          expect(this.out.getOutput()).toContain("The oven heats up");
+          expect(this.out.getOutput()).toContain("stack trace one");
+          expect(this.out.getOutput()).toContain("stack trace two");
+        });
+
+      });
+
+      describe('Finished line', function(){
+      
+        it("prints the elapsed time in the summary message", function(){
+          this.reporter.now = function(){return 1000;};
+          this.reporter.reportRunnerStarting();
+          this.reporter.now = function(){return 1777;};
+          this.reporter.reportRunnerResults(passingRun);
+          expect(this.out.getOutput()).toContain("0.777 seconds");
+        });
+      
+        it("prints round time numbers correctly", function(){
+          var self = this;
+          function run(startTime, endTime) {
+            self.out.clear();
+            self.reporter.runnerStartTime = startTime;
+            self.reporter.now = function(){return endTime;};
+            self.reporter.reportRunnerResults(passingRun);          
+          }
+        
+          run(1000, 11000);
+          expect(this.out.getOutput()).toContain("10 seconds");
+        
+          run(1000, 2000);
+          expect(this.out.getOutput()).toContain("1 seconds");
+        
+          run(1000, 1100);
+          expect(this.out.getOutput()).toContain("0.1 seconds");
+
+          run(1000, 1010);
+          expect(this.out.getOutput()).toContain("0.01 seconds");
+
+          run(1000, 1001);        
+          expect(this.out.getOutput()).toContain("0.001 seconds");
+        });
+
+        it("prints the full finished message", function(){
+          this.reporter.now = function(){return 1000;};
+          this.reporter.reportRunnerStarting();
+          this.reporter.now = function(){return 1777;};
+          this.reporter.reportRunnerResults(failingRun);
+          expect(this.out.getOutput()).toContain("Finished in 0.777 seconds");
+        });
+      });
+
+      describe("specs/assertions/failures summary", function(){
+        it("prints statistics in green if there were no failures", function() {
+          this.reporter.reportRunnerResults({ 
+            results:function(){return {items_: [null, null, null], totalCount: 7, failedCount: 0};}
+          });
+          expect(this.out.getOutput()).
+            toContain("3 specs, 7 assertions, 0 failures");
+        });
+
+        it("prints statistics in red if there was a failure", function() {
+          this.reporter.reportRunnerResults({ 
+            results:function(){return {items_: [null, null, null], totalCount: 7, failedCount: 3};}
+          });
+          expect(this.out.getOutput()).
+            toContain("3 specs, 7 assertions, 3 failures");
+        });
+
+        it("handles pluralization with 1's ones appropriately", function() {
+          this.reporter.reportRunnerResults({ 
+            results:function(){return {items_: [null], totalCount: 1, failedCount: 1};}
+          });
+          expect(this.out.getOutput()).
+            toContain("1 spec, 1 assertion, 1 failure");
+        });
+      });
+      
+      describe("done callback", function(){
+        it("calls back when done", function() {
+          expect(this.done).toBeFalsy();
+          this.reporter.reportRunnerResults({ 
+            results:function(){return {items_: [null, null, null], totalCount: 7, failedCount: 0};}
+          });
+          expect(this.done).toBeTruthy();
+        });        
+      });
+      
+    });
+
+  });
+  
+});
\ No newline at end of file
diff --git a/src/console/TrivialConsoleReporter.js b/src/console/TrivialConsoleReporter.js
new file mode 100644
index 0000000..0d35606
--- /dev/null
+++ b/src/console/TrivialConsoleReporter.js
@@ -0,0 +1,144 @@
+jasmine.TrivialConsoleReporter = function(print, doneCallback) {
+  //inspired by mhevery's jasmine-node reporter
+  //https://github.com/mhevery/jasmine-node
+  
+  doneCallback = doneCallback || function(){};
+  
+  var defaultColumnsPerLine = 50,
+      ansi = { green: '\033[32m', red: '\033[31m', yellow: '\033[33m', none: '\033[0m' },
+      language = { spec:"spec", assertion:"assertion", failure:"failure" };
+  
+  function coloredStr(color, str) { return ansi[color] + str + ansi.none; }
+  
+  function greenStr(str)  { return coloredStr("green", str); }
+  function redStr(str)    { return coloredStr("red", str); }
+  function yellowStr(str) { return coloredStr("yellow", str); }
+  
+  function newline()         { print("\n"); }
+  function started()         { print("Started"); 
+                               newline(); }
+
+  function greenDot()        { print(greenStr(".")); }
+  function redF()            { print(redStr("F")); }
+  function yellowStar()      { print(yellowStr("*")); }
+  
+  function plural(str, count) { return count == 1 ? str : str + "s"; }
+  
+  function repeat(thing, times) { var arr = [];
+                                  for(var i=0; i<times; i++) arr.push(thing);
+                                  return arr;
+                                }
+  
+  function indent(str, spaces) { var lines = str.split("\n");
+                                 var newArr = [];
+                                 for(var i=0; i<lines.length; i++) {
+                                   newArr.push(repeat(" ", spaces).join("") + lines[i]);
+                                 }
+                                 return newArr.join("\n");
+                               }
+  
+  function specFailureDetails(suiteDescription, specDescription, stackTraces)  { 
+                               newline(); 
+                               print(suiteDescription + " " + specDescription); 
+                               newline();
+                               for(var i=0; i<stackTraces.length; i++) {
+                                 print(indent(stackTraces[i], 2));
+                                 newline();
+                               }
+                             }
+  function finished(elapsed)  { newline(); 
+                                print("Finished in " + elapsed/1000 + " seconds"); }
+  function summary(colorF, specs, assertions, failed)  { newline(); 
+                                                         print(colorF(specs + " " + plural(language.spec, specs) + ", " +
+                                                                      assertions + " " + plural(language.assertion, assertions) + ", " +
+                                                                      failed + " " + plural(language.failure, failed))); 
+                                                         newline();
+                                                         newline(); }
+  function greenSummary(specs, assertions, failed){ summary(greenStr, specs, assertions, failed); }
+  function redSummary(specs, assertions, failed){ summary(redStr, specs, assertions, failed); }
+  
+  
+  
+  
+  function lineEnder(columnsPerLine) {
+    var columnsSoFar = 0;
+    return function() {
+      columnsSoFar += 1;
+      if (columnsSoFar == columnsPerLine) {
+        newline();
+        columnsSoFar = 0;
+      }
+    };
+  }
+
+  function fullSuiteDescription(suite) {
+    var fullDescription = suite.description;
+    if (suite.parentSuite) fullDescription = fullSuiteDescription(suite.parentSuite) + " " + fullDescription ;
+    return fullDescription;
+  }
+  
+  var startNewLineIfNecessary = lineEnder(defaultColumnsPerLine);
+  
+  this.now = function() { return new Date().getTime(); };
+  
+  this.reportRunnerStarting = function() {
+    this.runnerStartTime = this.now();
+    started();
+  };
+  
+  this.reportSpecStarting = function() { /* do nothing */ };
+  
+  this.reportSpecResults = function(spec) {
+    var results = spec.results();
+    if (results.skipped) {
+      yellowStar();
+    } else if (results.passed()) {
+      greenDot();
+    } else {
+      redF();
+    } 
+    startNewLineIfNecessary();   
+  };
+  
+  this.suiteResults = [];
+  
+  this.reportSuiteResults = function(suite) {
+    var suiteResult = {
+      description: fullSuiteDescription(suite),
+      failedSpecResults: []
+    };
+    
+    suite.results().items_.forEach(function(spec){
+      if (spec.failedCount > 0 && spec.description) suiteResult.failedSpecResults.push(spec);
+    });
+    
+    this.suiteResults.push(suiteResult);
+  };
+  
+  function eachSpecFailure(suiteResults, callback) {
+    for(var i=0; i<suiteResults.length; i++) {
+      var suiteResult = suiteResults[i];
+      for(var j=0; j<suiteResult.failedSpecResults.length; j++) {
+        var failedSpecResult = suiteResult.failedSpecResults[j];
+        var stackTraces = [];
+        for(var k=0; k<failedSpecResult.items_.length; k++) stackTraces.push(failedSpecResult.items_[k].trace.stack);
+        callback(suiteResult.description, failedSpecResult.description, stackTraces);
+      }
+    }
+  }
+  
+  this.reportRunnerResults = function(runner) {
+    newline();
+    
+    eachSpecFailure(this.suiteResults, function(suiteDescription, specDescription, stackTraces) {
+      specFailureDetails(suiteDescription, specDescription, stackTraces);
+    });
+    
+    finished(this.now() - this.runnerStartTime);
+    
+    var results = runner.results();
+    var summaryFunction = results.failedCount === 0 ? greenSummary : redSummary;
+    summaryFunction(results.items_.length, results.totalCount, results.failedCount);
+    doneCallback(runner);
+  };
+};
\ No newline at end of file