diff --git a/src/01.cs b/src/01.cs
index c5f9a9f..13a248a 100644
--- a/src/01.cs
+++ b/src/01.cs
@@ -27,7 +27,7 @@ internal class Day01 : Day
             lastDepth = depth;
         }
 
-        Logger.Log($"part1: <blue>{numIncreased}<r>");
+        Logger.Log($"<+black>> part1: <+white>{numIncreased}<r>");
     }
 
     private static void Part2(IEnumerable<string> lines)
@@ -61,6 +61,6 @@ internal class Day01 : Day
             lastTotal = total;
         }
 
-        Logger.Log($"part2: <blue>{numIncreased}<r>");
+        Logger.Log($"<+black>> part2: <+white>{numIncreased}<r>");
     }
 }
diff --git a/src/01.go b/src/01.go
index abe0eff..921aefb 100644
--- a/src/01.go
+++ b/src/01.go
@@ -39,7 +39,7 @@ func part1(depths []int) {
 		lastDepth = depth
 	}
 
-	fmt.Println("part1: increased:", numIncreased)
+	fmt.Println("<+black>> part1: increased:", numIncreased)
 }
 
 func part2(depths []int) {
@@ -65,5 +65,5 @@ func part2(depths []int) {
 		lastTotal = total
 	}
 
-	fmt.Println("part2: increased:", numIncreased)
+	fmt.Println("<+black>> part2: increased:", numIncreased)
 }
diff --git a/src/02.cs b/src/02.cs
index e7e00aa..fdbcabe 100644
--- a/src/02.cs
+++ b/src/02.cs
@@ -54,7 +54,7 @@ internal class Day02 : Day
             }
         }
 
-        Logger.Log($"part1: h: {pos.h}, d: {pos.d}, result: <blue>{pos.h * pos.d}<r>");
+        Logger.Log($"<+black>> part1: h: {pos.h}, d: {pos.d}, result: <+white>{pos.h * pos.d}<r>");
     }
 
     private static void Part2(IEnumerable<Instruction> instructions)
@@ -81,6 +81,6 @@ internal class Day02 : Day
             }
         }
 
-        Logger.Log($"part2: h: {pos.h}, d: {pos.d}, result: <blue>{pos.h * pos.d}<r>");
+        Logger.Log($"<+black>> part2: h: {pos.h}, d: {pos.d}, result: <+white>{pos.h * pos.d}<r>");
     }
 }
diff --git a/src/03.cs b/src/03.cs
index 7369935..81b75b3 100644
--- a/src/03.cs
+++ b/src/03.cs
@@ -41,7 +41,7 @@ internal class Day03 : Day
             }
         }
 
-        Logger.Log($"part1: gamma rate: {gammaRate}, epsilon rate: {epsilonRate}, mult: <blue>{gammaRate * epsilonRate}<r>");
+        Logger.Log($"<+black>> part1: gamma rate: {gammaRate}, epsilon rate: {epsilonRate}, mult: <+white>{gammaRate * epsilonRate}<r>");
     }
 
     private static void Part2(IEnumerable<string> lines)
@@ -123,6 +123,6 @@ internal class Day03 : Day
             }
         }
 
-        Logger.Log($"part2: o2*co2 = {o2} * {co2} = <blue>{o2 * co2}<r>");
+        Logger.Log($"<+black>> part2: o2*co2 = {o2} * {co2} = <+white>{o2 * co2}<r>");
     }
 }
diff --git a/src/05.cs b/src/05.cs
index 024fb9b..4141e5f 100644
--- a/src/05.cs
+++ b/src/05.cs
@@ -72,14 +72,14 @@ internal class Day05 : Day
     {
         using var t = new Timer();
         int numPointsGreater = Solve(lines, (line) => !(line.Start.X == line.End.X || line.Start.Y == line.End.Y));
-        Logger.Log($"part1: <blue>{numPointsGreater}<r>");
+        Logger.Log($"<+black>> part1: <+white>{numPointsGreater}<r>");
     }
 
     private static void Part2(IEnumerable<Line> lines)
     {
         using var t = new Timer();
         int numPointsGreater = Solve(lines, (line) => false);
-        Logger.Log($"part2: <blue>{numPointsGreater}<r>");
+        Logger.Log($"<+black>> part2: <+white>{numPointsGreater}<r>");
     }
 
     private static int Solve(IEnumerable<Line> lines, Func<Line, bool> filter)
