Further expanded plugins

Added navigation between modules

src/Artemis.Core/Artemis.Core.csproj

@@ -35,8 +35,8 @@
     <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
       <HintPath>..\packages\Castle.Core.4.2.1\lib\net45\Castle.Core.dll</HintPath>
     </Reference>
-    <Reference Include="CSScriptLibrary, Version=3.27.2.0, Culture=neutral, PublicKeyToken=70fcc3d18c749033, processorArchitecture=MSIL">
+    <Reference Include="CSScriptLibrary, Version=3.28.0.0, Culture=neutral, PublicKeyToken=70fcc3d18c749033, processorArchitecture=MSIL">
-      <HintPath>..\packages\CS-Script.bin.3.27.2.0\lib\net46\CSScriptLibrary.dll</HintPath>
+      <HintPath>..\packages\CS-Script.bin.3.28.0.1\lib\net46\CSScriptLibrary.dll</HintPath>
     </Reference>
     <Reference Include="HidSharp, Version=1.5.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\HidSharp.1.5\lib\net35\HidSharp.dll</HintPath>
@@ -54,10 +54,10 @@
       <HintPath>..\packages\Microsoft.CodeAnalysis.Scripting.Common.2.6.1\lib\netstandard1.3\Microsoft.CodeAnalysis.Scripting.dll</HintPath>
     </Reference>
     <Reference Include="Mono.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756, processorArchitecture=MSIL">
-      <HintPath>..\packages\CS-Script.bin.3.27.2.0\lib\net46\Mono.CSharp.dll</HintPath>
+      <HintPath>..\packages\CS-Script.bin.3.28.0.1\lib\net46\Mono.CSharp.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+    <Reference Include="Newtonsoft.Json, Version=11.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.10.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.11.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="Ninject, Version=3.3.4.0, Culture=neutral, PublicKeyToken=c7192dc5380945e7, processorArchitecture=MSIL">
       <HintPath>..\packages\Ninject.3.3.4\lib\net45\Ninject.dll</HintPath>
@@ -104,8 +104,8 @@
     <Reference Include="RGB.NET.Input, Version=0.0.1.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\RGB.NET.Input.0.0.1.26\lib\net45\RGB.NET.Input.dll</HintPath>
     </Reference>
-    <Reference Include="Sanford.Multimedia.Midi, Version=6.4.2.0, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="Sanford.Multimedia.Midi, Version=6.6.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Sanford.Multimedia.Midi.6.4.2\lib\net20\Sanford.Multimedia.Midi.dll</HintPath>
+      <HintPath>..\packages\Sanford.Multimedia.Midi.6.6.0\lib\net20\Sanford.Multimedia.Midi.dll</HintPath>
     </Reference>
     <Reference Include="Stylet, Version=1.1.21.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\Stylet.1.1.21\lib\net45\Stylet.dll</HintPath>
@@ -196,6 +196,9 @@
     <Compile Include="ProfileElements\Profile.cs" />
     <Compile Include="Ninject\CoreModule.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Scripting.evaluator.cs" />
+    <Compile Include="Scripting.Extensions.cs" />
+    <Compile Include="Scripting.native.cs" />
     <Compile Include="Services\CoreService.cs" />
     <Compile Include="Services\RgbService.cs" />
     <Compile Include="Services\Interfaces\IRgbService.cs" />
@@ -209,10 +212,6 @@
     <None Include="app.config" />
     <None Include="packages.config" />
   </ItemGroup>
-  <ItemGroup>
-    <Analyzer Include="..\packages\Microsoft.CodeAnalysis.Analyzers.1.1.0\analyzers\dotnet\cs\Microsoft.CodeAnalysis.Analyzers.dll" />
-    <Analyzer Include="..\packages\Microsoft.CodeAnalysis.Analyzers.1.1.0\analyzers\dotnet\cs\Microsoft.CodeAnalysis.CSharp.Analyzers.dll" />
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Artemis.Plugins\Artemis.Plugins.csproj">
       <Project>{cd23bc5e-57f0-46ce-a007-24d031146219}</Project>

src/Artemis.Core/Scripting.Extensions.cs

