diff --git a/.travis.yml b/.travis.yml
index 4a51cdf..0ba9847 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,6 +2,7 @@ language: php
 
 dist: trusty
 
+## Cache composer bits
 cache:
   directories:
     - $HOME/.composer/cache/files
diff --git a/Makefile b/Makefile
index 49f933e..accc86f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 SHELL = /bin/sh
 
-DOCKER ?= $(shell which docker)
+DOCKER = $(shell which docker)
 PHP_VER := 7.2
 IMAGE := graze/php-alpine:${PHP_VER}-test
 VOLUME := /srv
@@ -9,8 +9,9 @@ DOCKER_RUN := ${DOCKER_RUN_BASE} ${IMAGE}
 
 PREFER_LOWEST ?=
 
-.PHONY: install composer clean help run
-.PHONY: test lint lint-fix test-unit test-integration test-matrix test-coverage test-coverage-html test-coverage-clover
+.PHONY: build build-update composer-% clean help run
+.PHONY: lint lint-fix
+.PHONY: test test-unit test-integration test-lowest test-matrix test-coverage test-coverage-html test-coverage-clover
 
 .SILENT: help
 
@@ -36,7 +37,7 @@ composer-%: ## Run a composer command, `make "composer-<command> [...]"`.
 
 # Testing
 
-test: ## Run the unit testsuites.
+test: ## Run the unit and integration testsuites.
 test: lint test-unit
 
 lint: ## Run phpcs against the code.
@@ -46,7 +47,11 @@ lint-fix: ## Run phpcsf and fix possible lint errors.
 	${DOCKER_RUN} vendor/bin/phpcbf -p src/ tests/
 
 test-unit: ## Run the unit testsuite.
-	${DOCKER_RUN} vendor/bin/phpunit --colors=always --testsuite unit
+	${DOCKER_RUN} vendor/bin/phpunit --testsuite unit
+
+test-lowest: ## Test using the lowest possible versions of the dependencies
+test-lowest: PREFER_LOWEST=--prefer-lowest
+test-lowest: build-update test
 
 test-matrix-lowest: ## Test all version, with the lowest version
 	${MAKE} test-matrix PREFER_LOWEST=--prefer-lowest
@@ -59,13 +64,22 @@ test-matrix: ## Run the unit tests against multiple targets.
 	${MAKE} PHP_VER="7.2" build-update test
 
 test-coverage: ## Run all tests and output coverage to the console.
-	${DOCKER_RUN_BASE} ${IMAGE} phpdbg7 -qrr vendor/bin/phpunit --coverage-text
+	${DOCKER_RUN} phpdbg7 -qrr vendor/bin/phpunit --coverage-text
 
 test-coverage-html: ## Run all tests and output coverage to html.
-	${DOCKER_RUN_BASE} ${IMAGE} phpdbg7 -qrr vendor/bin/phpunit --coverage-html=./tests/report/html
+	${DOCKER_RUN} phpdbg7 -qrr vendor/bin/phpunit --coverage-html=./tests/report/html
 
 test-coverage-clover: ## Run all tests and output clover coverage to file.
-	${DOCKER_RUN_BASE} ${IMAGE} phpdbg7 -qrr vendor/bin/phpunit --coverage-clover=./tests/report/coverage.clover
+	${DOCKER_RUN} phpdbg7 -qrr vendor/bin/phpunit --coverage-clover=./tests/report/coverage.clover
+
+
+# Examples
+
+example-lines: ## Run the lines example
+	${DOCKER_RUN} php tests/example/lines.php
+
+example-table: ## Run the table example
+	${DOCKER_RUN} php tests/example/table.php
 
 # Help
 
diff --git a/README.md b/README.md
index 00a7f20..1156e8b 100644
--- a/README.md
+++ b/README.md
@@ -15,10 +15,16 @@ Run multiple `Synfony\Process`'s at the same time.
 
 Via Composer
 
-``` bash
+```bash
 $ composer require graze/parallel-process
 ```
 
+If you want to use Tables or Lines to output to the console, include:
+
+```bash
+$ composer require graze/console-diff-renderer
+```
+
 ## Usage
 
 ``` php
@@ -41,11 +47,12 @@ $pool->run(); // blocking that will run till it finishes
 Visual output of the parallel processes
 
 ```php
-$table = new Table($output);
+$pool = new \Graze\ParallelProcess\Pool();
 for ($i = 0; $i < 5; $i++) {
     $time = $i + 5;
-    $table->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' => $time]);
+    $pool->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' => $time]);
 }
+$table = new \Graze\ParallelProcess\Table($output, $pool);
 $table->run();
 ```
 
@@ -58,11 +65,11 @@ Write the output of each process to the screen
 ```php
 $pool = new \Graze\ParallelProcess\Pool();
 $pool->setMaxSimultaneous(3);
-$lines = new Lines($output, $pool);
 for ($i = 0; $i < 5; $i++) {
     $time = $i + 5;
-    $lines->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' . $time]);
+    $pool->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' . $time]);
 }
+$lines = new \Graze\ParallelProcess\Lines($output, $pool);
 $lines->run();
 ```
 
diff --git a/composer.json b/composer.json
index c887ade..09269f1 100644
--- a/composer.json
+++ b/composer.json
@@ -1,56 +1,58 @@
 {
-    "name": "graze/parallel-process",
-    "description": "run a pool of processes simultaneously",
-    "keywords": [
-        "graze",
-        "parallel-process"
-    ],
-    "homepage": "https://github.com/graze/parallel-process",
-    "license": "MIT",
-    "authors": [
-        {
-            "name": "Harry Bragg",
-            "email": "harry.bragg@graze.com",
-            "role": "Developer"
-        },
-        {
-            "name": "Graze Developers",
-            "email": "developers@graze.com",
-            "homepage": "http://www.graze.com",
-            "role": "Development Team"
-        }
-    ],
-    "require": {
-        "php": "^5.5 | ^7.0",
-        "symfony/process": "^2.8 | ^3.2 | ^4.0",
-        "graze/data-structure": "^2.0",
-        "graze/console-diff-renderer": "^0.6.1"
+  "name": "graze/parallel-process",
+  "description": "run a pool of processes simultaneously",
+  "keywords": [
+    "graze",
+    "parallel-process"
+  ],
+  "homepage": "https://github.com/graze/parallel-process",
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "Harry Bragg",
+      "email": "harry.bragg@graze.com",
+      "role": "Developer"
     },
-    "require-dev": {
-        "mockery/mockery": "^1.0",
-        "phpunit/phpunit": "^5.7.21|^6|^7",
-        "squizlabs/php_codesniffer": "^3",
-        "graze/standards": "^2",
-        "symfony/console": "^3.1 | ^4"
-    },
-    "suggest": {
-        "symfony/console": "To use the Table to print current runs"
-    },
-    "autoload": {
-        "psr-4": {
-            "Graze\\ParallelProcess\\": "src"
-        }
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "Graze\\ParallelProcess\\Test\\": "tests/src",
-            "Graze\\ParallelProcess\\Test\\Unit\\": "tests/unit",
-            "Graze\\ParallelProcess\\Test\\Integration\\": "tests/integration"
-        }
-    },
-    "config": {
-        "platform": {
-            "php": "7.2"
-        }
+    {
+      "name": "Graze Developers",
+      "email": "developers@graze.com",
+      "homepage": "http://www.graze.com",
+      "role": "Development Team"
+    }
+  ],
+  "require": {
+    "php": "^5.5 | ^7.0",
+    "symfony/process": "^2.8 | ^3.2 | ^4.0",
+    "graze/data-structure": "^2.0",
+    "symfony/event-dispatcher": "^2.8 | ^3.2 | ^4.0"
+  },
+  "require-dev": {
+    "mockery/mockery": "^1.0",
+    "phpunit/phpunit": "^5.7.21|^6|^7",
+    "squizlabs/php_codesniffer": "^3",
+    "graze/standards": "^2",
+    "symfony/console": "^3.1 | ^4",
+    "graze/console-diff-renderer": "^0.6.1"
+  },
+  "suggest": {
+    "symfony/console": "To use the Table to print current runs",
+    "graze/console-diff-renderer": "required to use Table and Lines"
+  },
+  "autoload": {
+    "psr-4": {
+      "Graze\\ParallelProcess\\": "src"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "Graze\\ParallelProcess\\Test\\": "tests/src",
+      "Graze\\ParallelProcess\\Test\\Unit\\": "tests/unit",
+      "Graze\\ParallelProcess\\Test\\Integration\\": "tests/integration"
+    }
+  },
+  "config": {
+    "platform": {
+      "php": "7.2"
     }
+  }
 }
