diff --git a/src/Calculator.Shared/Assets/CalcMDL2.woff b/src/Calculator.Shared/Assets/CalcMDL2.woff
new file mode 100644
index 00000000..e32f7a09
Binary files /dev/null and b/src/Calculator.Shared/Assets/CalcMDL2.woff differ
diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs
index cfd5b643..d5b675da 100644
--- a/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs
+++ b/src/Calculator.Shared/CalcManager/CalculatorManager.Interop.cs
@@ -10,137 +10,142 @@ using System.Text;
 
 namespace CalculationManager
 {
+	public static class NativeDispatch
+	{
+		[DllImport("CalcManager")]
+		public static extern int CalculatorManager_Create(ref CalculatorManager_CreateParams parms);
+
+		[DllImport("CalcManager")]
+		public static extern void CalculatorManager_SendCommand(int instance, Command command);
+
+		private delegate int GetCEngineStringFunc(int state, string id);
+		private delegate void BinaryOperatorReceivedFunc(int state);
+		private delegate void SetPrimaryDisplayCallbackFunc(int state, string displayStringValue, bool isError);
+		private delegate void SetIsInErrorCallbackFunc(int state, bool isError);
+		private delegate void SetParenthesisNumberCallbackFunc(int state, int parenthesisCount);
+
+		private delegate void MaxDigitsReachedCallbackFunc(int state);
+		private delegate void MemoryItemChangedCallbackFunc(int state, int indexOfMemory);
+		private delegate void OnHistoryItemAddedCallbackFunc(int state, int addedItemIndex);
+		private delegate void OnNoRightParenAddedCallbackFunc(int state);
+		private delegate void SetExpressionDisplayCallbackFunc(int state);
+		private delegate void SetMemorizedNumbersCallbackFunc(int state, string[] newMemorizedNumbers);
+
+		private static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback;
+		private static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback;
+		private static SetPrimaryDisplayCallbackFunc _setPrimaryDisplayCallback = SetPrimaryDisplayCallback;
+		private static SetIsInErrorCallbackFunc _setIsInErrorCallback = SetIsInErrorCallback;
+		private static SetParenthesisNumberCallbackFunc _setParenthesisNumberCallback = SetParenthesisNumberCallback;
+
+		private static MaxDigitsReachedCallbackFunc _maxDigitsReachedCallback = MaxDigitsReachedCallback;
+		private static MemoryItemChangedCallbackFunc _memoryItemChangedCallback = MemoryItemChangedCallback;
+		private static OnHistoryItemAddedCallbackFunc _onHistoryItemAddedCallback = OnHistoryItemAddedCallback;
+		private static OnNoRightParenAddedCallbackFunc _onNoRightParenAddedCallback = OnNoRightParenAddedCallback;
+		private static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback = SetExpressionDisplayCallback;
+		private static SetMemorizedNumbersCallbackFunc _setMemorizedNumbersCallback = SetMemorizedNumbersCallback;
+
+		public static void MaxDigitsReachedCallback(int state)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.MaxDigitsReached();
+
+			Debug.WriteLine($"CalculatorManager.MaxDigitsReachedCallback");
+		}
+
+		public static void MemoryItemChangedCallback(int state, int indexOfMemory)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.MemoryItemChanged(indexOfMemory);
+
+			Debug.WriteLine($"CalculatorManager.MemoryItemChangedCallback({indexOfMemory})");
+		}
+
+		public static void OnHistoryItemAddedCallback(int state, int addedItemIndex)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.OnHistoryItemAdded(addedItemIndex);
+
+			Debug.WriteLine($"CalculatorManager.OnHistoryItemAddedCallback({addedItemIndex})");
+		}
+
+		public static void OnNoRightParenAddedCallback(int state)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.OnNoRightParenAdded();
+
+			Debug.WriteLine($"CalculatorManager.OnNoRightParenAddedCallback");
+		}
+
+		public static void SetExpressionDisplayCallback(int state)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			// manager.SetExpressionDisplay();
+
+			Debug.WriteLine($"CalculatorManager.SetExpressionDisplayCallback");
+		}
+
+		public static void SetMemorizedNumbersCallback(int state, string[] newMemorizedNumbers)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.SetMemorizedNumbers(newMemorizedNumbers.ToList());
+
+			Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", newMemorizedNumbers)})");
+		}
+
+		public static void SetParenthesisNumberCallback(int state, int parenthesisCount)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.SetParenthesisNumber(parenthesisCount);
+
+			Debug.WriteLine($"CalculatorManager.SetParenthesisNumberCallback({parenthesisCount})");
+		}
+
+		public static void BinaryOperatorReceivedCallback(int state)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.BinaryOperatorReceived();
+
+			Debug.WriteLine($"CalculatorManager.BinaryOperatorReceivedCallback");
+		}
+
+		public static void SetPrimaryDisplayCallback(int state, string displayStringValue, bool isError)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.SetPrimaryDisplay(displayStringValue, isError);
+
+			Debug.WriteLine($"CalculatorManager.SetPrimaryDisplayCallback({displayStringValue}, {isError})");
+		}
+
+		public static void SetIsInErrorCallback(int state, bool isError)
+		{
+			var manager = GCHandle.FromIntPtr((IntPtr)state).Target as CalculatorDisplay;
+			manager.SetIsInError(isError);
+
+			Debug.WriteLine($"CalculatorManager.SetIsInErrorCallback({isError})");
+		}
+
+		public static int GetCEngineStringCallback(int state, string resourceId)
+		{
+			var provider = GCHandle.FromIntPtr((IntPtr)state).Target as EngineResourceProvider;
+			var ret = provider.GetCEngineString(resourceId) ?? "";
+
+			var retBytes = Encoding.UTF8.GetBytes(ret);
+			var retPtr = Marshal.AllocHGlobal(retBytes.Length + 1);
+			Marshal.WriteByte(retPtr + retBytes.Length, 0);
+			Marshal.Copy(retBytes, 0, retPtr, retBytes.Length);
+
+			Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})");
+
+			return (int)retPtr;
+		}
+	}
+
     public partial class CalculatorManager : ICalcDisplay
     {
-        [DllImport("CalcManager")]
-        public static extern IntPtr CalculatorManager_Create(ref CalculatorManager_CreateParams parms);
 
-        [DllImport("CalcManager")]
-        public static extern void CalculatorManager_SendCommand(IntPtr instance, Command command);
+		private GCHandle _displayCallbackHandle;
+		private GCHandle _resourceProviderHandle;
+		private readonly int _nativeManager;
 
-        private delegate IntPtr GetCEngineStringFunc(IntPtr state, string id);
-        private delegate void BinaryOperatorReceivedFunc(IntPtr state);
-        private delegate void SetPrimaryDisplayCallbackFunc(IntPtr state, string displayStringValue, bool isError);
-        private delegate void SetIsInErrorCallbackFunc(IntPtr state, bool isError);
-        private delegate void SetParenthesisNumberCallbackFunc(IntPtr state, int parenthesisCount);
-
-        private delegate void MaxDigitsReachedCallbackFunc(IntPtr state);
-        private delegate void MemoryItemChangedCallbackFunc(IntPtr state, int indexOfMemory);
-        private delegate void OnHistoryItemAddedCallbackFunc(IntPtr state, int addedItemIndex);
-        private delegate void OnNoRightParenAddedCallbackFunc(IntPtr state);
-        private delegate void SetExpressionDisplayCallbackFunc(IntPtr state);
-        private delegate void SetMemorizedNumbersCallbackFunc(IntPtr state, string[] newMemorizedNumbers);
-
-        private static GetCEngineStringFunc _getCEngineStringCallback = GetCEngineStringCallback;
-        private static BinaryOperatorReceivedFunc _binaryOperatorReceivedCallback = BinaryOperatorReceivedCallback;
-        private static SetPrimaryDisplayCallbackFunc _setPrimaryDisplayCallback = SetPrimaryDisplayCallback;
-        private static SetIsInErrorCallbackFunc _setIsInErrorCallback = SetIsInErrorCallback;
-        private static SetParenthesisNumberCallbackFunc _setParenthesisNumberCallback = SetParenthesisNumberCallback;
-
-        private static MaxDigitsReachedCallbackFunc _maxDigitsReachedCallback           = MaxDigitsReachedCallback;
-        private static MemoryItemChangedCallbackFunc _memoryItemChangedCallback         = MemoryItemChangedCallback;
-        private static OnHistoryItemAddedCallbackFunc _onHistoryItemAddedCallback       = OnHistoryItemAddedCallback;
-        private static OnNoRightParenAddedCallbackFunc _onNoRightParenAddedCallback     = OnNoRightParenAddedCallback;
-        private static SetExpressionDisplayCallbackFunc _setExpressionDisplayCallback   = SetExpressionDisplayCallback;
-        private static SetMemorizedNumbersCallbackFunc _setMemorizedNumbersCallback     = SetMemorizedNumbersCallback;
-
-        private GCHandle _displayCallbackHandle;
-        private GCHandle _resourceProviderHandle;
-        private readonly IntPtr _nativeManager;
-
-        private static void MaxDigitsReachedCallback(IntPtr state)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.MaxDigitsReached();
-
-            Debug.WriteLine($"CalculatorManager.MaxDigitsReachedCallback");
-        }
-
-        private static void MemoryItemChangedCallback(IntPtr state, int indexOfMemory)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.MemoryItemChanged(indexOfMemory);
-
-            Debug.WriteLine($"CalculatorManager.MemoryItemChangedCallback({indexOfMemory})");
-        }
-
-        private static void OnHistoryItemAddedCallback(IntPtr state, int addedItemIndex)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.OnHistoryItemAdded(addedItemIndex);
-
-            Debug.WriteLine($"CalculatorManager.OnHistoryItemAddedCallback({addedItemIndex})");
-        }
-
-        private static void OnNoRightParenAddedCallback(IntPtr state)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.OnNoRightParenAdded();
-
-            Debug.WriteLine($"CalculatorManager.OnNoRightParenAddedCallback");
-        }
-
-        private static void SetExpressionDisplayCallback(IntPtr state)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            // manager.SetExpressionDisplay();
-
-            Debug.WriteLine($"CalculatorManager.SetExpressionDisplayCallback");
-        }
-
-        private static void SetMemorizedNumbersCallback(IntPtr state, string[] newMemorizedNumbers)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.SetMemorizedNumbers(newMemorizedNumbers.ToList());
-
-            Debug.WriteLine($"CalculatorManager.SetMemorizedNumbersCallback({string.Join(";", newMemorizedNumbers)})");
-        }
-
-        private static void SetParenthesisNumberCallback(IntPtr state, int parenthesisCount)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.SetParenthesisNumber(parenthesisCount);
-
-            Debug.WriteLine($"CalculatorManager.SetParenthesisNumberCallback({parenthesisCount})");
-        }
-
-        private static void BinaryOperatorReceivedCallback(IntPtr state)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.BinaryOperatorReceived();
-
-            Debug.WriteLine($"CalculatorManager.BinaryOperatorReceivedCallback");
-        }
-
-        private static void SetPrimaryDisplayCallback(IntPtr state, string displayStringValue, bool isError)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.SetPrimaryDisplay(displayStringValue, isError);
-
-            Debug.WriteLine($"CalculatorManager.SetPrimaryDisplayCallback({displayStringValue}, {isError})");
-        }
-
-        private static void SetIsInErrorCallback(IntPtr state, bool isError)
-        {
-            var manager = GCHandle.FromIntPtr(state).Target as CalculatorDisplay;
-            manager.SetIsInError(isError);
-
-            Debug.WriteLine($"CalculatorManager.SetIsInErrorCallback({isError})");
-        }
-
-        private static IntPtr GetCEngineStringCallback(IntPtr state, string resourceId)
-        {
-            var provider = GCHandle.FromIntPtr(state).Target as EngineResourceProvider;
-            var ret = provider.GetCEngineString(resourceId) ?? "";
-
-            var retBytes = Encoding.UTF8.GetBytes(ret);
-            var retPtr = Marshal.AllocHGlobal(retBytes.Length+1);
-            Marshal.WriteByte(retPtr + retBytes.Length, 0);
-            Marshal.Copy(retBytes, 0, retPtr, retBytes.Length);
-
-            Debug.WriteLine($"CalculatorManager.GetCEngineStringCallback({resourceId},{ret})");
-
-            return retPtr;
-        }
-    }
+	}
 }