diff --git a/src/06.cs b/src/06.cs
index a1a5d4a..02b4a36 100644
--- a/src/06.cs
+++ b/src/06.cs
@@ -45,7 +45,7 @@ internal class Day06 : Day
         }
 
 #pragma warning disable CA1829 // Use Length/Count property instead of Count() when available - Count is of type int, list might be longer than that
-        Logger.Log($"part1: #fish=<blue>{list.LongCount()}<r>");
+        Logger.Log($"<+black>> part1: #fish=<+white>{list.LongCount()}<r>");
 #pragma warning restore CA1829 // Use Length/Count property instead of Count() when available
     }
 
@@ -72,6 +72,6 @@ internal class Day06 : Day
             fishAtState[8] = adders;
         }
 
-        Logger.Log($"part2: #fish=<blue>{fishAtState.Values.Sum()}<r>");
+        Logger.Log($"<+black>> part2: #fish=<+white>{fishAtState.Values.Sum()}<r>");
     }
 }
diff --git a/src/07.cs b/src/07.cs
index c6c5383..dd2e4b9 100644
--- a/src/07.cs
+++ b/src/07.cs
@@ -39,7 +39,7 @@ internal class Day07 : Day
 
         var (minDist, minNum) = Solve(nums, (d) => d);
 
-        Logger.Log($"part1: position: {minNum}, fuel cost: <blue>{minDist}<r>");
+        Logger.Log($"<+black>> part1: position: {minNum}, fuel cost: <+white>{minDist}<r>");
     }
 
     private static void Part2(IEnumerable<int> nums)
@@ -50,6 +50,6 @@ internal class Day07 : Day
         // found by searching "factorial but with addition" because i'm smart like that.
         var (minDist, minNum) = Solve(nums, (d) => ((d * d) + d) / 2);
 
-        Logger.Log($"part2: position: {minNum}, fuel cost: <blue>{minDist}<r>");
+        Logger.Log($"<+black>> part2: position: {minNum}, fuel cost: <+white>{minDist}<r>");
     }
 }
diff --git a/src/08.cs b/src/08.cs
index a51fced..db6c79e 100644
--- a/src/08.cs
+++ b/src/08.cs
@@ -36,7 +36,7 @@ internal class Day08 : Day
             }
         }
 
-        Logger.Log($"part1: <blue>{count}<r>");
+        Logger.Log($"<+black>> part1: <+white>{count}<r>");
     }
 
     private static void Part2(List<(List<string>, List<string>)> lines)
@@ -100,7 +100,7 @@ internal class Day08 : Day
             sum += num;
         }
 
-        Logger.Log($"part2: <blue>{sum}<r>");
+        Logger.Log($"<+black>> part2: <+white>{sum}<r>");
     }
 
     private static int FindNum(char[] segments, string num)
diff --git a/src/09.cs b/src/09.cs
index a99e3f5..53fb46f 100644
--- a/src/09.cs
+++ b/src/09.cs
@@ -24,7 +24,7 @@ internal class Day09 : Day
         var lowPoints = GetLowPoints(grid);
         var totalRisk = lowPoints.Sum(x => grid[x.Item1, x.Item2] + 1);
 
-        Logger.Log($"part1: <blue>{totalRisk}<r>");
+        Logger.Log($"<+black>> part1: <+white>{totalRisk}<r>");
     }
 
     private static List<(int, int)> GetLowPoints(byte[,] grid)
@@ -72,7 +72,7 @@ internal class Day09 : Day
         }
         var top3Mult = basins.OrderByDescending(x => x).Take(3).Aggregate(1, (x, y) => x * y);
 