diff --git a/composer.lock b/composer.lock
index 72e9bf1..db14ea2 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "ae209754248dedccd8e204bfe22fb229",
+    "content-hash": "a51437e8a437b9493423fcf9756db435",
     "packages": [
         {
             "name": "graze/console-diff-renderer",
@@ -342,6 +342,69 @@
             "homepage": "https://symfony.com",
             "time": "2018-05-16T09:05:32+00:00"
         },
+        {
+            "name": "symfony/event-dispatcher",
+            "version": "v4.1.3",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/event-dispatcher.git",
+                "reference": "bfb30c2ad377615a463ebbc875eba64a99f6aa3e"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/event-dispatcher/zipball/bfb30c2ad377615a463ebbc875eba64a99f6aa3e",
+                "reference": "bfb30c2ad377615a463ebbc875eba64a99f6aa3e",
+                "shasum": ""
+            },
+            "require": {
+                "php": "^7.1.3"
+            },
+            "conflict": {
+                "symfony/dependency-injection": "<3.4"
+            },
+            "require-dev": {
+                "psr/log": "~1.0",
+                "symfony/config": "~3.4|~4.0",
+                "symfony/dependency-injection": "~3.4|~4.0",
+                "symfony/expression-language": "~3.4|~4.0",
+                "symfony/stopwatch": "~3.4|~4.0"
+            },
+            "suggest": {
+                "symfony/dependency-injection": "",
+                "symfony/http-kernel": ""
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "4.1-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Symfony\\Component\\EventDispatcher\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Symfony EventDispatcher Component",
+            "homepage": "https://symfony.com",
+            "time": "2018-07-26T09:10:45+00:00"
+        },
         {
             "name": "symfony/polyfill-mbstring",
             "version": "v1.8.0",
diff --git a/phpcs.xml b/phpcs.xml
index 24ef6b9..dc28736 100644
--- a/phpcs.xml
+++ b/phpcs.xml
@@ -2,7 +2,7 @@
 <!--
   ~ This file is part of graze/parallel-process.
   ~
-  ~ Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+  ~ Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
   ~
   ~ For the full copyright and license information, please view the LICENSE
   ~ file that was distributed with this source code.
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index e45cac9..491a8c8 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -2,7 +2,7 @@
 <!--
   ~ This file is part of graze/parallel-process.
   ~
-  ~ Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+  ~ Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
   ~
   ~ For the full copyright and license information, please view the LICENSE
   ~ file that was distributed with this source code.
diff --git a/src/Event/EventDispatcherTrait.php b/src/Event/EventDispatcherTrait.php
new file mode 100644
index 0000000..602d7e3
--- /dev/null
+++ b/src/Event/EventDispatcherTrait.php
@@ -0,0 +1,82 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Event;
+
+use Symfony\Component\EventDispatcher\Event;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+
+trait EventDispatcherTrait
+{
+    /** @var EventDispatcherInterface */
+    protected $eventDispatcher;
+
+    /**
+     * @return EventDispatcherInterface
+     */
+    protected function getEventDispatcher()
+    {
+        if (is_null($this->eventDispatcher)) {
+            $this->eventDispatcher = new EventDispatcher();
+        }
+        return $this->eventDispatcher;
+    }
+
+    /**
+     * @return string[]
+     */
+    protected abstract function getEventNames();
+
+    /**
+     * @param string   $eventName
+     * @param callable $handler
+     *
+     * @return $this
+     */
+    public function addListener($eventName, callable $handler)
+    {
+        $this->assertEventName($eventName);
+        $this->getEventDispatcher()->addListener($eventName, $handler);
+        return $this;
+    }
+
+    /**
+     * @param string $eventName
+     * @param Event  $event
+     *
+     * @return $this
+     */
+    protected function dispatch($eventName, Event $event)
+    {
+        $this->assertEventName($eventName);
+        $this->getEventDispatcher()->dispatch($eventName, $event);
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     *
+     * @throws \InvalidArgumentException
+     */
+    private function assertEventName($name)
+    {
+        if (!in_array($name, $this->getEventNames())) {
+            throw new \InvalidArgumentException(sprintf(
+                'The supplied event name: %s is not one of the expected: %s',
+                $name,
+                implode(', ', $this->getEventNames())
+            ));
+        }
+    }
+}
diff --git a/src/Event/PoolRunEvent.php b/src/Event/PoolRunEvent.php
new file mode 100644
index 0000000..1040895
--- /dev/null
+++ b/src/Event/PoolRunEvent.php
@@ -0,0 +1,45 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Event;
+
+use Graze\ParallelProcess\Pool;
+use Graze\ParallelProcess\RunInterface;
+
+class PoolRunEvent extends RunEvent
+{
+    const POOL_RUN_ADDED = 'run.added';
+
+    /** @var Pool */
+    private $pool;
+
+    /**
+     * PoolRunEvent constructor.
+     *
+     * @param Pool         $pool
+     * @param RunInterface $run
+     */
+    public function __construct(Pool $pool, RunInterface $run)
+    {
+        parent::__construct($run);
+        $this->pool = $pool;
+    }
+
+    /**
+     * @return Pool
+     */
+    public function getPool()
+    {
+        return $this->pool;
+    }
+}
diff --git a/src/Event/RunEvent.php b/src/Event/RunEvent.php
new file mode 100644
index 0000000..f30b602
--- /dev/null
+++ b/src/Event/RunEvent.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Event;
+
+use Graze\ParallelProcess\RunInterface;
+use Symfony\Component\EventDispatcher\Event;
+
+class RunEvent extends Event
+{
+    const STARTED   = 'started';
+    const COMPLETED = 'completed';
+    const FAILED    = 'failed';
+    const UPDATED   = 'updated';
+
+    /** @var RunInterface */
+    private $run;
+
+    /**
+     * RunEvent constructor.
+     *
+     * @param RunInterface $run
+     */
+    public function __construct(RunInterface $run)
+    {
+        $this->run = $run;
+    }
+
+    /**
+     * @return RunInterface
+     */
+    public function getRun()
+    {
+        return $this->run;
+    }
+}
diff --git a/src/Exceptions/NotRunningException.php b/src/Exceptions/NotRunningException.php
index d9332d2..652fb0a 100644
--- a/src/Exceptions/NotRunningException.php
+++ b/src/Exceptions/NotRunningException.php
@@ -1,4 +1,15 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess\Exceptions;
 
diff --git a/src/Lines.php b/src/Lines.php
index 37d19e9..0d0f27e 100644
--- a/src/Lines.php
+++ b/src/Lines.php
@@ -1,12 +1,23 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess;
 
 use Graze\DiffRenderer\DiffConsoleOutput;
 use Graze\DiffRenderer\Terminal\TerminalInterface;
+use Graze\ParallelProcess\Event\PoolRunEvent;
+use Graze\ParallelProcess\Event\RunEvent;
 use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Process\Exception\ProcessFailedException;
-use Symfony\Component\Process\Process;
 
 class Lines
 {
@@ -23,12 +34,18 @@ class Lines
     /** @var bool */
     private $showType = true;
     /** @var bool */
+    private $showProgress = true;
+    /** @var bool */
     private $colourProcesses = true;
     /** @var string[] */
     private $colours = ['red', 'green', 'blue', 'yellow', 'magenta', 'white', 'cyan'];
+    /** @var TinyProgressBar|null */
+    private $bar = null;
+    /** @var int */
+    private $counter = 0;
 
     /**
-     * Stream constructor.
+     * Lines constructor.
      *
      * @param OutputInterface $output
      * @param Pool|null       $pool
@@ -44,6 +61,15 @@ public function __construct(OutputInterface $output, Pool $pool = null)
         }
         $this->terminal = $this->output->getTerminal();
         $this->processPool = $pool ?: new Pool();
+
+        $this->processPool->addListener(
+            PoolRunEvent::POOL_RUN_ADDED,
+            function (PoolRunEvent $event) {
+                $this->add($event->getRun());
+            }
+        );
+
+        array_map([$this, 'add'], $this->processPool->getAll());
     }
 
     /**
@@ -67,6 +93,25 @@ public function isShowDuration()
         return $this->showDuration;
     }
 
+    /**
+     * @return bool
+     */
+    public function isShowProgress()
+    {
+        return $this->showProgress;
+    }
+
+    /**
+     * @param bool $showProgress
+     *
+     * @return Lines
+     */
+    public function setShowProgress($showProgress)
+    {
+        $this->showProgress = $showProgress;
+        return $this;
+    }
+
     /**
      * Show the type of each output (`out` or `err`)
      *
@@ -112,64 +157,96 @@ public function isColourProcesses()
     }
 
     /**
-     * @param Process $process
-     * @param array   $data
+     * @param RunInterface $run
      */
-    public function add(Process $process, array $data = [])
+    public function add(RunInterface $run)
     {
-        $index = $this->processPool->count();
-        $onProgress = function (Process $process, $duration, $last, $lastType) use ($index, $data) {
-            $message = ($this->showType ? sprintf('(%s) %s', $lastType, $last) : $last);
-            $this->output->writeln($this->format($index, $data, $duration, $message));
-        };
-
-        $run = new Run(
-            $process,
-            function (Process $process, $duration) use ($index, $data) {
-                $this->output->writeln($this->format($index, $data, $duration, "<info>✓ Succeeded</info>"));
-            },
-            function (Process $process, $duration) use ($index, $data) {
+        $index = $this->counter++;
+        $run->addListener(
+            RunEvent::UPDATED,
+            function (RunEvent $event) use ($index) {
+                $run = $event->getRun();
+                $message = '';
+                if ($run instanceof Run) {
+                    $message = ($this->showType && $run instanceof Run)
+                        ? sprintf('(%s) %s', $run->getLastMessageType(), $run->getLastMessage())
+                        : $run->getLastMessage();
+                }
+                $this->output->writeln($this->format($index, $run, $message));
+            }
+        );
+        $run->addListener(
+            RunEvent::STARTED,
+            function (RunEvent $event) use ($index) {
+                $run = $event->getRun();
+                $this->output->writeln(
+                    $this->format($index, $run, "<fg=blue>→ Started</>")
+                );
+            }
+        );
+        $run->addListener(
+            RunEvent::COMPLETED,
+            function (RunEvent $event) use ($index) {
+                $run = $event->getRun();
                 $this->output->writeln(
-                    $this->format(
-                        $index,
-                        $data,
-                        $duration,
-                        sprintf(
-                            "<error>x Failed</error> (code: %d) %s",
-                            $process->getExitCode(),
-                            $process->getExitCodeText()
-                        )
-                    )
+                    $this->format($index, $run, "<info>✓ Succeeded</info>")
                 );
-                $this->output->writeln((new ProcessFailedException($process))->getMessage());
-            },
-            $onProgress,
-            function (Process $process, $duration) use ($index, $data) {
-                $this->output->writeln($this->format($index, $data, $duration, "<fg=blue>→ Started</>"));
             }
         );
-        $run->setUpdateOnPoll(false);
-        $this->processPool->add($run);
+        $run->addListener(
+            RunEvent::FAILED,
+            function (RunEvent $event) use ($index) {
+                $run = $event->getRun();
+                $exceptions = $run->getExceptions();
+                $exception = null;
+                if (count($exceptions) > 0) {
+                    $exception = reset($exceptions);
+                    $error = sprintf(
+                        "<error>x Failed</error> (%d) %s",
+                        $exception->getCode(),
+                        $exception->getMessage()
+                    );
+                } else {
+                    $error = "<error>x Failed</error>";
+                }
+                $this->output->writeln($this->format($index, $run, $error));
+                if ($exception) {
+                    $this->output->writeln($exception->getMessage());
+                }
+            }
+        );
 
-        $this->updateRowKeyLengths($data);
+        if ($run instanceof Run) {
+            $run->setUpdateOnPoll(false);
+        }
+        $this->updateRowKeyLengths($run->getTags());
     }
 
     /**
-     * @param int    $index
-     * @param array  $data
-     * @param float  $duration
-     * @param string $message
+     * @param int          $index
+     * @param RunInterface $run
+     * @param string       $message
      *
      * @return string
      */
-    private function format($index, array $data, $duration, $message = '')
+    private function format($index, RunInterface $run, $message = '')
     {
         $output = $this->formatTags(
-            $data,
+            $run->getTags(),
             ($this->colourProcesses ? $this->colours[$index % count($this->colours)] : null)
         );
         if ($this->showDuration) {
-            $output .= sprintf(' (<comment>%6.2fs</comment>)', $duration);
+            $output .= sprintf(' (<comment>%6.2fs</comment>)', $run->getDuration());
+        }
+        $progress = $run->getProgress();
+        if ($this->showProgress && !is_null($progress)) {
+            if (is_null($this->bar)) {
+                $this->bar = new TinyProgressBar(2, TinyProgressBar::FORMAT_SHORT, 1);
+            }
+            $output .= $this->bar->setPosition($progress[2])
+                                 ->setPosition($progress[0])
+                                 ->setMax($progress[1])
+                                 ->render();
         }
 
         return sprintf("%s %s", $output, $this->terminal->filter($message));
diff --git a/src/Pool.php b/src/Pool.php
index ec03387..b07393f 100644
--- a/src/Pool.php
+++ b/src/Pool.php
@@ -2,7 +2,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -13,13 +13,20 @@
 
 namespace Graze\ParallelProcess;
 
+use Exception;
 use Graze\DataStructure\Collection\Collection;
+use Graze\ParallelProcess\Event\EventDispatcherTrait;
+use Graze\ParallelProcess\Event\PoolRunEvent;
+use Graze\ParallelProcess\Event\RunEvent;
 use Graze\ParallelProcess\Exceptions\NotRunningException;
 use InvalidArgumentException;
 use Symfony\Component\Process\Process;
+use Throwable;
 
 class Pool extends Collection implements RunInterface
 {
+    use EventDispatcherTrait;
+
     const CHECK_INTERVAL = 0.1;
     const NO_MAX         = -1;
 
@@ -29,18 +36,20 @@ class Pool extends Collection implements RunInterface
     protected $running = [];
     /** @var RunInterface[] */
     protected $waiting = [];
-    /** @var callable|null */
-    protected $onSuccess;
-    /** @var callable|null */
-    protected $onFailure;
-    /** @var callable|null */
-    protected $onProgress;
-    /** @var callable|null */
-    protected $onStart;
+    /** @var RunInterface[] */
+    protected $finished = [];
+    /** @var float */
+    private $started;
+    /** @var float */
+    private $finishedTime;
     /** @var int */
     private $maxSimultaneous = -1;
     /** @var bool */
     private $runInstantly = false;
+    /** @var string[] */
+    private $tags;
+    /** @var Exception[]|Throwable[] */
+    private $exceptions = [];
 
     /**
      * Pool constructor.
@@ -48,100 +57,55 @@ class Pool extends Collection implements RunInterface
      * Set the default callbacks here
      *
      * @param RunInterface[]|Process[] $items
-     * @param callable|null            $onSuccess       function (Process $process, float $duration, string $last,
-     *                                                  string $lastType) : void
-     * @param callable|null            $onFailure       function (Process $process, float $duration, string $last,
-     *                                                  string $lastType) : void
-     * @param callable|null            $onProgress      function (Process $process, float $duration, string $last,
-     *                                                  string $lastType) : void
-     * @param callable|null            $onStart         function (Process $process, float $duration, string $last,
-     *                                                  string $lastType) : void
      * @param int                      $maxSimultaneous Maximum number of simulatneous processes
      * @param bool                     $runInstantly    Run any added processes immediately if they are not already
      *                                                  running
+     * @param array                    $tags
      */
     public function __construct(
         array $items = [],
-        callable $onSuccess = null,
-        callable $onFailure = null,
-        callable $onProgress = null,
-        callable $onStart = null,
         $maxSimultaneous = self::NO_MAX,
-        $runInstantly = false
+        $runInstantly = false,
+        array $tags = []
     ) {
         parent::__construct($items);
 
-        $this->onSuccess = $onSuccess;
-        $this->onFailure = $onFailure;
-        $this->onProgress = $onProgress;
-        $this->onStart = $onStart;
         $this->maxSimultaneous = $maxSimultaneous;
         $this->runInstantly = $runInstantly;
 
         if ($this->runInstantly) {
             $this->start();
         }
+        $this->tags = $tags;
     }
 
     /**
-     * @param callable|null $onSuccess function (Process $process, float $duration, string $last, string $lastType) :
-     *                                 void
-     *
-     * @return $this
-     */
-    public function setOnSuccess($onSuccess)
-    {
-        $this->onSuccess = $onSuccess;
-        return $this;
-    }
-
-    /**
-     * @param callable|null $onFailure function (Process $process, float $duration, string $last, string $lastType) :
-     *                                 void
-     *
-     * @return $this
-     */
-    public function setOnFailure($onFailure)
-    {
-        $this->onFailure = $onFailure;
-        return $this;
-    }
-
-    /**
-     * @param callable|null $onProgress function (Process $process, float $duration, string $last, string $lastType) :
-     *                                  void
-     *
-     * @return $this
-     */
-    public function setOnProgress($onProgress)
-    {
-        $this->onProgress = $onProgress;
-        return $this;
-    }
-
-    /**
-     * @param callable|null $onStart function (Process $process, float $duration, string $last, string $lastType) :
-     *                               void
-     *
-     * @return $this
+     * @return string[]
      */
-    public function setOnStart($onStart)
+    protected function getEventNames()
     {
-        $this->onStart = $onStart;
-        return $this;
+        return [
+            RunEvent::STARTED,
+            RunEvent::COMPLETED,
+            RunEvent::FAILED,
+            RunEvent::UPDATED,
+            PoolRunEvent::POOL_RUN_ADDED,
+        ];
     }
 
     /**
      * Add a new process to the pool
      *
      * @param RunInterface|Process $item
+     * @param array                $tags If a process is supplied, these are added to create a run.
+     *                                   This is ignored when adding a run
      *
      * @return $this
      */
-    public function add($item)
+    public function add($item, array $tags = [])
     {
         if ($item instanceof Process) {
-            return $this->addProcess($item);
+            return $this->addProcess($item, $tags);
         }
 
         if (!$item instanceof RunInterface) {
@@ -154,6 +118,14 @@ public function add($item)
 
         parent::add($item);
 
+        $this->dispatch(PoolRunEvent::POOL_RUN_ADDED, new PoolRunEvent($this, $item));
+        $item->addListener(
+            RunEvent::FAILED,
+            function (RunEvent $event) {
+                $this->exceptions += $event->getRun()->getExceptions();
+            }
+        );
+
         if ($this->isRunning() || $this->runInstantly) {
             $this->startRun($item);
         }
@@ -165,20 +137,13 @@ public function add($item)
      * Add a new process to the pool using the default callbacks
      *
      * @param Process $process
+     * @param array   $tags
      *
      * @return $this
      */
-    protected function addProcess(Process $process)
+    private function addProcess(Process $process, array $tags = [])
     {
-        return $this->add(
-            new Run(
-                $process,
-                $this->onSuccess,
-                $this->onFailure,
-                $this->onProgress,
-                $this->onStart
-            )
-        );
+        return $this->add(new Run($process, $tags));
     }
 
     /**
@@ -192,6 +157,11 @@ public function start()
             $this->startRun($run);
         }
 
+        if (count($this->running) > 0) {
+            $this->started = microtime(true);
+            $this->dispatch(RunEvent::STARTED, new RunEvent($this));
+        }
+
         return $this;
     }
 
@@ -205,6 +175,10 @@ private function startRun(RunInterface $run)
         if ($this->maxSimultaneous === static::NO_MAX || count($this->running) < $this->maxSimultaneous) {
             $run->start();
             $this->running[] = $run;
+            if (is_null($this->started)) {
+                $this->started = microtime(true);
+                $this->dispatch(RunEvent::STARTED, new RunEvent($this));
+            }
         } else {
             $this->waiting[] = $run;
         }
@@ -267,17 +241,29 @@ public function hasStarted()
      */
     public function poll()
     {
-        /** @var Run[] $running */
-        $this->running = array_filter(
-            $this->running,
-            function (RunInterface $run) {
-                return $run->poll();
+        foreach ($this->running as $i => $run) {
+            if (!$run->poll()) {
+                $this->finished[] = $run;
+                $this->running[$i] = null;
             }
-        );
+        }
+        $this->running = array_filter($this->running);
 
         $this->checkFinished();
 
-        return $this->isRunning();
+        $this->dispatch(RunEvent::UPDATED, new RunEvent($this));
+
+        if (!$this->isRunning()) {
+            $this->finishedTime = microtime(true);
+            if ($this->isSuccessful()) {
+                $this->dispatch(RunEvent::COMPLETED, new RunEvent($this));
+            } else {
+                $this->dispatch(RunEvent::FAILED, new RunEvent($this));
+            }
+            return false;
+        }
+
+        return true;
     }
 
     /**
@@ -328,6 +314,16 @@ public function getWaiting()
         return $this->waiting;
     }
 
+    /**
+     * Get a list of all the current waiting runs
+     *
+     * @return RunInterface[]
+     */
+    public function getFinished()
+    {
+        return $this->finished;
+    }
+
     /**
      * @return int
      */
@@ -365,4 +361,45 @@ public function setRunInstantly($runInstantly)
         $this->runInstantly = $runInstantly;
         return $this;
     }
+
+    /**
+     * Get a set of tags associated with this run
+     *
+     * @return array
+     */
+    public function getTags()
+    {
+        return $this->tags;
+    }
+
+    /**
+     * @return float number of seconds this run has been running or did run for (0 for not started)
+     */
+    public function getDuration()
+    {
+        if ($this->isRunning()) {
+            return microtime(true) - $this->started;
+        } elseif (!$this->hasStarted()) {
+            return 0;
+        }
+        return $this->finishedTime - $this->started;
+    }
+
+    /**
+     * @return float[]|null an array of values of the current position, max, and percentage. null if not applicable
+     */
+    public function getProgress()
+    {
+        return [count($this->finished), count($this->items), count($this->finished) / count($this->items)];
+    }
+
+    /**
+     * If the run was unsuccessful, get the error if applicable
+     *
+     * @return Exception[]|Throwable[]
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
 }
diff --git a/src/Run.php b/src/Run.php
index 7266578..674def3 100644
--- a/src/Run.php
+++ b/src/Run.php
@@ -1,27 +1,37 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess;
 
+use Exception;
+use Graze\ParallelProcess\Event\EventDispatcherTrait;
+use Graze\ParallelProcess\Event\RunEvent;
+use Symfony\Component\Process\Exception\ProcessFailedException;
 use Symfony\Component\Process\Process;
+use Throwable;
 
 class Run implements RunInterface
 {
+    use EventDispatcherTrait;
+
     const ON_SUCCESS  = 1;
     const ON_FAILURE  = 2;
     const ON_PROGRESS = 3;
 
     /** @var Process */
     private $process;
-    /** @var callable|null */
-    private $onSuccess;
-    /** @var callable|null */
-    private $onFailure;
-    /** @var callable|null */
-    private $onProgress;
-    /** @var callable|null */
-    private $onStart;
     /** @var float */
-    private $started;
+    private $started = 0;
     /** @var bool */
     private $successful = false;
     /** @var bool */
@@ -34,36 +44,32 @@ class Run implements RunInterface
     private $updateOnPoll = true;
     /** @var bool */
     private $updateOnProcessOutput = true;
+    /** @var array */
+    private $tags;
 
     /**
      * Run constructor.
      *
-     * @param Process       $process
-     * @param callable|null $onSuccess  When the process finishes and is successful
-     *                                  function (Process $process, float $duration, string $last, string $lastType) :
-     *                                  void
-     * @param callable|null $onFailure  When the process finishes and failed
-     *                                  function (Process $process, float $duration, string $last, string $lastType) :
-     *                                  void
-     * @param callable|null $onProgress Called every check period or a message is returned from the process
-     *                                  function (Process $process, float $duration, string $last, string $lastType) :
-     *                                  void
-     * @param callable|null $onStart    When the process starts
-     *                                  function (Process $process, float $duration, string $last, string $lastType) :
-     *                                  void
-     */
-    public function __construct(
-        Process $process,
-        callable $onSuccess = null,
-        callable $onFailure = null,
-        callable $onProgress = null,
-        callable $onStart = null
-    ) {
+     * @param Process $process
+     * @param array   $tags List of key value tags associated with this run
+     */
+    public function __construct(Process $process, array $tags = [])
+    {
         $this->process = $process;
-        $this->onSuccess = $onSuccess;
-        $this->onFailure = $onFailure;
-        $this->onProgress = $onProgress;
-        $this->onStart = $onStart;
+        $this->tags = $tags;
+    }
+
+    /**
+     * @return string[]
+     */
+    protected function getEventNames()
+    {
+        return [
+            RunEvent::STARTED,
+            RunEvent::COMPLETED,
+            RunEvent::FAILED,
+            RunEvent::UPDATED,
+        ];
     }
 
     /**
@@ -75,14 +81,17 @@ public function start()
     {
         if (!$this->process->isRunning()) {
             $this->started = microtime(true);
-            $this->update($this->onStart);
+            $this->dispatch(RunEvent::STARTED, new RunEvent($this));
             $this->process->start(
                 function ($type, $data) {
                     $this->lastType = $type;
                     foreach (explode("\n", $data) as $line) {
-                        $this->last = rtrim($line);
-                        if (mb_strlen($this->last) > 0 && $this->updateOnProcessOutput) {
-                            $this->update($this->onProgress);
+                        $line = rtrim($line);
+                        if (mb_strlen($line) > 0) {
+                            $this->last = $line;
+                            if ($this->updateOnProcessOutput) {
+                                $this->dispatch(RunEvent::UPDATED, new RunEvent($this));
+                            }
                         }
                     }
                 }
@@ -106,7 +115,7 @@ public function poll()
 
         if ($this->process->isRunning()) {
             if ($this->updateOnPoll) {
-                $this->update($this->onProgress);
+                $this->dispatch(RunEvent::UPDATED, new RunEvent($this));
             }
             return true;
         }
@@ -115,9 +124,9 @@ public function poll()
 
         if ($this->process->isSuccessful()) {
             $this->successful = true;
-            $this->update($this->onSuccess);
+            $this->dispatch(RunEvent::COMPLETED, new RunEvent($this));
         } else {
-            $this->update($this->onFailure);
+            $this->dispatch(RunEvent::FAILED, new RunEvent($this));
         }
         return false;
     }
@@ -132,24 +141,6 @@ public function isRunning()
         return $this->process->isRunning();
     }
 
-    /**
-     * Call an event callback
-     *
-     * @param callable|null $func
-     */
-    protected function update($func)
-    {
-        if (!is_null($func)) {
-            call_user_func(
-                $func,
-                $this->process,
-                microtime(true) - $this->started,
-                $this->last,
-                $this->lastType
-            );
-        }
-    }
-
     /**
      * @return bool
      */
@@ -211,4 +202,57 @@ public function isUpdateOnProcessOutput()
     {
         return $this->updateOnProcessOutput;
     }
+
+    /**
+     * @return array
+     */
+    public function getTags()
+    {
+        return $this->tags;
+    }
+
+    /**
+     * @return float number of seconds this run has been running for (0 for not started)
+     */
+    public function getDuration()
+    {
+        return $this->started > 0 ? microtime(true) - $this->started : 0;
+    }
+
+    /**
+     * @return float[]|null the process between 0 and 1 if the run supports it, otherwise null
+     */
+    public function getProgress()
+    {
+        return null;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLastMessage()
+    {
+        return $this->last;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLastMessageType()
+    {
+        return $this->lastType;
+    }
+
+    /**
+     * If the run was unsuccessful, get the error if applicable
+     *
+     * @return Exception[]|Throwable[]
+     */
+    public function getExceptions()
+    {
+        if ($this->hasStarted() && !$this->isSuccessful()) {
+            return [new ProcessFailedException($this->process)];
+        }
+        return [];
+    }
 }
diff --git a/src/RunInterface.php b/src/RunInterface.php
index 4157be3..0fd2013 100644
--- a/src/RunInterface.php
+++ b/src/RunInterface.php
@@ -1,7 +1,21 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess;
 
+use Exception;
+use Throwable;
+
 interface RunInterface
 {
     /**
@@ -29,6 +43,13 @@ public function start();
      */
     public function isSuccessful();
 
+    /**
+     * If the run was unsuccessful, get the error if applicable
+     *
+     * @return Exception[]|Throwable[]
+     */
+    public function getExceptions();
+
     /**
      * We think this is running
      *
@@ -42,4 +63,29 @@ public function isRunning();
      * @return bool
      */
     public function poll();
+
+    /**
+     * Get a set of tags associated with this run
+     *
+     * @return array
+     */
+    public function getTags();
+
+    /**
+     * @param string   $name    The name of the event: 'started', 'completed', 'failed', 'updated'
+     * @param callable $handler The handler for the event
+     *
+     * @return void
+     */
+    public function addListener($name, callable $handler);
+
+    /**
+     * @return float number of seconds this run has been running for (0 for not started)
+     */
+    public function getDuration();
+
+    /**
+     * @return float[]|null an array of values of the current position, max, and percentage. null if not applicable
+     */
+    public function getProgress();
 }
diff --git a/src/Table.php b/src/Table.php
index 6dd6e92..3be630c 100644
--- a/src/Table.php
+++ b/src/Table.php
@@ -2,7 +2,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -16,9 +16,9 @@
 use Exception;
 use Graze\DiffRenderer\DiffConsoleOutput;
 use Graze\DiffRenderer\Terminal\TerminalInterface;
+use Graze\ParallelProcess\Event\PoolRunEvent;
+use Graze\ParallelProcess\Event\RunEvent;
 use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Process\Exception\ProcessFailedException;
-use Symfony\Component\Process\Process;
 
 class Table
 {
@@ -58,67 +58,86 @@ public function __construct(OutputInterface $output, Pool $pool = null)
         }
         $this->terminal = $this->output->getTerminal();
         $this->exceptions = [];
+
+        $this->processPool->addListener(
+            PoolRunEvent::POOL_RUN_ADDED,
+            function (PoolRunEvent $event) {
+                $this->add($event->getRun());
+            }
+        );
+
+        array_map([$this, 'add'], $this->processPool->getAll());
     }
 
     /**
-     * @param array  $data
-     * @param string $status
-     * @param float  $duration
-     * @param string $extra
+     * @param RunInterface $run
+     * @param string       $status
      *
      * @return string
      */
-    private function formatRow(array $data, $status, $duration, $extra = '')
+    private function formatRow(RunInterface $run, $status)
     {
-        $tags = $this->formatTags($data);
-        $extra = $extra ? '  ' . $this->terminal->filter($extra) : '';
-        return sprintf("%s (<comment>%6.2fs</comment>) %s%s", $tags, $duration, $status, $extra);
+        $tags = $this->formatTags($run->getTags());
+        $extra = ($this->showOutput && $run instanceof Run && mb_strlen($run->getLastMessage()) > 0)
+            ? '  ' . $this->terminal->filter($run->getLastMessage())
+            : '';
+        return sprintf("%s (<comment>%6.2fs</comment>) %s%s", $tags, $run->getDuration(), $status, $extra);
     }
 
     /**
-     * @param Process $process
-     * @param array   $data
+     * @param RunInterface $run
      */
-    public function add(Process $process, array $data = [])
+    public function add(RunInterface $run)
     {
         $index = count($this->rows);
-        $this->rows[$index] = $this->formatRow($data, '', 0);
+        $this->rows[$index] = $this->formatRow($run, '');
         $spinner = 0;
+        $bar = new TinyProgressBar(2, TinyProgressBar::FORMAT_DEFAULT, 1);
 
         if ($this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
-            $onProgress = function ($process, $duration, $last) use ($index, $data, &$spinner) {
-                $this->rows[$index] = $this->formatRow(
-                    $data,
-                    mb_substr(static::SPINNER, $spinner++, 1),
-                    $duration,
-                    ($this->showOutput ? $last : '')
-                );
-                if ($spinner > mb_strlen(static::SPINNER) - 1) {
-                    $spinner = 0;
+            $run->addListener(
+                RunEvent::UPDATED,
+                function (RunEvent $event) use ($index, &$spinner, $bar) {
+                    $run = $event->getRun();
+                    $progress = $run->getProgress();
+                    $status = (!is_null($progress))
+                        ? $bar->setPosition($progress[2])
+                              ->setPosition($progress[0])
+                              ->setMax($progress[1])
+                              ->render()
+                        : mb_substr(static::SPINNER, $spinner++, 1);
+                    $this->rows[$index] = $this->formatRow(
+                        $run,
+                        $status
+                    );
+                    if ($spinner > mb_strlen(static::SPINNER) - 1) {
+                        $spinner = 0;
+                    }
+                    $this->render();
                 }
-                $this->render();
-            };
-        } else {
-            $onProgress = null;
+            );
         }
 
-        $run = new Run(
-            $process,
-            function ($process, $duration, $last) use ($index, $data) {
-                $this->rows[$index] = $this->formatRow($data, "<info>✓</info>", $duration, $last);
+        $run->addListener(
+            RunEvent::COMPLETED,
+            function (RunEvent $event) use ($index, &$bar, &$spinner) {
+                $this->rows[$index] = $this->formatRow($event->getRun(), "<info>✓</info>");
                 $this->render($index);
-            },
-            function ($process, $duration, $last) use ($index, $data) {
-                $this->rows[$index] = $this->formatRow($data, "<error>x</error>", $duration, $last);
+            }
+        );
+        $run->addListener(
+            RunEvent::FAILED,
+            function (RunEvent $event) use ($index, &$bar, &$spinner) {
+                $run = $event->getRun();
+                $this->rows[$index] = $this->formatRow($run, "<error>x</error>");
                 $this->render($index);
-                $this->exceptions[] = new ProcessFailedException($process);
-            },
-            $onProgress
+                $this->exceptions += $run->getExceptions();
+            }
         );
-        $run->setUpdateOnProcessOutput(false);
-        $this->processPool->add($run);
-
-        $this->updateRowKeyLengths($data);
+        if ($run instanceof Run) {
+            $run->setUpdateOnProcessOutput(false);
+        }
+        $this->updateRowKeyLengths($run->getTags());
     }
 
     /**
diff --git a/src/TagsTrait.php b/src/TagsTrait.php
index 2a1d238..230b9dc 100644
--- a/src/TagsTrait.php
+++ b/src/TagsTrait.php
@@ -1,10 +1,20 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess;
 
 trait TagsTrait
 {
-
     /** @var int[] */
     protected $maxLengths = [];
 
diff --git a/src/TinyProgressBar.php b/src/TinyProgressBar.php
new file mode 100644
index 0000000..fbf1f23
--- /dev/null
+++ b/src/TinyProgressBar.php
@@ -0,0 +1,232 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess;
+
+use InvalidArgumentException;
+
+class TinyProgressBar
+{
+    /**
+     * Format for a progress bar
+     *
+     * Options:
+     *  - `{bar}` The actual bar
+     *  - `{perc}` Display the percentage e.g 2%
+     *  - `{position}` Display the current position e.g 1
+     *  - `{max}` Display the maximum possible value e.g 100
+     *
+     * Example formats:
+     *  - `{bar} {position}/{max} {perc}`
+     */
+    const FORMAT_DEFAULT         = '▕<comment>{bar}</comment>▏<info>{perc}</info> {position}/{max}';
+    const FORMAT_SHORT           = '▕<comment>{bar}</comment>▏<info>{perc}</info>';
+    const FORMAT_BAR_ONLY        = '{bar}';
+    const FORMAT_COLOUR_BAR_ONLY = '<comment>{bar}</comment>';
+
+    /** @var int */
+    private $length;
+    /** @var string */
+    private $format;
+    /** @var float */
+    private $position;
+    /** @var float */
+    private $max;
+    /** @var string[] */
+    private $bar;
+
+    /**
+     * TinyProgressBar constructor.
+     *
+     * @param int    $numChars The number of characters to use for the bar
+     * @param string $format   The format for the bar
+     * @param int    $max      The maximum value for a bar
+     */
+    public function __construct($numChars, $format = self::FORMAT_DEFAULT, $max = 100)
+    {
+        $this->setLength($numChars);
+        $this->setMax($max);
+        $this->format = $format;
+        $this->position = 0;
+        $this->bar = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+    }
+
+    /**
+     * Sets the characters to use for a bar. A bar is n chars long (defined in the constructor), each char will use
+     * each character in the array once.
+     *
+     * The first character should always be blank
+     *
+     * Example:
+     *
+     *     ->setBarCharacters([" ","▄","█"]);
+     *
+     *     ▄
+     *
+     *     █
+     *
+     *     █▄
+     *
+     *     ██
+     *
+     *     ██▄
+     *
+     *     ███
+     *
+     * @param array $characters
+     *
+     * @return $this
+     */
+    public function setBarCharacters(array $characters)
+    {
+        $this->bar = $characters;
+        return $this;
+    }
+
+    /**
+     * @param float $step
+     *
+     * @return $this
+     */
+    public function advance($step = 1.0)
+    {
+        if ($this->position < $this->max) {
+            $this->position = min($this->position + $step, $this->max);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function render()
+    {
+        $percentage = round($this->position / $this->max, 2);
+
+        // number of chars to display
+        $displayChars = ceil($percentage * $this->length);
+        if ($displayChars == 0) {
+            $displayChars = 1;
+        }
+
+        // normalise the percentage to this character
+        $percentageStep = 1 / $this->length;
+        $minPercentage = $percentageStep * ($displayChars - 1);
+        $maxPercentage = $minPercentage + $percentageStep;
+        $charPercentage = ($percentage - $minPercentage) / ($maxPercentage - $minPercentage);
+        if ($charPercentage == 0) {
+            $charIndex = 0;
+        } else {
+            $charIndex = (int) (floor((count($this->bar) - 2) * $charPercentage) + 1);
+        }
+        $char = $this->bar[$charIndex];
+
+        $bar = sprintf(
+            '%s%s%s',
+            str_repeat(end($this->bar), $displayChars - 1),
+            $char,
+            str_repeat(' ', $this->length - $displayChars)
+        );
+
+        $percentageText = sprintf('%3d%%', $percentage * 100);
+
+        return str_replace(
+            ['{bar}', '{perc}', '{position}', '{max}'],
+            [$bar, $percentageText, $this->position, $this->max],
+            $this->format
+        );
+    }
+
+    /**
+     * @return int
+     */
+    public function getLength()
+    {
+        return $this->length;
+    }
+
+    /**
+     * @param int $length
+     *
+     * @return $this
+     */
+    public function setLength($length)
+    {
+        if ($length <= 0) {
+            throw new InvalidArgumentException(sprintf('Supplied bar length: %d must be greater than 0', $length));
+        }
+        $this->length = $length;
+        return $this;
+    }
+
+    /**
+     * @return float
+     */
+    public function getMax()
+    {
+        return $this->max;
+    }
+
+    /**
+     * @param float $max
+     *
+     * @return $this
+     */
+    public function setMax($max)
+    {
+        if ($max <= 0) {
+            throw new InvalidArgumentException(sprintf('Supplied max value: %d must be greater than 0', $max));
+        }
+        $this->max = $max;
+        return $this;
+    }
+
+    /**
+     * @return float
+     */
+    public function getPosition()
+    {
+        return $this->position;
+    }
+
+    /**
+     * @return string
+     */
+    public function getFormat()
+    {
+        return $this->format;
+    }
+
+    /**
+     * @param string $format
+     *
+     * @return $this
+     */
+    public function setFormat($format)
+    {
+        $this->format = $format;
+        return $this;
+    }
+
+    /**
+     * @param float $position
+     *
+     * @return TinyProgressBar
+     */
+    public function setPosition($position)
+    {
+        $this->position = max(min($position, $this->max), 0);
+        return $this;
+    }
+}
diff --git a/tests/example/lines.php b/tests/example/lines.php
index 6147923..7dc0e87 100644
--- a/tests/example/lines.php
+++ b/tests/example/lines.php
@@ -3,7 +3,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -23,9 +23,9 @@
 
 $pool = new \Graze\ParallelProcess\Pool();
 $pool->setMaxSimultaneous(3);
-$lines = new Lines($output, $pool);
 for ($i = 0; $i < 5; $i++) {
     $time = $i + 5;
-    $lines->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' . $time]);
+    $pool->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' . $time]);
 }
+$lines = new Lines($output, $pool);
 $lines->run();
diff --git a/tests/example/table.php b/tests/example/table.php
index 5631fa3..669c193 100644
--- a/tests/example/table.php
+++ b/tests/example/table.php
@@ -3,7 +3,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -23,9 +23,9 @@
 
 $pool = new \Graze\ParallelProcess\Pool();
 $pool->setMaxSimultaneous(3);
-$table = new Table($output, $pool);
 for ($i = 0; $i < 5; $i++) {
     $time = $i + 5;
-    $table->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' => $time]);
+    $pool->add(new Process(sprintf('for i in `seq 1 %d` ; do date ; sleep 1 ; done', $time)), ['sleep' => $time]);
 }
+$table = new Table($output, $pool);
 $table->run();
diff --git a/tests/src/BufferDiffOutput.php b/tests/src/BufferDiffOutput.php
index 1a0d777..ab529a9 100644
--- a/tests/src/BufferDiffOutput.php
+++ b/tests/src/BufferDiffOutput.php
@@ -1,4 +1,15 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess\Test;
 
diff --git a/tests/src/EventDispatcherFake.php b/tests/src/EventDispatcherFake.php
new file mode 100644
index 0000000..52e7d99
--- /dev/null
+++ b/tests/src/EventDispatcherFake.php
@@ -0,0 +1,42 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Test;
+
+use Graze\ParallelProcess\Event\EventDispatcherTrait;
+use Symfony\Component\EventDispatcher\Event;
+
+class EventDispatcherFake
+{
+    const EVENT_VALID   = 'valid';
+    const EVENT_INVALID = 'invalid';
+
+    use EventDispatcherTrait;
+
+    /**
+     * @return string[]
+     */
+    protected function getEventNames()
+    {
+        return [static::EVENT_VALID];
+    }
+
+    /**
+     * @param string $eventName
+     * @param Event  $event
+     */
+    public function doDispatch($eventName, Event $event)
+    {
+        $this->dispatch($eventName, $event);
+    }
+}
diff --git a/tests/src/TestCase.php b/tests/src/TestCase.php
index e51a2cc..4122f2d 100644
--- a/tests/src/TestCase.php
+++ b/tests/src/TestCase.php
@@ -3,7 +3,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
diff --git a/tests/unit/Event/EventDispatcherTest.php b/tests/unit/Event/EventDispatcherTest.php
new file mode 100644
index 0000000..4bb63eb
--- /dev/null
+++ b/tests/unit/Event/EventDispatcherTest.php
@@ -0,0 +1,69 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Test\Unit\Event;
+
+use Graze\ParallelProcess\Test\EventDispatcherFake;
+use Graze\ParallelProcess\Test\TestCase;
+use Symfony\Component\EventDispatcher\Event;
+
+class EventDispatcherTest extends TestCase
+{
+    /** @var EventDispatcherFake */
+    private $dispatcher;
+
+    public function setUp()
+    {
+        $this->dispatcher = new EventDispatcherFake();
+    }
+
+    public function testValidNameAddListener()
+    {
+        $this->assertSame(
+            $this->dispatcher,
+            $this->dispatcher->addListener(
+                EventDispatcherFake::EVENT_VALID,
+                function () {
+                }
+            )
+        );
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testInvalidNameAddListenerThrowsAnException()
+    {
+        $this->dispatcher->addListener(
+            EventDispatcherFake::EVENT_INVALID,
+            function () {
+            }
+        );
+    }
+
+    public function testValidNameDispatch()
+    {
+        $this->dispatcher->doDispatch(EventDispatcherFake::EVENT_VALID, new Event());
+
+        // no exceptions should be thrown
+        $this->assertTrue(true);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testInvalidNameDispatchThrowsAnException()
+    {
+        $this->dispatcher->doDispatch(EventDispatcherFake::EVENT_INVALID, new Event());
+    }
+}
diff --git a/tests/unit/LinesTest.php b/tests/unit/LinesTest.php
index 447035e..62f9c2a 100644
--- a/tests/unit/LinesTest.php
+++ b/tests/unit/LinesTest.php
@@ -1,9 +1,24 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess\Test\Unit;
 
+use Exception;
+use Graze\ParallelProcess\Event\RunEvent;
 use Graze\ParallelProcess\Lines;
 use Graze\ParallelProcess\Pool;
+use Graze\ParallelProcess\Run;
+use Graze\ParallelProcess\RunInterface;
 use Graze\ParallelProcess\Test\BufferDiffOutput;
 use Graze\ParallelProcess\Test\TestCase;
 use Mockery;
@@ -50,6 +65,7 @@ public function testShowType()
 
         $this->assertFalse($lines->isShowType());
     }
+
     public function testShowProcessColours()
     {
         $output = Mockery::mock(OutputInterface::class);
@@ -96,7 +112,7 @@ function ($closure) {
         );
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
 
-        $this->lines->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->lines->run(0);
 
@@ -137,7 +153,7 @@ function ($closure) {
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
 
         $this->lines->setColourProcesses(false);
-        $this->lines->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->lines->run(0);
 
@@ -177,7 +193,7 @@ function ($closure) {
         );
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
 
-        $this->lines->add($process, ['value']);
+        $this->pool->add($process, ['value']);
 
         $this->lines->run(0);
 
@@ -223,15 +239,33 @@ function ($closure) {
         $process->shouldReceive('getErrorOutput')->andReturn('some error text');
         $process->shouldReceive('getOutput')->andReturn('first line');
 
-        $this->lines->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->lines->run(0);
 
         $expected = [
             ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <fg=blue>→ Started</>%'],
             ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) \(out\) first line%'],
-            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <error>x Failed</error> \(code: 3\) some error%'],
-            [<<<TEXT
+            [
+                <<<TEXT
+%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <error>x Failed</error> \(0\) The command "test" failed.
+
+Exit Code: 3\(some error\)
+
+Working directory: /tmp
+
+Output:
+================
+first line
+
+Error Output:
+================
+some error text%
+TEXT
+                ,
+            ],
+            [
+                <<<TEXT
 %The command "test" failed.
 
 Exit Code: 3\(some error\)
@@ -246,6 +280,7 @@ function ($closure) {
 ================
 some error text%
 TEXT
+                ,
             ],
         ];
 
@@ -278,7 +313,7 @@ function ($closure) {
         $process->shouldReceive('getOutput')->andReturn('first line');
 
         $this->lines->setShowType(false);
-        $this->lines->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->lines->run(0);
 
@@ -291,7 +326,7 @@ function ($closure) {
         $this->compareOutputs($expected, $this->bufferOutput->getWritten());
     }
 
-    public function testShowDurationDoesNotShowTheDuration()
+    public function testShowDurationToFalseDoesNotShowTheDuration()
     {
         $process = Mockery::mock(Process::class);
         $process->shouldReceive('stop');
@@ -317,7 +352,7 @@ function ($closure) {
         $process->shouldReceive('getOutput')->andReturn('first line');
 
         $this->lines->setShowDuration(false);
-        $this->lines->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->lines->run(0);
 
@@ -329,4 +364,250 @@ function ($closure) {
 
         $this->compareOutputs($expected, $this->bufferOutput->getWritten());
     }
+
+    public function testShowProgressShowsTheProgress()
+    {
+        $process = Mockery::mock(Process::class);
+        $process->shouldReceive('stop');
+        $process->shouldReceive('start')->with(
+            Mockery::on(
+                function ($closure) {
+                    call_user_func($closure, Process::OUT, 'first line');
+                    return true;
+                }
+            )
+        )->once();
+        $process->shouldReceive('isStarted')->andReturn(true);
+        $process->shouldReceive('isRunning')->andReturn(
+            false, // add
+            false, // start
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
+        $process->shouldReceive('getOutput')->andReturn('first line');
+
+        $run = Mockery::mock(Run::class, [$process, ['key' => 'value']])->makePartial();
+        $run->allows()
+            ->getProgress()
+            ->andReturns([0, 100, 0], [50, 100, 0.5], [100, 100, 1]);
+
+        $this->lines->setShowProgress(true);
+        $this->pool->add($run);
+
+        $this->lines->run(0);
+
+        $expected = [
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) |<comment>  </comment>| <fg=black;bg=cyan>  0\%</> <fg=blue>→ Started</>%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) |<comment>█ </comment>| <fg=black;bg=cyan> 50\%</> \(out\) first line%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) |<comment>██</comment>| <fg=black;bg=cyan>100\%</> <info>✓ Succeeded</info>%'],
+        ];
+
+        $this->compareOutputs($expected, $this->bufferOutput->getWritten());
+    }
+
+    public function testNonShowProgressShowsTheProgress()
+    {
+        $process = Mockery::mock(Process::class);
+        $process->shouldReceive('stop');
+        $process->shouldReceive('start')->with(
+            Mockery::on(
+                function ($closure) {
+                    call_user_func($closure, Process::OUT, 'first line');
+                    return true;
+                }
+            )
+        )->once();
+        $process->shouldReceive('isStarted')->andReturn(true);
+        $process->shouldReceive('isRunning')->andReturn(
+            false, // add
+            false, // start
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
+        $process->shouldReceive('getOutput')->andReturn('first line');
+
+        $run = Mockery::mock(Run::class, [$process, ['key' => 'value']])->makePartial();
+        $run->allows()
+            ->getProgress()
+            ->andReturns([0, 100, 0], [50, 100, 0.5], [100, 100, 1]);
+
+        $this->lines->setShowProgress(false);
+        $this->assertFalse($this->lines->isShowProgress());
+        $this->pool->add($run);
+
+        $this->lines->run(0);
+
+        $expected = [
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <fg=blue>→ Started</>%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) \(out\) first line%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <info>✓ Succeeded</info>%'],
+        ];
+
+        $this->compareOutputs($expected, $this->bufferOutput->getWritten());
+    }
+
+    public function testNonProcessRunFailure()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('stop');
+        $run->shouldReceive('start')->once();
+        $run->shouldReceive('hasStarted')->andReturn(true);
+        $run->shouldReceive('isRunning')->andReturn(
+            false, // add
+            false, // start
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $run->shouldReceive('poll')->andReturn(
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $run->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(false);
+
+        $startedEvent = $completedEvent = $updatedEvent = null;
+        $failedEvents = [];
+
+        $run->allows()->addListener(
+            RunEvent::STARTED,
+            Mockery::on(function (callable $callback) use (&$startedEvent) {
+                $startedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::COMPLETED,
+            Mockery::on(function (callable $callback) use (&$completedEvent) {
+                $completedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::FAILED,
+            Mockery::on(function (callable $callback) use (&$failedEvents) {
+                $failedEvents[] = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::UPDATED,
+            Mockery::on(function (callable $callback) use (&$updatedEvent) {
+                $updatedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows(['getTags' => ['key' => 'value'], 'getProgress' => null]);
+
+        $this->pool->add($run);
+
+        $this->lines->run(0);
+
+        $run->allows()->getDuration()->andReturns(0, 0.1);
+
+        $run->allows()->getExceptions()->andReturns([new Exception('some error', 5)]);
+
+        call_user_func($startedEvent, new RunEvent($run));
+        foreach ($failedEvents as $failedEvent) {
+            call_user_func($failedEvent, new RunEvent($run));
+        }
+
+        $expected = [
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <fg=blue>→ Started</>%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <error>x Failed</error> \(5\) some error%'],
+            ['%some error%'],
+        ];
+
+        $this->compareOutputs($expected, $this->bufferOutput->getWritten());
+    }
+
+    public function testRunFailureWithNoException()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('stop');
+        $run->shouldReceive('start')->once();
+        $run->shouldReceive('hasStarted')->andReturn(true);
+        $run->shouldReceive('isRunning')->andReturn(
+            false, // add
+            false, // start
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $run->shouldReceive('poll')->andReturn(
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            false // complete
+        );
+        $run->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(false);
+
+        $startedEvent = $completedEvent = $updatedEvent = null;
+        $failedEvents = [];
+
+        $run->allows()->addListener(
+            RunEvent::STARTED,
+            Mockery::on(function (callable $callback) use (&$startedEvent) {
+                $startedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::COMPLETED,
+            Mockery::on(function (callable $callback) use (&$completedEvent) {
+                $completedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::FAILED,
+            Mockery::on(function (callable $callback) use (&$failedEvents) {
+                $failedEvents[] = $callback;
+                return true;
+            })
+        );
+        $run->allows()->addListener(
+            RunEvent::UPDATED,
+            Mockery::on(function (callable $callback) use (&$updatedEvent) {
+                $updatedEvent = $callback;
+                return true;
+            })
+        );
+        $run->allows(['getTags' => ['key' => 'value'], 'getProgress' => null]);
+
+        $this->pool->add($run);
+
+        $this->lines->run(0);
+
+        $run->allows()->getDuration()->andReturns(0, 0.1);
+
+        $run->allows()->getExceptions()->andReturns([]);
+
+        call_user_func($startedEvent, new RunEvent($run));
+        foreach ($failedEvents as $failedEvent) {
+            call_user_func($failedEvent, new RunEvent($run));
+        }
+
+        $expected = [
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <fg=blue>→ Started</>%'],
+            ['%<info>key</info>: <options=bold;fg=\w+>value</> \(<comment>[ 0-9\.s]+</comment>\) <error>x Failed</error>%'],
+        ];
+
+        $this->compareOutputs($expected, $this->bufferOutput->getWritten());
+    }
 }
diff --git a/tests/unit/PoolMaxSimultaneousTest.php b/tests/unit/PoolMaxSimultaneousTest.php
index e4ea188..473ce11 100644
--- a/tests/unit/PoolMaxSimultaneousTest.php
+++ b/tests/unit/PoolMaxSimultaneousTest.php
@@ -3,7 +3,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -97,7 +97,7 @@ public function testSingleMaxAdding2Processes()
 
     public function testAddingTooManyProcessesPutsThemOnTheWaitingList()
     {
-        $pool = new Pool([], null, null, null, null, 1);
+        $pool = new Pool([], 1);
         $this->assertEquals(1, $pool->getMaxSimultaneous());
 
         $pool->add($this->process);
diff --git a/tests/unit/PoolTest.php b/tests/unit/PoolTest.php
index 187e9cd..d9caa7f 100644
--- a/tests/unit/PoolTest.php
+++ b/tests/unit/PoolTest.php
@@ -3,7 +3,7 @@
 /**
  * This file is part of graze/parallel-process.
  *
- * Copyright (c) 2017 Nature Delivered Ltd. <https://www.graze.com>
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -14,7 +14,10 @@
 
 namespace Graze\ParallelProcess\Test\Unit;
 
+use Exception;
 use Graze\DataStructure\Collection\CollectionInterface;
+use Graze\ParallelProcess\Event\PoolRunEvent;
+use Graze\ParallelProcess\Event\RunEvent;
 use Graze\ParallelProcess\Pool;
 use Graze\ParallelProcess\Run;
 use Graze\ParallelProcess\RunInterface;
@@ -69,7 +72,7 @@ public function testPoolConstructor()
         $runs = [];
         for ($i = 0; $i < 2; $i++) {
             $runs[] = Mockery::mock(RunInterface::class)
-                             ->allows(['isRunning' => false, 'hasStarted' => false]);
+                             ->allows(['isRunning' => false, 'hasStarted' => false, 'addListener' => true]);
         }
 
         $pool = new Pool($runs);
@@ -99,7 +102,7 @@ public function testPoolInitialStateWithNoRuns()
     public function testPoolAddingRun()
     {
         $run = Mockery::mock(RunInterface::class);
-        $run->allows(['hasStarted' => false, 'isRunning' => false]);
+        $run->allows(['hasStarted' => false, 'isRunning' => false, 'addListener' => $run]);
 
         $pool = new Pool();
         $pool->add($run);
@@ -107,6 +110,28 @@ public function testPoolAddingRun()
         $this->assertEquals(1, $pool->count());
     }
 
+    public function testPoolAddingRunFiresAnEvent()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->allows(['hasStarted' => false, 'isRunning' => false, 'addListener' => $run]);
+
+        $hit = false;
+
+        $pool = new Pool();
+        $pool->addListener(
+            PoolRunEvent::POOL_RUN_ADDED,
+            function (PoolRunEvent $event) use ($pool, $run, &$hit) {
+                $this->assertSame($pool, $event->getPool());
+                $this->assertSame($run, $event->getRun());
+                $hit = true;
+            }
+        );
+        $pool->add($run);
+
+        $this->assertEquals(1, $pool->count());
+        $this->assertTrue($hit);
+    }
+
     public function testPoolAddingProcess()
     {
         $pool = new Pool();
@@ -119,6 +144,30 @@ public function testPoolAddingProcess()
         $this->assertEquals($this->process, $run->getProcess());
     }
 
+    public function testPoolAddingProcessFiresAnEvent()
+    {
+        $pool = new Pool();
+        $pool->addListener(
+            PoolRunEvent::POOL_RUN_ADDED,
+            function (PoolRunEvent $event) use ($pool, &$hit) {
+                $this->assertSame($pool, $event->getPool());
+                $run = $event->getRun();
+                if ($run instanceof Run) {
+                    $this->assertSame($this->process, $run->getProcess());
+                }
+                $hit = true;
+            }
+        );
+        $pool->add($this->process);
+
+        $this->assertEquals(1, $pool->count());
+        $runs = $pool->getAll();
+        $run = reset($runs);
+
+        $this->assertEquals($this->process, $run->getProcess());
+        $this->assertTrue($hit);
+    }
+
     public function testSuccessfulRun()
     {
         $run = Mockery::mock(RunInterface::class);
@@ -130,6 +179,8 @@ public function testSuccessfulRun()
             ->andReturn(true);
         $run->shouldReceive('isSuccessful')
             ->andReturn(true);
+        $run->allows()
+            ->addListener(RunEvent::FAILED, Mockery::type('callable'));
 
         $pool = new Pool([$run]);
 
@@ -141,222 +192,162 @@ public function testSuccessfulRun()
         $this->assertTrue($pool->isSuccessful());
     }
 
-    /**
-     * @expectedException \Graze\ParallelProcess\Exceptions\NotRunningException
-     */
-    public function testPoolUnableToAddRunningProcessWhenPoolHasNotStarted()
+    public function testSuccessfulRunWithEvents()
     {
         $run = Mockery::mock(RunInterface::class);
         $run->shouldReceive('isRunning')
+            ->andReturn(false);
+        $run->shouldReceive('poll')
+            ->andReturn(true, false);
+        $run->shouldReceive('hasStarted')
             ->andReturn(true);
+        $run->shouldReceive('isSuccessful')
+            ->andReturn(true);
+        $run->allows()
+            ->addListener(RunEvent::FAILED, Mockery::type('callable'));
 
-        $pool = new Pool();
-
-        $pool->add($run);
-    }
-
-    public function testPoolAbleToAddRunningProcessWhenPoolHasStarted()
-    {
-        $run = Mockery::mock(RunInterface::class)
-                      ->allows(['isRunning' => false, 'hasStarted' => false, 'start' => null]);
         $pool = new Pool([$run]);
-        $pool->start();
 
-        $run2 = Mockery::mock(RunInterface::class)
-                       ->allows(['isRunning' => true, 'start' => null]);
-        $pool->add($run2);
+        $startedHit = false;
+        $completedHit = false;
 
-        $this->assertEquals(2, $pool->count());
-        $this->assertTrue($pool->isRunning());
-    }
-
-    public function testOnSuccessIsCalledOnSuccessfulProcess()
-    {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(true);
-
-        $hit = false;
-
-        $pool = new Pool(
-            [],
-            function ($proc) use ($process, &$hit) {
-                $this->assertSame($proc, $process);
-                $hit = true;
+        $pool->addListener(
+            RunEvent::STARTED,
+            function (RunEvent $event) use ($pool, &$startedHit) {
+                $this->assertSame($pool, $event->getRun());
+                $startedHit = true;
             }
         );
-
-        $pool->add($process);
-
-        $pool->run(0);
-
-        $this->assertTrue($hit);
-    }
-
-    public function testOnFailureIsCalledForErroredProcess()
-    {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(false);
-
-        $hit = false;
-
-        $pool = new Pool(
-            [],
-            null,
-            function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
-                $hit = true;
+        $pool->addListener(
+            RunEvent::COMPLETED,
+            function (RunEvent $event) use ($pool, &$completedHit) {
+                $this->assertSame($pool, $event->getRun());
+                $completedHit = true;
             }
         );
 
-        $pool->add($process);
-
+        $run->shouldReceive('start');
         $pool->run(0);
 
-        $this->assertTrue($hit);
+        $this->assertTrue($pool->hasStarted());
+        $this->assertFalse($pool->isRunning());
+        $this->assertTrue($pool->isSuccessful());
+
+        $this->assertTrue($startedHit);
+        $this->assertTrue($completedHit);
     }
 
-    public function testOnProgressIsCalledDuringProcessRun()
+    public function testFailedRunWithEvents()
     {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false, false, true, false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(false);
+        $run = Mockery::mock(RunInterface::class);
+        $run->allows([
+            'isRunning'    => false,
+            'hasStarted'   => true,
+            'isSuccessful' => false,
+        ]);
+        $run->shouldReceive('poll')
+            ->andReturn(true, false);
+        $failedListener = null;
+        $run->allows()
+            ->addListener(
+                RunEvent::FAILED,
+                Mockery::on(function (callable $handler) use (&$failedListener) {
+                    $failedListener = $handler;
+                    return true;
+                })
+            );
 
-        $hit = false;
+        $pool = new Pool([$run]);
 
-        $pool = new Pool(
-            [],
-            null,
-            null,
-            function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
-                $hit = true;
+        $startedHit = false;
+        $failedHit = false;
+
+        $pool->addListener(
+            RunEvent::STARTED,
+            function (RunEvent $event) use ($pool, &$startedHit) {
+                $this->assertSame($pool, $event->getRun());
+                $startedHit = true;
+            }
+        );
+        $pool->addListener(
+            RunEvent::FAILED,
+            function (RunEvent $event) use ($pool, &$failedHit) {
+                $this->assertSame($pool, $event->getRun());
+                $failedHit = true;
             }
         );
 
-        $pool->add($process);
-
+        $run->shouldReceive('start');
         $pool->run(0);
 
-        $this->assertTrue($hit);
-    }
+        $exception = new Exception('test exception');
+        $run->allows()
+            ->getExceptions()->andReturn([$exception]);
 
-    public function testOnSuccessSetterIsCalledOnSuccessfulProcess()
-    {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(true);
-
-        $hit = false;
-
-        $pool = new Pool();
-        $this->assertSame(
-            $pool,
-            $pool->setOnSuccess(function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
-                $hit = true;
-            })
-        );
+        call_user_func($failedListener, new RunEvent($run));
 
-        $pool->add($process);
+        $this->assertTrue($pool->hasStarted());
+        $this->assertFalse($pool->isRunning());
+        $this->assertFalse($pool->isSuccessful());
 
-        $pool->run(0);
+        $this->assertTrue($startedHit);
+        $this->assertTrue($failedHit);
 
-        $this->assertTrue($hit);
+        $this->assertEquals([$exception], $pool->getExceptions());
     }
 
-    public function testOnFailureSetterIsCalledForErroredProcess()
+    /**
+     * @expectedException \Graze\ParallelProcess\Exceptions\NotRunningException
+     */
+    public function testPoolUnableToAddRunningProcessWhenPoolHasNotStarted()
     {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false);
-        $process->shouldReceive('poll')->andReturn(false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(false);
-
-        $hit = false;
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('isRunning')
+            ->andReturn(true);
 
         $pool = new Pool();
-        $this->assertSame(
-            $pool,
-            $pool->setOnFailure(function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
-                $hit = true;
-            })
-        );
-
-        $pool->add($process);
 
-        $pool->run(0);
-
-        $this->assertTrue($hit);
+        $pool->add($run);
     }
 
-    public function testOnProgressSetterIsCalledDuringProcessRun()
+    public function testPoolAbleToAddRunningProcessWhenPoolHasStarted()
     {
-        $process = Mockery::mock(Process::class);
-        $process->shouldReceive('stop');
-        $process->shouldReceive('isStarted')->andReturn(true);
-        $process->shouldReceive('isRunning')->andReturn(false, false, true, false);
-        $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(false);
-
-        $hit = false;
-
-        $pool = new Pool();
-        $this->assertSame(
-            $pool,
-            $pool->setOnProgress(function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
-                $hit = true;
-            })
-        );
-
-        $pool->add($process);
+        $run = Mockery::mock(RunInterface::class)
+                      ->allows(['isRunning' => false, 'hasStarted' => false, 'start' => null, 'addListener' => true]);
+        $pool = new Pool([$run]);
+        $pool->start();
 
-        $pool->run(0);
+        $run2 = Mockery::mock(RunInterface::class)
+                       ->allows(['isRunning' => true, 'start' => null, 'addListener' => true]);
+        $pool->add($run2);
 
-        $this->assertTrue($hit);
+        $this->assertEquals(2, $pool->count());
+        $this->assertTrue($pool->isRunning());
     }
 
-    public function testOnStartSetterIsCalledDuringProcessRun()
+    public function testOnProgressIsCalledDuringProcessRun()
     {
         $process = Mockery::mock(Process::class);
         $process->shouldReceive('stop');
         $process->shouldReceive('isStarted')->andReturn(true);
         $process->shouldReceive('isRunning')->andReturn(false, false, true, false);
         $process->shouldReceive('start')->atLeast()->once();
-        $process->shouldReceive('isSuccessful')->once()->andReturn(false);
+        $process->shouldReceive('isSuccessful')->once()->andReturn(true);
 
         $hit = false;
 
         $pool = new Pool();
-        $this->assertSame(
-            $pool,
-            $pool->setOnStart(function ($proc) use ($process, &$hit) {
-                $this->assertEquals($proc, $process);
+        $pool->addListener(
+            RunEvent::UPDATED,
+            function (RunEvent $event) use ($pool, &$hit) {
+                $run = $event->getRun();
+                $this->assertEquals($pool, $run);
                 $hit = true;
-            })
+            }
         );
 
         $pool->add($process);
-
         $pool->run(0);
-
         $this->assertTrue($hit);
     }
 
@@ -378,9 +369,10 @@ public function testPoolInitialStateWithInstantRun()
                           'poll'         => false,
                           'hasStarted'   => true,
                           'isSuccessful' => true,
+                          'addListener'  => true,
                       ]);
 
-        $pool = new Pool([$run], null, null, null, null, Pool::NO_MAX, true);
+        $pool = new Pool([$run], Pool::NO_MAX, true);
 
         $this->assertTrue($pool->hasStarted());
         $this->assertTrue($pool->isRunning());
@@ -396,7 +388,6 @@ public function testPoolInitialStateWithInstantRun()
 
     public function testPoolRunsRunWhenInstantRunIsOn()
     {
-        $run = Mockery::mock(RunInterface::class);
         $pool = new Pool();
         $pool->setRunInstantly(true);
 
@@ -407,6 +398,7 @@ public function testPoolRunsRunWhenInstantRunIsOn()
                           'poll'         => false,
                           'hasStarted'   => true,
                           'isSuccessful' => true,
+                          'addListener'  => true,
                       ]);
 
         $pool->add($run);
@@ -424,7 +416,6 @@ public function testPoolRunsRunWhenInstantRunIsOn()
 
     public function testRunningRunAddingToAnInstantRunProcessCarriesOn()
     {
-        $run = Mockery::mock(RunInterface::class);
         $pool = new Pool();
         $pool->setRunInstantly(true);
 
@@ -435,6 +426,7 @@ public function testRunningRunAddingToAnInstantRunProcessCarriesOn()
                           'poll'         => false,
                           'hasStarted'   => true,
                           'isSuccessful' => true,
+                          'addListener'  => true,
                       ]);
 
         $pool->add($run);
@@ -449,4 +441,88 @@ public function testRunningRunAddingToAnInstantRunProcessCarriesOn()
         $this->assertFalse($pool->isRunning());
         $this->assertTrue($pool->isSuccessful());
     }
+
+    public function testFinished()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('isRunning')
+            ->andReturn(false);
+        $run->shouldReceive('poll')
+            ->andReturn(true, false);
+        $run->shouldReceive('hasStarted')
+            ->andReturn(true);
+        $run->shouldReceive('isSuccessful')
+            ->andReturn(true);
+        $run->allows()
+            ->addListener(RunEvent::FAILED, Mockery::type('callable'));
+
+        $pool = new Pool([$run]);
+
+        $run->shouldReceive('start');
+        $pool->run(0);
+
+        $this->assertEquals([$run], $pool->getFinished());
+    }
+
+    public function testTags()
+    {
+        $pool = new Pool([], Pool::NO_MAX, false, ['tag1', 'key' => 'value']);
+
+        $this->assertSame(['tag1', 'key' => 'value'], $pool->getTags());
+    }
+
+    public function testProgress()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('isRunning')
+            ->andReturn(false);
+        $run->shouldReceive('poll')
+            ->andReturn(true, false);
+        $run->shouldReceive('hasStarted')
+            ->andReturn(true);
+        $run->shouldReceive('isSuccessful')
+            ->andReturn(true);
+        $run->allows()
+            ->addListener(RunEvent::FAILED, Mockery::type('callable'));
+
+        $pool = new Pool([$run]);
+
+        $this->assertEquals([0, 1, 0], $pool->getProgress());
+
+        $run->shouldReceive('start');
+        $pool->run(0);
+
+        $this->assertEquals([1, 1, 1], $pool->getProgress());
+    }
+
+    public function testDuration()
+    {
+        $run = Mockery::mock(RunInterface::class);
+        $run->shouldReceive('isRunning')
+            ->andReturn(false, true, false);
+        $run->shouldReceive('poll')
+            ->andReturn(true, false);
+        $run->shouldReceive('hasStarted')
+            ->andReturn(false, true);
+        $run->shouldReceive('isSuccessful')
+            ->andReturn(true);
+        $run->allows()
+            ->addListener(RunEvent::FAILED, Mockery::type('callable'));
+
+        $pool = new Pool([$run]);
+
+        $this->assertEquals(0, $pool->getDuration());
+
+        $run->shouldReceive('start');
+
+        $pool->start();
+
+        $this->assertGreaterThan(0, $pool->getDuration());
+
+        $pool->run(0);
+
+        $duration = $pool->getDuration();
+
+        $this->assertEquals($duration, $pool->getDuration());
+    }
 }
diff --git a/tests/unit/RunTest.php b/tests/unit/RunTest.php
index 33b3642..314b1a6 100644
--- a/tests/unit/RunTest.php
+++ b/tests/unit/RunTest.php
@@ -1,7 +1,19 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess\Test\Unit;
 
+use Graze\ParallelProcess\Event\RunEvent;
 use Graze\ParallelProcess\Run;
 use Graze\ParallelProcess\RunInterface;
 use Graze\ParallelProcess\Test\TestCase;
@@ -39,6 +51,7 @@ public function testInitialState()
         $this->assertFalse($run->isSuccessful(), 'should not be successful');
         $this->assertTrue($run->isUpdateOnPoll(), 'update on poll should be on by deafult');
         $this->assertTrue($run->isUpdateOnProcessOutput(), 'update on poll should be on by deafult');
+        $this->assertEquals([], $run->getExceptions(), 'no exceptions should be returned');
     }
 
     public function testUpdateOnPoll()
@@ -110,6 +123,31 @@ public function testRun()
         $this->assertTrue($run->hasStarted());
     }
 
+    public function testOnStart()
+    {
+        $process = Mockery::mock(Process::class);
+        $process->shouldReceive('stop');
+
+        $hit = false;
+
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::STARTED,
+            function (RunEvent $event) use (&$run, &$hit) {
+                $this->assertSame($event->getRun(), $run);
+                $hit = true;
+            }
+        );
+
+        $process->shouldReceive('start')->once();
+        $process->shouldReceive('isStarted')->andReturn(true);
+        $process->shouldReceive('isRunning')->andReturn(false);
+        $process->shouldReceive('isSuccessful')->once()->andReturn(true);
+
+        $run->start();
+        $this->assertFalse($run->poll());
+    }
+
     public function testOnSuccess()
     {
         $process = Mockery::mock(Process::class);
@@ -117,10 +155,11 @@ public function testOnSuccess()
 
         $hit = false;
 
-        $run = new Run(
-            $process,
-            function ($proc) use ($process, &$hit) {
-                $this->assertSame($proc, $process);
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::COMPLETED,
+            function (RunEvent $event) use (&$run, &$hit) {
+                $this->assertSame($event->getRun(), $run);
                 $hit = true;
             }
         );
@@ -141,11 +180,11 @@ public function testOnFailure()
 
         $hit = false;
 
-        $run = new Run(
-            $process,
-            null,
-            function ($proc) use ($process, &$hit) {
-                $this->assertSame($proc, $process);
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::FAILED,
+            function (RunEvent $event) use (&$run, &$hit) {
+                $this->assertSame($event->getRun(), $run);
                 $hit = true;
             }
         );
@@ -166,12 +205,11 @@ public function testOnProgress()
 
         $hit = false;
 
-        $run = new Run(
-            $process,
-            null,
-            null,
-            function ($proc) use ($process, &$hit) {
-                $this->assertSame($proc, $process);
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::UPDATED,
+            function (RunEvent $event) use (&$run, &$hit) {
+                $this->assertSame($event->getRun(), $run);
                 $hit = true;
             }
         );
@@ -216,13 +254,15 @@ function (callable $fn) {
                 )
                 ->once();
 
-        $run = new Run(
-            $process,
-            function ($proc, $dur, $last, $lastType) use ($process) {
-                $this->assertSame($process, $proc);
-                $this->assertInternalType('float', $dur);
-                $this->assertEquals('some text', $last);
-                $this->assertEquals(Process::OUT, $lastType);
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::UPDATED,
+            function (RunEvent $event) use (&$run, &$hits) {
+                $this->assertSame($event->getRun(), $run);
+                $this->assertInternalType('float', $run->getDuration());
+                $this->assertEquals('some text', $run->getLastMessage());
+                $this->assertEquals(Process::OUT, $run->getLastMessageType());
+                $hits++;
             }
         );
 
@@ -252,15 +292,14 @@ function (callable $fn) {
                 ->once();
 
         $hits = 0;
-        $run = new Run(
-            $process,
-            null,
-            null,
-            function ($proc, $dur, $last, $lastType) use ($process, &$hits) {
-                $this->assertSame($process, $proc);
-                $this->assertInternalType('float', $dur);
-                $this->assertContains($last, ['line 1', 'line 2']);
-                $this->assertEquals(Process::OUT, $lastType);
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::UPDATED,
+            function (RunEvent $event) use (&$run, &$hits) {
+                $this->assertSame($event->getRun(), $run);
+                $this->assertInternalType('float', $run->getDuration());
+                $this->assertContains($run->getLastMessage(), ['line 1', 'line 2']);
+                $this->assertEquals(Process::OUT, $run->getLastMessageType());
                 $hits++;
             }
         );
@@ -281,10 +320,9 @@ public function testUpdateOnPollOffDoesNotUpdateOnPoll()
 
         $process->shouldReceive('start')->once();
 
-        $run = new Run(
-            $process,
-            null,
-            null,
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::UPDATED,
             function () {
                 $this->fail('onProgress should not be called');
             }
@@ -317,10 +355,9 @@ function (callable $fn) {
                 )
                 ->once();
 
-        $run = new Run(
-            $process,
-            null,
-            null,
+        $run = new Run($process);
+        $run->addListener(
+            RunEvent::UPDATED,
             function () {
                 $this->fail('onProgress should not be called');
             }
diff --git a/tests/unit/TableTest.php b/tests/unit/TableTest.php
index 25cbda0..860b6ae 100644
--- a/tests/unit/TableTest.php
+++ b/tests/unit/TableTest.php
@@ -1,8 +1,20 @@
 <?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
 
 namespace Graze\ParallelProcess\Test\Unit;
 
 use Graze\ParallelProcess\Pool;
+use Graze\ParallelProcess\Run;
 use Graze\ParallelProcess\Table;
 use Graze\ParallelProcess\Test\BufferDiffOutput;
 use Graze\ParallelProcess\Test\TestCase;
@@ -88,7 +100,7 @@ public function testSpinnerLoop()
         );
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
 
-        $this->table->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         $this->table->run(0);
 
@@ -111,6 +123,126 @@ public function testSpinnerLoop()
         $this->compareOutputs($expected, $this->bufferOutput->getWritten());
     }
 
+    public function testProgressBar()
+    {
+        $this->table->setShowSummary(false);
+        $this->bufferOutput->setVerbosity(OutputInterface::VERBOSITY_VERBOSE);
+
+        $process = Mockery::mock(Process::class);
+        $process->shouldReceive('stop');
+        $process->shouldReceive('start')->once();
+        $process->shouldReceive('isStarted')->andReturn(true);
+        $process->shouldReceive('isRunning')->andReturn(
+            false, // add
+            false, // start
+            true,  // check
+            true,  // ...
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false // complete
+        );
+        $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
+
+        $run = Mockery::mock(Run::class, [$process, ['key' => 'value']])->makePartial();
+        $this->pool->add($run);
+
+        $run->allows()
+            ->getProgress()
+            ->andReturns(
+                [0, 100, 0],
+                [5, 100, 0.05],
+                [10, 100, 0.1],
+                [15, 100, 0.15],
+                [20, 100, 0.2],
+                [25, 100, 0.25],
+                [30, 100, 0.3],
+                [35, 100, 0.35],
+                [40, 100, 0.4],
+                [45, 100, 0.45],
+                [50, 100, 0.5],
+                [55, 100, 0.55],
+                [60, 100, 0.6],
+                [65, 100, 0.65],
+                [70, 100, 0.7],
+                [75, 100, 0.75],
+                [80, 100, 0.8],
+                [85, 100, 0.85],
+                [90, 100, 0.9],
+                [95, 100, 0.95],
+                [100, 100, 1]
+            );
+        $run->allows()
+            ->getDuration()
+            ->andReturns(
+                0,
+                0.05,
+                0.1,
+                0.15,
+                0.2,
+                0.25,
+                0.3,
+                0.35,
+                0.4,
+                0.45,
+                0.5,
+                0.55,
+                0.6,
+                0.65,
+                0.7,
+                0.75,
+                0.8,
+                0.85,
+                0.9,
+                0.95,
+                1
+            );
+
+        $this->table->run(0);
+
+        $expected = [
+            ['/<info>key<\/info>: value \(<comment>  0.00s<\/comment>\) /'],
+            ['/<info>key<\/info>: value \(<comment>  0.00s<\/comment>\) ▕<comment>  <\/comment>▏<info>  0%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.05s<\/comment>\) ▕<comment>▏ <\/comment>▏<info>  5%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.10s<\/comment>\) ▕<comment>▎ <\/comment>▏<info> 10%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.15s<\/comment>\) ▕<comment>▍ <\/comment>▏<info> 15%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.20s<\/comment>\) ▕<comment>▍ <\/comment>▏<info> 20%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.25s<\/comment>\) ▕<comment>▌ <\/comment>▏<info> 25%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.30s<\/comment>\) ▕<comment>▋ <\/comment>▏<info> 30%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.35s<\/comment>\) ▕<comment>▋ <\/comment>▏<info> 35%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.40s<\/comment>\) ▕<comment>▊ <\/comment>▏<info> 40%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.45s<\/comment>\) ▕<comment>▉ <\/comment>▏<info> 45%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.50s<\/comment>\) ▕<comment>█ <\/comment>▏<info> 50%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.55s<\/comment>\) ▕<comment>█▏<\/comment>▏<info> 55%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.60s<\/comment>\) ▕<comment>█▎<\/comment>▏<info> 60%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.65s<\/comment>\) ▕<comment>█▍<\/comment>▏<info> 65%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.70s<\/comment>\) ▕<comment>█▍<\/comment>▏<info> 70%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.75s<\/comment>\) ▕<comment>█▌<\/comment>▏<info> 75%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.80s<\/comment>\) ▕<comment>█▋<\/comment>▏<info> 80%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.85s<\/comment>\) ▕<comment>█▋<\/comment>▏<info> 85%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.90s<\/comment>\) ▕<comment>█▊<\/comment>▏<info> 90%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  0.95s<\/comment>\) ▕<comment>█▉<\/comment>▏<info> 95%<\/info>/'],
+            ['/<info>key<\/info>: value \(<comment>  1.00s<\/comment>\) <info>✓<\/info>/'],
+        ];
+
+        $this->compareOutputs($expected, $this->bufferOutput->getWritten());
+    }
+
     public function testValueDataArrayDoesNotShowTheKey()
     {
         $this->table->setShowSummary(false);
@@ -128,7 +260,7 @@ public function testValueDataArrayDoesNotShowTheKey()
         );
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
 
-        $this->table->add($process, ['value', 'value2']);
+        $this->pool->add($process, ['value', 'value2']);
 
         $this->table->run(0);
 
@@ -160,7 +292,7 @@ public function testSummaryIsWaitingBeforeTheProcessStarts()
         $process->shouldReceive('isSuccessful')->atLeast()->once()->andReturn(true);
         $process->shouldReceive('getOutput')->andReturn('some text');
 
-        $this->table->add($process, ['key' => 'value']);
+        $this->pool->add($process, ['key' => 'value']);
 
         try {
             $this->table->run(0);
@@ -235,7 +367,7 @@ public function testOutput($verbosity, $showOutput, $showSummary, array $process
                 $oneFails = true;
             }
 
-            $this->table->add($process, ['key' => 'value', 'run' => $i]);
+            $this->pool->add($process, ['key' => 'value', 'run' => $i]);
         }
 
         try {
@@ -256,24 +388,24 @@ public function outputData()
     {
         return [
             [ // verbose with single valid run
-                OutputInterface::VERBOSITY_VERBOSE,
-                false,
-                false,
-                [true],
-                [
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%'],
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%'],
-                ],
+              OutputInterface::VERBOSITY_VERBOSE,
+              false,
+              false,
+              [true],
+              [
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%'],
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%'],
+              ],
             ],
             [ // normal verbosity only writes a single line
-                OutputInterface::VERBOSITY_NORMAL,
-                false,
-                false,
-                [true],
-                [
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%'],
-                ],
+              OutputInterface::VERBOSITY_NORMAL,
+              false,
+              false,
+              [true],
+              [
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%'],
+              ],
             ],
             [
                 OutputInterface::VERBOSITY_NORMAL,
@@ -286,44 +418,44 @@ public function outputData()
                 ],
             ],
             [ // multiple runs with verbosity will update each item one at a time
-                OutputInterface::VERBOSITY_VERBOSE,
-                false,
-                false,
-                [true, true],
-                [
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                    ],
-                ],
+              OutputInterface::VERBOSITY_VERBOSE,
+              false,
+              false,
+              [true, true],
+              [
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                  ],
+              ],
             ],
             [ // errors will display an error
-                OutputInterface::VERBOSITY_VERBOSE,
-                false,
-                false,
-                [false],
-                [
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%'],
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%'],
-                    [
-                        <<<DOC
+              OutputInterface::VERBOSITY_VERBOSE,
+              false,
+              false,
+              [false],
+              [
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%'],
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%'],
+                  [
+                      <<<DOC
 %The command "test" failed.
 
 Exit Code: 1\(failed\)
@@ -338,19 +470,19 @@ public function outputData()
 ================
 some error text%
 DOC
-                        ,
-                    ],
-                ],
+                      ,
+                  ],
+              ],
             ],
             [ // errors will display an error
-                OutputInterface::VERBOSITY_NORMAL,
-                false,
-                false,
-                [false],
-                [
-                    ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%'],
-                    [
-                        <<<DOC
+              OutputInterface::VERBOSITY_NORMAL,
+              false,
+              false,
+              [false],
+              [
+                  ['%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%'],
+                  [
+                      <<<DOC
 %The command "test" failed.
 
 Exit Code: 1\(failed\)
@@ -365,38 +497,38 @@ public function outputData()
 ================
 some error text%
 DOC
-                        ,
-                    ],
-                ],
+                      ,
+                  ],
+              ],
             ],
             [ // multiple runs with verbosity will update each item one at a time
-                OutputInterface::VERBOSITY_VERBOSE,
-                false,
-                false,
-                [true, false],
-                [
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%',
-                    ],
-                    [
-                        <<<DOC
+              OutputInterface::VERBOSITY_VERBOSE,
+              false,
+              false,
+              [true, false],
+              [
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <error>x</error>%',
+                  ],
+                  [
+                      <<<DOC
 %The command "test" failed.
 
 Exit Code: 1\(failed\)
@@ -411,58 +543,58 @@ public function outputData()
 ================
 some error text%
 DOC
-                        ,
-                    ],
-                ],
+                      ,
+                  ],
+              ],
             ],
             [ // include output
-                OutputInterface::VERBOSITY_VERBOSE,
-                true,
-                false,
-                [true],
-                [
-                    ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
-                    ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]  some text%'],
-                    ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>  some text%'],
-                ],
+              OutputInterface::VERBOSITY_VERBOSE,
+              true,
+              false,
+              [true],
+              [
+                  ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %'],
+                  ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]  some text%'],
+                  ['%(*UTF8)<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>  some text%'],
+              ],
             ],
             [ // include a summary
-                OutputInterface::VERBOSITY_VERBOSE,
-                false,
-                true,
-                [true, true],
-                [
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                        '%^$%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
-                        '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
-                        '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
-                    ],
-                    [
-                        '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
-                        '%^$%',
-                    ],
-                ],
+              OutputInterface::VERBOSITY_VERBOSE,
+              false,
+              true,
+              [true, true],
+              [
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) %',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                      '%^$%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) %',
+                      '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) [⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]%',
+                      '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<comment>Total</comment>:  2, <comment>Running</comment>:  2, <comment>Waiting</comment>:  0%',
+                  ],
+                  [
+                      '%<info>key</info>: value <info>run</info>: 0 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%<info>key</info>: value <info>run</info>: 1 \(<comment>[ 0-9\.s]+</comment>\) <info>✓</info>%',
+                      '%^$%',
+                  ],
+              ],
             ],
         ];
     }
diff --git a/tests/unit/TinyProgressBarTest.php b/tests/unit/TinyProgressBarTest.php
new file mode 100644
index 0000000..f2f5b7d
--- /dev/null
+++ b/tests/unit/TinyProgressBarTest.php
@@ -0,0 +1,156 @@
+<?php
+/**
+ * This file is part of graze/parallel-process.
+ *
+ * Copyright © 2018 Nature Delivered Ltd. <https://www.graze.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @license https://github.com/graze/parallel-process/blob/master/LICENSE.md
+ * @link    https://github.com/graze/parallel-process
+ */
+
+namespace Graze\ParallelProcess\Test\Unit;
+
+use Graze\ParallelProcess\Test\TestCase;
+use Graze\ParallelProcess\TinyProgressBar;
+
+class TinyProgressBarTest extends TestCase
+{
+    /**
+     * @dataProvider barDataProvider
+     *
+     * @param int    $length
+     * @param float  $position
+     * @param float  $max
+     * @param string $expected
+     * @param string $format
+     * @param array  $barChars
+     */
+    public function testBar(
+        $length,
+        $position,
+        $max,
+        $expected,
+        $format = '▕{bar}▏{perc} {position}/{max}',
+        array $barChars = []
+    ) {
+        $bar = new TinyProgressBar($length, $format, $max);
+
+        if (count($barChars) > 0) {
+            $bar->setBarCharacters($barChars);
+        }
+
+        $bar->setPosition($position);
+
+        $this->assertEquals($expected, $bar->render());
+    }
+
+    /**
+     * @return array
+     */
+    public function barDataProvider()
+    {
+        return [
+            [3, 10, 100, '▕▍  ▏ 10% 10/100'],
+            [3, 1, 100, '▕▏  ▏  1% 1/100'], // anything over 0 will display something
+            [3, 0, 100, '▕   ▏  0% 0/100'],
+            [3, 100, 100, '▕███▏100% 100/100'],
+            [3, 99, 100, '▕██▉▏ 99% 99/100'], // 99% will display less than 100%
+            [5, 20, 100, '▕█    ▏ 20% 20/100'],
+            [3, 0.3, 1, '▕▉  ▏ 30% 0.3/1'],
+            [10, 12.5, 120, '▕█         ▏ 10% 12.5/120'],
+            [3, -10, 100, '▕   ▏  0% 0/100'], // position must be greater than or equal to than 0
+            [3, 120, 100, '▕███▏100% 100/100'], // position must be less than or equal to max
+            [3, 100, 100, '▕███▏100%', '▕{bar}▏{perc}'],
+            [3, 100, 100, '▕███▏', '▕{bar}▏'],
+            [3, 100, 100, '███', '{bar}'],
+            [3, 100, 100, '100/100', '{position}/{max}'],
+            [3, 100, 100, '100%', '{perc}'],
+            [10, 15, 100, '▕█▄        ▏ 15% 15/100', '▕{bar}▏{perc} {position}/{max}', [" ", "▄", "█"]],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidLengthsData
+     * @expectedException \InvalidArgumentException
+     *
+     * @param int $length
+     */
+    public function testInvalidLengthWillThrowAnException($length)
+    {
+        new TinyProgressBar($length);
+    }
+
+    /**
+     * @return array
+     */
+    public function invalidLengthsData()
+    {
+        return [
+            [0],
+            [-1],
+            [-9223372036854775808],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidMaxData
+     * @expectedException \InvalidArgumentException
+     *
+     * @param int $max
+     */
+    public function testInvalidMaximumValuesWillThrowAnException($max)
+    {
+        new TinyProgressBar(3, TinyProgressBar::FORMAT_DEFAULT, $max);
+    }
+
+    /**
+     * @return array
+     */
+    public function invalidMaxData()
+    {
+        return [
+            [0],
+            [-1],
+            [-9223372036854775808],
+        ];
+    }
+
+    public function testAccessors()
+    {
+        $bar = new TinyProgressBar(5);
+
+        $this->assertEquals(0, $bar->getPosition());
+        $this->assertEquals(100, $bar->getMax());
+        $this->assertEquals(5, $bar->getLength());
+        $this->assertEquals(TinyProgressBar::FORMAT_DEFAULT, $bar->getFormat());
+
+        $this->assertSame($bar, $bar->setPosition(5));
+        $this->assertSame($bar, $bar->setMax(200));
+        $this->assertSame($bar, $bar->setLength(10));
+        $this->assertSame($bar, $bar->setFormat(TinyProgressBar::FORMAT_SHORT));
+
+        $this->assertEquals(5, $bar->getPosition());
+        $this->assertEquals(200, $bar->getMax());
+        $this->assertEquals(10, $bar->getLength());
+        $this->assertEquals(TinyProgressBar::FORMAT_SHORT, $bar->getFormat());
+    }
+
+    public function testAdvance()
+    {
+        $bar = new TinyProgressBar(5);
+
+        $this->assertEquals(0, $bar->getPosition());
+
+        $this->assertSame($bar, $bar->advance());
+        $this->assertEquals(1, $bar->getPosition());
+
+        $this->assertSame($bar, $bar->advance(3));
+        $this->assertEquals(4, $bar->getPosition());
+
+        $this->assertSame($bar, $bar->advance(0.2));
+        $this->assertEquals(4.2, $bar->getPosition(), '', 0.00001);
+    }
+}