diff --git a/src/Calculator.Shared/CalcManager/CalculatorManager.cs b/src/Calculator.Shared/CalcManager/CalculatorManager.cs
index 46a8241e..3002f44e 100644
--- a/src/Calculator.Shared/CalcManager/CalculatorManager.cs
+++ b/src/Calculator.Shared/CalcManager/CalculatorManager.cs
@@ -6,6 +6,8 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Text;
+using Uno;
+using Uno.Foundation;
 
 namespace CalculationManager
 {
@@ -100,13 +102,36 @@ namespace CalculationManager
 
         public CalculatorManager(ref CalculatorDisplay displayCallback, ref EngineResourceProvider resourceProvider)
         {
-            Debug.WriteLine($"new CalculatorManager");
+			Debug.WriteLine($"new CalculatorManager");
             displayCallback = new CalculatorDisplay();
             resourceProvider = new EngineResourceProvider();
 
             _displayCallbackHandle = GCHandle.Alloc(displayCallback);
             _resourceProviderHandle = GCHandle.Alloc(resourceProvider);
 
+#if __WASM__
+			var rawPtrs = WebAssemblyRuntime.InvokeJS("CalcManager.registerCallbacks()");
+			var ptrs = rawPtrs.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+
+			var p = new CalculatorManager_CreateParams
+			{
+				CalculatorState = GCHandle.ToIntPtr(_displayCallbackHandle),
+				ResourceState = GCHandle.ToIntPtr(_resourceProviderHandle),
+
+				GetCEngineString = (IntPtr)int.Parse(ptrs[0]),
+				BinaryOperatorReceived = (IntPtr)int.Parse(ptrs[1]),
+				SetPrimaryDisplay = (IntPtr)int.Parse(ptrs[2]),
+				SetIsInError = (IntPtr)int.Parse(ptrs[3]),
+				SetParenthesisNumber = (IntPtr)int.Parse(ptrs[4]),
+				MaxDigitsReached = (IntPtr)int.Parse(ptrs[5]),
+				MemoryItemChanged = (IntPtr)int.Parse(ptrs[6]),
+				OnHistoryItemAdded = (IntPtr)int.Parse(ptrs[7]),
+				OnNoRightParenAdded = (IntPtr)int.Parse(ptrs[8]),
+				SetExpressionDisplay = (IntPtr)int.Parse(ptrs[9]),
+				SetMemorizedNumbers = (IntPtr)int.Parse(ptrs[10]),
+			};
+
+#else
             var p = new CalculatorManager_CreateParams
             {
                 CalculatorState = GCHandle.ToIntPtr(_displayCallbackHandle),
@@ -125,8 +150,11 @@ namespace CalculationManager
                 SetMemorizedNumbers = Marshal.GetFunctionPointerForDelegate(_setMemorizedNumbersCallback),
             };
 
-            _nativeManager = CalculatorManager_Create(ref p);
-        }
+#endif
+			Debug.WriteLine($"-> CalculatorManager_Create");
+            _nativeManager = NativeDispatch.CalculatorManager_Create(ref p);
+			Debug.WriteLine($"<- CalculatorManager_Create");
+		}
 
         public void Reset(bool clearMemory = true) => throw new NotImplementedException();
         public void SetStandardMode() => throw new NotImplementedException();
