diff --git a/MusicBoxConverter/Help.txt b/MusicBoxConverter/Help.txt
new file mode 100644
index 0000000..639c610
--- /dev/null
+++ b/MusicBoxConverter/Help.txt
@@ -0,0 +1,13 @@
+﻿MusicBoxConverter
+    by Starbeamrainbowlabs
+
+Converts MIDI files to SVG music box strips.
+
+Usage:
+    mono [--debug] MusicBoxConverter.exe {options}
+
+Options:
+    -h  --help              Shows this help message.
+    -i  --input {filename}  Specifies the input midi file to convert.
+    -o  --output {filename} Specified the file path to output the SVG music box strip to.
+        --debug             Activates additional debugging output.
diff --git a/MusicBoxConverter/MusicBoxConverter.csproj b/MusicBoxConverter/MusicBoxConverter.csproj
index 1f85f31..d6dd135 100644
--- a/MusicBoxConverter/MusicBoxConverter.csproj
+++ b/MusicBoxConverter/MusicBoxConverter.csproj
@@ -30,10 +30,10 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
-    <Reference Include="Melanchall.DryWetMidi">
-      <HintPath>..\packages\Melanchall.DryWetMidi.2.0.0\lib\net461\Melanchall.DryWetMidi.dll</HintPath>
-    </Reference>
     <Reference Include="System.Xml" />
+    <Reference Include="Melanchall.DryWetMidi">
+      <HintPath>..\packages\Melanchall.DryWetMidi.2.0.1\lib\net45\Melanchall.DryWetMidi.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Program.cs" />
@@ -43,12 +43,16 @@
     <Compile Include="Utilities\Vector2.cs" />
     <Compile Include="MusicBox.cs" />
     <Compile Include="Utilities\NoteUtilities.cs" />
+    <Compile Include="Utilities\EmbeddedFiles.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Utilities\" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
-    <Folder Include="Utilities\" />
+    <EmbeddedResource Include="Help.txt" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
 </Project>
