diff --git a/build.bat b/build.bat
index 094a0ff..4c984ad 100644
--- a/build.bat
+++ b/build.bat
@@ -1,2 +1,2 @@
-"C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe" ^
+"C:\Program Files (x86)\MSBuild\14.0\Bin\MsBuild.exe" ^
   build\Build.proj /p:NuspecFile=build\ShellProgressBar.nuspec;BUILD_NUMBER=%1 /t:NugetPackage
\ No newline at end of file
diff --git a/build/Build.proj b/build/Build.proj
index 277fa3f..6aa2816 100644
--- a/build/Build.proj
+++ b/build/Build.proj
@@ -33,7 +33,7 @@
                 
 		  AssemblyVersion="$(Version)"
 		  AssemblyFileVersion="$(Version)"/>
-		<MSBuild Projects="$(SolutionFile)" Properties="Configuration=$(Configuration)"  />
+		<MSBuild Projects="$(SolutionFile)" Properties="Configuration=$(Configuration)"  ToolsVersion="14.0" />
 	</Target>
 
 	<Target Name="NuGetPackage" DependsOnTargets="Compile">
diff --git a/src/ShellProgressBar.Example/Examples/DeeplyNestedProgressBarTreeExample.cs b/src/ShellProgressBar.Example/Examples/DeeplyNestedProgressBarTreeExample.cs
new file mode 100644
index 0000000..398a17c
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/DeeplyNestedProgressBarTreeExample.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class DeeplyNestedProgressBarTreeExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var random = new Random();
+
+			var numberOfSteps = 7;
+
+			var overProgressOptions = new ProgressBarOptions
+			{
+				BackgroundColor = ConsoleColor.DarkGray,
+			};
+
+			using (var pbar = new ProgressBar(numberOfSteps, "overal progress", overProgressOptions))
+			{
+				var stepBarOptions = new ProgressBarOptions
+				{
+					ForeGroundColor = ConsoleColor.Cyan,
+					ForeGroundColorDone = ConsoleColor.DarkGreen,
+					ProgressCharacter = '─',
+					BackgroundColor = ConsoleColor.DarkGray,
+					CollapseWhenFinished = false,
+
+				} ;
+				Parallel.For(0, numberOfSteps, (i) =>
+				{
+					var workBarOptions = new ProgressBarOptions
+					{
+						ForeGroundColor = ConsoleColor.Yellow,
+						ProgressCharacter = '─',
+						BackgroundColor = ConsoleColor.DarkGray,
+					};
+					var childSteps = random.Next(1, 5);
+					using (var childProgress = pbar.Spawn(childSteps, $"step {i} progress", stepBarOptions))
+						Parallel.For(0, childSteps, (ci) =>
+						{
+							var childTicks = random.Next(50, 250);
+							using (var innerChildProgress = childProgress.Spawn(childTicks, $"step {i}::{ci} progress", workBarOptions))
+							{
+								for (var r = 0; r < childTicks; r++)
+								{
+									innerChildProgress.Tick();
+									Program.BusyWait(50);
+								}
+							}
+							childProgress.Tick();
+						});
+					
+					pbar.Tick();
+				});
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/DrawsOnlyOnTickExample.cs b/src/ShellProgressBar.Example/Examples/DrawsOnlyOnTickExample.cs
new file mode 100644
index 0000000..734f19b
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/DrawsOnlyOnTickExample.cs
@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class DrawsOnlyOnTickExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 5;
+			var updateOnTicksOnlyOptions = new ProgressBarOptions {DisplayTimeInRealTime = false};
+			using (var pbar = new ProgressBar(ticks, "only update time on ticks", updateOnTicksOnlyOptions))
+			{
+				for (var i = 0; i < ticks; i++)
+				{
+					pbar.Tick("only update time on ticks, current: " + i);
+					Thread.Sleep(1750);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/LongRunningExample.cs b/src/ShellProgressBar.Example/Examples/LongRunningExample.cs
new file mode 100644
index 0000000..18f0efa
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/LongRunningExample.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class LongRunningExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 100;
+			using (var pbar = new ProgressBar(ticks, "my long running operation", ConsoleColor.Green))
+			{
+				for (var i = 0; i < ticks; i++)
+				{
+					pbar.Tick("step " + i);
+					Thread.Sleep(50);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/NegativeMaxTicksExample.cs b/src/ShellProgressBar.Example/Examples/NegativeMaxTicksExample.cs
new file mode 100644
index 0000000..0f8df1d
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/NegativeMaxTicksExample.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class NegativeMaxTicksExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = -100;
+			using (var pbar = new ProgressBar(ticks, "my operation with negative ticks", ConsoleColor.Cyan))
+			{
+				for (var i = 0; i < ticks; i++)
+				{
+					pbar.Tick("step " + i);
+					Thread.Sleep(50);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/NestedProgressBarPerStepProgress.cs b/src/ShellProgressBar.Example/Examples/NestedProgressBarPerStepProgress.cs
new file mode 100644
index 0000000..f5b0e0a
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/NestedProgressBarPerStepProgress.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class NestedProgressBarPerStepProgress : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var outerTicks = 10;
+			using (var pbar = new ProgressBar(outerTicks, "outer progress", ConsoleColor.Cyan))
+			{
+				for (var i = 0; i < outerTicks; i++)
+				{
+					InnerProgressBars(pbar);
+					pbar.Tick();
+				}
+			}
+			return Task.FromResult(1);
+		}
+
+		private static void InnerProgressBars(ProgressBar pbar)
+		{
+			var innerProgressBars = Enumerable.Range(0, new Random().Next(2, 6))
+				.Select(s => pbar.Spawn(new Random().Next(2, 5), $"inner bar {s}"))
+				.ToList();
+
+			var maxTicks = innerProgressBars.Max(p => p.MaxTicks);
+
+			for (var ii = 0; ii < maxTicks; ii++)
+			{
+				foreach (var p in innerProgressBars)
+				{
+					InnerInnerProgressBars(p);
+					p.Tick();
+				}
+
+
+				Thread.Sleep(4);
+			}
+			foreach (var p in innerProgressBars) p.Dispose();
+		}
+
+		private static void InnerInnerProgressBars(ChildProgressBar pbar)
+		{
+			var progressBarOption = new ProgressBarOptions { ForeGroundColor = ConsoleColor.Yellow };
+			var innerProgressBars = Enumerable.Range(0, new Random().Next(1, 3))
+				.Select(s => pbar.Spawn(new Random().Next(5, 10), $"inner bar {s}", progressBarOption))
+				.ToList();
+			if (!innerProgressBars.Any()) return;
+
+			var maxTicks = innerProgressBars.Max(p => p.MaxTicks);
+
+			for (var ii = 0; ii < maxTicks; ii++)
+			{
+				foreach (var p in innerProgressBars)
+					p.Tick();
+			}
+			foreach (var p in innerProgressBars) p.Dispose();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/NeverCompletesExample.cs b/src/ShellProgressBar.Example/Examples/NeverCompletesExample.cs
new file mode 100644
index 0000000..6c21404
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/NeverCompletesExample.cs
@@ -0,0 +1,21 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class NeverCompletesExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 5;
+			using (var pbar = new ProgressBar(ticks, "A console progress bar does not complete"))
+			{
+				pbar.Tick();
+				pbar.Tick();
+				pbar.Tick();
+				pbar.Tick();
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/NeverTicksExample.cs b/src/ShellProgressBar.Example/Examples/NeverTicksExample.cs
new file mode 100644
index 0000000..a45acfa
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/NeverTicksExample.cs
@@ -0,0 +1,17 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class NeverTicksExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 10;
+			using (var pbar = new ProgressBar(ticks, "A console progress bar that never ticks"))
+			{
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/ThreadedTicksOverflowExample.cs b/src/ShellProgressBar.Example/Examples/ThreadedTicksOverflowExample.cs
new file mode 100644
index 0000000..1a602e2
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/ThreadedTicksOverflowExample.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class ThreadedTicksOverflowExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 200;
+			using (var pbar = new ProgressBar(ticks/10, "My operation that ticks to often using threads", ConsoleColor.Cyan))
+			{
+				var threads = Enumerable.Range(0, ticks).Select(i => new Thread(() => pbar.Tick("threaded tick " + i))).ToList();
+				foreach (var thread in threads) thread.Start();
+				foreach (var thread in threads) thread.Join();
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/TicksOverflowExample.cs b/src/ShellProgressBar.Example/Examples/TicksOverflowExample.cs
new file mode 100644
index 0000000..a3d6c2c
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/TicksOverflowExample.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class TicksOverflowExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 10;
+			using (var pbar = new ProgressBar(ticks, "My operation that ticks to often", ConsoleColor.Cyan))
+			{
+				for (var i = 0; i < ticks*10; i++)
+				{
+					pbar.Tick("too many steps " + i);
+					Thread.Sleep(50);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/UpdatesMaxTicksExample.cs b/src/ShellProgressBar.Example/Examples/UpdatesMaxTicksExample.cs
new file mode 100644
index 0000000..8d022c3
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/UpdatesMaxTicksExample.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class UpdatesMaxTicksExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 10;
+			using (var pbar = new ProgressBar(ticks, "My operation that updates maxTicks", ConsoleColor.Cyan))
+			{
+				var sleep = 1000;
+				for (var i = 0; i < ticks; i++)
+				{
+					pbar.Tick("Updating maximum ticks " + i);
+					if (i == 5)
+					{
+						ticks = 120;
+						pbar.UpdateMaxTicks(ticks);
+						sleep = 50;
+					}
+					Thread.Sleep(sleep);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Examples/ZeroMaxTicksExample.cs b/src/ShellProgressBar.Example/Examples/ZeroMaxTicksExample.cs
new file mode 100644
index 0000000..184c7ef
--- /dev/null
+++ b/src/ShellProgressBar.Example/Examples/ZeroMaxTicksExample.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example.Examples
+{
+	public class ZeroMaxTicksExample : IProgressBarExample
+	{
+		public Task Start(CancellationToken token)
+		{
+			var ticks = 0;
+			using (var pbar = new ProgressBar(ticks, "my operation with zero ticks", ConsoleColor.Cyan))
+			{
+				for (var i = 0; i < ticks; i++)
+				{
+					pbar.Tick("step " + i);
+					Thread.Sleep(50);
+				}
+			}
+			return Task.FromResult(1);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/IProgressBarExample.cs b/src/ShellProgressBar.Example/IProgressBarExample.cs
new file mode 100644
index 0000000..297b7ea
--- /dev/null
+++ b/src/ShellProgressBar.Example/IProgressBarExample.cs
@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ShellProgressBar.Example
+{
+	public interface IProgressBarExample
+	{
+		Task Start(CancellationToken token);
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar.Example/Program.cs b/src/ShellProgressBar.Example/Program.cs
index 1274b9a..cfaceb5 100644
--- a/src/ShellProgressBar.Example/Program.cs
+++ b/src/ShellProgressBar.Example/Program.cs
@@ -1,71 +1,64 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using ShellProgressBar.Example.Examples;
 
 namespace ShellProgressBar.Example
 {
 	class Program
 	{
+		private static readonly IList<IProgressBarExample> ExampleProgressBars = new List<IProgressBarExample>
+		{
+			new DeeplyNestedProgressBarTreeExample(),
+			new NestedProgressBarPerStepProgress(),
+			new DrawsOnlyOnTickExample(),
+			new ThreadedTicksOverflowExample(),
+			new TicksOverflowExample(),
+			new NegativeMaxTicksExample(),
+			new ZeroMaxTicksExample(),
+			new LongRunningExample(),
+			new NeverCompletesExample(),
+			new UpdatesMaxTicksExample(),
+			new NeverTicksExample(),
+		};
+
 		static void Main(string[] args)
 		{
-			var ticks = 10;
-			using (var pbar = new ProgressBar(ticks, "A console progress bar that never ticks"))
-			{
-			}
-			using (var pbar = new ProgressBar(ticks, "A console progress bar does not complete"))
-			{
-				pbar.Tick();
-				pbar.Tick();
-				pbar.Tick();
-				pbar.Tick();
-			}
-			ticks = 100;
-			using (var pbar = new ProgressBar(ticks, "my long running operation", ConsoleColor.Green))
-			{
-				for (var i = 0; i < ticks; i++)
-				{
-					pbar.Tick("step " + i);
-					Thread.Sleep(50);
-				}
-			}
-			ticks = 0;
-			using (var pbar = new ProgressBar(ticks, "my operation with zero ticks", ConsoleColor.Cyan))
-			{
-				for (var i = 0; i < ticks; i++)
-				{
-					pbar.Tick("step " + i);
-					Thread.Sleep(50);
-				}
-			}
-			ticks = -100;
-			using (var pbar = new ProgressBar(ticks, "my operation with negative ticks", ConsoleColor.Cyan))
-			{
-				for (var i = 0; i < ticks; i++)
-				{
-					pbar.Tick("step " + i);
-					Thread.Sleep(50);
-				}
-			}
-			ticks = 10;
-			using (var pbar = new ProgressBar(ticks, "My operation that ticks to often", ConsoleColor.Cyan))
+			Console.WindowWidth = Console.LargestWindowWidth / 2;
+			Console.WindowHeight = Console.LargestWindowHeight / 3;
+
+			var cts = new CancellationTokenSource();
+
+			Console.CancelKeyPress += (s, e) =>
 			{
-				for (var i = 0; i < ticks * 10; i++)
-				{
-					pbar.Tick("too many steps " + i);
-					Thread.Sleep(50);
-				}
-			}
-			ticks = 200;
-			using (var pbar = new ProgressBar(ticks / 10, "My operation that ticks to often using threads", ConsoleColor.Cyan))
+				e.Cancel = true;
+				cts.Cancel();
+			};
+
+			MainAsync(args, cts.Token).GetAwaiter().GetResult();
+		}
+
+		static async Task MainAsync(string[] args, CancellationToken token)
+		{
+			foreach (var example in ExampleProgressBars)
 			{
-				var threads = Enumerable.Range(0, ticks).Select(i => new Thread(() => pbar.Tick("threaded tick " + i))).ToList();
-				foreach (var thread in threads) thread.Start();
-				foreach (var thread in threads) thread.Join();
+				await example.Start(token);
+				Console.Clear();
 			}
+
 			Console.ReadLine();
 		}
+		public static void BusyWait(int milliseconds)
+		{
+		    var sw = Stopwatch.StartNew();
+
+		    while (sw.ElapsedMilliseconds < milliseconds)
+		        Thread.SpinWait(1000);
+		}
+
 	}
 }
diff --git a/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj b/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj
index a428070..79fda04 100644
--- a/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj
+++ b/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj
@@ -42,8 +42,20 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Examples\DeeplyNestedProgressBarTreeExample.cs" />
+    <Compile Include="Examples\DrawsOnlyOnTickExample.cs" />
+    <Compile Include="Examples\LongRunningExample.cs" />
+    <Compile Include="Examples\NegativeMaxTicksExample.cs" />
+    <Compile Include="Examples\NeverCompletesExample.cs" />
+    <Compile Include="Examples\NeverTicksExample.cs" />
+    <Compile Include="Examples\TicksOverflowExample.cs" />
+    <Compile Include="Examples\UpdatesMaxTicksExample.cs" />
+    <Compile Include="Examples\ZeroMaxTicksExample.cs" />
+    <Compile Include="IProgressBarExample.cs" />
+    <Compile Include="Examples\NestedProgressBarPerStepProgress.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Examples\ThreadedTicksOverflowExample.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
@@ -54,6 +66,7 @@
       <Name>ShellProgressBar</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/ShellProgressBar.sln b/src/ShellProgressBar.sln
index 6551f3f..97d5f25 100644
--- a/src/ShellProgressBar.sln
+++ b/src/ShellProgressBar.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
-VisualStudioVersion = 14.0.23107.0
+VisualStudioVersion = 14.0.24720.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ShellProgressBar", "ShellProgressBar\ShellProgressBar.csproj", "{4767E390-2159-470C-AE49-E75E2DDF80A4}"
 EndProject
@@ -17,6 +17,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		..\build.bat = ..\build.bat
 		..\build\Build.proj = ..\build\Build.proj
+		..\README.md = ..\README.md
+		..\build\ShellProgressBar.nuspec = ..\build\ShellProgressBar.nuspec
 	EndProjectSection
 EndProject
 Global
diff --git a/src/ShellProgressBar/ChildProgressBar.cs b/src/ShellProgressBar/ChildProgressBar.cs
new file mode 100644
index 0000000..442b90f
--- /dev/null
+++ b/src/ShellProgressBar/ChildProgressBar.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace ShellProgressBar
+{
+	public class ChildProgressBar : ProgressBarBase, IProgressBar
+	{
+		private readonly Action _scheduleDraw;
+		private readonly Action<ProgressBarHeight> _growth;
+
+		public DateTime StartDate { get; }  = DateTime.Now;
+
+		protected override void DisplayProgress() => _scheduleDraw?.Invoke();
+
+		internal ChildProgressBar(int maxTicks, string message, Action scheduleDraw, ProgressBarOptions options = null, Action<ProgressBarHeight> growth = null)
+			: base(maxTicks, message, options)
+		{
+			_scheduleDraw = scheduleDraw;
+			_growth = growth;
+			_growth?.Invoke(ProgressBarHeight.Increment);
+		}
+
+		private bool _calledDone;
+		private readonly object _callOnce = new object();
+
+		protected override void OnDone()
+		{
+			if (_calledDone) return;
+			lock(_callOnce)
+			{
+				if (_calledDone) return;
+
+				if (this.EndTime == null)
+					this.EndTime = DateTime.Now;
+
+				if (this.Collapse)
+					_growth?.Invoke(ProgressBarHeight.Decrement);
+
+				_calledDone = true;
+			}
+
+		}
+
+		public void Dispose()
+		{
+			OnDone();
+			foreach (var c in this.Children) c.Dispose();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar/IProgressBar.cs b/src/ShellProgressBar/IProgressBar.cs
new file mode 100644
index 0000000..7bd65fc
--- /dev/null
+++ b/src/ShellProgressBar/IProgressBar.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace ShellProgressBar
+{
+	public interface IProgressBar : IDisposable
+	{
+		ChildProgressBar Spawn(int maxTicks, string message, ProgressBarOptions options = null);
+
+		void Tick(string message = "");
+
+		double Percentage { get; }
+		int CurrentTick { get; }
+		int MaxTicks { get; }
+
+		ConsoleColor ForeGroundColor { get; }
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar/ProgressBar.cs b/src/ShellProgressBar/ProgressBar.cs
index c6bc8ab..73c29c3 100644
--- a/src/ShellProgressBar/ProgressBar.cs
+++ b/src/ShellProgressBar/ProgressBar.cs
@@ -1,119 +1,279 @@
 using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 
 namespace ShellProgressBar
 {
-    public class ProgressBar : IDisposable
+	public class ProgressBar : ProgressBarBase, IDisposable, IProgressBar
     {
-        private static readonly object _lock = new object();
+        private static readonly object Lock = new object();
 
-        private readonly int _maxTicks;
-        private readonly ConsoleColor _color;
-        private readonly DateTime _startDate = DateTime.Now;
+		private readonly ConsoleColor _originalColor;
+	    private readonly int _originalCursorTop;
+		private readonly int _originalWindowTop;
+		private bool _isDisposed;
 
-        private int _currentTick = 0;
-        private string _message = null;
-        private Timer _timer = null;
-        private readonly char _progressCharacter;
+		private Timer _timer;
 
-		public int CurrentTick { get { return Math.Min(_maxTicks, _currentTick); } }
+		private int _visisbleDescendants = 0;
 
-        public ProgressBar(int maxTicks, string message, ConsoleColor color = ConsoleColor.Green, char progressCharacter = '\u2588')
-        {
-            _progressCharacter = progressCharacter;
-            _maxTicks = Math.Max(0, maxTicks);
-            _message = message;
-            _color = color;
-            Console.WriteLine();
-            _timer = new Timer((s) => DisplayProgress(), null, 500, 500);
-            DisplayProgress();
-        }
+		public ProgressBar(int maxTicks, string message, ConsoleColor color) 
+			: this(maxTicks, message, new ProgressBarOptions { ForeGroundColor = color }) { }
 
-        public void Tick(string message = "")
+	    public ProgressBar(int maxTicks, string message, ProgressBarOptions options = null)
+			: base(maxTicks, message, options)
         {
-            Interlocked.Increment(ref _currentTick);
-            if (message != "")
-                Interlocked.Exchange(ref _message, message);
+			_originalCursorTop = Console.CursorTop;
+			_originalWindowTop = Console.WindowTop;
+	        _originalColor = Console.ForegroundColor;
 
-            DisplayProgress();
+			Console.CursorVisible = false;
 
+			if (this.Options.DisplayTimeInRealTime)
+				_timer = new Timer((s) => DisplayProgress(), null, 500, 500);
         }
 
-        public void Message(string message)
-        {
-            if (message != "") Interlocked.Exchange(ref _message, message);
+		protected override void Grow(ProgressBarHeight direction)
+		{
+			switch (direction)
+			{
+				case ProgressBarHeight.Increment:
+					Interlocked.Increment(ref _visisbleDescendants);
+					break;
+				case ProgressBarHeight.Decrement:
+					Interlocked.Decrement(ref _visisbleDescendants);
+					break;
+			}
+		}
 
-            DisplayProgress();
-        }
+		private struct Indentation
+		{
+			public Indentation(ConsoleColor color, bool lastChild)
+			{
+				this.ConsoleColor = color;
+				this.LastChild = lastChild;
+			}
 
-        private void DisplayProgress()
-        {
-            if (_timer == null) return;
-
-            double percentage = Math.Max(0, Math.Min(100, (100.0 / _maxTicks) * this.CurrentTick));
-            // Gracefully handle if the percentage is NaN due to division by 0
-            if (Double.IsNaN(percentage) || percentage < 0) percentage = 100;
-            var duration = (DateTime.Now - _startDate);
-            var durationString = string.Format("{0:00}:{1:00}:{2:00}", duration.Hours, duration.Minutes, duration.Seconds);
-            var column1width = Console.WindowWidth - durationString.Length - 2;
-            var column2width = durationString.Length;
-            var format = string.Format("{{0, -{0}}} {{1,{1}}}", column1width, column2width);
-
-            var message = StringExtensions.Excerpt(string.Format("{0:N2}%", percentage) + " " + _message, column1width);
-            var formatted = String.Format(format, message, durationString);
-            lock (_lock)
-            {
-                RenderConsoleProgress(percentage, _progressCharacter, _color, formatted);
-                if (percentage > 100)
-                {
-                    _timer.Dispose();
-                    _timer = null;
-                }
-            }
+			public string Glyph => !LastChild ? "├─" : "└─";
 
-        }
+			public readonly ConsoleColor ConsoleColor;
+			public readonly bool LastChild;
+		}
 
+		private static void ProgressBarBottomHalf(double percentage, DateTime startDate, DateTime? endDate, string message, Indentation[] indentation, bool progressBarOnTop)
+		{
+			var depth = indentation.Length;
+			var maxCharacterWidth = Console.WindowWidth - (depth*2) + 2;
+			var duration = ((endDate ?? DateTime.Now) - startDate);
+			var durationString = $"{duration.Hours:00}:{duration.Minutes:00}:{duration.Seconds:00}";
 
-        public static void OverwriteConsoleMessage(string message)
-        {
-            Console.CursorLeft = 0;
-            int maxCharacterWidth = Console.WindowWidth - 1;
-            message = message + new string(' ', maxCharacterWidth - message.Length);
-            Console.Write(message);
-        }
+			var column1Width = Console.WindowWidth - durationString.Length - (depth*2) + 2;
+			var column2Width = durationString.Length;
 
-        public static void RenderConsoleProgress(double percentage, char progressBarCharacter, ConsoleColor color, string message)
-        {
-            Console.CursorVisible = false;
-            ConsoleColor originalColor = Console.ForegroundColor;
-            Console.ForegroundColor = color;
-            Console.CursorLeft = 0;
-			var currentTop = Console.CursorTop;
-
-            int width = Console.WindowWidth - 1;
-            int newWidth = (int)((width * percentage) / 100d);
-            string progBar = new string(progressBarCharacter, newWidth) + new string(' ', width - newWidth);
-            Console.Write(progBar);
-
-            if (string.IsNullOrEmpty(message)) message = "";
-            //Console.CursorTop = Math.Min(Console.BufferHeight - 1, Console.CursorTop + 1);
-			Console.CursorTop = currentTop + 1;
-            OverwriteConsoleMessage(message);
-			Console.CursorTop = currentTop;
-
-            Console.ForegroundColor = originalColor;
-            Console.CursorVisible = true;
-        }
+			if (progressBarOnTop)
+				DrawTopHalfPrefix(indentation, depth);
+			else 
+				DrawBottomHalfPrefix(indentation, depth);
 
+			var format = $"{{0, -{column1Width}}}{{1,{column2Width}}}";
 
-        public void Dispose()
-        {
-            Console.WriteLine();
-            if (_timer != null)
-                _timer.Dispose();
-            _timer = null;
+			var truncatedMessage = StringExtensions.Excerpt($"{percentage:N2}%" + " " + message, column1Width);
+			var formatted = string.Format(format, truncatedMessage, durationString);
+			var m = formatted + new string(' ', Math.Max(0, maxCharacterWidth - formatted.Length));
+			Console.Write(m);
+		}
+
+		private static void DrawBottomHalfPrefix(Indentation[] indentation, int depth)
+		{
+			for (var i = 1; i < depth; i++)
+			{
+				var ind = indentation[i];
+				Console.ForegroundColor = indentation[i - 1].ConsoleColor;
+				if (!ind.LastChild)
+					Console.Write(i == (depth - 1) ? ind.Glyph : "│ ");
+				else
+					Console.Write(i == (depth - 1) ? ind.Glyph : "  ");
+			}
+			Console.ForegroundColor = indentation[depth - 1].ConsoleColor;
+		}
+
+		private static void ProgressBarTopHalf(double percentage, char progressCharacter, ConsoleColor? backgroundColor, Indentation[] indentation, bool progressBarOnTop)
+		{
+			var depth = indentation.Length;
+			var width = Console.WindowWidth - (depth*2) + 2;
+
+			if (progressBarOnTop)
+				DrawBottomHalfPrefix(indentation, depth);
+			else 
+				DrawTopHalfPrefix(indentation, depth);
+
+
+			var newWidth = (int) ((width*percentage)/100d);
+			var progBar = new string(progressCharacter, newWidth);
+			Console.Write(progBar);
+			if (backgroundColor.HasValue)
+			{
+				Console.ForegroundColor = backgroundColor.Value;
+				Console.Write(new string(progressCharacter, width - newWidth));
+			}
+			else Console.Write(new string(' ', width - newWidth));
+			Console.ForegroundColor = indentation[depth - 1].ConsoleColor;
+		}
+
+		private static void DrawTopHalfPrefix(Indentation[] indentation, int depth)
+		{
+			for (var i = 1; i < depth; i++)
+			{
+				var ind = indentation[i];
+				Console.ForegroundColor = indentation[i - 1].ConsoleColor;
+				if (ind.LastChild && i != (depth - 1))
+					Console.Write("  ");
+				else
+					Console.Write("│ ");
+			}
+			Console.ForegroundColor = indentation[depth - 1].ConsoleColor;
+		}
+
+		private static string ResetString() => new string(' ', Console.WindowWidth);
+
+		protected override void DisplayProgress()
+		{
+			if (_isDisposed) return;
+
+			var indentation = new[] {new Indentation(this.ForeGroundColor, true)};
+			var mainPercentage = this.Percentage;
+
+			var windowTop = Console.WindowTop;
+
+			lock (Lock)
+			{
+				Console.ForegroundColor = this.ForeGroundColor;
+
+				if (this.Options.ProgressBarOnBottom)
+				{
+					Console.CursorLeft = 0;
+					ProgressBarBottomHalf(mainPercentage, this._startDate, null, this.Message, indentation, this.Options.ProgressBarOnBottom);
+
+					Console.CursorLeft = 0;
+					ProgressBarTopHalf(mainPercentage, this.Options.ProgressCharacter, this.Options.BackgroundColor, indentation, this.Options.ProgressBarOnBottom);
+
+				}
+				else
+				{
+					Console.CursorLeft = 0;
+					ProgressBarTopHalf(mainPercentage, this.Options.ProgressCharacter, this.Options.BackgroundColor, indentation, this.Options.ProgressBarOnBottom);
+
+					Console.CursorLeft = 0;
+					ProgressBarBottomHalf(mainPercentage, this._startDate, null, this.Message, indentation, this.Options.ProgressBarOnBottom);
+				}
+
+				DrawChildren(this.Children, indentation);
+
+				ResetToBottom();
+
+				Console.CursorLeft = 0;
+				Console.WindowTop = _originalWindowTop;
+				Console.CursorTop = _originalCursorTop;
+				Console.ForegroundColor = _originalColor;
+
+				if (mainPercentage >= 100)
+				{
+					_timer?.Dispose();
+					_timer = null;
+				}
+			}
+		}
+
+		private static void ResetToBottom()
+		{
+			if (Console.CursorTop >= (Console.WindowHeight - 1)) return;
+			do
+			{
+				Console.Write(ResetString());
+
+			}
+			while (Console.CursorTop < (Console.WindowHeight - 1));
+		}
+
+		private static void DrawChildren(IEnumerable<ChildProgressBar> children, Indentation[] indentation)
+		{
+			var view = children.Where(c => !c.Collapse).Select((c, i) => new {c, i}).ToList();
+			if (!view.Any()) return;
+
+			var lastChild = view.Max(t => t.i);
+			foreach (var tuple in view)
+			{
+				if (Console.CursorTop >= (Console.WindowHeight - 2))
+					return;
+
+				var child = tuple.c;
+				var currentIndentation = new Indentation(child.ForeGroundColor, tuple.i == lastChild);
+				var childIndentation = NewIndentation(indentation, currentIndentation);
+
+				var percentage = child.Percentage;
+				Console.ForegroundColor = child.ForeGroundColor;
+
+				if (child.Options.ProgressBarOnBottom)
+				{
+					Console.CursorLeft = 0;
+					ProgressBarBottomHalf(percentage, child.StartDate, child.EndTime, child.Message, childIndentation, child.Options.ProgressBarOnBottom);
+
+					Console.CursorLeft = 0;
+					ProgressBarTopHalf(percentage, child.Options.ProgressCharacter, child.Options.BackgroundColor, childIndentation, child.Options.ProgressBarOnBottom);
+
+				}
+				else
+				{
+
+					Console.CursorLeft = 0;
+					ProgressBarTopHalf(percentage, child.Options.ProgressCharacter, child.Options.BackgroundColor, childIndentation, child.Options.ProgressBarOnBottom);
+
+					Console.CursorLeft = 0;
+					ProgressBarBottomHalf(percentage, child.StartDate, child.EndTime, child.Message, childIndentation, child.Options.ProgressBarOnBottom);
+				}
+
+				DrawChildren(child.Children, childIndentation);
+			}
+		}
+
+		private static Indentation[] NewIndentation(Indentation[] array, Indentation append)
+		{
+			var result = new Indentation[array.Length + 1];
+			Array.Copy(array, result, array.Length);
+			result[array.Length] = append;
+			return result;
+		}
+
+		public void Dispose()
+		{
+			if (this.EndTime == null) this.EndTime = DateTime.Now;
+			var openDescendantsPadding = (_visisbleDescendants * 2);
+
+			try
+			{
+
+				var moveDown = 0;
+				var currentWindowTop = Console.WindowTop;
+				if (currentWindowTop != _originalWindowTop)
+				{
+					var x = Math.Max(0, Math.Min(2, currentWindowTop - _originalWindowTop));
+					moveDown = _originalCursorTop + x;
+				}
+				else moveDown = _originalCursorTop + 2;
+
+				Console.CursorVisible = true;
+				Console.CursorLeft = 0;
+				Console.CursorTop = (openDescendantsPadding + moveDown);
+			}
+			// This is bad and I should feel bad, but i rather eat pbar exceptions in productions then causing false negatives
+			catch { }
 			Console.WriteLine();
-        }
+			_isDisposed = true;
+			_timer?.Dispose();
+			_timer = null;
+			foreach (var c in this.Children) c.Dispose();
+		}
     }
-
 }
diff --git a/src/ShellProgressBar/ProgressBarBase.cs b/src/ShellProgressBar/ProgressBarBase.cs
new file mode 100644
index 0000000..1ee5cc2
--- /dev/null
+++ b/src/ShellProgressBar/ProgressBarBase.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace ShellProgressBar
+{
+	public abstract class ProgressBarBase
+	{
+		protected readonly DateTime _startDate = DateTime.Now;
+		private int _maxTicks;
+		private int _currentTick;
+		private string _message;
+
+		protected ProgressBarBase(int maxTicks, string message, ProgressBarOptions options)
+		{
+			this._maxTicks = Math.Max(0, maxTicks);
+			this._message = message;
+			this.Options = options ?? ProgressBarOptions.Default;
+		}
+
+		internal ProgressBarOptions Options { get; }
+		internal ConcurrentBag<ChildProgressBar> Children { get; } = new ConcurrentBag<ChildProgressBar>();
+
+		public DateTime? EndTime { get; protected set; }
+
+		public ConsoleColor ForeGroundColor => 
+			EndTime.HasValue ? this.Options.ForeGroundColorDone ?? this.Options.ForeGroundColor : this.Options.ForeGroundColor;
+
+		public int CurrentTick => _currentTick;
+		public int MaxTicks => _maxTicks;
+		public string Message => _message;
+
+		public double Percentage
+		{
+			get
+			{
+				var percentage = Math.Max(0, Math.Min(100, (100.0 / this._maxTicks) * this._currentTick));
+				// Gracefully handle if the percentage is NaN due to division by 0
+				if (double.IsNaN(percentage) || percentage < 0) percentage = 100;
+				return percentage;
+			}
+		}
+
+		public bool Collapse => this.EndTime.HasValue && this.Options.CollapseWhenFinished;
+
+		protected abstract void DisplayProgress();
+
+		public ChildProgressBar Spawn(int maxTicks, string message, ProgressBarOptions options = null)
+		{
+			var pbar = new ChildProgressBar(maxTicks, message, DisplayProgress, options, this.Grow);
+			this.Children.Add(pbar);
+			DisplayProgress();
+			return pbar;
+		}
+
+		protected virtual void Grow(ProgressBarHeight direction)
+		{
+
+		}
+		protected virtual void OnDone()
+		{
+
+		}
+
+		public void Tick(string message = null)
+		{
+			Interlocked.Increment(ref _currentTick);
+			if (message != null)
+				Interlocked.Exchange(ref _message, message);
+
+			if (_currentTick >= _maxTicks)
+			{
+				this.EndTime = DateTime.Now;
+				this.OnDone();
+			}
+			DisplayProgress();
+		}
+
+		public void UpdateMaxTicks(int maxTicks)
+		{
+			Interlocked.Exchange(ref _maxTicks, maxTicks);
+		}
+
+		public void UpdateMessage(string message)
+		{
+			Interlocked.Exchange(ref _message, message);
+
+			DisplayProgress();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar/ProgressBarHeight.cs b/src/ShellProgressBar/ProgressBarHeight.cs
new file mode 100644
index 0000000..dc69b99
--- /dev/null
+++ b/src/ShellProgressBar/ProgressBarHeight.cs
@@ -0,0 +1,7 @@
+namespace ShellProgressBar
+{
+	public enum ProgressBarHeight
+	{
+		Increment, Decrement
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar/ProgressBarOptions.cs b/src/ShellProgressBar/ProgressBarOptions.cs
new file mode 100644
index 0000000..dc0cfb8
--- /dev/null
+++ b/src/ShellProgressBar/ProgressBarOptions.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace ShellProgressBar
+{
+	public class ProgressBarOptions
+	{
+		public static readonly ProgressBarOptions Default = new ProgressBarOptions();
+
+		public ConsoleColor ForeGroundColor { get; set; } = ConsoleColor.Green;
+		public ConsoleColor? ForeGroundColorDone { get; set; }
+		public ConsoleColor? BackgroundColor { get; set; }
+		public char ProgressCharacter { get; set; } = '\u2588';
+		public bool DisplayTimeInRealTime { get; set; } = true;
+		public bool CollapseWhenFinished { get; set; } = true;
+		public bool ProgressBarOnBottom { get; set; }
+	}
+}
\ No newline at end of file
diff --git a/src/ShellProgressBar/Properties/AssemblyInfo.cs b/src/ShellProgressBar/Properties/AssemblyInfo.cs
index c362332..05465b5 100644
--- a/src/ShellProgressBar/Properties/AssemblyInfo.cs
+++ b/src/ShellProgressBar/Properties/AssemblyInfo.cs
@@ -15,7 +15,7 @@
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
 [assembly: System.CLSCompliant(true)]
 [assembly: System.Runtime.InteropServices.Guid("07E5CFA3-CF5F-4D17-874C-8D5CC6FA3E73")]
-[assembly: System.Reflection.AssemblyVersion("1.2.0")]
-[assembly: System.Reflection.AssemblyFileVersion("1.2.0")]
+[assembly: System.Reflection.AssemblyVersion("2.0.0")]
+[assembly: System.Reflection.AssemblyFileVersion("2.0.0")]
 
 
diff --git a/src/ShellProgressBar/ShellProgressBar.csproj b/src/ShellProgressBar/ShellProgressBar.csproj
index fb7018d..577032c 100644
--- a/src/ShellProgressBar/ShellProgressBar.csproj
+++ b/src/ShellProgressBar/ShellProgressBar.csproj
@@ -1,57 +1,62 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-	<PropertyGroup>
-		<MSBuildCommunityTasksPath>$(SolutionDir)\.build</MSBuildCommunityTasksPath>
-	</PropertyGroup>
-	<Import Project="$(MSBuildCommunityTasksPath)\MSBuild.Community.Tasks.Targets" />
-	<PropertyGroup>
-		<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-		<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-		<ProjectGuid>{4767E390-2159-470C-AE49-E75E2DDF80A4}</ProjectGuid>
-		<OutputType>Library</OutputType>
-		<AppDesignerFolder>Properties</AppDesignerFolder>
-		<RootNamespace>ShellProgressBar</RootNamespace>
-		<AssemblyName>ShellProgressBar</AssemblyName>
-		<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-		<FileAlignment>512</FileAlignment>
-		<TargetFrameworkProfile />
-	</PropertyGroup>
-	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-		<DebugSymbols>true</DebugSymbols>
-		<DebugType>full</DebugType>
-		<Optimize>false</Optimize>
-		<OutputPath>bin\Debug\</OutputPath>
-		<DefineConstants>DEBUG;TRACE</DefineConstants>
-		<ErrorReport>prompt</ErrorReport>
-		<WarningLevel>4</WarningLevel>
-	</PropertyGroup>
-	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-		<DebugType>pdbonly</DebugType>
-		<Optimize>true</Optimize>
-		<OutputPath>bin\Release\</OutputPath>
-		<DefineConstants>TRACE</DefineConstants>
-		<ErrorReport>prompt</ErrorReport>
-		<WarningLevel>4</WarningLevel>
-	</PropertyGroup>
-	<ItemGroup>
-		<Reference Include="System" />
-		<Reference Include="System.Core" />
-		<Reference Include="System.Xml.Linq" />
-		<Reference Include="System.Data.DataSetExtensions" />
-		<Reference Include="Microsoft.CSharp" />
-		<Reference Include="System.Data" />
-		<Reference Include="System.Xml" />
-	</ItemGroup>
-	<ItemGroup>
-		<Compile Include="ProgressBar.cs" />
-		<Compile Include="Properties\AssemblyInfo.cs" />
-		<Compile Include="StringExtensions.cs" />
-	</ItemGroup>
-	<ItemGroup>
-		<None Include="packages.config" />
-	</ItemGroup>
-	<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-	<!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <PropertyGroup>
+    <MSBuildCommunityTasksPath>$(SolutionDir)\.build</MSBuildCommunityTasksPath>
+  </PropertyGroup>
+  <Import Project="$(MSBuildCommunityTasksPath)\MSBuild.Community.Tasks.Targets" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4767E390-2159-470C-AE49-E75E2DDF80A4}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ShellProgressBar</RootNamespace>
+    <AssemblyName>ShellProgressBar</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ChildProgressBar.cs" />
+    <Compile Include="ProgressBarHeight.cs" />
+    <Compile Include="IProgressBar.cs" />
+    <Compile Include="ProgressBar.cs" />
+    <Compile Include="ProgressBarBase.cs" />
+    <Compile Include="ProgressBarOptions.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StringExtensions.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
   </Target>
diff --git a/src/ShellProgressBar/StringExtensions.cs b/src/ShellProgressBar/StringExtensions.cs
index 1268405..bc3071b 100644
--- a/src/ShellProgressBar/StringExtensions.cs
+++ b/src/ShellProgressBar/StringExtensions.cs
@@ -4,7 +4,7 @@
 
 namespace ShellProgressBar
 {
-    public static class StringExtensions
+    internal static class StringExtensions
     {
         public static string Excerpt(string phrase, int length = 60)
         {