@@ -136,7 +164,7 @@ namespace CalculationManager
         {
             Debug.WriteLine($"CalculatorManager.SendCommand({command})");
 
-            CalculatorManager_SendCommand(_nativeManager, command);
+			NativeDispatch.CalculatorManager_SendCommand(_nativeManager, command);
         }
 
         public List<char> SerializeCommands() => throw new NotImplementedException();
diff --git a/src/Calculator.Shared/Calculator.Shared.projitems b/src/Calculator.Shared/Calculator.Shared.projitems
index 6dd46e12..24599449 100644
--- a/src/Calculator.Shared/Calculator.Shared.projitems
+++ b/src/Calculator.Shared/Calculator.Shared.projitems
@@ -225,6 +225,7 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="$(MSBuildThisFileDirectory)Assets\CalcMDL2.ttf" />
+    <Content Include="$(MSBuildThisFileDirectory)Assets\CalcMDL2.woff" />
     <Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorAppList.targetsize-96.png" />
     <Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorLargeTile.contrast-white_scale-400.png" />
     <Content Include="$(MSBuildThisFileDirectory)Assets\CalculatorMedTile.contrast-white_scale-400.png" />
diff --git a/src/Calculator.Shared/Styles.xaml b/src/Calculator.Shared/Styles.xaml
index 98abae65..5d3fd51a 100644
--- a/src/Calculator.Shared/Styles.xaml
+++ b/src/Calculator.Shared/Styles.xaml
@@ -1,10 +1,13 @@
 <ResourceDictionary
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
+    xmlns:xamarin="http://uno.ui/xamarin" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:Controls="using:CalculatorApp.Controls"
     xmlns:common="using:CalculatorApp.Common"
     xmlns:converters="using:CalculatorApp.Converters"