\ No newline at end of file
diff --git a/MusicBoxConverter/MusicBoxScoreGenerator.cs b/MusicBoxConverter/MusicBoxScoreGenerator.cs
index 4b9112c..d426ac4 100644
--- a/MusicBoxConverter/MusicBoxScoreGenerator.cs
+++ b/MusicBoxConverter/MusicBoxScoreGenerator.cs
@@ -10,10 +10,12 @@ namespace MusicBoxConverter
 {
     public class MusicBoxScoreGenerator
     {
-        public Vector2 offset { get; set; } = new Vector2(10, 10);
-        public Vector2 scaleFactor { get; set; } = new Vector2(0.03f, 4f);
+		public bool Debug { get; set; } = false;
 
-		public float holeSize { get; set; } = 1f;
+		public Vector2 Offset { get; set; } = new Vector2(10, 10);
+		public Vector2 ScaleFactor { get; set; } = new Vector2(0.03f, 4f);
+
+		public float HoleSize { get; set; } = 1f;
 
         private int trackLength;
         public int TrackLength
@@ -28,40 +30,41 @@ namespace MusicBoxConverter
 
 		public int MaxNoteNumber {
 			get {
-				return MusicBox.HighestNote.NoteNumber;
+				return SelectedMusicBox.HighestNote.NoteNumber;
 			}
 		}
 		public int MinNoteNumber {
 			get
 			{
-				return MusicBox.LowestNote.NoteNumber;
+				return SelectedMusicBox.LowestNote.NoteNumber;
 			}
 		}
 
-        public MusicBox MusicBox { get; private set; }
-		MidiFile midiFile;
+		public MusicBox SelectedMusicBox { get; private set; }
+
+		private MidiFile midiFile;
 		
 		public MusicBoxScoreGenerator(string filename, MusicBox inMusicBox)
 		{
-            MusicBox = inMusicBox;
+            SelectedMusicBox = inMusicBox;
 			midiFile = MidiFile.Read(filename);
 
 			// Set the scale factor based on the strip height of the music box
-			scaleFactor = new Vector2(
-				scaleFactor.X,
-				MusicBox.StripHeightMm / (MusicBox.NoteCount-1)
+			ScaleFactor = new Vector2(
+				ScaleFactor.X,
+				SelectedMusicBox.StripHeightMm / (SelectedMusicBox.NoteCount-1)
 			);
 
             foreach(Note note in AllNotes()) {
-                if (!MusicBox.IsValidNote(note))
-                    Console.Error.WriteLine($"Warning: The note {note} at {note.Time} can't be played by the {MusicBox}.");
+                if (!SelectedMusicBox.IsValidNote(note))
+                    Console.Error.WriteLine($"Warning: The note {note} at {note.Time} can't be played by the {SelectedMusicBox}.");
             }
 		}
 
 		public void Output(string destinationFilename)
 		{
-			Vector2 area = new Vector2(TrackLength, MusicBox.NoteCount-1).Multiply(scaleFactor);
-			Vector2 size = area.Add(offset.Multiply(2));
+			Vector2 area = new Vector2(TrackLength, SelectedMusicBox.NoteCount-1).Multiply(ScaleFactor);
+			Vector2 size = area.Add(Offset.Multiply(2));
 
 			SvgWriter svg = new SvgWriter(
 				destinationFilename,
@@ -69,23 +72,32 @@ namespace MusicBoxConverter
 			);
 			svg.UnitSuffix = "mm";
 
-			for(float i = 0; i < area.Y; i += scaleFactor.Y)
+			for(float i = 0; i < area.Y; i += ScaleFactor.Y)
 			{
-				Vector2 start = offset.Add(new Vector2(0, i));
+				Vector2 start = Offset.Add(new Vector2(0, i));
 				svg.WriteLine(start, start.Add(new Vector2(area.X, 0)), "darkgreen", 0.75f);
 			}
 
-			svg.WriteRectangle(offset, area, "red", 0.75f);
+			svg.WriteRectangle(Offset, area, "red", 0.75f);
 
 			foreach(Note note in AllNotes())
 			{
-				Console.WriteLine("[{0}] {1}{2}/{3}", note.Time, note.NoteName, note.Octave, note.NoteNumber);
+				if(Debug) {
+					Console.WriteLine(
+						"[Note] {0}: {1}{2}/{3}",
+						note.Time,
+						note.NoteName,
+						note.Octave,
+						note.NoteNumber
+					);
+				}
+
 				svg.WriteCircle(
 					new Vector2(
-						offset.X + note.Time * scaleFactor.X,
-						offset.Y + ((MusicBox.NoteCount-1) - MusicBox.NoteToBoxNumber(note)) * scaleFactor.Y
+						Offset.X + note.Time * ScaleFactor.X,
+						Offset.Y + ((SelectedMusicBox.NoteCount-1) - SelectedMusicBox.NoteToBoxNumber(note)) * ScaleFactor.Y
 					),
-					holeSize // radius
+					HoleSize // radius
 				);
 			}
 
diff --git a/MusicBoxConverter/Program.cs b/MusicBoxConverter/Program.cs
index 24b0082..9ade201 100644
--- a/MusicBoxConverter/Program.cs
+++ b/MusicBoxConverter/Program.cs
@@ -1,19 +1,72 @@
 ﻿using System;
-using System.Reflection;
+
 using Melanchall.DryWetMidi.Common;
 
+using SBRL.Utilities;
+
 namespace MusicBoxConverter
 {
 	class MainClass
 	{
-		public static void Main(string[] args)
+		public static int Main(string[] args)
 		{
-            MusicBoxScoreGenerator converter = new MusicBoxScoreGenerator(
-                //"/home/sbrl/Music/Sheets/HappyBirthday.midi",
-				"/tmp/Scale.midi",
+			string inputFilename = "";
+			string outputFilename = "";
+			bool debug = false;
+
+			for(int i = 0; i < args.Length; i++)
+			{
+				switch(args[i])
+				{
+					case "-i":
+					case "--input":
+						inputFilename = args[++i];
+						break;
+
+					case "-o":
+					case "--output":
+						outputFilename = args[++i];
+						break;
+
+					case "--auto-dev":
+						inputFilename = "/home/sbrl/Music/Sheets/HappyBirthday.midi";
+						//inputFilename = "/tmp/Scale.midi";
+
+						outputFilename = "/tmp/test.svg";
+						break;
+
+					case "--debug":
+						debug = true;
+						break;
+
+					case "-h":
+					case "--help":
+						Console.Error.WriteLine(EmbeddedFiles.ReadAllText("MusicBoxConverter.Help.txt"));
+						return 0;
+
+					default:
+						Console.Error.WriteLine("Error: Unknown option {0}.", args[i]);
+						return 1;
+				}
+			}
+
+			if(inputFilename == string.Empty) {
+				Console.Error.WriteLine("Error: No input file specified.");
+				return 1;
+			}
+			if(outputFilename == string.Empty) {
+				Console.Error.WriteLine("Error: No output file specified.");
+				return 1;
+			}
+
+			MusicBoxScoreGenerator converter = new MusicBoxScoreGenerator(
+				inputFilename,
 				MusicBox.Note30
 			);
-			converter.Output("/tmp/test.svg");
+			converter.Debug = debug;
+			converter.Output(outputFilename);
+
+			return 0;
 		}
 	}
 }
diff --git a/MusicBoxConverter/Utilities/EmbeddedFiles.cs b/MusicBoxConverter/Utilities/EmbeddedFiles.cs
new file mode 100644
index 0000000..8135cee
--- /dev/null
+++ b/MusicBoxConverter/Utilities/EmbeddedFiles.cs
@@ -0,0 +1,189 @@
+﻿using System;
+using System.Reflection;
+using System.IO;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace SBRL.Utilities
+{
+	/// <summary>
+	/// A collection of static methods for manipulating embedded resources.
+	/// </summary>
+	/// <description>
+	/// v0.5, by Starbeamrainbowlabs <feedback@starbeamrainbowlabs.com>
+	/// Last updated 8th August 2016.
+	/// Licensed under MPL-2.0.
+	/// 
+	/// Changelog:
+	/// v0.1 (25th July 2016):
+	/// 	- Initial release.
+	/// v0.2 (8th August 2016):
+	/// 	- Changed namespace.
+	/// v0.3 (21st January 2017):
+	/// 	- Added GetRawReader().
+	/// v0.4 (8th April 2017):
+	/// 	- Removed unnecessary using statement.
+	/// v0.5 (3rd September 2017):
+	/// 	- Changed namespace
+	/// </description>
+	public static class EmbeddedFiles
+	{
+		/// <summary>
+		/// An array of the filenames of all the resources embedded in the calling assembly.
+		/// </summary>
+		/// <value>The resource list.</value>
+		public static string[] ResourceList {
+			get {
+				return Assembly.GetCallingAssembly().GetManifestResourceNames();
+			}
+		}
+
+		public static string GetResourceListText()
+		{
+			StringWriter result = new StringWriter();
+			result.WriteLine("Files embedded in {0}:", Assembly.GetCallingAssembly().GetName().Name);
+			foreach(string filename in ResourceList)
+				result.WriteLine(" - {0}", filename);
+			return result.ToString();
+		}
+		/// <summary>
+		/// Writes a list of embedded resources to the Console's standard output.
+		/// </summary>
+		public static void WriteResourceList()
+		{
+			Console.WriteLine(GetResourceListText());
+		}
+
+		/// <summary>
+		/// Gets a StreamReader attached to the specified embedded resource.
+		/// </summary>
+		/// <param name="filename">The filename of the embedded resource to get a StreamReader of.</param>
+		/// <returns>A StreamReader attached to the specified embedded resource.</returns>
+		public static StreamReader GetReader(string filename)
+		{
+			return new StreamReader(GetRawReader(filename));
+		}
+
+		/// <summary>
+		/// Gets a raw Stream that's attached to the specified embedded resource.
+		/// Useful when you want to copy an embedded resource to some other stream.
+		/// </summary>
+		/// <param name="filename">The path to the embedded resource.</param>
+		/// <returns>A raw Stream object attached to the specified file..</returns>
+		public static Stream GetRawReader(string filename)
+		{
+			return Assembly.GetCallingAssembly().GetManifestResourceStream(filename);
+		}
+
+		/// <summary>
+		/// Gets the specified embedded resource's content as a byte array.
+		/// </summary>
+		/// <param name="filename">The filename of the embedded resource to get conteent of.</param>
+		/// <returns>The specified embedded resource's content as a byte array.</returns>
+		public static byte[] ReadAllBytes(string filename)
+		{
+			// Referencing the Result property will block until the async method completes
+			return ReadAllBytesAsync(filename).Result;
+		}
+		/// <summary>
+		/// Gets the specified embedded resource's content as a byte array asynchronously.
+		/// </summary>
+		/// <param name="filename">The filename of the embedded resource to get conteent of.</param>
+		/// <returns>The specified embedded resource's content as a byte array.</returns>
+		public static async Task<byte[]> ReadAllBytesAsync(string filename)
+		{
+			using(Stream resourceStream = Assembly.GetCallingAssembly().GetManifestResourceStream(filename))
+			using(MemoryStream temp = new MemoryStream())
+			{
+				await resourceStream.CopyToAsync(temp);
+				return temp.ToArray();
+			}
+		}
+
+		/// <summary>
+		/// Gets all the text stored in the specified embedded resource.
+		/// </summary>
+		/// <param name="filename">The filename to fetch the content of.</param>
+		/// <returns>All the text stored in the specified embedded resource.</returns>
+		public static string ReadAllText(string filename)
+		{
+			using(StreamReader resourceReader = new StreamReader(Assembly.GetCallingAssembly().GetManifestResourceStream(filename)))
+			{
+				return resourceReader.ReadToEnd();
+			}
+		}
+		/// <summary>
+		/// Gets all the text stored in the specified embedded resource asynchronously.
+		/// </summary>
+		/// <param name="filename">The filename to fetch the content of.</param>
+		/// <returns>All the text stored in the specified embedded resource.</returns>
+		public static async Task<string> ReadAllTextAsync(string filename)
+		{
+			using(StreamReader resourceReader = new StreamReader(Assembly.GetCallingAssembly().GetManifestResourceStream(filename)))
+			{
+				return await resourceReader.ReadToEndAsync();
+			}
+		}
+
+		/// <summary>
+		/// Enumerates the lines of text in the specified embedded resource.
+		/// </summary>
+		/// <param name="filename">The filename of the embedded resource to enumerate.</param>
+		/// <returns>An IEnumerator that enumerates the specified embedded resource.</returns>
+		public static IEnumerator<string> EnumerateLines(string filename)
+		{
+			using(StreamReader resourceReader = new StreamReader(Assembly.GetCallingAssembly().GetManifestResourceStream(filename)))
+			{
+				string nextLine;
+				while((nextLine = resourceReader.ReadLine()) != null)
+				{
+					yield return nextLine;
+				}
+			}
+		}
+		/// <summary>
+		/// Enumerates the lines of text in the specified embedded resource asynchronously.
+		/// Each successive call returns a task that, when complete, returns the next line of text stored
+		/// in the embedded resource.
+		/// </summary>
+		/// <param name="filename">The filename of the embedded resource to enumerate.</param>
+		/// <returns>An IEnumerator that enumerates the specified embedded resource.</returns>
+		public static IEnumerable<Task<string>> EnumerateLinesAsync(string filename)
+		{
+			using(StreamReader resourceReader = new StreamReader(Assembly.GetCallingAssembly().GetManifestResourceStream(filename)))
+			{
+				while(!resourceReader.EndOfStream)
+				{
+					yield return resourceReader.ReadLineAsync();
+				}
+			}
+		}
+
+		/// <summary>
+		/// Gets all the lines of text in the specified embedded resource.
+		/// You might find EnumerateLines(string filename) more useful depending on your situation.
+		/// </summary>
+		/// <param name="filename">The filename to obtain the lines of text from.</param>
+		/// <returns>A list of lines in the specified embedded resource.</returns>
+		public static List<string> GetAllLines(string filename)
+		{
+			// Referencing the Result property will block until the async method completes
+			return GetAllLinesAsync(filename).Result;
+		}
+		/// <summary>
+		/// Gets all the lines of text in the specified embedded resource asynchronously.
+		/// </summary>
+		/// <param name="filename">The filename to obtain the lines of text from.</param>
+		/// <returns>A list of lines in the specified embedded resource.</returns>
+		public static async Task<List<string>> GetAllLinesAsync(string filename)
+		{
+			List<string> lines = new List<string>();
+			IEnumerable<Task<string>> lineIterator = EnumerateLinesAsync(filename);
+			foreach(Task<string> nextLine in lineIterator)
+			{
+				lines.Add(await nextLine);
+			}
+			return lines;
+		}
+	}
+}
diff --git a/MusicBoxConverter/packages.config b/MusicBoxConverter/packages.config
index 95050a9..0c7c6b9 100644
--- a/MusicBoxConverter/packages.config
+++ b/MusicBoxConverter/packages.config
@@ -1,4 +1,4 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Melanchall.DryWetMidi" version="2.0.0" targetFramework="net461" />
+  <package id="Melanchall.DryWetMidi" version="2.0.1" targetFramework="net461" />
 </packages>
\ No newline at end of file
