diff --git a/Runtime/PimDeWitte.UnityMainThreadDispatcher.asmdef b/Runtime/PimDeWitte.UnityMainThreadDispatcher.asmdef
index c8c36b0..38f6169 100755
--- a/Runtime/PimDeWitte.UnityMainThreadDispatcher.asmdef
+++ b/Runtime/PimDeWitte.UnityMainThreadDispatcher.asmdef
@@ -1,3 +1,14 @@
 {
-	"name": "PimDeWitte.UnityMainThreadDispatcher"
+	"name": "PimDeWitte.UnityMainThreadDispatcher",
+	"rootNamespace": "PimDeWitte.UnityMainThreadDispatcher",
+	"references": [],
+    	"includePlatforms": [],
+    	"excludePlatforms": [],
+    	"allowUnsafeCode": false,
+    	"overrideReferences": false,
+    	"precompiledReferences": [],
+    	"autoReferenced": true,
+    	"defineConstraints": [],
+    	"versionDefines": [],
+    	"noEngineReferences": false
 }
diff --git a/Runtime/UnityMainThreadDispatcher.cs b/Runtime/UnityMainThreadDispatcher.cs
index 7a4f783..0716d36 100755
--- a/Runtime/UnityMainThreadDispatcher.cs
+++ b/Runtime/UnityMainThreadDispatcher.cs
@@ -20,100 +20,102 @@ limitations under the License.
 using System;
 using System.Threading.Tasks;
 
-/// Author: Pim de Witte (pimdewitte.com) and contributors, https://github.com/PimDeWitte/UnityMainThreadDispatcher
-/// <summary>
-/// A thread-safe class which holds a queue with actions to execute on the next Update() method. It can be used to make calls to the main thread for
-/// things such as UI Manipulation in Unity. It was developed for use in combination with the Firebase Unity plugin, which uses separate threads for event handling
-/// </summary>
-public class UnityMainThreadDispatcher : MonoBehaviour {
-
-	private static readonly Queue<Action> _executionQueue = new Queue<Action>();
-
-	public void Update() {
-		lock(_executionQueue) {
-			while (_executionQueue.Count > 0) {
-				_executionQueue.Dequeue().Invoke();
+namespace PimDeWitte.UnityMainThreadDispatcher {
+	/// Author: Pim de Witte (pimdewitte.com) and contributors, https://github.com/PimDeWitte/UnityMainThreadDispatcher
+	/// <summary>
+	/// A thread-safe class which holds a queue with actions to execute on the next Update() method. It can be used to make calls to the main thread for
+	/// things such as UI Manipulation in Unity. It was developed for use in combination with the Firebase Unity plugin, which uses separate threads for event handling
+	/// </summary>
+	public class UnityMainThreadDispatcher : MonoBehaviour {
+
+		private static readonly Queue<Action> _executionQueue = new Queue<Action>();
+
+		public void Update() {
+			lock(_executionQueue) {
+				while (_executionQueue.Count > 0) {
+					_executionQueue.Dequeue().Invoke();
+				}
 			}
 		}
-	}
 
-	/// <summary>
-	/// Locks the queue and adds the IEnumerator to the queue
-	/// </summary>
-	/// <param name="action">IEnumerator function that will be executed from the main thread.</param>
-	public void Enqueue(IEnumerator action) {
-		lock (_executionQueue) {
-			_executionQueue.Enqueue (() => {
-				StartCoroutine (action);
-			});
+		/// <summary>
+		/// Locks the queue and adds the IEnumerator to the queue
+		/// </summary>
+		/// <param name="action">IEnumerator function that will be executed from the main thread.</param>
+		public void Enqueue(IEnumerator action) {
+			lock (_executionQueue) {
+				_executionQueue.Enqueue (() => {
+					StartCoroutine (action);
+				});
+			}
 		}
-	}
 
-        /// <summary>
-        /// Locks the queue and adds the Action to the queue
-	/// </summary>
-	/// <param name="action">function that will be executed from the main thread.</param>
-	public void Enqueue(Action action)
-	{
-		Enqueue(ActionWrapper(action));
-	}
-	
-	/// <summary>
-	/// Locks the queue and adds the Action to the queue, returning a Task which is completed when the action completes
-	/// </summary>
-	/// <param name="action">function that will be executed from the main thread.</param>
-	/// <returns>A Task that can be awaited until the action completes</returns>
-	public Task EnqueueAsync(Action action)
-	{
-		var tcs = new TaskCompletionSource<bool>();
-
-		void WrappedAction() {
-			try 
-			{
-				action();
-				tcs.TrySetResult(true);
-			} catch (Exception ex) 
-			{
-				tcs.TrySetException(ex);
+		/// <summary>
+		/// Locks the queue and adds the Action to the queue
+		/// </summary>
+		/// <param name="action">function that will be executed from the main thread.</param>
+		public void Enqueue(Action action)
+		{
+			Enqueue(ActionWrapper(action));
+		}
+
+		/// <summary>
+		/// Locks the queue and adds the Action to the queue, returning a Task which is completed when the action completes
+		/// </summary>
+		/// <param name="action">function that will be executed from the main thread.</param>
+		/// <returns>A Task that can be awaited until the action completes</returns>
+		public Task EnqueueAsync(Action action)
+		{
+			var tcs = new TaskCompletionSource<bool>();
+
+			void WrappedAction() {
+				try 
+				{
+					action();
+					tcs.TrySetResult(true);
+				} catch (Exception ex) 
+				{
+					tcs.TrySetException(ex);
+				}
 			}
+
+			Enqueue(ActionWrapper(WrappedAction));
+			return tcs.Task;
 		}
 
-		Enqueue(ActionWrapper(WrappedAction));
-		return tcs.Task;
-	}
 
-	
-	IEnumerator ActionWrapper(Action a)
-	{
-		a();
-		yield return null;
-	}
+		IEnumerator ActionWrapper(Action a)
+		{
+			a();
+			yield return null;
+		}
 
 
-	private static UnityMainThreadDispatcher _instance = null;
+		private static UnityMainThreadDispatcher _instance = null;
 
-	public static bool Exists() {
-		return _instance != null;
-	}
+		public static bool Exists() {
+			return _instance != null;
+		}
 
-	public static UnityMainThreadDispatcher Instance() {
-		if (!Exists ()) {
-			throw new Exception ("UnityMainThreadDispatcher could not find the UnityMainThreadDispatcher object. Please ensure you have added the MainThreadExecutor Prefab to your scene.");
+		public static UnityMainThreadDispatcher Instance() {
+			if (!Exists ()) {
+				throw new Exception ("UnityMainThreadDispatcher could not find the UnityMainThreadDispatcher object. Please ensure you have added the MainThreadExecutor Prefab to your scene.");
+			}
+			return _instance;
 		}
-		return _instance;
-	}
 
 
-	void Awake() {
-		if (_instance == null) {
-			_instance = this;
-			DontDestroyOnLoad(this.gameObject);
+		void Awake() {
+			if (_instance == null) {
+				_instance = this;
+				DontDestroyOnLoad(this.gameObject);
+			}
 		}
-	}
 
-	void OnDestroy() {
-			_instance = null;
-	}
+		void OnDestroy() {
+				_instance = null;
+		}
 
 
+	}
 }