-    xmlns:local="using:CalculatorApp">
+	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:local="using:CalculatorApp"
+	mc:Ignorable="xamarin">
 
   <ResourceDictionary.MergedDictionaries>
     <!--
@@ -254,7 +257,8 @@
   <x:Double x:Key="AppMinWindowHeight">500</x:Double>
   <x:Double x:Key="AppMinWindowWidth">320</x:Double>
 
-  <FontFamily x:Key="CalculatorFontFamily">ms-appx:///Assets/CalcMDL2.ttf#Calculator MDL2 Assets</FontFamily>
+  <win:FontFamily x:Key="CalculatorFontFamily">ms-appx:///Assets/CalcMDL2.ttf#Calculator MDL2 Assets</win:FontFamily>
+  <xamarin:FontFamily x:Key="CalculatorFontFamily">Calculator MDL2 Assets</xamarin:FontFamily>
 
   <x:Double x:Key="SplitViewOpenPaneLength">256</x:Double>
   <Thickness x:Key="PivotPortraitThemePadding">0,1,0,0</Thickness>
diff --git a/src/Calculator.Shared/ViewModels/ApplicationViewModel.cs b/src/Calculator.Shared/ViewModels/ApplicationViewModel.cs
index 6694811b..2069defe 100644
--- a/src/Calculator.Shared/ViewModels/ApplicationViewModel.cs
+++ b/src/Calculator.Shared/ViewModels/ApplicationViewModel.cs
@@ -110,12 +110,15 @@ namespace CalculatorApp.ViewModel
 
             try
             {
+				Console.WriteLine($"ApplicationViewModel.Mode1={mode}");
                 Mode = mode;
-            }
-            catch (Exception e)
+				Console.WriteLine($"ApplicationViewModel.Mode2={Mode}");
+			}
+			catch (Exception e)
             {
-                // TraceLogger.GetInstance().LogPlatformException(__FUNCTIONW__, e);
-                if (!TryRecoverFromNavigationModeFailure())
+				Console.WriteLine($"ApplicationViewModel.Mode3={e}");
+				// TraceLogger.GetInstance().LogPlatformException(__FUNCTIONW__, e);
+				if (!TryRecoverFromNavigationModeFailure())
                 {
                     // Could not navigate to standard mode either.
                     // Throw the original exception so we have a good stack to debug.
@@ -152,6 +155,7 @@ namespace CalculatorApp.ViewModel
                     m_CalculatorViewModel = new StandardCalculatorViewModel();
                 }
                 m_CalculatorViewModel.SetCalculatorType(m_mode);
+				Console.WriteLine($"m_CalculatorViewMode = {m_CalculatorViewModel}");
             }
             else if (NavCategory.IsDateCalculatorViewMode(m_mode))
             {
@@ -228,4 +232,4 @@ namespace CalculatorApp.ViewModel
             Categories = NavCategoryGroup.CreateMenuOptions();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Calculator.Shared/ViewModels/StandardCalculatorViewModel.cs b/src/Calculator.Shared/ViewModels/StandardCalculatorViewModel.cs
index b215c6a6..92b64cc2 100644
--- a/src/Calculator.Shared/ViewModels/StandardCalculatorViewModel.cs
+++ b/src/Calculator.Shared/ViewModels/StandardCalculatorViewModel.cs
@@ -510,6 +510,8 @@ namespace CalculatorApp.ViewModel
 
         public StandardCalculatorViewModel()
         {
+			Console.WriteLine("new StandardCalculatorViewModel()");
+
             m_DisplayValue = "0";
             m_DecimalDisplayValue = "0";
             m_HexDisplayValue = "0";
@@ -571,11 +573,13 @@ namespace CalculatorApp.ViewModel
 
             m_decimalSeparator = LocalizationSettings.GetInstance().GetDecimalSeparator();
 
-            if (CoreWindow.GetForCurrentThread() != null)
+#if !__WASM__
+			if (CoreWindow.GetForCurrentThread() != null)
             {
                 // Must have a CoreWindow to access the resource context.
                 m_isRtlLanguage = LocalizationService.GetInstance().IsRtlLayout();
             }
+#endif
 
             IsEditingEnabled = false;
             IsUnaryOperatorEnabled = true;
@@ -2435,4 +2439,4 @@ namespace CalculatorApp.ViewModel
 
         private void IFTPlatformException(bool result) { /* hresult validation is not used in C# */}
     }
-}
\ No newline at end of file
+}
diff --git a/src/Calculator.Shared/Views/MainPage.xaml.cs b/src/Calculator.Shared/Views/MainPage.xaml.cs
index aecb04ce..9977ac9a 100644
--- a/src/Calculator.Shared/Views/MainPage.xaml.cs
+++ b/src/Calculator.Shared/Views/MainPage.xaml.cs
@@ -75,7 +75,11 @@ namespace CalculatorApp
 
         protected override void OnNavigatedTo(NavigationEventArgs e)
         {
-            if (m_model.CalculatorViewModel != null)
+			initialized = true;
+
+			NavView.DataContext = m_model;
+
+			if (m_model.CalculatorViewModel != null)
             {
                 m_model.CalculatorViewModel.HistoryVM.ClearHistory();
             }
@@ -101,8 +105,14 @@ namespace CalculatorApp
                 }
             }
 