@@ -0,0 +1,295 @@
+using CSScriptLibrary;
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.Remoting.Lifetime;
+using System.Threading;
+using System.Threading.Tasks;
+
+// Read in more details about all aspects of CS-Script hosting in applications 
+// here: http://www.csscript.net/help/Script_hosting_guideline_.html
+//
+// This file contains samples for the script hosting scenarios requiring asynchronous script execution as well as unloading the 
+// scripts being executed.
+//  AsyncSamples
+//    Samples demonstrate the use of Async and Await mechanism available in C# 5 and higher. Note that the async method extensions 
+//    cover the complete set of CSScript.Evaluator methods. 
+//
+//  UnloadingSamples 
+//    Samples demonstrate the use of temporary AppDoamain for loading and executing dynamic C# code (script). It is the 
+//    only mechanism available for unloading dynamically loaded assemblies. This is a well known CLR design limitation that leads to 
+//    memory leaks if the assembly/script loaded in the caller AppDomain. The problem affects all C# script engines (e.g. Roslyn, CodeDom)
+//    and it cannot be solved by the engine itself thus CS-Script provides a work around in form of the MethodExtensions for the 
+//    CSScript.Evaluator methods that are compatible with the unloading mechanism.
+//
+//    Nevertheless you should try to avoid using remote AppDoamain unless you have to. It is very heavy and also imposes the serialization
+//    constrains.  
+//
+// All samples rely on the compiler agnostic CSScript.Evaluator API. 
+namespace CSScriptEvaluatorExtensions
+{
+    public class HostApp
+    {
+        public static void Test()
+        {
+            Console.WriteLine("---------------------------------------------");
+            Console.WriteLine("Testing asynchronous API");
+            Console.WriteLine("---------------------------------------------");
+            new AsyncSamples().RunAll();
+            Thread.Sleep(2000);
+            Console.WriteLine("\nPress 'Enter' to run uloading samples...");
+            Console.ReadLine();
+            Console.WriteLine("---------------------------------------------");
+            Console.WriteLine("Testing unloading API");
+            Console.WriteLine("---------------------------------------------");
+            new UnloadingSamples().RunAll();
+        }
+
+        class AsyncSamples
+        {
+            public void RunAll()
+            {
+                Action<Action, string> run = (action, name) => { action(); Console.WriteLine(name); };
+
+                run(LoadDelegateAsync, "Start of " + nameof(LoadDelegateAsync));
+                run(LoadMethodAsync, "Start of " + nameof(LoadMethodAsync));
+                run(LoadCodeAsync, "Start of " + nameof(LoadCodeAsync));
+                run(CreateDelegateAsync, "Start of " + nameof(CreateDelegateAsync));
+                run(CompileCodeAsync, "Start of " + nameof(CompileCodeAsync));
+                run(RemoteAsynch, "Start of " + nameof(RemoteAsynch));
+            }
+
+            async void LoadDelegateAsync()
+            {
+                var product = await CSScript.Evaluator
+                                            .LoadDelegateAsync<Func<int, int, int>>(
+                                                  @"int Product(int a, int b)
+                                                    {
+                                                        return a * b;
+                                                    }");
+
+                Console.WriteLine("   End of {0}: {1}", nameof(LoadDelegateAsync), product(4, 2));
+            }
+
+            public async void LoadMethodAsync()
+            {
+                dynamic script = await CSScript.Evaluator
+                                               .LoadMethodAsync(@"public int Sum(int a, int b)
+                                                                  {
+                                                                      return a + b;
+                                                                  }
+                                                                  public int Div(int a, int b)
+                                                                  {
+                                                                      return a/b;
+                                                                  }");
+
+                Console.WriteLine("   End of {0}: {1}", nameof(LoadMethodAsync), script.Div(15, 3));
+            }
+
+            public async void LoadCodeAsync()
+            {
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                ICalc calc = await CSScript.Evaluator
+                                           .LoadCodeAsync<ICalc>(
+                                                  @"using System;
+                                                    public class Script
+                                                    {
+                                                        public int Sum(int a, int b)
+                                                        {
+                                                            return a+b;
+                                                        }
+                                                    }");
+
+                Console.WriteLine("   End of {0}: {1}", nameof(LoadCodeAsync), calc.Sum(1, 2));
+            }
+
+            public async void CreateDelegateAsync()
+            {
+                var product = await CSScript.Evaluator
+                                            .CreateDelegateAsync<int>(
+                                                  @"int Product(int a, int b)
+                                                    {
+                                                        return a * b;
+                                                    }");
+
+                Console.WriteLine("   End of {0}: {1}", nameof(CreateDelegateAsync), product(15, 3));
+            }
+
+            public async void CompileCodeAsync()
+            {
+                Assembly script = await CSScript.Evaluator
+                                                .CompileCodeAsync(@"using System;
+                                                                    public class Script
+                                                                    {
+                                                                        public int Sum(int a, int b)
+                                                                        {
+                                                                            return a+b;
+                                                                        }
+                                                                    }");
+                dynamic calc = script.CreateObject("*");
+
+                Console.WriteLine("   End of {0}: {1}", nameof(CompileCodeAsync), calc.Sum(15, 3));
+            }
+
+            public async void RemoteAsynch()
+            {
+                var sum = await Task.Run(() =>
+                                     CSScript.Evaluator
+                                             .CreateDelegateRemotely<int>(
+                                                                   @"int Sum(int a, int b)
+                                                                     {
+                                                                         return a+b;
+                                                                     }")
+                                                                          );
+                Console.WriteLine("   End of {0}: {1}", nameof(RemoteAsynch), sum(1, 2));
+
+                sum.UnloadOwnerDomain();
+            }
+        }
+
+        class UnloadingSamples
+        {
+            public void RunAll()
+            {
+                CreateDelegateRemotely();
+                LoadMethodRemotely();
+                LoadCodeRemotely();
+                LoadCodeRemotelyWithInterface();
+            }
+
+            public void CreateDelegateRemotely()
+            {
+                var sum = CSScript.Evaluator
+                                    .CreateDelegateRemotely<int>(@"int Sum(int a, int b)
+                                                    {
+                                                        return a+b;
+                                                    }");
+
+                Console.WriteLine("{0}: {1}", nameof(CreateDelegateRemotely), sum(15, 3));
+
+                sum.UnloadOwnerDomain();
+            }
+
+            public void LoadCodeRemotely()
+            {
+                // Class Calc doesn't implement ICals interface. Thus the compiled object cannot be typecasted into 
+                // the interface and Evaluator will emit duck-typed assembly instead. 
+                // But Mono and Roslyn build file-less assemblies, meaning that they cannot be used to build 
+                // duck-typed proxies and CodeDomEvaluator needs to be used explicitly.
+                // Note class Calc also inherits from MarshalByRefObject. This is required for all object that 
+                // are passed between AppDomain: they must inherit from MarshalByRefObject or be serializable.
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                var script = CSScript.CodeDomEvaluator
+                                     .LoadCodeRemotely<ICalc>(
+                                                      @"using System;
+                                                        public class Calc : MarshalByRefObject
+                                                        { 
+                                                            object t;
+                                                            public int Sum(int a, int b)
+                                                            {
+                                                                t = new Test();
+                                                                return a+b;
+                                                            }
+                                                        }    
+                                                        
+                                                        class Test
+                                                        {
+                                                            ~Test()
+                                                            {
+                                                                Console.WriteLine(""Domain is unloaded: ~Test()"");
+                                                            }
+                                                        }                                         
+                                                        ");
+
+                Console.WriteLine("{0}: {1}", nameof(LoadCodeRemotely), script.Sum(15, 3));
+
+                script.UnloadOwnerDomain();
+            }
+
+            public void LoadCodeRemotelyWithInterface()
+            {
+                // Note class Calc also inherits from MarshalByRefObject. This is required for all object that 
+                // are passed between AppDomain: they must inherit from MarshalByRefObject or be serializable.
+                var script = CSScript.Evaluator
+                                     .LoadCodeRemotely<ICalc>(
+                                                      @"using System;
+                                                        public class Calc : MarshalByRefObject, CSScriptEvaluatorExtensions.ICalc
+                                                        { 
+                                                            public int Sum(int a, int b)
+                                                            {
+                                                                return a+b;
+                                                            }
+                                                        }    
+                                                        ");
+
+                Console.WriteLine("{0}: {1}", nameof(LoadCodeRemotelyWithInterface), script.Sum(15, 3));
+
+                script.UnloadOwnerDomain();
+            }
+
+            public void LoadMethodRemotely()
+            {
+                // LoadMethodRemotely is essentially the same as LoadCodeRemotely. It just deals not with the 
+                // whole class definition but a single method(s) only. And the rest of the class definition is 
+                // added automatically by CS-Script. The auto-generated class declaration also indicates 
+                // that the class implements ICalc interface. Meaning that it will trigger compile error
+                // if the set of methods in the script code doesn't implement all interface members.
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                var script = CSScript.Evaluator
+                                        .LoadMethodRemotely<IFullCalc>(
+                                                        @"public int Sum(int a, int b)
+                                                            {
+                                                                return a+b;
+                                                            }
+                                                            public int Sub(int a, int b)
+                                                            {
+                                                                return a-b;
+                                                            }");
+
+                Console.WriteLine("{0}: {1}", nameof(LoadMethodRemotely), script.Sum(15, 3));
+
+                script.UnloadOwnerDomain();
+            }
+
+            MethodDelegate sum;
+            ClientSponsor sumSponsor;
+
+            public void KeepRemoteObjectAlive()
+            {
+                sum = CSScript.Evaluator
+                              .CreateDelegateRemotely(@"int Sum(int a, int b)
+                                                        {
+                                                            return a+b;
+                                                        }");
+
+                //Normally remote objects are disposed if they are not accessed withing a default timeout period.
+                //It is not even enough to keep transparent proxies or their wrappers (e.g. 'sum') referenced. 
+                //To prevent GC collection in the remote domain use .NET ClientSponsor mechanism as below.
+                sumSponsor = sum.ExtendLifeFromMinutes(30);
+            }
+        }
+    }
+
+    public interface ICalc
+    {
+        int Sum(int a, int b);
+    }
+
+    public interface IFullCalc
+    {
+        int Sum(int a, int b);
+
+        int Sub(int a, int b);
+    }
+}

src/Artemis.Core/Scripting.evaluator.cs

@@ -0,0 +1,345 @@
+using CSScriptLibrary;
+using System;
+using System.Diagnostics;
+
+// Read in more details about all aspects of CS-Script hosting in applications 
+// here: http://www.csscript.net/help/Script_hosting_guideline_.html
+//
+// This file contains samples for the script hosting scenarios relying on CS-Script Evaluator interface (API).
+// This API is a unified generic interface allowing dynamic switch of the underlying compiling services (Mono, Roslyn, CodeDom)
+// without the need for changing the hosting code. 
+//
+// Apart from Evaluator (compiler agnostic) API CS-Script offers alternative hosting model: CS-Script Native, 
+// which relies solely on CodeDom compiler. CS-Script Native offers some features that are not available with CS-Script Evaluator 
+// (e.g. script unloading). 
+// 
+// The choice of the underlying compiling engine (e.g. Mono vs CodeDom) when using CS-Script Evaluator is always dictated by the 
+// specifics of the hosting scenario. Thanks to in-process compiler hosting, Mono and Roslyn demonstrate much better compiling 
+// performance comparing to CodeDom engine. However they don't allow  script debugging and caching easily supported with CodeDom. 
+// Mono and particularly Roslyn also leas create more memory pressure due to the higher volume of the temp assemblies loaded into 
+// the hosting AppDomain. Roslyn (at least CSharp.Scripting-v1.2.0.0) also has very high initial loading overhead up to 4 seconds.
+//
+// One of the possible approaches would be to use EvaluatorEngine.CodeDom during the active development and later on switch to Mono/Roslyn.
+
+namespace CSScriptEvaluatorApi
+{
+    public class HostApp
+    {
+        public static void Test()
+        {
+            // Just in case clear AlternativeCompiler so it is not set to Roslyn or anything else by 
+            // the CS-Script installed (if any) on the host OS
+            CSScript.GlobalSettings.UseAlternativeCompiler = null;
+
+            var samples = new EvaluatorSamples();
+
+            Console.WriteLine("Testing compiling services");
+            Console.WriteLine("---------------------------------------------");
+
+            CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Mono;
+            Console.WriteLine(CSScript.Evaluator.GetType().Name + "...");
+            samples.RunAll();
+
+            Console.WriteLine("---------------------------------------------");
+
+            CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Roslyn;
+            Console.WriteLine(CSScript.Evaluator.GetType().Name + "...");
+            samples.RunAll();
+
+            Console.WriteLine("---------------------------------------------");
+
+            CSScript.EvaluatorConfig.Engine = EvaluatorEngine.CodeDom;
+            Console.WriteLine(CSScript.Evaluator.GetType().Name + "...");
+
+            samples.RunAll();
+
+            //samples.DebugTest(); //uncomment if want to fire an assertion during the script execution
+
+            //Profile(); //uncomment if want to test performance of the engines
+        }
+
+        class EvaluatorSamples
+        {
+            public void RunAll()
+            {
+                Action<Action, string> run = (action, name) => { action(); Console.WriteLine(name + " - OK"); };
+
+                run(CompileMethod_Instance, nameof(CompileMethod_Instance));
+                run(CompileMethod_Static, nameof(CompileMethod_Static));
+                run(CreateDelegate, nameof(CreateDelegate));
+                run(LoadDelegate, nameof(LoadDelegate));
+                run(LoadCode, nameof(LoadCode));
+                run(LoadMethod, nameof(LoadMethod));
+                run(LoadMethodWithInterface, nameof(LoadMethodWithInterface));
+                run(LoadCode_WithInterface, nameof(LoadCode_WithInterface));
+                run(LoadCode_WithDuckTypedInterface, nameof(LoadCode_WithDuckTypedInterface));
+            }
+
+            public void CompileMethod_Instance()
+            {
+                // 1- CompileMethod wraps method into a class definition and returns compiled assembly
+                // 2 - CreateObject creates instance of a first class in the assembly
+
+                dynamic script = CSScript.Evaluator
+                                         .CompileMethod(@"int Sqr(int data)
+                                                          {
+                                                              return data * data;
+                                                          }")
+                                         .CreateObject("*");
+
+                var result = script.Sqr(7);
+            }
+
+            public void CompileMethod_Static()
+            {
+                // 1 - CompileMethod wraps method into a class definition and returns compiled assembly
+                // 2 - GetStaticMethod returns duck-typed delegate that accepts 'params object[]' arguments
+                // Note: GetStaticMethodWithArgs can be replaced with a more convenient/shorter version
+                // that takes the object instead of the Type and then queries objects type internally:
+                //  "GetStaticMethod("*.Test", data)"
+
+                var test = CSScript.Evaluator
+                                   .CompileMethod(@"using CSScriptEvaluatorApi;
+                                                    static void Test(InputData data)
+                                                    {
+                                                        data.Index = GetIndex();
+                                                    }
+                                                    static int GetIndex()
+                                                    {
+                                                        return Environment.TickCount;
+                                                    }")
+                                   .GetStaticMethodWithArgs("*.Test", typeof(InputData));
+
+                var data = new InputData();
+                test(data);
+            }
+
+            public void CreateDelegate()
+            {
+                // Wraps method into a class definition, compiles it and loads the compiled assembly.
+                // It returns duck-typed delegate. A delegate with 'params object[]' arguments and
+                // without any specific return type.
+
+                var sqr = CSScript.Evaluator
+                                  .CreateDelegate(@"int Sqr(int a)
+                                                    {
+                                                        return a * a;
+                                                    }");
+
+                var r = sqr(3);
+            }
+
+            public void LoadDelegate()
+            {
+                // Wraps method into a class definition, loads the compiled assembly
+                // and returns the method delegate for the method, which matches the delegate specified
+                // as the type parameter of LoadDelegate
+
+                var product = CSScript.Evaluator
+                                      .LoadDelegate<Func<int, int, int>>(
+                                                  @"int Product(int a, int b)
+                                                    {
+                                                        return a * b;
+                                                    }");
+
+                int result = product(3, 2);
+            }
+
+            public void LoadCode()
+            {
+                // LoadCode compiles code and returns instance of a first class
+                // in the compiled assembly
+
+                dynamic script = CSScript.Evaluator
+                                         .LoadCode(@"using System;
+                                                     public class Script
+                                                     {
+                                                         public int Sum(int a, int b)
+                                                         {
+                                                             return a+b;
+                                                         }
+                                                     }");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public void LoadMethod()
+            {
+                // LoadMethod compiles code and returns instance of a first class
+                // in the compiled assembly.
+                // LoadMethod is essentially the same as LoadCode. It just deals not with the 
+                // whole class definition but a single method(s) only. And the rest of the class definition is 
+                // added automatically by CS-Script. 
+                // 'public' is optional as it will be injected if the code doesn't start with it.
+                dynamic script = CSScript.Evaluator
+                                         .LoadMethod(@"using System;
+                                                       public int Sum(int a, int b)
+                                                       {
+                                                           return a+b;
+                                                       }");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public void LoadMethodWithInterface()
+            {
+                // LoadMethod compiles code and returns instance of a first class
+                // in the compiled assembly.
+                // LoadMethod is essentially the same as LoadCode. It just deals not with the 
+                // whole class definition but a single method(s) only. And the rest of the class definition is 
+                // added automatically by CS-Script. The auto-generated class declaration also indicates 
+                // that the class implements ICalc interface. Meaning that it will trigger compile error
+                // if the set of methods in the script code doesn't implement all interface members.
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                ICalc script = CSScript.Evaluator
+                                       .LoadMethod<ICalc>(
+                                                     @"int Sum(int a, int b)
+                                                       {
+                                                           return a+b;
+                                                       }");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public void LoadCode_WithInterface()
+            {
+                // 1 - LoadCode compiles code and returns instance of a first class in the compiled assembly
+                // 2 - The script class implements host app interface so the returned object can be type casted into it
+
+                var script = (ICalc)CSScript.Evaluator
+                                            .LoadCode(@"using System;
+                                                        public class Script : CSScriptEvaluatorApi.ICalc
+                                                        {
+                                                            public int Sum(int a, int b)
+                                                            {
+                                                                return a+b;
+                                                            }
+                                                        }");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public void LoadCode_WithDuckTypedInterface()
+            {
+                // 1 - LoadCode compiles code and returns instance of a first class in the compiled assembly
+                // 2- The script class doesn't implement host app interface but it can still be aligned to
+                // one as long at it implements the  interface members
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                ICalc script = CSScript.MonoEvaluator
+                                       .LoadCode<ICalc>(@"using System;
+                                                          public class Script
+                                                          {
+                                                              public int Sum(int a, int b)
+                                                              {
+                                                                  return a+b;
+                                                              }
+                                                          }");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public void PerformanceTest(int count = -1)
+            {
+                var code = @"int Sqr(int a)
+                            {
+                                return a * a;
+                            }";
+
+                if (count != -1)
+                    code += "//" + count; //this unique extra code comment ensures the code to be compiled cannot be cached
+
+                dynamic script = CSScript.Evaluator
+                                         .CompileMethod(code)
+                                         .CreateObject("*");
+
+                var r = script.Sqr(3);
+            }
+
+            public void DebugTest()
+            {
+                //pops up an assertion dialog 
+
+                CSScript.EvaluatorConfig.DebugBuild = true;
+                CSScript.EvaluatorConfig.Engine = EvaluatorEngine.CodeDom;
+
+                dynamic script = CSScript.Evaluator
+                                         .LoadCode(@"using System;
+                                                     using System.Diagnostics;
+                                                     public class Script
+                                                     {
+                                                         public int Sum(int a, int b)
+                                                         {
+                                                             Debug.Assert(false,""Testing CS-Script debugging..."");
+                                                             return a+b;
+                                                         }
+                                                     }");
+
+                var r = script.Sum(3, 4);
+            }
+        }
+
+        public static void Profile()
+        {
+            var sw = new Stopwatch();
+            var samples = new EvaluatorSamples();
+            var count = 20;
+            var inxed = 0;
+            bool preventCaching = false;
+
+            Action run = () =>
+            {
+                sw.Restart();
+                for (int i = 0; i < count; i++)
+                    if (preventCaching)
+                        samples.PerformanceTest(inxed++);
+                    else
+                        samples.PerformanceTest();
+
+                Console.WriteLine(CSScript.Evaluator.GetType().Name + ": " + sw.ElapsedMilliseconds);
+            };
+
+            Action runAll = () =>
+            {
+                Console.WriteLine("\n---------------------------------------------");
+                Console.WriteLine($"Caching enabled: {!preventCaching}\n");
+
+                CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Mono;
+                run();
+
+                CSScript.EvaluatorConfig.Engine = EvaluatorEngine.CodeDom;
+                run();
+
+                CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Roslyn;
+                run();
+            };
+
+            RoslynEvaluator.LoadCompilers(); //Roslyn is extremely heavy so exclude startup time from profiling
+
+            Console.WriteLine("Testing performance");
+
+            preventCaching = true;
+            runAll();
+
+            preventCaching = false;
+            runAll();
+        }
+    }
+
+    public interface ICalc
+    {
+        int Sum(int a, int b);
+    }
+
+    public class InputData
+    {
+        public int Index = 0;
+    }
+}

src/Artemis.Core/Scripting.native.cs

@@ -0,0 +1,354 @@
+using CSScriptLibrary;
+using System;
+using System.Linq;
+using System.IO;
+using csscript;
+using System.CodeDom.Compiler;
+
+// Read in more details about all aspects of CS-Script hosting in applications 
+// here: http://www.csscript.net/help/Script_hosting_guideline_.html
+//   
+// This file contains samples for the script hosting scenarios relying on CS-Script Native interface (API).
+// This API is a compiler specific interface, which relies solely on CodeDom compiler. In most of the cases 
+// CS-Script Native model is the most flexible and natural choice 
+//
+// Apart from Native API CS-Script offers alternative hosting model: CS-Script Evaluator, which provides
+// a unified generic interface allowing dynamic switch the underlying compiling services (Mono, Roslyn, CodeDom) 
+// without the need for changing the hosting code. 
+//   
+// The Native interface is the original API that was designed to take maximum advantage of the dynamic C# code 
+// execution with CodeDom. The original implementation of this API was developed even before any compiler-as-service 
+// solution became available. Being based solely on CodeDOM the API doesn't utilize neither Mono nor Roslyn 
+// scripting solutions. Despite that CS-Script Native is the most mature, powerful and flexible API available with CS-Script.
+// 
+// Native interface allows some unique features that are not available with CS-Script Evaluator:
+//  - Debugging scripts
+//  - Script caching
+//  - Script unloading
+
+namespace CSScriptNativeApi
+{
+    public class HostApp
+    {
+        public static void Test()
+        {
+            var host = new HostApp();
+            host.Log("Testing compiling services CS-Script Native API");
+            Console.WriteLine("---------------------------------------------");
+
+            CodeDomSamples.LoadMethod_Instance();
+            CodeDomSamples.LoadMethod_Static();
+            CodeDomSamples.LoadDelegate();
+            CodeDomSamples.CreateAction();
+            CodeDomSamples.CreateFunc();
+            CodeDomSamples.LoadCode();
+            CodeDomSamples.LoadCode_WithInterface(host);
+            CodeDomSamples.LoadCode_WithDuckTypedInterface(host);
+            CodeDomSamples.ExecuteAndUnload();
+            //CodeDomSamples.DebugTest(); //uncomment if want to fire an assertion during the script execution
+        }
+
+        public class CodeDomSamples
+        {
+            public static void LoadMethod_Instance()
+            {
+                // 1- LoadMethod wraps method into a class definition, compiles it and returns loaded assembly
+                // 2 - CreateObject creates instance of a first class in the assembly  
+
+                dynamic script = CSScript.LoadMethod(@"int Sqr(int data)
+                                                       {
+                                                           return data * data;
+                                                       }")
+                                         .CreateObject("*");
+
+                var result = script.Sqr(7);
+            }
+
+            public static void LoadMethod_Static()
+            {
+                // 1 - LoadMethod wraps method into a class definition, compiles it and returns loaded assembly
+                // 2 - GetStaticMethod returns first found static method as a duck-typed delegate that 
+                //     accepts 'params object[]' arguments 
+                //
+                // Note: you can use GetStaticMethodWithArgs for higher precision method search: GetStaticMethodWithArgs("*.SayHello", typeof(string)); 
+                var sayHello = CSScript.LoadMethod(@"static void SayHello(string greeting)
+                                                     {
+                                                         Console.WriteLine(greeting);
+                                                     }")
+                                       .GetStaticMethod();
+
+                sayHello("Hello World!");
+            }
+
+            public static void LoadDelegate()
+            {
+                // LoadDelegate wraps method into a class definition, compiles it and loads the compiled assembly.
+                // It returns the method delegate for the method, which matches the delegate specified 
+                // as the type parameter of LoadDelegate
+
+                // The 'using System;' is optional; it demonstrates how to specify 'using' in the method-only syntax
+
+                var sayHello = CSScript.LoadDelegate<Action<string>>(
+                                                   @"void SayHello(string greeting)
+                                                     {
+                                                         Console.WriteLine(greeting);
+                                                     }");
+
+                sayHello("Hello World!");
+            }
+
+            public static void CreateAction()
+            {
+                // Wraps method into a class definition, compiles it and loads the compiled assembly.
+                // It returns duck-typed delegate. A delegate with 'params object[]' arguments and 
+                // without any specific return type. 
+
+                var sayHello = CSScript.CreateAction(@"void SayHello(string greeting)
+                                                       {
+                                                           Console.WriteLine(greeting);
+                                                       }");
+
+                sayHello("Hello World!");
+            }
+
+            public static void CreateFunc()
+            {
+                // Wraps method into a class definition, compiles it and loads the compiled assembly.
+                // It returns duck-typed delegate. A delegate with 'params object[]' arguments and 
+                // int as a return type. 
+
+                var Sqr = CSScript.CreateFunc<int>(@"int Sqr(int a)
+                                                     {
+                                                         return a * a;
+                                                     }");
+                int r = Sqr(3);
+            }
+
+            public static void LoadCode()
+            {
+                // LoadCode compiles code and returns instance of a first class 
+                // in the compiled assembly  
+
+                dynamic script = CSScript.LoadCode(@"using System;
+                                                     public class Script
+                                                     {
+                                                         public int Sum(int a, int b)
+                                                         {
+                                                             return a+b;
+                                                         }
+                                                     }")
+                                         .CreateObject("*");
+
+                int result = script.Sum(1, 2);
+            }
+
+            public static void LoadCodeWithConfig()
+            {
+                // LoadCode compiles code and returns instance of a first class 
+                // in the compiled assembly  
+
+                string file = Path.GetTempFileName();
+                try
+                {
+                    File.WriteAllText(file, @"using System;
+                                              public class Script
+                                              {
+                                                  public int Sum(int a, int b)
+                                                  {
+                                                      return a+b;
+                                                  }
+                                              }");
+
+                    var settings = new Settings();
+                    //settings = null; // set to null to foll back to defaults 
+
+                    dynamic script = CSScript.LoadWithConfig(file, null, false, settings, "/define:TEST")
+                                             .CreateObject("*");
+
+                    int result = script.Sum(1, 2);
+                }
+                finally
+                {
+                    if (File.Exists(file))
+                        File.Delete(file);
+                }
+            }
+
+            public static void LoadCode_WithInterface(HostApp host)
+            {
+                // 1 - LoadCode compiles code and returns instance of a first class in the compiled assembly. 
+                // 2 - The script class implements host app interface so the returned object can be type casted into it.
+                // 3 - In this sample host object is passed into script routine.
+
+                var calc = (ICalc) CSScript.LoadCode(@"using CSScriptNativeApi;
+                                                      public class Script : ICalc
+                                                      { 
+                                                          public int Sum(int a, int b)
+                                                          {
+                                                              if(Host != null) 
+                                                                  Host.Log(""Sum is invoked"");
+                                                              return a + b;
+                                                          }
+                                                      
+                                                          public HostApp Host { get; set; }
+                                                      }")
+                                          .CreateObject("*");
+                calc.Host = host;
+                int result = calc.Sum(1, 2);
+            }
+
+            public static void LoadCode_WithDuckTypedInterface(HostApp host)
+            {
+                // 1 - LoadCode compiles code and returns instance of a first class in the compiled assembly 
+                // 2- The script class doesn't implement host app interface but it can still be aligned to 
+                // one as long at it implements the  interface members
+                // 3 - In this sample host object is passed into script routine.
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                ICalc calc = CSScript.LoadCode(@"using CSScriptNativeApi;
+                                                 public class Script  
+                                                 { 
+                                                     public int Sum(int a, int b)
+                                                     {
+                                                         if(Host != null) 
+                                                             Host.Log(""Sum is invoked"");
+                                                         return a + b;
+                                                     }
+                                                 
+                                                     public HostApp Host { get; set; }
+                                                 }")
+                                     .CreateObject("*")
+                                     .AlignToInterface<ICalc>();
+                calc.Host = host;
+                int result = calc.Sum(1, 2);
+            }
+
+            public static void ExecuteAndUnload()
+            {
+                // The script will be loaded into a temporary AppDomain and unloaded after the execution.
+
+                // Note: remote execution is a subject of some restrictions associated with the nature of the 
+                // CLR cross-AppDomain interaction model: 
+                // * the script class must be serializable or derived from MarshalByRefObject.
+                //
+                // * any object (call arguments, return objects) that crosses ApPDomain boundaries
+                //   must be serializable or derived from MarshalByRefObject.
+                //
+                // * long living script class instances may get disposed in remote domain even if they are 
+                //   being referenced in the current AppDomain. You need to use the usual .NET techniques
+                //   to prevent that. See LifetimeManagement.cs sample for details.  
+
+                //This use-case uses Interface Alignment and this requires all assemblies involved to have 
+                //non-empty Assembly.Location 
+                CSScript.GlobalSettings.InMemoryAssembly = false;
+
+                var code = @"using System;
+                             public class Script : MarshalByRefObject
+                             {
+                                 public void Hello(string greeting)
+                                 {
+                                     Console.WriteLine(greeting);
+                                 }
+                             }";
+
+                //Note: usage of helper.CreateAndAlignToInterface<IScript>("Script") is also acceptable
+                using (var helper = new AsmHelper(CSScript.CompileCode(code), null, deleteOnExit: true))
+                {
+                    IScript script = helper.CreateAndAlignToInterface<IScript>("*");
+                    script.Hello("Hi there...");
+                }
+                //from this point AsmHelper is disposed and the temp AppDomain is unloaded
+            }
+
+            public static void DebugTest()
+            {
+                //pops up an assertion dialog 
+                dynamic script = CSScript.LoadCode(@"using System;
+                                                     using System.Diagnostics;
+                                                     public class Script
+                                                     {
+                                                         public int Sum(int a, int b)
+                                                         {
+                                                             Debug.Assert(false,""Testing CS-Script debugging..."");
+                                                             return a+b;
+                                                         }
+                                                     }", null, debugBuild: true).CreateObject("*");
+
+                int result = script.Sum(1, 2);
+            }
+        }
+
+        public void Log(string message)
+        {
+            Console.WriteLine(message);
+        }
+    }
+
+    public interface IScript
+    {
+        void Hello(string greeting);
+    }
+
+    public interface ICalc
+    {
+        HostApp Host { get; set; }
+
+        int Sum(int a, int b);
+    }
+
+    public class Samples
+    {
+        static public void CompilingHistory()
+        {
+            string script = Path.GetTempFileName();
+            string scriptAsm = script + ".dll";
+            CSScript.KeepCompilingHistory = true;
+
+            try
+            {
+                File.WriteAllText(script, @"using System;
+                                            using System.Windows.Forms;
+                                            public class Script
+                                            {
+                                                public int Sum(int a, int b)
+                                                {
+                                                    return a+b;
+                                                }
+                                            }");
+
+
+
+                CSScript.CompileFile(script, scriptAsm, false, null);
+
+                CompilingInfo info = CSScript.CompilingHistory
+                                             .Values
+                                             .FirstOrDefault(item => item.ScriptFile == script);
+                if (info != null)
+                {
+                    Console.WriteLine("Script: " + info.ScriptFile);
+
+                    Console.WriteLine("Referenced assemblies:");
+                    foreach (string asm in info.Input.ReferencedAssemblies)
+                        Console.WriteLine(asm);
+
+                    if (info.Result.Errors.HasErrors)
+                    {
+                        foreach (CompilerError err in info.Result.Errors)
+                            if (!err.IsWarning)
+                                Console.WriteLine("Error: " + err.ErrorText);
+                    }
+                }
+
+                CSScript.CompilingHistory.Clear();
+
+            }
+            finally
+            {
+                CSScript.KeepCompilingHistory = false;
+            }
+        }
+    }
+}

src/Artemis.Core/Services/CoreService.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using Artemis.Core.Exceptions;
 using Artemis.Core.Services.Interfaces;
+using Artemis.Plugins.Interfaces;
+using RGB.NET.Core;
 
 namespace Artemis.Core.Services
 {
@@ -14,6 +17,7 @@ namespace Artemis.Core.Services
         {
             _pluginService = pluginService;
             _rgbService = rgbService;
+            _rgbService.Surface.Updating += SurfaceOnUpdating;
 
             Task.Run(Initialize);
         }
@@ -34,10 +38,27 @@ namespace Artemis.Core.Services
             // Initialize the services
             await _pluginService.LoadPlugins();
             await _rgbService.LoadDevices();
-
+            
             OnInitialized();
         }
 
+        private void SurfaceOnUpdating(UpdatingEventArgs args)
+        {
+            try
+            {
+                // Update all active modules
+                foreach (var module in _pluginService.Plugins.OfType<IModule>())
+                    module.Update(args.DeltaTime);
+                // Render all active modules
+                foreach (var module in _pluginService.Plugins.OfType<IModule>())
+                    module.Render(args.DeltaTime);
+            }
+            catch (Exception e)
+            {
+                throw new ArtemisCoreException("Exception during update", e);
+            }
+        }
+
         #region Events
 
         public event EventHandler Initialized;

src/Artemis.Core/Services/Interfaces/IPluginService.cs

@@ -9,17 +9,32 @@ namespace Artemis.Core.Services.Interfaces
 {
     public interface IPluginService : IArtemisService, IDisposable
     {
+        /// <summary>
+        ///     Indicates wether or not plugins are currently being loaded
+        /// </summary>
         bool LoadingPlugins { get; }
+
+        /// <summary>
+        ///     All loaded plugins
+        /// </summary>
         ReadOnlyCollection<PluginInfo> Plugins { get; }
 
         /// <summary>
         ///     Loads all installed plugins. If plugins already loaded this will reload them all
         /// </summary>
-        /// <returns></returns>
         Task LoadPlugins();
 
+        /// <summary>
+        ///     Reloads the plugin accompanying the provided plugin info
+        /// </summary>
+        /// <param name="pluginInfo">The plugin info containing the plugin to reload</param>
         Task ReloadPlugin(PluginInfo pluginInfo);
-        Task<IPluginViewModel> GetPluginViewModel(PluginInfo pluginInfo);
+
+        /// <summary>
+        ///     Gets the view model of the module accompanying the provided plugin info
+        /// </summary>
+        /// <param name="pluginInfo">The plugin info containing the module for which to load the view model</param>
+        Task<IModuleViewModel> GetModuleViewModel(PluginInfo pluginInfo);
 
         /// <summary>
         ///     Occurs when a single plugin has loaded

src/Artemis.Core/Services/PluginService.cs

@@ -33,10 +33,6 @@ namespace Artemis.Core.Services
         public ReadOnlyCollection<PluginInfo> Plugins => _plugins.AsReadOnly();
 
         /// <inheritdoc />
-        /// <summary>
-        ///     Loads all installed plugins. If plugins already loaded this will reload them all
-        /// </summary>
-        /// <returns></returns>
         public async Task LoadPlugins()
         {
             if (LoadingPlugins)
@@ -56,18 +52,22 @@ namespace Artemis.Core.Services
 
         public async Task ReloadPlugin(PluginInfo pluginInfo)
         {
+            throw new NotImplementedException();
         }
 
-        public async Task<IPluginViewModel> GetPluginViewModel(PluginInfo pluginInfo)
+        public async Task<IModuleViewModel> GetModuleViewModel(PluginInfo pluginInfo)
         {
+            // Don't attempt to locave VMs for something other than a module
+            if (pluginInfo.Plugin is IModule)
+                throw new ArtemisPluginException(pluginInfo, "Cannot locate a view model for this plugin as it's not a module.");
             // Compile the ViewModel and get the type
             var compile = await Task.Run(() => CSScript.LoadFile(pluginInfo.Folder + pluginInfo.ViewModel));
-            var vmType = compile.ExportedTypes.FirstOrDefault(t => typeof(IPluginViewModel).IsAssignableFrom(t));
+            var vmType = compile.ExportedTypes.FirstOrDefault(t => typeof(IModuleViewModel).IsAssignableFrom(t));
             if (vmType == null)
-                throw new ArtemisPluginException(pluginInfo, "Cannot locate a view model for this plugin.");
+                throw new ArtemisPluginException(pluginInfo, "Cannot locate a view model for this module.");
            
             // Instantiate the ViewModel with Ninject
-            var vm = (IPluginViewModel) _kernel.Get(vmType);
+            var vm = (IModuleViewModel) _kernel.Get(vmType);
             vm.PluginInfo = pluginInfo;
             return vm;
         }
@@ -94,25 +94,10 @@ namespace Artemis.Core.Services
         }
 
         #region Events
-
+        
-        /// <summary>
-        ///     Occurs when a single plugin has loaded
-        /// </summary>
         public event EventHandler<PluginEventArgs> PluginLoaded;
-
-        /// <summary>
-        ///     Occurs when a single plugin has reloaded
-        /// </summary>
         public event EventHandler<PluginEventArgs> PluginReloaded;
-
-        /// <summary>
-        ///     Occurs when loading all plugins has started
-        /// </summary>
         public event EventHandler StartedLoadingPlugins;
-
-        /// <summary>
-        ///     Occurs when loading all plugins has finished
-        /// </summary>
         public event EventHandler FinishedLoadedPlugins;
 
         private void OnPluginLoaded(PluginEventArgs e)

src/Artemis.Core/packages.config

@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Castle.Core" version="4.2.1" targetFramework="net46" />
-  <package id="CS-Script" version="3.27.2.0" targetFramework="net46" />
+  <package id="CS-Script" version="3.28.0.1" targetFramework="net46" />
-  <package id="CS-Script.bin" version="3.27.2.0" targetFramework="net46" />
+  <package id="CS-Script.bin" version="3.28.0.1" targetFramework="net46" />
   <package id="HidSharp" version="1.5" targetFramework="net46" />
-  <package id="Microsoft.CodeAnalysis.Analyzers" version="1.1.0" targetFramework="net46" />
+  <package id="Microsoft.CodeAnalysis.Analyzers" version="2.6.0" targetFramework="net46" developmentDependency="true" />
   <package id="Microsoft.CodeAnalysis.Common" version="2.6.1" targetFramework="net46" />
   <package id="Microsoft.CodeAnalysis.CSharp" version="2.6.1" targetFramework="net46" />
   <package id="Microsoft.CodeAnalysis.CSharp.Scripting" version="2.6.1" targetFramework="net46" />
   <package id="Microsoft.CodeAnalysis.Scripting.Common" version="2.6.1" targetFramework="net46" />
-  <package id="Newtonsoft.Json" version="10.0.3" targetFramework="net46" />
+  <package id="Newtonsoft.Json" version="11.0.1" targetFramework="net46" />
   <package id="Ninject" version="3.3.4" targetFramework="net46" />
   <package id="Ninject.Extensions.Conventions" version="3.3.0" targetFramework="net46" />
   <package id="Ninject.Extensions.Factory" version="3.3.2" targetFramework="net46" />
@@ -28,7 +28,7 @@
   <package id="RGB.NET.Groups" version="0.0.1.26" targetFramework="net46" />
   <package id="RGB.NET.Input" version="0.0.1.26" targetFramework="net46" />
   <package id="RGB.NET.Presets" version="0.0.1.26" targetFramework="net46" />
-  <package id="Sanford.Multimedia.Midi" version="6.4.2" targetFramework="net46" />
+  <package id="Sanford.Multimedia.Midi" version="6.6.0" targetFramework="net46" />
   <package id="Stylet" version="1.1.21" targetFramework="net46" />
   <package id="System.AppContext" version="4.3.0" targetFramework="net46" />
   <package id="System.Collections" version="4.3.0" targetFramework="net46" />

src/Artemis.Plugins/Abstract/ModuleViewModel.cs

@@ -4,7 +4,7 @@ using Stylet;
 
 namespace Artemis.Plugins.Abstract
 {
-    public abstract class PluginViewModel : Screen, IPluginViewModel
+    public abstract class ModuleViewModel : Screen, IModuleViewModel
     {
         public PluginInfo PluginInfo { get; set; }
     }

src/Artemis.Plugins/Artemis.Plugins.csproj

@@ -30,8 +30,8 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+    <Reference Include="Newtonsoft.Json, Version=11.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.10.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.11.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="Ninject, Version=3.3.4.0, Culture=neutral, PublicKeyToken=c7192dc5380945e7, processorArchitecture=MSIL">
       <HintPath>..\packages\Ninject.3.3.4\lib\net45\Ninject.dll</HintPath>
@@ -49,13 +49,13 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Abstract\PluginViewModel.cs" />
+    <Compile Include="Abstract\ModuleViewModel.cs" />
     <Compile Include="Interfaces\IDataModelExpansion.cs" />
     <Compile Include="Interfaces\IDevice.cs" />
     <Compile Include="Interfaces\ILayerType.cs" />
     <Compile Include="Interfaces\IModule.cs" />
     <Compile Include="Interfaces\IPlugin.cs" />
-    <Compile Include="Interfaces\IPluginViewModel.cs" />
+    <Compile Include="Interfaces\IModuleViewModel.cs" />
     <Compile Include="Models\PluginInfo.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

src/Artemis.Plugins/Interfaces/IModule.cs

@@ -6,5 +6,16 @@
     /// </summary>
     public interface IModule : IPlugin
     {
+        /// <summary>
+        ///     Called each frame when the module must update
+        /// </summary>
+        /// <param name="deltaTime">Time since the last update</param>
+        void Update(double deltaTime);
+
+        /// <summary>
+        ///     Called each frame when the module must render
+        /// </summary>
+        /// <param name="deltaTime">Time since the last render</param>
+        void Render(double deltaTime);
     }
 }

src/Artemis.Plugins/Interfaces/IModuleViewModel.cs

@@ -5,9 +5,9 @@ namespace Artemis.Plugins.Interfaces
 {
     /// <inheritdoc />
     /// <summary>
-    ///     Allows you to create a view model for a plugin
+    ///     Allows you to create a view model for a module
     /// </summary>
-    public interface IPluginViewModel : IScreen
+    public interface IModuleViewModel : IScreen
     {
         PluginInfo PluginInfo { get; set; }
     }

src/Artemis.Plugins/Interfaces/IPlugin.cs

@@ -4,7 +4,8 @@
     ///     This is the base plugin type, use the other interfaces such as IModule to create plugins
     /// </summary>
     public interface IPlugin
-    {/// <summary>
+    {
+        /// <summary>
         ///     Called when the plugin is loaded
         /// </summary>
         void LoadPlugin();

src/Artemis.Plugins/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Newtonsoft.Json" version="10.0.3" targetFramework="net46" />
+  <package id="Newtonsoft.Json" version="11.0.1" targetFramework="net46" />
   <package id="Ninject" version="3.3.4" targetFramework="net46" />
   <package id="Stylet" version="1.1.21" targetFramework="net46" />
 </packages>

src/Artemis.UI/Artemis.UI.csproj

@@ -39,11 +39,14 @@
     <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
       <HintPath>..\packages\Castle.Core.4.2.1\lib\net45\Castle.Core.dll</HintPath>
     </Reference>
+    <Reference Include="ControlzEx, Version=3.0.2.4, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ControlzEx.3.0.2.4\lib\net45\ControlzEx.dll</HintPath>
+    </Reference>
     <Reference Include="HidSharp, Version=1.5.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\HidSharp.1.5\lib\net35\HidSharp.dll</HintPath>
     </Reference>
-    <Reference Include="MahApps.Metro, Version=1.5.0.23, Culture=neutral, PublicKeyToken=f4fb5a3c4d1e5b4f, processorArchitecture=MSIL">
+    <Reference Include="MahApps.Metro, Version=1.6.0.362, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\MahApps.Metro.1.5.0\lib\net45\MahApps.Metro.dll</HintPath>
+      <HintPath>..\packages\MahApps.Metro.1.6.0\lib\net45\MahApps.Metro.dll</HintPath>
     </Reference>
     <Reference Include="MaterialDesignColors, Version=1.1.3.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\MaterialDesignColors.1.1.3\lib\net45\MaterialDesignColors.dll</HintPath>
@@ -63,8 +66,8 @@
     <Reference Include="Ninject.Extensions.Factory, Version=3.3.2.0, Culture=neutral, PublicKeyToken=c7192dc5380945e7, processorArchitecture=MSIL">
       <HintPath>..\packages\Ninject.Extensions.Factory.3.3.2\lib\net45\Ninject.Extensions.Factory.dll</HintPath>
     </Reference>
-    <Reference Include="PropertyChanged, Version=2.2.4.0, Culture=neutral, PublicKeyToken=ee3ee20bcf148ddd, processorArchitecture=MSIL">
+    <Reference Include="PropertyChanged, Version=2.2.6.0, Culture=neutral, PublicKeyToken=ee3ee20bcf148ddd, processorArchitecture=MSIL">
-      <HintPath>..\packages\PropertyChanged.Fody.2.2.4.0\lib\net452\PropertyChanged.dll</HintPath>
+      <HintPath>..\packages\PropertyChanged.Fody.2.2.6\lib\net452\PropertyChanged.dll</HintPath>
     </Reference>
     <Reference Include="RGB.NET.Brushes, Version=0.0.1.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\RGB.NET.Brushes.0.0.1.26\lib\net45\RGB.NET.Brushes.dll</HintPath>
@@ -99,8 +102,8 @@
     <Reference Include="RGB.NET.Groups, Version=0.0.1.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\RGB.NET.Groups.0.0.1.26\lib\net45\RGB.NET.Groups.dll</HintPath>
     </Reference>
-    <Reference Include="Sanford.Multimedia.Midi, Version=6.4.1.0, Culture=neutral, processorArchitecture=MSIL">
+    <Reference Include="Sanford.Multimedia.Midi, Version=6.6.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Sanford.Multimedia.Midi.6.4.1\lib\net20\Sanford.Multimedia.Midi.dll</HintPath>
+      <HintPath>..\packages\Sanford.Multimedia.Midi.6.6.0\lib\net20\Sanford.Multimedia.Midi.dll</HintPath>
     </Reference>
     <Reference Include="Stylet, Version=1.1.21.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\Stylet.1.1.21\lib\net45\Stylet.dll</HintPath>
@@ -113,7 +116,7 @@
       <HintPath>..\packages\System.ValueTuple.4.4.0\lib\net461\System.ValueTuple.dll</HintPath>
     </Reference>
     <Reference Include="System.Windows.Interactivity, Version=4.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <HintPath>..\packages\MahApps.Metro.1.5.0\lib\net45\System.Windows.Interactivity.dll</HintPath>
+      <HintPath>..\packages\ControlzEx.3.0.2.4\lib\net45\System.Windows.Interactivity.dll</HintPath>
     </Reference>
     <Reference Include="System.Xml" />
     <Reference Include="Microsoft.CSharp" />
@@ -235,18 +238,17 @@
     <Resource Include="FodyWeavers.xml" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\packages\Fody.2.3.17\build\net452\Fody.targets" Condition="Exists('..\packages\Fody.2.3.17\build\net452\Fody.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\packages\Fody.2.3.17\build\net452\Fody.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Fody.2.3.17\build\net452\Fody.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.Asus.0.0.1.26\build\net45\RGB.NET.Devices.Asus.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.Asus.0.0.1.26\build\net45\RGB.NET.Devices.Asus.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.CoolerMaster.0.0.1.26\build\net45\RGB.NET.Devices.CoolerMaster.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.CoolerMaster.0.0.1.26\build\net45\RGB.NET.Devices.CoolerMaster.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.Corsair.0.0.1.26\build\net45\RGB.NET.Devices.Corsair.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.Corsair.0.0.1.26\build\net45\RGB.NET.Devices.Corsair.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.Logitech.0.0.1.26\build\net45\RGB.NET.Devices.Logitech.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.Logitech.0.0.1.26\build\net45\RGB.NET.Devices.Logitech.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.Msi.0.0.1.26\build\net45\RGB.NET.Devices.Msi.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.Msi.0.0.1.26\build\net45\RGB.NET.Devices.Msi.targets'))" />
     <Error Condition="!Exists('..\packages\RGB.NET.Devices.Razer.0.0.1.26\build\net45\RGB.NET.Devices.Razer.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\RGB.NET.Devices.Razer.0.0.1.26\build\net45\RGB.NET.Devices.Razer.targets'))" />
+    <Error Condition="!Exists('..\packages\Fody.2.4.2\build\Fody.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Fody.2.4.2\build\Fody.targets'))" />
   </Target>
   <Import Project="..\packages\RGB.NET.Devices.Asus.0.0.1.26\build\net45\RGB.NET.Devices.Asus.targets" Condition="Exists('..\packages\RGB.NET.Devices.Asus.0.0.1.26\build\net45\RGB.NET.Devices.Asus.targets')" />
   <Import Project="..\packages\RGB.NET.Devices.CoolerMaster.0.0.1.26\build\net45\RGB.NET.Devices.CoolerMaster.targets" Condition="Exists('..\packages\RGB.NET.Devices.CoolerMaster.0.0.1.26\build\net45\RGB.NET.Devices.CoolerMaster.targets')" />
@@ -254,4 +256,5 @@
   <Import Project="..\packages\RGB.NET.Devices.Logitech.0.0.1.26\build\net45\RGB.NET.Devices.Logitech.targets" Condition="Exists('..\packages\RGB.NET.Devices.Logitech.0.0.1.26\build\net45\RGB.NET.Devices.Logitech.targets')" />
   <Import Project="..\packages\RGB.NET.Devices.Msi.0.0.1.26\build\net45\RGB.NET.Devices.Msi.targets" Condition="Exists('..\packages\RGB.NET.Devices.Msi.0.0.1.26\build\net45\RGB.NET.Devices.Msi.targets')" />
   <Import Project="..\packages\RGB.NET.Devices.Razer.0.0.1.26\build\net45\RGB.NET.Devices.Razer.targets" Condition="Exists('..\packages\RGB.NET.Devices.Razer.0.0.1.26\build\net45\RGB.NET.Devices.Razer.targets')" />
+  <Import Project="..\packages\Fody.2.4.2\build\Fody.targets" Condition="Exists('..\packages\Fody.2.4.2\build\Fody.targets')" />
 </Project>

src/Artemis.UI/Stylet/ArtemisViewManager.cs

@@ -14,7 +14,7 @@ namespace Artemis.UI.Stylet
 
         public override UIElement CreateViewForModel(object model)
         {
-            if (model is IPluginViewModel)
+            if (model is IModuleViewModel)
                 return CreateViewForPlugin(model);
 
             return base.CreateViewForModel(model);
@@ -22,7 +22,7 @@ namespace Artemis.UI.Stylet
 
         private UIElement CreateViewForPlugin(object model)
         {
-            var pluginInfo = ((IPluginViewModel) model).PluginInfo;
+            var pluginInfo = ((IModuleViewModel) model).PluginInfo;
             var viewPath = pluginInfo.Folder + pluginInfo.ViewModel.Replace("ViewModel", "View").Replace(".cs", ".xaml");
             // There doesn't have to be a view so make sure one exists
             if (!File.Exists(viewPath))

src/Artemis.UI/ViewModels/RootViewModel.cs

@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Controls;
 using Artemis.Core.Services.Interfaces;
 using Artemis.Plugins.Interfaces;
 using Artemis.Plugins.Models;
-using Artemis.UI.Services.Interfaces;
 using Artemis.UI.ViewModels.Interfaces;
 using Stylet;
 
@@ -19,7 +21,7 @@ namespace Artemis.UI.ViewModels
         {
             _artemisViewModels = artemisViewModels;
             _pluginService = pluginService;
-            
+
             // Add the built-in items
             Items.AddRange(artemisViewModels);
             // Activate the home item
@@ -33,52 +35,78 @@ namespace Artemis.UI.ViewModels
 
             if (!LoadingPlugins)
                 Modules.AddRange(_pluginService.Plugins.Where(p => p.Plugin is IModule));
+
+            PropertyChanged += OnSelectedModuleChanged;
+            PropertyChanged += OnSelectedPageChanged;
         }
 
+
         public IObservableCollection<PluginInfo> Modules { get; set; }
 
         public bool MenuOpen { get; set; }
         public bool LoadingPlugins { get; set; }
+        public ListBoxItem SelectedPage { get; set; }
+        public PluginInfo SelectedModule { get; set; }
 
         private void PluginServiceOnStartedLoadingPlugins(object sender, EventArgs eventArgs)
         {
             LoadingPlugins = true;
+
             Modules.Clear();
+            SelectedModule = null;
         }
 
         private void PluginServiceOnFinishedLoadedPlugins(object sender, EventArgs eventArgs)
         {
-            LoadingPlugins = false;
             Modules.AddRange(_pluginService.Plugins.Where(p => p.Plugin is IModule));
-            NavigateToModule(Modules.First());
+            SelectedModule = null;
+
+            LoadingPlugins = false;
         }
 
-        public void NavigateToHome()
+        public async Task NavigateToSelectedModule()
         {
-            ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(HomeViewModel)));
+            if (SelectedModule == null || LoadingPlugins)
-            MenuOpen = false;
+                return;
-        }
 
-        public void NavigateToNews()
-        {
-        }
-
-        public void NavigateToWorkshop()
-        {
-        }
-
-        public void NavigateToSettings()
-        {
-            ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(SettingsViewModel)));
-            MenuOpen = false;
-        }
-
-        public async void NavigateToModule(PluginInfo pluginInfo)
-        {
             // Create a view model for the given plugin info (which will be a module)
-            var viewModel = await _pluginService.GetPluginViewModel(pluginInfo);
+            var viewModel = await _pluginService.GetModuleViewModel(SelectedModule);
             // Tell Stylet to active the view model, the view manager will compile and show the XAML
             ActivateItem(viewModel);
+
+            SelectedPage = null;
+            MenuOpen = false;
+        }
+
+        private async void OnSelectedModuleChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == "SelectedModule")
+                await NavigateToSelectedModule();
+        }
+
+        private void OnSelectedPageChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName != "SelectedPage" || SelectedPage == null)
+                return;
+
+            switch (SelectedPage.Name)
+            {
+                case "Home":
+                    ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(HomeViewModel)));
+                    break;
+                case "News":
+                    // ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(NewsViewModel)));
+                    break;
+                case "Workshop":
+                    // ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(WorkshopViewModel)));
+                    break;
+                case "Settings":
+                    ActivateItem(_artemisViewModels.First(v => v.GetType() == typeof(SettingsViewModel)));
+                    break;
+            }
+
+            SelectedModule = null;
+            MenuOpen = false;
         }
     }
 }

src/Artemis.UI/ViewModels/SettingsViewModel.cs

@@ -1,37 +1,10 @@
-using System.Linq;
+using Artemis.UI.ViewModels.Interfaces;
-using Artemis.Core.Services.Interfaces;
-using Artemis.UI.ViewModels.Interfaces;
-using RGB.NET.Core;
 using Stylet;
 
 namespace Artemis.UI.ViewModels
 {
     public class SettingsViewModel : Screen, ISettingsViewModel
     {
-        private readonly IRgbService _rgbService;
-
-        public SettingsViewModel(IRgbService rgbService)
-        {
-            _rgbService = rgbService;
-            _rgbService.FinishedLoadedDevices += (sender, args) => SetTestDevice();
-        }
-
-        protected override void OnActivate()
-        {
-            SetTestDevice();
-            base.OnActivate();
-        }
-
-        private void SetTestDevice()
-        {
-            if (!IsActive)
-                return;
-
-            if (!_rgbService.LoadingDevices)
-                TestDevice = _rgbService.Surface.Devices.FirstOrDefault(d => d.DeviceInfo.DeviceType == RGBDeviceType.Keyboard);
-        }
-
-        public IRGBDevice TestDevice { get; set; }
         public string Title => "Settings";
     }
 }

src/Artemis.UI/Views/RootView.xaml

@@ -7,6 +7,7 @@
                    xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
                    xmlns:s="https://github.com/canton7/Stylet"
                    xmlns:vms="clr-namespace:Artemis.UI.ViewModels"
+                   xmlns:models="clr-namespace:Artemis.Plugins.Models;assembly=Artemis.Plugins"
                    mc:Ignorable="d"
                    GlowBrush="{DynamicResource AccentColorBrush}"
                    FontFamily="{StaticResource DefaultFont}"
@@ -80,29 +81,30 @@
                     <!-- Built-in pages -->
                     <ListBox Margin="0 16 0 16"
                              SelectedIndex="0"
-                             DockPanel.Dock="Top">
+                             DockPanel.Dock="Top"
-                        <ListBoxItem PreviewMouseLeftButtonUp="{s:Action NavigateToHome}">
+                             SelectedItem="{Binding SelectedPage}">
+                        <ListBoxItem x:Name="Home">
                             <StackPanel Orientation="Horizontal">
                                 <materialDesign:PackIcon Kind="Home"
                                                          Margin="0,0,8,0" />
                                 <TextBlock>Home</TextBlock>
                             </StackPanel>
                         </ListBoxItem>
-                        <ListBoxItem PreviewMouseLeftButtonUp="{s:Action NavigateToNews}">
+                        <ListBoxItem x:Name="News">
                             <StackPanel Orientation="Horizontal">
                                 <materialDesign:PackIcon Kind="Newspaper"
                                                          Margin="0,0,8,0" />
                                 <TextBlock>News</TextBlock>
                             </StackPanel>
                         </ListBoxItem>
-                        <ListBoxItem PreviewMouseLeftButtonUp="{s:Action NavigateToWorkshop}">
+                        <ListBoxItem x:Name="Workshop">
                             <StackPanel Orientation="Horizontal">
                                 <materialDesign:PackIcon Kind="TestTube"
                                                          Margin="0,0,8,0" />
                                 <TextBlock>Workshop</TextBlock>
                             </StackPanel>
                         </ListBoxItem>
-                        <ListBoxItem PreviewMouseLeftButtonUp="{s:Action NavigateToSettings}">
+                        <ListBoxItem x:Name="Settings">
                             <StackPanel Orientation="Horizontal">
                                 <materialDesign:PackIcon Kind="Settings"
                                                          Margin="0,0,8,0" />
@@ -118,39 +120,23 @@
                     </TextBlock>
                     <Border BorderThickness="0 1 0 0"
                             BorderBrush="{DynamicResource MaterialDesignDivider}">
-                        <ScrollViewer DockPanel.Dock="Top">
+                        <ListBox Margin="0 0 0 16"
-                            <ListBox Margin="0 0 0 16"
+                                 SelectedIndex="0"
-                                     SelectedIndex="0">
+                                 ItemsSource="{Binding Modules}"
-                                <ListBoxItem>
+                                 SelectedItem="{Binding SelectedModule}"
-                                    <StackPanel Orientation="Horizontal">
+                                 DockPanel.Dock="Top">
+                            <ListBox.ItemTemplate>
+                                <DataTemplate DataType="models:PluginInfo">
+                                    <DockPanel HorizontalAlignment="Stretch"
+                                               VerticalAlignment="Stretch"
+                                               Margin="0">
                                         <materialDesign:PackIcon Kind="Home"
                                                                  Margin="0,0,8,0" />
-                                        <TextBlock>Home</TextBlock>
+                                        <TextBlock Text="{Binding Name}" />
-                                    </StackPanel>
+                                    </DockPanel>
-                                </ListBoxItem>
+                                </DataTemplate>
-                                <ListBoxItem>
+                            </ListBox.ItemTemplate>
-                                    <StackPanel Orientation="Horizontal">
+                        </ListBox>
-                                        <materialDesign:PackIcon Kind="Newspaper"
-                                                                 Margin="0,0,8,0" />
-                                        <TextBlock>News</TextBlock>
-                                    </StackPanel>
-                                </ListBoxItem>
-                                <ListBoxItem>
-                                    <StackPanel Orientation="Horizontal">
-                                        <materialDesign:PackIcon Kind="TestTube"
-                                                                 Margin="0,0,8,0" />
-                                        <TextBlock>Workshop</TextBlock>
-                                    </StackPanel>
-                                </ListBoxItem>
-                                <ListBoxItem>
-                                    <StackPanel Orientation="Horizontal">
-                                        <materialDesign:PackIcon Kind="Settings"
-                                                                 Margin="0,0,8,0" />
-                                        <TextBlock>Settings</TextBlock>
-                                    </StackPanel>
-                                </ListBoxItem>
-                            </ListBox>
-                        </ScrollViewer>
                     </Border>
                 </DockPanel>
             </materialDesign:DrawerHost.LeftDrawerContent>
@@ -185,4 +171,4 @@
             </DockPanel>
         </materialDesign:DrawerHost>
     </materialDesign:DialogHost>
-</metro:MetroWindow>
+</metro:MetroWindow> 

src/Artemis.UI/Views/SettingsView.xaml

@@ -3,11 +3,24 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:local="clr-namespace:Artemis.UI.Views"
-             xmlns:visualizers="clr-namespace:Artemis.UI.Controls.Visualizers"
              mc:Ignorable="d"
-             d:DesignHeight="300" d:DesignWidth="300">
+             d:DesignHeight="600" d:DesignWidth="600">
-    <Grid>
+    <UserControl.Resources>
-        <visualizers:RGBSurfaceVisualizer></visualizers:RGBSurfaceVisualizer>
+        <ResourceDictionary>
-    </Grid>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.TextBlock.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </UserControl.Resources>
+    <StackPanel Margin="16">
+        <TextBlock Style="{StaticResource MaterialDesignDisplay1TextBlock}">General</TextBlock>
+        <Grid>
+            <TextBlock>General settings like start up with Windows etc.</TextBlock>
+        </Grid>
+
+        <TextBlock Style="{StaticResource MaterialDesignDisplay1TextBlock}">Plugins</TextBlock>
+        <Grid>
+            <TextBlock>A list of plugins and options to disable them</TextBlock>
+        </Grid>
+    </StackPanel>
 </UserControl>

src/Artemis.UI/packages.config

@@ -1,16 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Castle.Core" version="4.2.1" targetFramework="net461" />
-  <package id="Fody" version="2.3.17" targetFramework="net461" developmentDependency="true" />
+  <package id="ControlzEx" version="3.0.2.4" targetFramework="net461" />
+  <package id="Fody" version="2.4.2" targetFramework="net461" developmentDependency="true" />
   <package id="HidSharp" version="1.5" targetFramework="net461" />
-  <package id="MahApps.Metro" version="1.5.0" targetFramework="net461" />
+  <package id="MahApps.Metro" version="1.6.0" targetFramework="net461" />
   <package id="MaterialDesignColors" version="1.1.3" targetFramework="net461" />
   <package id="MaterialDesignThemes" version="2.3.1.953" targetFramework="net461" />
   <package id="MaterialDesignThemes.MahApps" version="0.0.11" targetFramework="net461" />
   <package id="Ninject" version="3.3.4" targetFramework="net461" />
   <package id="Ninject.Extensions.Conventions" version="3.3.0" targetFramework="net461" />
   <package id="Ninject.Extensions.Factory" version="3.3.2" targetFramework="net461" />
-  <package id="PropertyChanged.Fody" version="2.2.4.0" targetFramework="net461" developmentDependency="true" />
+  <package id="PropertyChanged.Fody" version="2.2.6" targetFramework="net461" developmentDependency="true" />
   <package id="RGB.NET" version="0.0.1.26" targetFramework="net461" />
   <package id="RGB.NET.Brushes" version="0.0.1.26" targetFramework="net461" />
   <package id="RGB.NET.Core" version="0.0.1.26" targetFramework="net461" />
@@ -25,7 +26,7 @@
   <package id="RGB.NET.Devices.Razer" version="0.0.1.26" targetFramework="net461" />
   <package id="RGB.NET.Groups" version="0.0.1.26" targetFramework="net461" />
   <package id="RGB.NET.Presets" version="0.0.1.26" targetFramework="net461" />
-  <package id="Sanford.Multimedia.Midi" version="6.4.1" targetFramework="net461" />
+  <package id="Sanford.Multimedia.Midi" version="6.6.0" targetFramework="net461" />
   <package id="Stylet" version="1.1.21" targetFramework="net461" />
   <package id="System.ValueTuple" version="4.4.0" targetFramework="net461" />
 </packages>