-        Logger.Log($"part2: <blue>{top3Mult}<r>");
+        Logger.Log($"<+black>> part2: <+white>{top3Mult}<r>");
     }
 
     private static List<(int, int)> GetBasinSize(byte[,] grid, int i, int j)
diff --git a/src/10.cs b/src/10.cs
index c7ddc99..0df8580 100644
--- a/src/10.cs
+++ b/src/10.cs
@@ -49,7 +49,7 @@ internal class Day10 : Day
             }
         }
 
-        Logger.Log($"part1: <blue>{score}<r>");
+        Logger.Log($"<+black>> part1: <+white>{score}<r>");
     }
 
     private static (bool, char) IsCorrupted(string line)
@@ -133,6 +133,6 @@ internal class Day10 : Day
 
         var final = scores.OrderBy(x => x).Skip(scores.Count / 2).First();
 
-        Logger.Log($"part2: <blue>{final}<r>");
+        Logger.Log($"<+black>> part2: <+white>{final}<r>");
     }
 }
diff --git a/src/11.cs b/src/11.cs
index 0c34d08..8d74607 100644
--- a/src/11.cs
+++ b/src/11.cs
@@ -99,7 +99,7 @@ internal class Day11 : Day
             }
         }
 
-        Logger.Log($"part1: <blue>{numFlashes}<r>");
+        Logger.Log($"<+black>> part1: <+white>{numFlashes}<r>");
     }
 
     private static void Part2(byte[,] grid)
@@ -132,6 +132,6 @@ internal class Day11 : Day
             }
         }
 
-        Logger.Log($"part2: <blue>{step}<r>");
+        Logger.Log($"<+black>> part2: <+white>{step}<r>");
     }
 }
diff --git a/src/12.cs b/src/12.cs
index 8fc6fa9..2206c9e 100644
--- a/src/12.cs
+++ b/src/12.cs
@@ -47,7 +47,7 @@ internal class Day12 : Day
         var validPaths = new List<List<string>>();
         FindPaths(paths, validPaths, new List<string>(){ "START" }, false);
 
-        Logger.Log($"part1: <blue>{validPaths.Count}<r>");
+        Logger.Log($"<+black>> part1: <+white>{validPaths.Count}<r>");
         //validPaths.Select(x => string.Join(',', x)).OrderBy(x => x).ForEach(x => Logger.Log(x));
     }
 
@@ -102,7 +102,7 @@ internal class Day12 : Day
         var validPaths = new List<List<string>>();
         FindPaths(paths, validPaths, new List<string>() { "START" }, true);
 
-        Logger.Log($"part2: <blue>{validPaths.Count}<r>");
+        Logger.Log($"<+black>> part2: <+white>{validPaths.Count}<r>");
         //validPaths.Select(x => string.Join(',', x)).OrderBy(x => x).ForEach(x => Logger.Log(x));
     }
 }
diff --git a/src/13.cs b/src/13.cs
index df8adf1..71140b3 100644
--- a/src/13.cs
+++ b/src/13.cs
@@ -57,7 +57,7 @@ internal class Day13 : Day
 
         Fold(grid, folds[0].axis, folds[0].line);
 
-        Logger.Log($"part1: <blue>{grid.Count}<r>");
+        Logger.Log($"<+black>> part1: <+white>{grid.Count}<r>");
     }
 
     private static void Part2(ICollection<(int x, int y)> grid, IList<(char axis, int line)> folds)
@@ -87,7 +87,7 @@ internal class Day13 : Day
                 sb.Append('\n');
             }
         }
-        Logger.Log($"<blue>{sb}<r>");
-        Logger.Log($"part2: {grid.Count}");
+        Logger.Log($"<+white>{sb}<r>");
+        Logger.Log($"<+black>> part2: {grid.Count}<r>");
     }
 }