-            m_model.Initialize(initialMode);
-        }
+			m_model.Initialize(initialMode);
+
+
+			EnsureCalculator();
+			m_calculator.DataContext = m_model.CalculatorViewModel;
+
+			Initialize();
+		}
 
         void WindowSizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
         {
@@ -229,34 +239,46 @@ namespace CalculatorApp
         }
 
         void OnPageLoaded(object sender, RoutedEventArgs args)
-        {
-            if (m_converter == null && m_calculator == null && m_dateCalculator == null)
-            {
-                // We have just launched into our default mode (standard calc) so ensure calc is loaded
-                EnsureCalculator();
-                m_model.CalculatorViewModel.IsStandard = true;
-            }
+		{
+			Initialize();
+		}
 
-            Windows.UI.Xaml.Window.Current.SizeChanged += WindowSizeChanged;
-            UpdateViewState();
+		bool initialized = false;
+		private void Initialize()
+		{
+			// UNO TODO Check for Initialized (Load/OnNavigatedTo order is different)
+			if (initialized)
+			{
+				if (m_converter == null && m_calculator == null && m_dateCalculator == null)
+				{
+					// We have just launched into our default mode (standard calc) so ensure calc is loaded
+					EnsureCalculator();
+					m_model.CalculatorViewModel.IsStandard = true;
+				}
 
-            SetHeaderAutomationName();
-            SetDefaultFocus();
 
-            // Delay load things later when we get a chance.
-            this.Dispatcher.RunAsync(
-                CoreDispatcherPriority.Normal, () => {
-                // UNO TODO
-                //if (TraceLogger.GetInstance().UpdateWindowIdLog(ApplicationView.GetApplicationViewIdForWindow(CoreWindow.GetForCurrentThread())))
-                //{
-                //    TraceLogger.GetInstance().LogAppLaunchComplete();
-                //    AppLifecycleLogger.GetInstance().LaunchUIResponsive();
-                //    AppLifecycleLogger.GetInstance().LaunchVisibleComplete();
-                //}
-            });
-        }
+				Windows.UI.Xaml.Window.Current.SizeChanged += WindowSizeChanged;
+				UpdateViewState();
 
-        void SetDefaultFocus()
+				SetHeaderAutomationName();
+				SetDefaultFocus();
+
+				// Delay load things later when we get a chance.
+				this.Dispatcher.RunAsync(
+					CoreDispatcherPriority.Normal, () =>
+					{
+					// UNO TODO
+					//if (TraceLogger.GetInstance().UpdateWindowIdLog(ApplicationView.GetApplicationViewIdForWindow(CoreWindow.GetForCurrentThread())))
+					//{
+					//    TraceLogger.GetInstance().LogAppLaunchComplete();
+					//    AppLifecycleLogger.GetInstance().LaunchUIResponsive();
+					//    AppLifecycleLogger.GetInstance().LaunchVisibleComplete();
+					//}
+				});
+			}
+		}
+
+		void SetDefaultFocus()
         {
             if (m_calculator != null && m_calculator.Visibility == Visibility.Visible)
             {
@@ -281,7 +303,7 @@ namespace CalculatorApp
                 // delay load calculator.
                 m_calculator = new Calculator();
                 m_calculator.Name = "Calculator";
-                m_calculator.DataContext = m_model.CalculatorViewModel;
+				m_calculator.DataContext = m_model.CalculatorViewModel;
                 Binding isStandardBinding = new Binding();
                 isStandardBinding.Path = new PropertyPath("IsStandard");
                 m_calculator.SetBinding(CalculatorApp.Calculator.IsStandardProperty, isStandardBinding);
@@ -305,7 +327,7 @@ namespace CalculatorApp
                 ShowHideControls(this.Model.Mode);
             }
 
-            if (m_dateCalculator != null)
+			if (m_dateCalculator != null)
             {
                 // UNO TODO
                 // m_dateCalculator.CloseCalendarFlyout();
diff --git a/src/Calculator.Wasm/Calculator.Wasm.csproj b/src/Calculator.Wasm/Calculator.Wasm.csproj
index 1555afa4..bf3ff1c9 100644
--- a/src/Calculator.Wasm/Calculator.Wasm.csproj
+++ b/src/Calculator.Wasm/Calculator.Wasm.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -6,15 +6,18 @@
     <WasmHead>true</WasmHead>
     <DefineConstants>$(DefineConstants);__WASM__</DefineConstants>
     <NoWarn>NU1701</NoWarn>
-    <WasmShellGenerateCompressedFiles Condition="'$(Configuration)'=='DEBUG'">false</WasmShellGenerateCompressedFiles>
+    <WasmShellGenerateCompressedFiles Condition="'$(Configuration)'=='Debug'">false</WasmShellGenerateCompressedFiles>
     <!--<BuildingInsideUnoSourceGenerator>true</BuildingInsideUnoSourceGenerator>-->
-  </PropertyGroup>
+		<MonoRuntimeDebuggerEnabled Condition="'$(Configuration)'=='Debug'">true</MonoRuntimeDebuggerEnabled>
+		<MonoWasmRuntimeConfiguration>release-dynamic</MonoWasmRuntimeConfiguration>
+		<MonoWasmSDKUri>C:\Users\jerome.laban\Downloads\mono-wasm-4d023b6bf84.zip</MonoWasmSDKUri>
+	</PropertyGroup>
   <ItemGroup>
     <Content Include="..\Calculator.UWP\Assets\*.png" Link="Assets\%(FileName)%(Extension)" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="WasmCSS\Fonts.css" />
-    <EmbeddedResource Include="WasmScripts\AppManifest.js" />
+    <EmbeddedResource Include="WasmScripts\*.js" />
   </ItemGroup>
   <ItemGroup>
     <LinkerDescriptor Include="LinkerConfig.xml" />
@@ -27,9 +30,10 @@
     You can safely remove this ItemGroup completely.
     -->
     <Compile Remove="Program.cs" />
+    <None Remove="WasmScripts\CalcManager.js" />
     <Compile Include="Program.cs" />
     <Content Include="LinkerConfig.xml" />
-  </ItemGroup>
+  </ItemGroup> 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="1.1.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.1" />
@@ -37,5 +41,8 @@
     <PackageReference Include="Uno.Wasm.Bootstrap" Version="1.0.0-dev.269" />
     <DotNetCliToolReference Include="Uno.Wasm.Bootstrap.Cli" Version="1.0.0-dev.269" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="..\CalcManager\CalcManager.wasm" Link="CalcManager.wasm" />
+  </ItemGroup>
   <Import Project="..\Calculator.Shared\Calculator.Shared.projitems" Label="Shared" Condition="Exists('..\Calculator.Shared\Calculator.Shared.projitems')" />
 </Project>
diff --git a/src/Calculator.Wasm/Program.cs b/src/Calculator.Wasm/Program.cs
index 46ada3e5..40b01b4c 100644
--- a/src/Calculator.Wasm/Program.cs
+++ b/src/Calculator.Wasm/Program.cs
@@ -11,8 +11,10 @@ namespace WindowsCalculator.Wasm
 		private static App _app;
 
 		static void Main(string[] args)
-        {
-            ConfigureFilters(LogExtensionPoint.AmbientLoggerFactory);
+		{
+			Console.WriteLine("Program.Main");
+
+			ConfigureFilters(LogExtensionPoint.AmbientLoggerFactory);
 
             Windows.UI.Xaml.Application.Start(_ => _app = new App());
 		}
diff --git a/src/Calculator.Wasm/WasmCSS/Fonts.css b/src/Calculator.Wasm/WasmCSS/Fonts.css
index 27e5a545..a49767b6 100644
--- a/src/Calculator.Wasm/WasmCSS/Fonts.css
+++ b/src/Calculator.Wasm/WasmCSS/Fonts.css
@@ -1,7 +1,12 @@
 @font-face {
-    font-family: "Symbols";
-    /* winjs-symbols.woff2: https://github.com/Microsoft/fonts/tree/master/Symbols */
-    src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff');
+  font-family: "Calculator MDL2 Assets";
+  src: url("Assets/CalcMDL2.woff") format('woff');
+}
+
+@font-face {
+  font-family: "Symbols";
+  /* winjs-symbols.woff2: https://github.com/Microsoft/fonts/tree/master/Symbols */
+  src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff');
 }
 
 @font-face {
diff --git a/src/Calculator.Wasm/WasmScripts/CalcManager.js b/src/Calculator.Wasm/WasmScripts/CalcManager.js
new file mode 100644
index 00000000..fffd2bfa
--- /dev/null
+++ b/src/Calculator.Wasm/WasmScripts/CalcManager.js
@@ -0,0 +1,44 @@
+class CalcManager {
+    static registerCallbacks() {
+
+        var _getCEngineStringCallback       = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:GetCEngineStringCallback");
+        var _binaryOperatorReceivedCallback = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:BinaryOperatorReceivedCallback");
+        var _setPrimaryDisplayCallback      = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetPrimaryDisplayCallback");
+        var _setIsInErrorCallback           = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetIsInErrorCallback");
+        var _setParenthesisNumberCallback   = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetParenthesisNumberCallback");
+        var _maxDigitsReachedCallback       = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:MaxDigitsReachedCallback");
+        var _memoryItemChangedCallback      = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:MemoryItemChangedCallback");
+        var _onHistoryItemAddedCallback     = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:OnHistoryItemAddedCallback");
+        var _onNoRightParenAddedCallback    = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:OnNoRightParenAddedCallback");
+        var _setExpressionDisplayCallback   = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetExpressionDisplayCallback");
+        var _setMemorizedNumbersCallback    = Module.mono_bind_static_method("[Calculator.Wasm] CalculationManager.NativeDispatch:SetMemorizedNumbersCallback");
+
+        var fGetCEngineStringCallback       = Module.addFunction((state, id) => _getCEngineStringCallback(state, Module.UTF8ToString(id)), 'iii');
+
+        var fBinaryOperatorReceivedCallback = Module.addFunction((state) => _binaryOperatorReceivedCallback(state), 'vi');
+        var fSetPrimaryDisplayCallback      = Module.addFunction((state, displayStringValue, isError) => _setPrimaryDisplayCallback(state, Module.UTF8ToString(displayStringValue), isError), 'viii');
+        var fSetIsInErrorCallback           = Module.addFunction((state, isError) => _setIsInErrorCallback(state, isError), 'vii');
+        var fSetParenthesisNumberCallback   = Module.addFunction((state, parenthesisCount) => _setParenthesisNumberCallback(state, parenthesisCount), 'vii');
+        var fMaxDigitsReachedCallback       = Module.addFunction((state) => _maxDigitsReachedCallback(state), 'vii');
+        var fMemoryItemChangedCallback      = Module.addFunction((state, indexOfMemory) => _memoryItemChangedCallback(state, indexOfMemory), 'vii');
+        var fOnHistoryItemAddedCallback     = Module.addFunction((state, addedItemIndex) => _onHistoryItemAddedCallback(state, addedItemIndex), 'vii');
+        var fOnNoRightParenAddedCallback    = Module.addFunction((state) => _onNoRightParenAddedCallback    (state), 'vi');
+        var fSetExpressionDisplayCallback   = Module.addFunction((state) => _setExpressionDisplayCallback   (state), 'vi');
+        var fSetMemorizedNumbersCallback    = Module.addFunction((state, numbers) => _setMemorizedNumbersCallback(state, numbers), 'vii');
+
+        var ret = `${fGetCEngineStringCallback};`
+            + `${fBinaryOperatorReceivedCallback};`
+            + `${fSetPrimaryDisplayCallback};`
+            + `${fSetIsInErrorCallback};`
+            + `${fSetParenthesisNumberCallback};`
+            + `${fMaxDigitsReachedCallback};`
+            + `${fMemoryItemChangedCallback};`
+            + `${fOnHistoryItemAddedCallback};`
+            + `${fOnNoRightParenAddedCallback};`
+            + `${fSetExpressionDisplayCallback};`
+            + `${fSetMemorizedNumbersCallback};`
+            ;
+
+        return ret;
+    }
+}