diff --git a/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs b/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs
new file mode 100644
index 0000000000..bb7da0ffe2
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/CommandsBinders.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+using Autodesk.Revit.UI.Events;
+
+namespace Dynamo.Applications
+{
+    /// <summary>
+    /// Bind/Unbind Ribbons Icon actions
+    /// </summary>
+    internal class CommandsBinders
+    {
+        #region Statics
+        /// <summary>
+        /// Dynamo Command ID
+        /// </summary>
+        public static readonly string DYNAMOID = "ID_VISUAL_PROGRAMMING_DYNAMO";
+
+        /// <summary>
+        /// Dynamo Player Command ID
+        /// </summary>
+        public static readonly string PLAYERID = "ID_PLAYLIST_DYNAMO";
+        #endregion
+
+        public event EventHandler<ExecutedEventArgs> OnDynamoClick;
+        public event EventHandler<ExecutedEventArgs> OnDynamoPlayerClick;
+
+        private UIControlledApplication uiControlledApplication;
+        private RevitCommandId DynamoCmdId;
+        private AddInCommandBinding DynamoCommand = null;
+        private RevitCommandId DynamoPlayerCmdId;
+        private AddInCommandBinding DynamoPlayerCommand = null;
+
+        private bool BindDynamoPlayer;
+
+        /// <summary>
+        /// Is Binding has been done
+        /// </summary>
+        public bool IsBinded { get; private set; }
+
+        /// <summary>
+        /// Constructor, Class to Bind/Unbind Ribbons Icon actions
+        /// </summary>
+        /// <param name="application"></param>
+        /// <param name="bindDynamoPlayer"></param>
+        public CommandsBinders(UIControlledApplication application, bool bindDynamoPlayer)
+        {
+            uiControlledApplication = application;
+            BindDynamoPlayer = bindDynamoPlayer;
+            DynamoCmdId = RevitCommandId.LookupCommandId(DYNAMOID);
+            DynamoPlayerCmdId = RevitCommandId.LookupCommandId(PLAYERID);
+            if (uiControlledApplication == null || DynamoCmdId == null || DynamoPlayerCmdId == null)
+                throw new ArgumentNullException();
+            IsBinded = false;
+        }
+
+        /// <summary>
+        /// Bind Ribbons Icon actions
+        /// </summary>
+        public void Bind()
+        {
+            if (IsBinded) return;
+            if (null == DynamoCommand)
+            {
+                DynamoCommand = uiControlledApplication.CreateAddInCommandBinding(DynamoCmdId);
+                DynamoCommand.CanExecute += canExecute;
+                DynamoCommand.BeforeExecuted += beforeExecuted;
+                DynamoCommand.Executed += executedDynamo;
+            }
+            if (null == DynamoPlayerCommand && BindDynamoPlayer)
+            {
+                DynamoPlayerCommand = uiControlledApplication.CreateAddInCommandBinding(DynamoPlayerCmdId);
+                DynamoPlayerCommand.CanExecute += canExecute;
+                DynamoPlayerCommand.BeforeExecuted += beforeExecuted;
+                DynamoPlayerCommand.Executed += executedPlayer;
+            }
+            IsBinded = true;
+        }
+
+        /// <summary>
+        /// UnBind Ribbons Icon actions
+        /// </summary>
+        public void UnBind()
+        {
+            if (!IsBinded) return;
+            if (null != DynamoCommand)
+            {
+                uiControlledApplication.RemoveAddInCommandBinding(DynamoCmdId);
+                DynamoCommand.BeforeExecuted -= beforeExecuted;
+                DynamoCommand.CanExecute -= canExecute;
+                DynamoCommand.Executed -= executedDynamo;
+                DynamoCommand = null;
+            }
+            if (null != DynamoPlayerCommand)
+            {
+                uiControlledApplication.RemoveAddInCommandBinding(DynamoPlayerCmdId);
+                DynamoPlayerCommand.BeforeExecuted -= beforeExecuted;
+                DynamoPlayerCommand.CanExecute -= canExecute;
+                DynamoPlayerCommand.Executed -= executedPlayer;
+                DynamoPlayerCommand = null;
+            }
+            IsBinded = false;
+        }
+
+        private void beforeExecuted(object sender, BeforeExecutedEventArgs e)
+        {
+            e.UsingCommandData = true;
+        }
+
+        private void canExecute(object sender, CanExecuteEventArgs e)
+        {
+            e.CanExecute = e.ActiveDocument != null;
+        }
+
+        private void executedDynamo(object sender, ExecutedEventArgs e)
+        {
+            OnDynamoClick(sender, e);
+        }
+
+        private void executedPlayer(object sender, ExecutedEventArgs e)
+        {
+            OnDynamoPlayerClick(sender, e);
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
index 6a4bb2446f..ea6f1f366d 100644
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
+++ b/src/Legacy/DynamoRevitVersionSelector/DynamoRevitVersionSelector.csproj
@@ -35,14 +35,18 @@
   <ItemGroup>
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
-    <Reference Include="RevitAPI">
-      <HintPath>$(REVITAPI)\RevitAPI.dll</HintPath>
+    <Reference Include="AdWindows">
+      <HintPath>$(REVITAPI)\AdWindows.dll</HintPath>
       <Private>False</Private>
     </Reference>
     <Reference Include="RevitAPIUI">
       <HintPath>$(REVITAPI)\RevitAPIUI.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="RevitAPI">
+      <HintPath>$(REVITAPI)\RevitAPI.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
@@ -54,6 +58,9 @@
     <Compile Include="$(SolutionDir)AssemblySharedInfoGenerator\AssemblySharedInfo.cs">
       <Link>Properties\AssemblySharedInfo.cs</Link>
     </Compile>
+    <Compile Include="CommandsBinders.cs" />
+    <Compile Include="Product.cs" />
+    <Compile Include="ProductsManager.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
@@ -64,21 +71,13 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.en-US.resx</DependentUpon>
     </Compile>
+    <Compile Include="Tools\ImageConversion.cs" />
+    <Compile Include="Tools\Presistence.cs" />
+    <Compile Include="Tools\UI.cs" />
+    <Compile Include="VersionDialog.cs" />
     <Compile Include="VersionSelectorApp.cs" />
-    <Compile Include="DynamoVersionSelector.xaml.cs">
-      <DependentUpon>DynamoVersionSelector.xaml</DependentUpon>
-    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Page Include="DynamoVersionSelector.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="logo_about.png" />
-    <None Include="Resources\dynamo_32x32.png" />
+    <Compile Include="VersionSelectorButton.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
@@ -90,6 +89,9 @@
       <LastGenOutput>Resources.en-US.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\dynamo_setting_32x32.png" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml b/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml
deleted file mode 100644
index 137a9f46ad..0000000000
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml
+++ /dev/null
@@ -1,15 +0,0 @@
-<Window x:Class="Dynamo.Applications.DynamoVersionSelector"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             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" 
-             mc:Ignorable="d" 
-             Height="240" Width="300">
-    <Grid>
-        <StackPanel Margin="5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Height="Auto">
-            <Image Source="/DynamoRevitVersionSelector;component/logo_about.png" Height="128" Width="128"></Image>
-            <TextBlock HorizontalAlignment="Center" Margin="5" Text="Choose a version of Dynamo."></TextBlock>
-            <ComboBox Name="VersionDropDown" Margin="5" ItemsSource="{Binding Versions}"></ComboBox>
-        </StackPanel>
-    </Grid>
-</Window>
diff --git a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs b/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs
deleted file mode 100644
index 40dbe0c4d9..0000000000
--- a/src/Legacy/DynamoRevitVersionSelector/DynamoVersionSelector.xaml.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-
-namespace Dynamo.Applications
-{
-    /// <summary>
-    /// Interaction logic for DynamoVersionSelector.xaml
-    /// </summary>
-    public partial class DynamoVersionSelector : Window
-    {
-        public DynamoVersionSelector()
-        {
-            InitializeComponent();
-        }
-    }
-}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Product.cs b/src/Legacy/DynamoRevitVersionSelector/Product.cs
new file mode 100644
index 0000000000..79dad6369f
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Product.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Dynamo.Applications
+{
+    /// <summary>
+    /// A Dyanmo product definition
+    /// </summary>
+    internal class Product
+    {
+        #region Statics
+        /// <summary>
+        /// A way to says "do not loat load Dyanmo during starup".
+        /// </summary>
+        /// <remarks>
+        /// Legacy use case - This should be the default case
+        /// This might be usefull when people need to change Dyanmo version on each Revit Session
+        /// </remarks>
+        public static readonly Version NODYNAMO = null;
+
+        /// <summary>
+        /// A way to says "please keep using the lastest installed version available".
+        /// </summary>
+        public static readonly Version LASTESTDYNAMO = new Version(0,0,0,0);
+
+        /// <summary>
+        /// Dynamo product's assembly should always define the same type name
+        /// </summary>
+        public static readonly String DYNAMO_TYPENAME = "Dynamo.Applications.DynamoRevitApp";
+        #endregion
+
+        #region Accessors
+        /// <summary>
+        /// Version
+        /// </summary>
+        public Version Version
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Asssembly Path (i.e. "DynamoRevitDS.dll" location), maybe null
+        /// </summary>
+        public string AsssemblyPath
+        {
+            get; private set;
+        }
+
+        /// <summary>
+        /// Flag to say that this product is currently used
+        /// </summary>
+        public bool isCurrent
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// How to describe this product in UI (Title)
+        /// </summary>
+        public string Title
+        {
+            get
+            {
+                if (Version == NODYNAMO)
+                    return Resources.DynamoVersionKeepClear;
+                var msg = isCurrent ? Resources.DynamoCurrentVersionText : Resources.DynamoVersionText;
+                return string.Format(msg, Version.ToString(4));
+            }
+        }
+
+        /// <summary>
+        /// How to describe this product (Sub Title)
+        /// </summary>
+        public string SubTitle
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// Generic String conversion
+        /// </summary>
+        public override string ToString()
+        {
+            return Title;
+        }
+
+        /// <summary>
+        /// Get product instance (if it has been created)
+        /// </summary>
+        /// <seealso cref="CreateInstance"/>
+        public Object Instance
+        {
+            get; private set;
+        }
+        #endregion
+
+        /// <summary>
+        /// Lazy constructor
+        /// </summary>
+        public Product(Version version)
+        {
+            Version = version;
+        }
+
+        /// <summary>
+        /// Constructor, for a full defined/existing dynamo product
+        /// </summary>
+        public Product(Version version, string assemblyPath, string installFolder)
+        {
+            Version = version;
+            AsssemblyPath = assemblyPath;
+            SubTitle = installFolder;
+        }
+
+        /// <summary>
+        /// Create a class instance from Assembly, exception needs to be properly handled
+        /// </summary>
+        /// <exception cref="System.ArgumentException">Thrown when Asssembly from AsssemblyPath can't be Loaded</exception>
+        /// <exception cref="System.MethodAccessException">Thrown when method can't be Access</exception>
+        public Object CreateInstance()
+        {
+            Assembly asm;
+            try
+            {
+                asm = Assembly.LoadFrom(AsssemblyPath);
+            }
+            catch (Exception)
+            {
+                throw new System.ArgumentException($"AsssemblyPath '{AsssemblyPath}', can't be loaded");
+            }
+            try
+            {
+                Instance = asm.CreateInstance(DYNAMO_TYPENAME);
+                return Instance;
+            }
+            catch (Exception)
+            {
+                throw new System.MethodAccessException($"AsssemblyPath '{AsssemblyPath}', can't be access to '{DYNAMO_TYPENAME}'");
+            }
+        }
+
+        /// <summary>
+        /// Execute OnStartup() by reflection
+        /// </summary>
+        /// <param name="application"></param>
+        /// <returns></returns>
+        public Result OnStartup(UIControlledApplication application)
+        {
+            var method = Instance.GetType().GetMethod("OnStartup");
+            return (Result)method.Invoke(Instance, new object[] { application });
+        }
+
+        /// <summary>
+        /// Execute ExecuteDynamoCommand() by reflection
+        /// </summary>
+        /// <param name="journalData"></param>
+        /// <param name="appUI"></param>
+        /// <returns></returns>
+        public Result ExecuteDynamoCommand(IDictionary<string, string> journalData, UIApplication appUI)
+        {
+            var method = Instance.GetType().GetMethod("ExecuteDynamoCommand");
+            return (Result)method.Invoke(Instance, new object[] { journalData, appUI });
+        }
+    }
+
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
new file mode 100644
index 0000000000..db02d7ecbc
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/ProductsManager.cs
@@ -0,0 +1,250 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using System.IO;
+using System.Reflection;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Dynamo.Applications
+{
+    internal class ProductsManager
+    {
+        /// <summary>
+        /// Check if a Product is currently loaded in Current Application Domain and returns its version.
+        /// </summary>
+        /// <returns>Dynamo product which is currently loaded, Product.NODYNAMO otherwise</returns>
+        public static Version LoadedProduct()
+        {
+            Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (Assembly asm in asms)
+            {
+                if (asm.GetType(Product.DYNAMO_TYPENAME) != null)
+                {
+                    return asm.GetName().Version;
+                }
+            }
+            return Product.NODYNAMO;
+        }
+
+        /// <summary>
+        /// Revit Version
+        /// </summary>
+        public string RevitVersion
+        {
+            get; private set;
+        }
+
+        #region Product List
+        /// <summary>
+        /// Accessor to the list of Dyanmo Product (the list is sorted).
+        /// </summary>
+        /// <seealso cref="Contains"/>
+        public List<Product> List
+        {
+            get {
+                var list = mProducts.Values.ToList();
+                return list.OrderByDescending(x => x.Version).ToList(); // -- list.first() = most recent version
+            }
+        }
+
+        /// <summary>
+        /// Accessor to return the most recent Dyanmo Product.
+        /// </summary>
+        /// <seealso cref="Contains"/>
+        public Product Latest
+        {
+            get
+            {
+                return this.List.First();
+            }
+        }
+
+        /// <summary>
+        /// Number of Dyanmo Products available
+        /// </summary>
+        /// <seealso cref="Contains"/>
+        public int Count
+        {
+            get { return mProducts.Count; }
+        }
+
+        /// <summary>
+        /// Return true if Product list contains a specific version (product should exist and be a real)
+        /// </summary>
+        public bool Contains(Version version)
+        {
+            if (version == Product.LASTESTDYNAMO) return false;
+            if (version == Product.NODYNAMO) return false;
+            return mProducts.ContainsKey(version);
+        }
+
+        /// <summary>
+        /// Return true if Product list contains at least one product with dynamo player in it
+        /// </summary>
+        public bool ContainsDynamoPlayer()
+        {
+            //Minimum version requirements needed by Playlist feature for Dynamo and Revit.
+            Version MinDynamoVersionForPlaylist = new Version(1, 2);
+            foreach (var p in mProducts.Values)
+            {
+                if (p.Version >= MinDynamoVersionForPlaylist)
+                    return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns one Product
+        /// </summary>
+        /// <param name="version"></param>
+        /// <returns></returns>
+        public Product Get(Version version)
+        {
+            return mProducts[version];
+        }
+        #endregion
+
+        protected UIControlledApplication uiControlledApplication;
+        protected Dictionary<Version, Product> mProducts;
+
+        public delegate void BeforeLoadEventHandler();
+        public event BeforeLoadEventHandler OnBeforeLoad;
+
+        /// <summary>
+        /// ProductsManager Contructor, Manage available Dyanmo Products (DLLs assemblies)
+        /// </summary>
+        public ProductsManager(UIControlledApplication application)
+        {
+            uiControlledApplication = application;
+            RevitVersion = application.ControlledApplication.VersionNumber;
+            var revitFolder = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
+            var debugPath = revitFolder.Parent.FullName;
+            var dynamoProducts = FindDynamoRevitInstallations(debugPath);
+            mProducts = new Dictionary<Version, Product>();
+            foreach (var p in dynamoProducts)
+            {
+                if (p.Version < new Version(0, 7))
+                    continue; //0.6.3 and older version not supported for Revit2015 onwards
+                if (!File.Exists(p.AsssemblyPath))
+                    continue; // .DLL do not exist
+                mProducts.Add(p.Version, p);
+            }
+        }
+
+        protected IEnumerable<Product> FindDynamoRevitInstallations(string debugPath)
+        {
+            // Installation enumeration is based on LocateDynamoInstallations() static method of 'DynamoInstallDetective.dll'
+            var assembly = Assembly.LoadFrom(Path.Combine(debugPath, "DynamoInstallDetective.dll"));
+            var type = assembly.GetType("DynamoInstallDetective.Utilities");
+            var LocateDynamoInstallations = type.GetMethod("LocateDynamoInstallations", BindingFlags.Public | BindingFlags.Static);
+            if (LocateDynamoInstallations == null)
+                throw new MissingMethodException("Method 'DynamoInstallDetective.Utilities.LocateDynamoInstallations' not found");
+
+            // Where search for "DynamoRevitDS.dll" products which follow this Pattern:
+            Func<string, string> fileLocator = p => Path.Combine(p, string.Format("Revit_{0}", RevitVersion), "DynamoRevitDS.dll");
+
+            // Invoke LocateDynamoInstallations
+            var methodParams = new object[] { debugPath, fileLocator };
+            var installs = LocateDynamoInstallations.Invoke(null, methodParams) as IEnumerable;
+            if (null == installs)
+                return null;
+
+            // Enumeration return
+            return
+                installs.Cast<KeyValuePair<string, Tuple<int, int, int, int>>>()
+                    .Select(
+                        p => new Product(new Version(p.Value.Item1, p.Value.Item2, p.Value.Item3, p.Value.Item4), fileLocator(p.Key), p.Key)
+                );
+        }
+
+        internal class LoadResult
+        {
+            /// <summary>
+            /// Version before Load() call
+            /// </summary>
+            public Version fromVersion;
+
+            /// <summary>
+            /// Version after Load() call
+            /// </summary>
+            public Version afterVersion;
+
+            public enum ResultType {
+                FAILED,
+                DONE,
+                PENDING
+            };
+
+            /// <summary>
+            /// Load Result
+            /// </summary>
+            public ResultType Result;
+
+            public bool IsSucceed {
+                get { return Result != ResultType.FAILED; }
+            }
+        }
+
+        /// <summary>
+        /// Load a specific product version
+        /// </summary>
+        /// <param name="version">Version expected</param>
+        /// <returns>Succeed if no error occurs</returns>
+        public LoadResult Load(Version version)
+        {
+            // Retreived product
+            Product product = null;
+            do
+            {
+                if (version == Product.NODYNAMO)
+                {
+                    product = new Product(Product.NODYNAMO);
+                    break;
+                }
+                if (version == Product.LASTESTDYNAMO)
+                {
+                    product = this.Latest;
+                    break;
+                }
+
+                product = mProducts[version];
+            } while (false);
+
+            LoadResult ret = new LoadResult();
+            ret.fromVersion = LoadedProduct();
+            ret.afterVersion = product.Version;
+
+            // Trivial - nothing to do
+            if (ret.fromVersion == ret.afterVersion)
+            {
+                ret.Result = LoadResult.ResultType.DONE;
+                return ret;
+            }
+
+            // Can we Load dll right now ?
+            if (ret.fromVersion != Product.NODYNAMO)
+            {
+                ret.Result = LoadResult.ResultType.PENDING;
+                return ret;
+            }
+
+            // Actual Load
+            try
+            {
+                OnBeforeLoad?.Invoke();
+                product.CreateInstance();
+                if (Result.Succeeded != product.OnStartup(uiControlledApplication))
+                    throw new Exception("OnStartup() Error");
+                ret.Result = LoadResult.ResultType.DONE;
+                return ret;
+            }
+            catch
+            {
+                ret.Result = LoadResult.ResultType.FAILED;
+                return ret;
+            }
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
index 7a09138cff..884cbfedf2 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.Designer.cs
@@ -63,13 +63,31 @@ internal Resources() {
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
-        internal static System.Drawing.Bitmap dynamo_32x32 {
+        internal static System.Drawing.Bitmap dynamo_setting_32x32 {
             get {
-                object obj = ResourceManager.GetObject("dynamo_32x32", resourceCulture);
+                object obj = ResourceManager.GetObject("dynamo_setting_32x32", resourceCulture);
                 return ((System.Drawing.Bitmap)(obj));
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Dynamo {0} (current).
+        /// </summary>
+        internal static string DynamoCurrentVersionText {
+            get {
+                return ResourceManager.GetString("DynamoCurrentVersionText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to None.
+        /// </summary>
+        internal static string DynamoVersionKeepClear {
+            get {
+                return ResourceManager.GetString("DynamoVersionKeepClear", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Dynamo Version.
         /// </summary>
@@ -98,39 +116,59 @@ internal static string DynamoVersionText {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit.
+        ///   Looks up a localized string similar to You need to restart Revit to apply this change.
         /// </summary>
-        internal static string DynamoVersionTooltip {
+        internal static string NeedToRestartRevit {
             get {
-                return ResourceManager.GetString("DynamoVersionTooltip", resourceCulture);
+                return ResourceManager.GetString("NeedToRestartRevit", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Dynamo version {0} will be loaded after Revit restart..
+        ///   Looks up a localized string similar to Dynamo [{0}] is selected..
         /// </summary>
-        internal static string RestartMessage {
+        internal static string ProductLoaded {
             get {
-                return ResourceManager.GetString("RestartMessage", resourceCulture);
+                return ResourceManager.GetString("ProductLoaded", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Multiple version of Dynamo installation found on this system.
-        ///Please select the Dynamo version you wish to run..
+        ///   Looks up a localized string similar to Dynamo [{0}] is selected.
+        ///
+        ///Please restart Revit to use it..
         /// </summary>
-        internal static string VersionSelectionContent {
+        internal static string ProductNeedToRestartRevit {
             get {
-                return ResourceManager.GetString("VersionSelectionContent", resourceCulture);
+                return ResourceManager.GetString("ProductNeedToRestartRevit", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Visual Programming.
+        ///   Looks up a localized string similar to Version Selection.
         /// </summary>
-        internal static string VisualProgramming {
+        internal static string VersionSelectionBtnText {
             get {
-                return ResourceManager.GetString("VisualProgramming", resourceCulture);
+                return ResourceManager.GetString("VersionSelectionBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Change active Dynamo version.
+        /// </summary>
+        internal static string VersionSelectionBtnToolTip {
+            get {
+                return ResourceManager.GetString("VersionSelectionBtnToolTip", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Multiple version of Dynamo installation found on this system.
+        ///Please select the Dynamo version you wish to run..
+        /// </summary>
+        internal static string VersionSelectionContent {
+            get {
+                return ResourceManager.GetString("VersionSelectionContent", resourceCulture);
             }
         }
     }
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
index 5e9192afb9..a8a4edd8fe 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.en-US.resx
@@ -123,19 +123,6 @@
   <data name="DynamoVersionText" xml:space="preserve">
     <value>Dynamo {0}</value>
   </data>
-  <data name="RestartMessage" xml:space="preserve">
-    <value>Dynamo version {0} will be loaded after Revit restart.</value>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="dynamo_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\dynamo_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="DynamoVersionTooltip" xml:space="preserve">
-    <value>Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit</value>
-  </data>
-  <data name="VisualProgramming" xml:space="preserve">
-    <value>Visual Programming</value>
-  </data>
   <data name="DynamoVersionSelection" xml:space="preserve">
     <value>Dynamo Version Selection</value>
   </data>
@@ -143,4 +130,32 @@
     <value>Multiple version of Dynamo installation found on this system.
 Please select the Dynamo version you wish to run.</value>
   </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="dynamo_setting_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dynamo_setting_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="ProductNeedToRestartRevit" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.
+
+Please restart Revit to use it.</value>
+    <comment>multiline text</comment>
+  </data>
+  <data name="VersionSelectionBtnText" xml:space="preserve">
+    <value>Version Selection</value>
+  </data>
+  <data name="VersionSelectionBtnToolTip" xml:space="preserve">
+    <value>Change active Dynamo version</value>
+  </data>
+  <data name="ProductLoaded" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.</value>
+  </data>
+  <data name="DynamoCurrentVersionText" xml:space="preserve">
+    <value>Dynamo {0} (current)</value>
+  </data>
+  <data name="DynamoVersionKeepClear" xml:space="preserve">
+    <value>None</value>
+  </data>
+  <data name="NeedToRestartRevit" xml:space="preserve">
+    <value>You need to restart Revit to apply this change</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
index 5e9192afb9..a8a4edd8fe 100644
--- a/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
+++ b/src/Legacy/DynamoRevitVersionSelector/Properties/Resources.resx
@@ -123,19 +123,6 @@
   <data name="DynamoVersionText" xml:space="preserve">
     <value>Dynamo {0}</value>
   </data>
-  <data name="RestartMessage" xml:space="preserve">
-    <value>Dynamo version {0} will be loaded after Revit restart.</value>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="dynamo_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\dynamo_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="DynamoVersionTooltip" xml:space="preserve">
-    <value>Launches Dynamo {0}, to launch a different version of Dynamo you may need to restart Revit</value>
-  </data>
-  <data name="VisualProgramming" xml:space="preserve">
-    <value>Visual Programming</value>
-  </data>
   <data name="DynamoVersionSelection" xml:space="preserve">
     <value>Dynamo Version Selection</value>
   </data>
@@ -143,4 +130,32 @@
     <value>Multiple version of Dynamo installation found on this system.
 Please select the Dynamo version you wish to run.</value>
   </data>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="dynamo_setting_32x32" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\dynamo_setting_32x32.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="ProductNeedToRestartRevit" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.
+
+Please restart Revit to use it.</value>
+    <comment>multiline text</comment>
+  </data>
+  <data name="VersionSelectionBtnText" xml:space="preserve">
+    <value>Version Selection</value>
+  </data>
+  <data name="VersionSelectionBtnToolTip" xml:space="preserve">
+    <value>Change active Dynamo version</value>
+  </data>
+  <data name="ProductLoaded" xml:space="preserve">
+    <value>Dynamo [{0}] is selected.</value>
+  </data>
+  <data name="DynamoCurrentVersionText" xml:space="preserve">
+    <value>Dynamo {0} (current)</value>
+  </data>
+  <data name="DynamoVersionKeepClear" xml:space="preserve">
+    <value>None</value>
+  </data>
+  <data name="NeedToRestartRevit" xml:space="preserve">
+    <value>You need to restart Revit to apply this change</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png b/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png
deleted file mode 100644
index 342516405a..0000000000
Binary files a/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_32x32.png and /dev/null differ
diff --git a/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png b/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png
new file mode 100644
index 0000000000..285e4bc4f9
Binary files /dev/null and b/src/Legacy/DynamoRevitVersionSelector/Resources/dynamo_setting_32x32.png differ
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs
new file mode 100644
index 0000000000..fe166fcc2d
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/ImageConversion.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class ImageConversion
+    {
+        /// <summary>
+        /// Converts a <see cref="System.Drawing.Image"/> into <see cref=" System.Windows.Media.ImageSource"/>.
+        /// </summary>
+        /// <param name="source">The source image.</param>
+        /// <returns>A BitmapSource</returns>
+        public static System.Windows.Media.ImageSource ToBitmapSource(this System.Drawing.Image source)
+        {
+            System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(source);
+
+            var bitSrc = bitmap.ToBitmapSource();
+
+            bitmap.Dispose();
+            bitmap = null;
+
+            return bitSrc;
+        }
+
+        /// <summary>
+        /// Converts a <see cref="System.Drawing.Bitmap"/> into <see cref="System.Windows.Media.ImageSource"/>.
+        /// </summary>
+        /// <remarks>Uses GDI to do the conversion. Hence the call to the marshalled DeleteObject.
+        /// </remarks>
+        /// <param name="source">The source bitmap.</param>
+        /// <returns>A BitmapSource</returns>
+        public static System.Windows.Media.ImageSource ToBitmapSource(this System.Drawing.Bitmap source)
+        {
+            System.Windows.Media.ImageSource bitSrc = null;
+
+            var hBitmap = source.GetHbitmap();
+
+            try
+            {
+                bitSrc = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
+                    hBitmap,
+                    IntPtr.Zero,
+                    System.Windows.Int32Rect.Empty,
+                    System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
+            }
+            catch (System.ComponentModel.Win32Exception)
+            {
+                bitSrc = null;
+            }
+            finally
+            {
+                NativeMethods.DeleteObject(hBitmap);
+            }
+
+            return bitSrc;
+        }
+
+        /// <summary>
+        /// FxCop requires all Marshalled functions to be in a class called NativeMethods.
+        /// </summary>
+        internal static class NativeMethods
+        {
+            [DllImport("gdi32.dll")]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static extern bool DeleteObject(IntPtr hObject);
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
new file mode 100644
index 0000000000..c1c2eac54f
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/Presistence.cs
@@ -0,0 +1,146 @@
+using System;
+using Microsoft.Win32;
+using System.Security.AccessControl;
+using System.Diagnostics;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class Presistence
+    {
+        /// <summary>
+        /// Dynamo Registry Key which may be null if couldn't be created or open
+        /// Typical: 'HKEY_CURRENT_USER\SOFTWARE\Dynamo'
+        /// </summary>
+        private static RegistryKey RegKey = null;
+        
+        /// <summary>
+        /// Dynamo Registry Key Security (i.e. access rights)
+        /// </summary>
+        private static RegistrySecurity RS = null;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        static Presistence()
+        {
+            const string KeyName = @"SOFTWARE\Dynamo";
+            string user = Environment.UserDomainName + "\\" + Environment.UserName;
+            RS = new RegistrySecurity();
+            RS.AddAccessRule(new RegistryAccessRule(user,
+                RegistryRights.FullControl,
+                InheritanceFlags.None,
+                PropagationFlags.None,
+                AccessControlType.Allow));
+            RegKey = OpenOrCreateSubKey(Registry.CurrentUser, KeyName, RS);
+            if (RegKey != null) RegKey.Close();
+            
+            // keep it open
+            RegKey = OpenOrCreateSubKey(Registry.CurrentUser, KeyName, RS);
+        }
+
+        private static readonly string VERSION = @"ActiveVersion";
+
+        public static Version ActiveVersion {
+            /// <summary>
+            /// Returns last dynamo version persisted
+            /// or null if no version was ever selected
+            /// </summary>
+            get
+            {
+                Object obj = null;
+                GetValue(RegKey, VERSION, ref obj);
+                if (obj == null) return null;
+                if (obj.GetType() == typeof(String))
+                {
+                    try {
+                        return new Version((string)obj);
+                    } catch (Exception e) {
+                        Debug.Write(e);
+                        return null;
+                    }
+                }
+                return null;
+            }
+
+            /// <summary>
+            /// Persist current Dynamo Version selected
+            /// </summary>
+            set
+            {
+                if (value == null)
+                {
+                    SetValue(RegKey, VERSION, null, RS);
+                }
+                else
+                {
+                    SetValue(RegKey, VERSION, value.ToString(4), RS);
+                }
+            }
+        }
+
+        #region SafeVersionOfRegistry
+        /// <summary>
+        /// Safetly Open or Create a SubKey
+        /// </summary>
+        private static RegistryKey OpenOrCreateSubKey(RegistryKey key, string keyName, RegistrySecurity rs) {
+            RegistryKey rk = null;
+            /* open if exist */
+            try {
+                rk = key.OpenSubKey(keyName, true);
+            } catch (Exception e) {
+                Debug.Write(e);
+            }
+            if (rk != null) return rk;
+
+            /* create one otherwise */
+            try
+            {
+                rk = key.CreateSubKey(keyName, RegistryKeyPermissionCheck.Default, rs);
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+            return rk;
+        }
+
+        /// <summary>
+        /// Safe version of SetValue
+        /// </summary>
+        private static void SetValue(RegistryKey key, String name, object value, RegistrySecurity rs)
+        {
+            try
+            {
+                if (value == null)
+                {
+                    key.DeleteValue(name);
+                }
+                else
+                {
+                    key.SetValue(name, value);
+                }
+                
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+        }
+
+        /// <summary>
+        /// Safe version of GetValue
+        /// </summary>
+        private static void GetValue(RegistryKey key, String name, ref object obj)
+        {
+            try
+            {
+                obj = key.GetValue(name);
+            }
+            catch (Exception e)
+            {
+                Debug.Write(e);
+            }
+        }
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
new file mode 100644
index 0000000000..344056f7f0
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/Tools/UI.cs
@@ -0,0 +1,197 @@
+using Autodesk.Revit.UI;
+using System;
+using System.Collections.Generic;
+using adWin = Autodesk.Windows;
+
+namespace Dynamo.Applications.Tools
+{
+    internal static class UI
+    {
+        static UI() {
+            adWin.ComponentManager.UIElementActivated += new EventHandler<adWin.UIElementActivatedEventArgs>(OnUIEvent);
+        }
+
+        // UI Event Handling
+        private delegate void EventHandler(object sender, adWin.UIElementActivatedEventArgs e);
+        private static Dictionary<string, EventHandler> listener = new Dictionary<string, EventHandler>();
+        private static readonly OperationRequestHandler opReq = new OperationRequestHandler();
+        private static void OnUIEvent(object sender, adWin.UIElementActivatedEventArgs e)
+        {
+            if (e == null) return;
+            if (e.Item == null) return;
+            if (e.Item.Id == null) return;
+            if (listener.ContainsKey(e.Item.Id))
+            {
+                opReq.Raise(() => {
+                    listener[e.Item.Id](sender, e);
+                });
+            }
+        }
+
+        ///
+        /// <summary>
+        ///     Get all the custom Panels on a designated Revit tab.
+        /// </summary>
+        /// 
+        /// <param name="tabName">
+        ///     The name of the tab on which the panels are located.
+        /// </param>
+        /// 
+        /// <remarks>
+        ///     With official UIControlledApplication.GetRibbonPanels(string tabName),
+        ///     Built-in panels would not be included. tabName would need be the name of one of the
+        ///     tabs added by Autodesk.Revit.UI.UIApplication.CreateRibbonTab(System.String).
+        ///     However thanks to Jeremy Tammik who brings a workaround in his blog post
+        ///     http://thebuildingcoder.typepad.com/blog/2013/02/adding-a-btn-to-existing-ribbon-panel.html
+        /// </remarks>  
+        public static adWin.RibbonPanelCollection GetRibbonPanels(string tabName)
+        {
+            adWin.RibbonControl ribbon = adWin.ComponentManager.Ribbon;
+            foreach (adWin.RibbonTab tab in ribbon.Tabs)
+            {
+                if (tab.Id == tabName)
+                {
+                    return tab.Panels;
+                }
+            }
+            return new adWin.RibbonPanelCollection(); // empty collection
+        }
+
+
+        ///
+        /// <summary>
+        ///     This class contains information necessary to construct a push btn in the Ribbon.
+        /// </summary>
+        public class PushButtonData
+        {
+            protected adWin.RibbonButton btn;
+
+            public adWin.RibbonButton Source
+            {
+                get { return btn; }
+            }
+
+            public String Text
+            {
+                get { return btn.Text; }
+                set { btn.Text = value; }
+            }
+
+            public String ToolTip
+            {
+                get { return (String)btn.ToolTip; }
+                set { btn.ToolTip = value; }
+            }
+
+            public System.Drawing.Bitmap Image
+            {
+                set
+                {
+                    btn.Image = ImageConversion.ToBitmapSource(value);
+                    btn.LargeImage = ImageConversion.ToBitmapSource(value);
+                    btn.ShowImage = true;
+                }
+            }
+
+            public Boolean IsEnabled
+            {
+                get { return btn.IsEnabled; }
+                set { btn.IsEnabled = value; }
+            }
+
+            public Boolean IsVisible
+            {
+                get { return btn.IsVisible; }
+                set { btn.IsVisible = value; }
+            }
+
+            public delegate void OnClickEventHandler();
+            public event OnClickEventHandler OnClickEvent;
+            private void OnUIEvent(object sender, adWin.UIElementActivatedEventArgs e)
+            {
+                OnClickEvent();
+            }
+
+            ///
+            /// <summary>
+            ///     Constructs a new instance of PushButtonData.
+            /// </summary>
+            /// 
+            /// <param name="id">
+            ///     Unique identifier (like "ID_MY_BUTTON")
+            /// </param>
+            /// <param name="name">
+            ///     The internal name of the new btn.
+            /// </param>
+            /// <param name="text">
+            ///     The user visible text seen on the new btn.
+            /// </param>
+            /// 
+            /// <exception cref="System.ArgumentNullException">Thrown when null is passed for one or more arguments</exception>
+            /// <exception cref="System.ArgumentException">Thrown when an empty string is passed for one or more arguments</exception>
+            public PushButtonData(string Id, string name = "", string text = "")
+            {
+                if (Id == null) throw new ArgumentNullException("Id", "Id shouldn't be null");
+                if (String.IsNullOrWhiteSpace(Id)) throw new ArgumentException("Id", "name shouldn't be empty");
+                if (String.IsNullOrWhiteSpace(name)) name = Id;
+                if (String.IsNullOrWhiteSpace(text)) text = name;
+                btn = new adWin.RibbonButton();
+                btn.IsEnabled = true;
+                btn.IsVisible = true;
+                btn.Name = name;
+                btn.Text = text;
+                btn.Id = Id;
+                btn.Size = adWin.RibbonItemSize.Large;
+                btn.Orientation = System.Windows.Controls.Orientation.Vertical;
+                btn.ShowImage = false;
+                btn.ShowText = true;
+                btn.GroupLocation = Autodesk.Private.Windows.RibbonItemGroupLocation.Last;
+                btn.IsCheckable = true;
+                listener.Add(btn.Id, this.OnUIEvent);
+            }
+        }
+
+        private class OperationRequestHandler : IExternalEventHandler
+        {
+            public delegate void Operation();
+            private Operation mOperation = null;
+            private readonly Object opLock = new Object();
+            ExternalEvent m_exEvent = null;
+
+            public OperationRequestHandler()
+            {
+                m_exEvent = ExternalEvent.Create(this);
+            }
+
+            public void Raise(Operation operation)
+            {
+                lock (opLock) mOperation = operation;
+                m_exEvent.Raise();
+            }
+
+
+            public String GetName()
+            {
+                return "UI OperationRequestHandler";
+            }
+
+            /// <summary>
+            ///   The top method of the event handler.
+            /// </summary>
+            /// <remarks>
+            ///   This is called by Revit after the corresponding
+            ///   external event was raised (by the modeless form)
+            ///   and Revit reached the time at which it could call
+            ///   the event's handler (i.e. this object)
+            /// </remarks>
+            /// 
+            public void Execute(UIApplication uiapp)
+            {
+                lock (opLock)
+                {
+                    mOperation();
+                }
+            }
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs b/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs
new file mode 100644
index 0000000000..20440a49cb
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionDialog.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+
+namespace Dynamo.Applications
+{
+    internal class VersionDialog
+    {
+        public delegate void SelectedEventHandler(Version version);
+        public event SelectedEventHandler OnSelection;
+
+        private List<Product> mProductList;
+
+        /// <summary>
+        /// Dialog to provide a Dyanmo Version Picker
+        /// </summary>
+        /// <param name="ProductList">List of product to show up</param>
+        public VersionDialog(List<Product> ProductList)
+        {
+            mProductList = ProductList;
+        }
+
+        /// <summary>
+        /// Add the option to select "No Dynamo"
+        /// </summary>
+        public void AddNoDynamoOption()
+        {
+            mProductList.Add(new Product(Product.NODYNAMO));
+        }
+
+        /// <summary>
+        /// Show modal dialog
+        /// </summary>
+        public void Show()
+        {
+            // Latest version available
+            Version latestVersion = mProductList.First().Version;
+
+            // Current Version loaded in appDomain
+            Version currentVersion = ProductsManager.LoadedProduct();
+             
+            // Selected Version
+            Version selectedVersion = Tools.Presistence.ActiveVersion;
+            if (selectedVersion == Product.LASTESTDYNAMO) selectedVersion = latestVersion;
+
+            // Creates a Revit task dialog to communicate information to the user.
+            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
+            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
+            mainDialog.MainContent = Resources.VersionSelectionContent;
+
+            // Add commmandLink options to task dialog
+            int id = (int)TaskDialogCommandLinkId.CommandLink1;
+            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
+            foreach (var item in mProductList)
+            {
+                item.isCurrent = (item.Version == currentVersion);
+                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, item.Title, item.SubTitle);
+                if (item.Version == selectedVersion) defaultResult = (TaskDialogResult)id;
+                id++;
+            }
+            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
+            mainDialog.DefaultButton = defaultResult;
+
+            TaskDialogResult tResult = mainDialog.Show();
+            if (tResult == TaskDialogResult.Close)
+                return;
+
+            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
+            try
+            {
+                var version = mProductList[index].Version;
+
+                // overwrite version by LASTESTDYNAMO, to keep tracking the latest version
+                if (version == latestVersion) version = Product.LASTESTDYNAMO;
+
+                // Propagate Version selection
+                OnSelection(version);
+            }
+            catch (Exception) { /* */ }
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
index 9436b804aa..3f6b41767d 100644
--- a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorApp.cs
@@ -1,409 +1,172 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Drawing;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Windows;
-using System.Windows.Interop;
-using System.Windows.Media.Imaging;
 using Autodesk.Revit.Attributes;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.UI;
+using Dynamo.Applications;
 using Autodesk.Revit.UI.Events;
+using System.Diagnostics;
 using DynamoRevitVersionSelector.Properties;
-using Microsoft.Win32;
 
 namespace Dynamo.Applications
 {
-    internal struct DynamoProduct
-    {
-        public string InstallLocation;
-        public Version VersionInfo;
-
-        public string VersionString
-        {
-            get
-            {
-                return string.Format(
-                    @"Dynamo {0}", VersionInfo.ToString(4));
-            }
-        }
-    }
-
     [Transaction(TransactionMode.Manual)]
     [Regeneration(RegenerationOption.Manual)]
     public class VersionLoader : IExternalApplication
     {
-        private static UIControlledApplication uiControlledApplication;
-        private AddInCommandBinding dynamoCommand;
-        private AddInCommandBinding dynamoPlayerCommand;
-        internal List<DynamoProduct> Products { get; private set; }
-        //PlaylistProducts represent a subset of available Dynamo Products who are supporting Playlist feature.        
-        private List<DynamoProduct> PlaylistProducts { get; set; }
-
-        //Minimum version requirements needed by Playlist feature for Dynamo and Revit.
-        private const int MinDynamoMajorVersionForPlaylist = 1;
-        private const int MinDynamoMinorVersionForPlaylist = 2;
-
-        internal static string GetDynamoRevitPath(DynamoProduct product, string revitVersion)
-        {
-            if (product.VersionInfo < new Version(0, 7))
-                return string.Empty; //0.6.3 and older version not supported for Revit2015 onwards
-
-            return Path.Combine(product.InstallLocation, string.Format("Revit_{0}", revitVersion), "DynamoRevitDS.dll");
-        }
+        ProductsManager DynamoProducts;
 
+        /// <summary>
+        /// VersionSelector starting point
+        /// </summary>
+        /// <param name="application"></param>
+        /// <returns></returns>
         public Result OnStartup(UIControlledApplication application)
         {
-            uiControlledApplication = application;
-            var revitVersion = application.ControlledApplication.VersionNumber;
-
-            var revitFolder =
-                new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
+            // Find available Dynamo Products
+            DynamoProducts = new ProductsManager(application);
+            if (DynamoProducts.Count == 0)
+                return Result.Failed;
 
-            var debugPath = revitFolder.Parent.FullName;
-            var dynamoProducts = FindDynamoRevitInstallations(debugPath, revitVersion);
+            // May be needed to re-route Revit Icons commands, if no Revit product is loaded
+            var Commands = new CommandsBinders(application, DynamoProducts.ContainsDynamoPlayer());
+            Commands.OnDynamoClick += OnDynamoIconClick;
+            Commands.OnDynamoPlayerClick += OnDynamoPlayerIconClick;
+            DynamoProducts.OnBeforeLoad += new ProductsManager.BeforeLoadEventHandler(delegate () {
+                Commands.UnBind();
+            });
 
-            Products = new List<DynamoProduct>();
-            PlaylistProducts = new List<DynamoProduct>();
-            foreach (var p in dynamoProducts)
+            // If multiple product are available then add a Version Selection Button in the Ribbon
+            if (DynamoProducts.Count > 1)
             {
-                var path = VersionLoader.GetDynamoRevitPath(p, revitVersion);
-                if (!File.Exists(path))
-                    continue;
-
-                Products.Add(p);
-
-                if (p.VersionInfo.Major >= MinDynamoMajorVersionForPlaylist
-                    && p.VersionInfo.Minor >= MinDynamoMinorVersionForPlaylist)
-                {
-                    PlaylistProducts.Add(p);
-                }
+                var selectBtn = new VersionSelectorButton();
+                selectBtn.AddInRibbon();
+                selectBtn.OnButtonClick += OnDynamoVersionIconClick;
             }
 
-            if (Products.Count == 0)
-                return Result.Failed;
-
-            Result preliminaryLoadResult = Result.Succeeded;
+            // Get Persisted Dynamo Version
+            Version activeVersion;
+            activeVersion = Tools.Presistence.ActiveVersion;
+            if ((activeVersion != Product.LASTESTDYNAMO) && (!DynamoProducts.Contains(activeVersion)))
+                activeVersion = Product.NODYNAMO; // default
 
-            // If there are multiple versions installed, then do the command 
-            // binding to prompt for version selector task dialog for user to 
-            // select specific Dynamo version.
-            if (Products.Count > 1)
-            {
-                var dynamoCmdId = RevitCommandId.LookupCommandId("ID_VISUAL_PROGRAMMING_DYNAMO");
-                dynamoCommand = application.CreateAddInCommandBinding(dynamoCmdId);
-                dynamoCommand.CanExecute += canExecute;
-                dynamoCommand.BeforeExecuted += beforeExecuted;
-                dynamoCommand.Executed += executed;
+            // Write it back to keep consistency
+            Tools.Presistence.ActiveVersion = activeVersion;
 
-                if (PlaylistProducts.Count >= 1)
-                {
-                    var dynamoPlayerCmdId = RevitCommandId.LookupCommandId("ID_PLAYLIST_DYNAMO");
-                    if (dynamoPlayerCmdId != null)
-                    {
-                        dynamoPlayerCommand = application.CreateAddInCommandBinding(dynamoPlayerCmdId);
-                        dynamoPlayerCommand.CanExecute += canExecute;
-                        dynamoPlayerCommand.BeforeExecuted += beforeExecuted;
-                        dynamoPlayerCommand.Executed += executedPlaylist;
-                    }
-                }
-            }
-            else //If only one product is installed load the Revit App directly
+            // Multiple Revit Product without any persisted version ?
+            if (DynamoProducts.Count > 1 && activeVersion == Product.NODYNAMO)
             {
-                preliminaryLoadResult = loadProduct(Products.First(), revitVersion);
+                Commands.Bind();
+                return Result.Succeeded;
             }
 
-            return preliminaryLoadResult;
-        }
-
-        void executed(object sender, ExecutedEventArgs e)
-        {
-            var product = PromptVersionSelectorDialog(Products);
-            if(product.HasValue)
-                LaunchDynamoCommand(product.Value, e);
-        }
-
-        private void executedPlaylist(object sender, ExecutedEventArgs e)
-        {
-            if (PlaylistProducts.Count == 0)
-                return;
-
-            DynamoProduct productToLaunch = PlaylistProducts.First();
-            if (PlaylistProducts.Count > 1)
+            // Single Revit Version
+            if (DynamoProducts.Count == 1)
             {
-                var product = PromptVersionSelectorDialog(PlaylistProducts);
-                if (product.HasValue)
-                {
-                    productToLaunch = product.Value;
-                }
+                Tools.Presistence.ActiveVersion = Product.NODYNAMO; // back to default
+                activeVersion = DynamoProducts.Latest.Version; // force to use the unique version available
             }
 
-            LaunchDynamoCommand(productToLaunch, e, true);
-        }
-
-        void beforeExecuted(object sender, BeforeExecutedEventArgs e)
-        {
-            e.UsingCommandData = true;
-        }
-
-        void canExecute(object sender, CanExecuteEventArgs e)
-        {
-            e.CanExecute = e.ActiveDocument != null;
-        }
-
-        private Result loadProduct(DynamoProduct product, string revitVersion)
-        {
-            string loadPath = GetDynamoRevitPath(product, revitVersion);
 
-            if (String.IsNullOrEmpty(loadPath))
+            // load expected product
+            var ret = DynamoProducts.Load(activeVersion);
+            if (!ret.IsSucceed) {
+                /* Error, go back in a safe position for the next time */
+                Tools.Presistence.ActiveVersion = Product.NODYNAMO;
                 return Result.Failed;
-
-            var ass = Assembly.LoadFrom(loadPath);
-            var revitApp = ass.CreateInstance("Dynamo.Applications.DynamoRevitApp");
-            revitApp.GetType().GetMethod("OnStartup").Invoke(revitApp, new object[] { uiControlledApplication });
+            }
 
             return Result.Succeeded;
         }
 
         /// <summary>
-        /// Prompts for version selection task dialog
+        /// Event when user click on "Dynamo" Icon
         /// </summary>
-        /// <param name="availableProducts">Choice list of Dynamo Products available for selection</param>
-        /// <returns>DynamoProduct to launch or null</returns>
-        private DynamoProduct? PromptVersionSelectorDialog(List<DynamoProduct> availableProducts)
+        /// <remarks>Only occurs if icon associated commands has been binded</remarks>
+        private void OnDynamoIconClick(object sender, ExecutedEventArgs e)
         {
-            // Creates a Revit task dialog to communicate information to the user.
-            TaskDialog mainDialog = new TaskDialog(Resources.DynamoVersions);
-            mainDialog.MainInstruction = Resources.DynamoVersionSelection;
-            mainDialog.MainContent = Resources.VersionSelectionContent;
-
-            // Add commmandLink options to task dialog
-            int id = (int)TaskDialogCommandLinkId.CommandLink1;
-            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
-            //Get the default selection data
-            var selectorData = VersionSelectorData.ReadFromRegistry(revitVersion);
-            var selectedVersion = selectorData.SelectedVersion.ToString(2);
-            TaskDialogResult defaultResult = TaskDialogResult.CommandLink1;
-            foreach (var item in availableProducts)
-            {
-                var versionText = String.Format(Resources.DynamoVersionText, item.VersionInfo.ToString(3));
-                mainDialog.AddCommandLink((TaskDialogCommandLinkId)id, versionText, item.InstallLocation);
-                if (item.VersionInfo.ToString(2) == selectedVersion)
-                    defaultResult = (TaskDialogResult)id;
-
-                id++;
-            }
-
-            // Set common buttons and default button. If no CommonButton or CommandLink is added,
-            // task dialog will show a Close button by default
-            mainDialog.CommonButtons = TaskDialogCommonButtons.Close;
-            mainDialog.DefaultButton = defaultResult;
-
-            TaskDialogResult tResult = mainDialog.Show();
-            if (tResult == TaskDialogResult.Close)
-                return null;
-
-            var index = (int)tResult - (int)TaskDialogCommandLinkId.CommandLink1;
-            return availableProducts[index];
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 1- Load Dynamo */
+                DynamoProducts.Load(v);
+            });
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 2- Start Dynamo */
+                Version currentversion = ProductsManager.LoadedProduct();
+                if (currentversion == Product.NODYNAMO) throw new ArgumentException($"{v} is not loaded");
+                UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
+                DynamoProducts.Get(currentversion).ExecuteDynamoCommand(e.GetJournalData(), uiApp);
+            });
+
+            dlg.Show();
         }
 
-
         /// <summary>
-        /// Launches specific version of Dynamo command
+        /// Event when user click on "Dynamo Player" Icon
         /// </summary>
-        /// <param name="product">DynamoProduct to launch</param>
-        /// <param name="e">Command executed event argument</param>
-        /// <param name="playlist">Launch the Playlist app or just Dynamo</param>
-        /// <returns>true for success</returns>
-        private bool LaunchDynamoCommand(DynamoProduct product, ExecutedEventArgs e,bool playlist = false)
+        /// <remarks>Only occurs if icon associated commands has been binded</remarks>
+        private void OnDynamoPlayerIconClick(object sender, ExecutedEventArgs e)
         {
-            if (uiControlledApplication == null)
-                throw new InvalidOperationException();
-
-            var revitVersion = uiControlledApplication.ControlledApplication.VersionNumber;
-            var path = GetDynamoRevitPath(product, revitVersion);
-            var data = new VersionSelectorData() { RevitVersion = revitVersion, SelectedVersion = product.VersionInfo };
-            data.WriteToRegistry();
-
-            //Initialize application
-            var ass = Assembly.LoadFrom(path);
-            var revitApp = ass.CreateInstance("Dynamo.Applications.DynamoRevitApp");
-            if (null == revitApp)
-                return false;
-            
-            //Remove the command binding, because now DynamoRevitApp will 
-            //do the command binding for DynamoRevit command.
-            RemoveCommandBinding();
-
-            var type = revitApp.GetType();
-            var result = type.GetMethod("OnStartup").Invoke(revitApp, new object[] { uiControlledApplication });
-            if ((Result)result != Result.Succeeded)
-                return false;
-
-            UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
-
-            if (!playlist)
-            {
-                //Invoke command
-                string message = string.Empty;
-                result = type.GetMethod("ExecuteDynamoCommand").Invoke(revitApp, new object[] { e.GetJournalData(), uiApp });
-                if ((Result)result != Result.Succeeded)
-                    return false;
-            }
-            else
-            {
-                //Dependent components have done a re-binding of Playlist command in order to be executed in their context.
-                //In order to lunch the Playlist we just need to post the command to the Revit application.
-                var dynamoPlayerCmdId = RevitCommandId.LookupCommandId("ID_PLAYLIST_DYNAMO");
-                if (dynamoPlayerCmdId != null)
-                    uiApp.PostCommand(dynamoPlayerCmdId);
-            }
-
-            uiControlledApplication = null; //release application, no more needed.
-            return true;
-        }
-
-        public Result OnShutdown(UIControlledApplication application)
-        {
-            RemoveCommandBinding();
-            return Result.Succeeded;
-        }
-
-        private void RemoveCommandBinding()
-        {
-            if (null != dynamoCommand)
-            {
-                uiControlledApplication.RemoveAddInCommandBinding(dynamoCommand.RevitCommandId);
-                dynamoCommand.BeforeExecuted -= beforeExecuted;
-                dynamoCommand.CanExecute -= canExecute;
-                dynamoCommand.Executed -= executed;
-                dynamoCommand = null;
-            }
-
-            if (null != dynamoPlayerCommand)
-            {
-                uiControlledApplication.RemoveAddInCommandBinding(dynamoPlayerCommand.RevitCommandId);
-                dynamoPlayerCommand.BeforeExecuted -= beforeExecuted;
-                dynamoPlayerCommand.CanExecute -= canExecute;
-                dynamoPlayerCommand.Executed -= executedPlaylist;
-                dynamoPlayerCommand = null;
-            }                
-
-        }
-
-        private static IEnumerable<DynamoProduct> FindDynamoRevitInstallations(string debugPath, string revitVersion)
-        {
-            var assembly = Assembly.LoadFrom(Path.Combine(debugPath, "DynamoInstallDetective.dll"));
-            var type = assembly.GetType("DynamoInstallDetective.Utilities");
-
-            var installationsMethod = type.GetMethod(
-                "LocateDynamoInstallations",
-                BindingFlags.Public | BindingFlags.Static);
-
-            if (installationsMethod == null)
-            {
-                throw new MissingMethodException("Method 'DynamoInstallDetective.Utilities.LocateDynamoInstallations' not found");
-            }
-
-            Func<string, string> fileLocator =
-                p => Path.Combine(p, string.Format("Revit_{0}", revitVersion), "DynamoRevitDS.dll");
-
-            var methodParams = new object[] { debugPath, fileLocator };
-
-            var installs = installationsMethod.Invoke(null, methodParams) as IEnumerable;
-            if(null == installs)
-                return null;
-
-            return
-                installs.Cast<KeyValuePair<string, Tuple<int, int, int, int>>>()
-                    .Select(
-                        p => new DynamoProduct() { InstallLocation = p.Key, 
-                            VersionInfo = new Version(p.Value.Item1, p.Value.Item2, p.Value.Item3, p.Value.Item4) });
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 1- Load Dynamo */
+                DynamoProducts.Load(v);
+            });
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v) {
+                /* 2- Start Dynamo Player (if we can) */
+                Version currentversion = ProductsManager.LoadedProduct();
+                if (currentversion == Product.NODYNAMO) throw new ArgumentException($"{v} is not loaded");
+                UIApplication uiApp = new UIApplication(e.ActiveDocument.Application);
+                var dynamoPlayerCmdId = RevitCommandId.LookupCommandId(CommandsBinders.PLAYERID);
+                uiApp.PostCommand(dynamoPlayerCmdId);
+            });
+
+            dlg.Show();
         }
 
-    }
-
-    /// <summary>
-    /// VersionSelectorData: A class to keep the selected version data to be stored in registry.
-    /// </summary>
-    internal class VersionSelectorData
-    {
-        const string RegKey64 = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\";
-        
         /// <summary>
-        /// Constructor
+        /// Event when user click on "Version selection" icon
         /// </summary>
-        public VersionSelectorData()
-        { 
-            ThisDynamoVersion = Assembly.GetExecutingAssembly().GetName().Version;
-        }
-
-        /// <summary>
-        /// Reads the version selection data for specific revit version from 
-        /// registry and returns a new VersionSelectorData.
-        /// </summary>
-        /// <param name="revitVersion">Revit version</param>
-        /// <returns>VersionSelectorData</returns>
-        public static VersionSelectorData ReadFromRegistry(string revitVersion)
+        /// <remarks>"Version selection" icon may not be present</remarks>
+        private void OnDynamoVersionIconClick()
         {
-            var data = new VersionSelectorData() { RevitVersion = revitVersion };
-            data.SelectedVersion = data.ThisDynamoVersion; //Default initialization
-
-            try
+            var dlg = new VersionDialog(DynamoProducts.List);
+            dlg.AddNoDynamoOption();
+            dlg.OnSelection += new VersionDialog.SelectedEventHandler(delegate (Version v)
             {
-                var regKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
-                regKey = regKey.OpenSubKey(RegKey64);
-
-                var key = string.Format(@"Dynamo {0}.{1}", data.ThisDynamoVersion.Major, data.ThisDynamoVersion.Minor);
-                regKey = regKey.OpenSubKey(key);
-                if (regKey == null)
-                    return data;
-
-                var version = regKey.GetValue(data.RevitVersion);
-
-                Version selectedVersion = null;
-                if (Version.TryParse(version as string, out selectedVersion))
-                    data.SelectedVersion = selectedVersion;
-            }
-            catch (SystemException) { }
+                /* Load Dynamo */
+                var ret = DynamoProducts.Load(v);
+                if (!ret.IsSucceed)
+                    return;
+            
+                /* Save Result */
+                Tools.Presistence.ActiveVersion = v;
+                
+                /* UI Confirmation */
+                if (ret.fromVersion != ret.afterVersion)
+                {
+                    var popup = new TaskDialog(Resources.DynamoVersions);
+                    popup.MainInstruction = Resources.DynamoVersionSelection;
+                    if (ret.Result == ProductsManager.LoadResult.ResultType.PENDING)
+                    {
+                        /* Need to restart Revit */
+                        popup.MainContent = String.Format(Resources.NeedToRestartRevit);
+                        if (ret.afterVersion != Product.NODYNAMO)
+                            popup.MainContent = String.Format(Resources.ProductNeedToRestartRevit, ret.afterVersion);
+                    }
+                    else
+                    {
+                        popup.MainContent = String.Format(Resources.ProductLoaded, ret.afterVersion);
+                    }
+                    popup.Show();
+                }
+            });
 
-            return data;
+            dlg.Show();
         }
 
-        /// <summary>
-        /// Saves this data to Registry
-        /// </summary>
-        public void WriteToRegistry()
+        public Result OnShutdown(UIControlledApplication application)
         {
-            try
-            {
-                var regKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
-                regKey = regKey.OpenSubKey(RegKey64);
-
-                var key = string.Format(@"Dynamo {0}.{1}", ThisDynamoVersion.Major, ThisDynamoVersion.Minor);
-                regKey = regKey.OpenSubKey(key, true);
-                if(null != regKey)
-                    regKey.SetValue(RevitVersion, SelectedVersion.ToString(), RegistryValueKind.String);
-            }
-            catch (SystemException) { }
+            return Result.Succeeded;
         }
-
-        /// <summary>
-        /// Gets the version of this Dynamo
-        /// </summary>
-        public Version ThisDynamoVersion { get; private set; }
-
-        /// <summary>
-        /// Revit version string
-        /// </summary>
-        public string RevitVersion { get; set; }
-
-        /// <summary>
-        /// Gets the version of Dynamo that was selected to run.
-        /// </summary>
-        public Version SelectedVersion { get; set; }
     }
 }
diff --git a/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
new file mode 100644
index 0000000000..484ee1f2e3
--- /dev/null
+++ b/src/Legacy/DynamoRevitVersionSelector/VersionSelectorButton.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using Autodesk.Revit.UI;
+using System.Linq;
+using DynamoRevitVersionSelector.Properties;
+using Autodesk.Revit.UI.Events;
+using Dynamo.Applications.Tools;
+
+namespace Dynamo.Applications
+{
+    internal class VersionSelectorButton
+    {
+        public delegate void OnClickEventHandler();
+        public event OnClickEventHandler OnButtonClick;
+
+        public void AddInRibbon()
+        {
+            foreach (var panel in Tools.UI.GetRibbonPanels("Manage"))
+            {
+                if(panel.Source.Id == "visualprogramming_shr")
+                {
+                    var btn = new Tools.UI.PushButtonData("ID_DYANMO_CHANGEVERSION");
+                    btn.Text = Resources.VersionSelectionBtnText;
+                    btn.ToolTip = Resources.VersionSelectionBtnToolTip;
+                    btn.Image = Resources.dynamo_setting_32x32;
+                    btn.OnClickEvent += ButtonClick;
+                    panel.Source.Items.Add(btn.Source);
+                }
+            }
+        }
+
+        private void ButtonClick()
+        {
+            OnButtonClick();
+        }
+    }
+}
diff --git a/src/Legacy/DynamoRevitVersionSelector/logo_about.png b/src/Legacy/DynamoRevitVersionSelector/logo_about.png
deleted file mode 100644
index 650d04700f..0000000000
Binary files a/src/Legacy/DynamoRevitVersionSelector/logo_about.png and /dev/null differ