diff --git a/src/14.cs b/src/14.cs
index c2acaed..ddb8886 100644
--- a/src/14.cs
+++ b/src/14.cs
@@ -59,7 +59,7 @@ internal class Day14 : Day
         var least = frequencies.Min(x => x.Value);
         var most = frequencies.Max(x => x.Value);
 
-        Logger.Log($"part1: <blue>{most - least}<r>");
+        Logger.Log($"<+black>> part1: <+white>{most - least}<r>");
     }
 
     private static void Part2(string template, Dictionary<string, char> rules)
@@ -110,6 +110,6 @@ internal class Day14 : Day
             }
         }
 
-        Logger.Log($"part2: <blue>{most - least}<r>");
+        Logger.Log($"<+black>> part2: <+white>{most - least}<r>");
     }
 }
diff --git a/src/15.cs b/src/15.cs
index d802b73..fba91f6 100644
--- a/src/15.cs
+++ b/src/15.cs
@@ -75,7 +75,7 @@ internal class Day15 : Day
 
         var risk = Solve(grid);
 
-        Logger.Log($"part1: <blue>{risk}<r>");
+        Logger.Log($"<+black>> part1: <+white>{risk}<r>");
     }
 
     private static byte[,] ScaleUp(byte[,] map)
@@ -107,6 +107,6 @@ internal class Day15 : Day
 
         var risk = Solve(ScaleUp(grid));
 
-        Logger.Log($"part2: <blue>{risk}<r>");
+        Logger.Log($"<+black>> part2: <+white>{risk}<r>");
     }
 }
diff --git a/src/16.cs b/src/16.cs
index 1ed4718..b876365 100644
--- a/src/16.cs
+++ b/src/16.cs
@@ -23,12 +23,12 @@ internal class Day16 : Day
 
     private static void Part1(long versionTotal)
     {
-        Logger.Log($"part1: version total: <blue>{versionTotal}<r>");
+        Logger.Log($"<+black>> part1: version total: <+white>{versionTotal}<r>");
     }
 
     private static void Part2(long result)
     {
-        Logger.Log($"part2: operator result: <blue>{result}<r>");
+        Logger.Log($"<+black>> part2: operator result: <+white>{result}<r>");
     }
 
     private static (long versionTotal, long result) DecodePacket(string binary, ref int idx)
diff --git a/src/Day.cs b/src/Day.cs
index 411fd44..3f3e67d 100644
--- a/src/Day.cs
+++ b/src/Day.cs
@@ -4,8 +4,8 @@ internal abstract class Day : IDisposable
 {
     public Day()
     {
-        Logger.Log($"\u001b[47m\u001b[30m{GetType().Name}\u001b[0m");
-        //Logger.Log("\u001b[47m\u001b[30m-----\u001b[0m");
+        Logger.Log($"<reverse>{GetType().Name}<r>");
+        //Logger.Log("<reverse>-----<r>");
     }
 
     public void Dispose()
diff --git a/src/Logger.cs b/src/Logger.cs
index 27ae4f0..a1c7fec 100644
--- a/src/Logger.cs
+++ b/src/Logger.cs
@@ -1,10 +1,49 @@
 using System.Diagnostics;
-using System.Text.RegularExpressions;
 
 namespace aoc2021
 {
     internal class Logger
     {
+        private static readonly Dictionary<string, string> colorCodes = new()
+        {
+            { "r", "\u001b[0m" },
+            { "black", "\u001b[30m" },
+            { "red", "\u001b[31m" },
+            { "green", "\u001b[32m" },
+            { "yellow", "\u001b[33m" },
+            { "blue", "\u001b[34m" },
+            { "magenta", "\u001b[35m" },
+            { "cyan", "\u001b[36m" },
+            { "white", "\u001b[37m" },
+            { "+black", "\u001b[30;1m" },
+            { "+red", "\u001b[31;1m" },
+            { "+green", "\u001b[32;1m" },
+            { "+yellow", "\u001b[33;1m" },
+            { "+blue", "\u001b[34;1m" },
+            { "+magenta", "\u001b[35;1m" },
+            { "+cyan", "\u001b[36;1m" },
+            { "+white", "\u001b[37;1m" },
+            { "bgBlack", "\u001b[40m" },
+            { "bgRed", "\u001b[41m" },
+            { "bgGreen", "\u001b[42m" },
+            { "bgYellow", "\u001b[43m" },
+            { "bgBlue", "\u001b[44m" },
+            { "bgMagenta", "\u001b[45m" },
+            { "bgCyan", "\u001b[46m" },
+            { "bgWhite", "\u001b[47m" },
+            { "+bgBlack", "\u001b[40;1m" },
+            { "+bgRed", "\u001b[41;1m" },
+            { "+bgGreen", "\u001b[42;1m" },
+            { "+bgYellow", "\u001b[43;1m" },
+            { "+bgBlue", "\u001b[44;1m" },
+            { "+bgMagenta", "\u001b[45;1m" },
+            { "+bgCyan", "\u001b[46;1m" },
+            { "+bgWhite", "\u001b[47;1m" },
+            { "bold", "\u001b[1m" },
+            { "underline", "\u001b[4m" },
+            { "reverse", "\u001b[7m" },
+        };
+
         public static void Log(string msg)
         {
             Console.WriteLine(InsertColorCodes(msg));
@@ -13,17 +52,22 @@ namespace aoc2021
 
         private static string InsertColorCodes(string msg)
         {
-            return msg.Replace("<blue>", "\u001b[36;1m")
-                .Replace("<r>", "\u001b[0m");
+            foreach (var code in colorCodes)
+            {
+                msg = msg.Replace($"<{code.Key}>", code.Value, StringComparison.CurrentCultureIgnoreCase);
+            }
+
+            return msg;
         }
 
-        private static readonly Regex colorCodes = new(@"(\u001b\[(?:\d+;)?(?:\d+;)?\d+m)", RegexOptions.Compiled);
         private static string StripColorCodes(string msg)
         {
-            var ret = msg;
-            var matches = colorCodes.Matches(msg);
-            matches?.ForEach(match => ret = ret.Replace(match.Groups[1].Value, ""));
-            return ret;
+            foreach (var code in colorCodes)
+            {
+                msg = msg.Replace($"<{code.Key}>", string.Empty, StringComparison.CurrentCultureIgnoreCase);
+            }
+
+            return msg;
         }
     }
 }
diff --git a/src/Template.cs b/src/Template.cs
index d0a1193..246f0df 100644
--- a/src/Template.cs
+++ b/src/Template.cs
@@ -13,13 +13,13 @@ internal class DayTemplate : Day
     {
         using var t = new Timer();
 
-        Logger.Log($"part1: <blue><r>");
+        Logger.Log($"<+black>> part1: <+white><r>");
     }
 
     private static void Part2(IEnumerable<string> lines)
     {
         using var t = new Timer();
 
-        Logger.Log($"part2: <blue><r>");
+        Logger.Log($"<+black>> part2: <+white><r>");
     }
 }
diff --git a/src/Timer.cs b/src/Timer.cs
index 996306b..83e26e9 100644
--- a/src/Timer.cs
+++ b/src/Timer.cs
@@ -28,16 +28,16 @@ namespace aoc2021
         {
             Stop();
             var (elapsed, unit) = ConvertElapsedToHumanReadable();
-            var color = "[31m";
+            var color = "<red>";
             if (unit == "us" || (unit == "ms" && elapsed < 10))
             {
-                color = "[32m";
+                color = "<green>";
             }
             else if (unit == "ms" && elapsed < 250)
             {
-                color = "[33m";
+                color = "<yellow>";
             }
-            Logger.Log($"{name}{(!string.IsNullOrEmpty(name) ? " t" : "T")}ook \u001b{color}{elapsed:N1}{unit}\u001b[0m");
+            Logger.Log($"<cyan>{name}{(!string.IsNullOrEmpty(name) ? " t" : "T")}ook {color}{elapsed:N1}{unit}<r>");
         }
 
         public (double elapsed, string unit) ConvertElapsedToHumanReadable()