diff --git a/resharper/.run/runIde.run.xml b/resharper/.run/runIde.run.xml
index 376fcbd4..1b525494 100644
--- a/resharper/.run/runIde.run.xml
+++ b/resharper/.run/runIde.run.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="runIde" type="DotNetProject" factoryName=".NET Project">
-    <option name="EXE_PATH" value="$PROJECT_DIR$/build/gradle-launcher/bin/Debug/net461/gradle-launcher.exe" />
+    <option name="EXE_PATH" value="$PROJECT_DIR$/build/gradle-launcher/bin/Debug/net472/gradle-launcher.exe" />
     <option name="PROGRAM_PARAMETERS" value="../../../rider runIde -PskipDotnet=true" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/build/gradle-launcher/" />
     <option name="PASS_PARENT_ENVS" value="1" />
@@ -16,7 +16,7 @@
     <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
     <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="0" />
     <option name="PROJECT_KIND" value="DotNetCore" />
-    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.6.1" />
+    <option name="PROJECT_TFM" value=".NETFramework,Version=v4.7.2" />
     <method v="2">
       <option name="Build" />
     </method>
diff --git a/resharper/godot-support.sln b/resharper/godot-support.sln
index d79a91dc..00b05f37 100644
--- a/resharper/godot-support.sln
+++ b/resharper/godot-support.sln
@@ -30,6 +30,7 @@ Global
 		{A0CA2638-35EE-4034-B1FA-F13345121485}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A0CA2638-35EE-4034-B1FA-F13345121485}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A0CA2638-35EE-4034-B1FA-F13345121485}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A0CA2638-35EE-4034-B1FA-F13345121485}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D331B4B-9B49-41A6-8322-0CFE82FA238E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{0D331B4B-9B49-41A6-8322-0CFE82FA238E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D331B4B-9B49-41A6-8322-0CFE82FA238E}.Release|Any CPU.ActiveCfg = Release|Any CPU
diff --git a/resharper/src/Application/Resources/Icons/Godot.cs b/resharper/src/Application/Resources/Icons/Godot.cs
new file mode 100644
index 00000000..0e26f913
--- /dev/null
+++ b/resharper/src/Application/Resources/Icons/Godot.cs
@@ -0,0 +1,257 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// for some reason this line was not compiling, so I have commented it.
+// [assembly: global::System.Windows.Markup.XmlnsDefinitionAttribute("urn:shemas-jetbrains-com:ui-application-icons-qydowyd-themed-icons", "JetBrains.UI.ThemedIcons")]
+
+namespace JetBrains.UI.ThemedIcons
+{
+	
+	
+	/// <summary>
+	///	<para>
+	///		<para>Autogenerated identifier classes and identifier objects to Themed Icons registered with <see cref="JetBrains.Application.Icons.IThemedIconManager"></see>.</para>
+	///		<para>Identifier classes should be used in attributes, XAML, or generic parameters. Where an <see cref="JetBrains.UI.Icons.IconId"></see> value is expected, use the identifier object in the <c>Id</c> field of the identifier class.</para>
+	///	</para>
+	///</summary>
+	///<remarks>
+	///	<para>This code was compile-time generated to support Themed Icons in the JetBrains application.</para>
+	///	<para>It has two primary goals: load the icons of this assembly to be registered with <see cref="JetBrains.Application.Icons.IThemedIconManager"></see> so that they were WPF-accessible and theme-sensitive; and emit early-bound accessors for referencing icons in codebehind in a compile-time-validated manner.</para>
+	///	<h1>XAML</h1>
+	///	<para>For performance reasons, the icons are not individually exposed with application resources. There is a custom markup extension to bind an image source in markup.</para>
+	///	<para>To use an icon from XAML, set an <see cref="System.Windows.Media.ImageSource"></see> property to the <see cref="System.CodeDom.CodeTypeReference"></see> markup extension, which takes an icon identifier class (nested in <see cref="JetBrains.UI.ThemedIcons.QydowydThemedIconsThemedIcons"></see> class) as a parameter.</para>
+	///	<para>Example:</para>
+	///	<code>&lt;Image Source="{icons:ThemedIcon myres:QydowydThemedIconsThemedIcons+Trinity}" /&gt;</code>
+	///	<h1>Attributes</h1>
+	///	<para>Sometimes you have to reference an icon from a type attriute when you're defining objects in code. Typical examples are Options pages and Tool Windows.</para>
+	///	<para>To avoid the use of string IDs which are not validated very well, we've emitted identifier classes to be used with <c>typeof()</c> expression, one per each icon. Use the attribute overload which takes a <see cref="System.Type"></see> for an image, and choose your icon class from nested classes in the <see cref="JetBrains.UI.ThemedIcons.QydowydThemedIconsThemedIcons"></see> class.</para>
+	///	<para>Example:</para>
+	///	<code>[Item(Name="Sample", Icon=typeof(QydowydThemedIconsThemedIcons.Trinity))]</code>
+	///	<h1>CodeBehind</h1>
+	///	<para>In codebehind, we have two distinct tasks: (a) specify some icon in the APIs and (b) render icon images onscreen.</para>
+	///	<para>On the APIs stage you should only manipulate icon identifier objects (of type <see cref="JetBrains.UI.Icons.IconId"></see>, statically defined in <see cref="JetBrains.UI.ThemedIcons.QydowydThemedIconsThemedIcons"></see> in <c>Id</c> fields). Icon identifier classes (nested in <see cref="JetBrains.UI.ThemedIcons.QydowydThemedIconsThemedIcons"></see>) should be turned into icon identifier objects as early as possible. Rendering is about getting an <see cref="System.Windows.Media.ImageSource"></see> to assign to WPF, or <see cref="System.Drawing.Bitmap"></see> to use with GDI+ / Windows Forms.</para>
+	///	<para>You should turn an identifier object into a rendered image as late as possible. The identifier is static and lightweight and does not depend on the current theme, while the image is themed and has to be loaded or generated/rasterized. You need an <see cref="JetBrains.Application.Icons.IThemedIconManager"></see> instance to get the image out of an icon identifier object. Once you got the image, you should take care to change it with theme changes — either by using a live image property, or by listening to the theme change event. See <see cref="JetBrains.Application.Icons.IThemedIconManager"></see> and its extensions for the related facilities.</para>
+	///	<para>Example:</para>
+	///	<code>// Getting IconId identifier object to use with APIs
+	///IconId iconid = QydowydThemedIconsThemedIcons.Trinity.Id;</code>
+	///	<code>// Getting IconId out of an Icon Identifier Class type
+	///IconId iconid = new JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsId(typeof(QydowydThemedIconsThemedIcons.Trinity));</code>
+	///	<code>// Getting image for screen rendering by IconId
+	///themediconmanager.Icons[icnoid]</code>
+	///	<code>// Getting image for screen rendering by Icon Identifier Class
+	///themediconmanager.GetIcon&lt;QydowydThemedIconsThemedIcons.Trinity&gt;()</code>
+	///	<h1>Icons Origin</h1>
+	///	<para>This code was generated by a pre-compile build task from a set of input files which are XAML files adhering to a certain convention, as convenient for exporting them from the Illustrator workspace, plus separate PNG files with raster icons. In the projects, these files are designated with <c>ThemedIconsXamlV3</c> and <c>ThemedIconPng</c> build actions and do not themselves get into the output assembly. All of such files are processed, vector images for different themes of the same icon are split and combined into the single list of icons in this assembly. This list is then written into the genearted XAML file (compiled into BAML within assembly), and serves as the source for this generated code.</para>
+	///</remarks>
+	public sealed class QydowydThemedIconsThemedIcons
+	{
+		
+		#region Godot
+		/// <summary>
+		///	<para>
+		///		<para>Godot Themed Icon generated identifiers:</para>
+		///		<para>— <see cref="Godot"></see> identifier class, for use in attributes, XAML, and generic parameters;</para>
+		///		<para>— <see cref="Id"></see> identifier object, as a field in the identifier class, for use where an <see cref="JetBrains.UI.Icons.IconId"></see> value is expected.</para>
+		///		<para>
+		///			<code>
+		///                                 
+		///          `-,;-    -;_-`         
+		///          ;TTTT_::_TTTT+         
+		///     `   `!TTTTTTTTTTTT+`   `    
+		///   `*Tr~*TTTTTTTTTTTTTTTT+~+Tr.  
+		///  `)TTTTTTTTTTTTTTTTTTTTTTTTTTT. 
+		///   `LTTTTTcTTTTTTTTTTTTcTTTTTc-  
+		///    =TTc-:!~,|TT+*TTT"~!:-rTT=   
+		///    =TT;`#DD^rTT` TT):DDD.;TT=   
+		///    =TTT!~;!*TTT-.TTTr;;^;TTT=   
+		///    ,;;==|TTTTTTTTTTTTTT)==;;,   
+		///    ~r*=,:TTT|`""""`rTTT":=*r;   
+		///    -TTT+:,,,::TTTT"::,,:*TTT:   
+		///     `;)TTTTTTTTTTTTTTTTTT|!.    
+		///        `-";=*rrrrrr+=;^:.       
+		///                                 
+		///</code>
+		///		</para>
+		///	</para>
+		///</summary>
+		///<remarks>
+		///	<para>For details on Themed Icons and their use, see Remarks on the outer class.</para>
+		///</remarks>
+		///<example>
+		///	<code>&lt;Image Source="{icons:ThemedIcon myres:QydowydThemedIconsThemedIcons+Godot}" /&gt;        &lt;!-- XAML --&gt;</code>
+		///</example>
+		///<example>
+		///	<code>[Item(Name="Sample", Icon=typeof(QydowydThemedIconsThemedIcons.Godot))]        // C# Type attribute</code>
+		///</example>
+		///<example>
+		///	<code>IconId iconid = QydowydThemedIconsThemedIcons.Godot.Id;        // IconId identifier object</code>
+		///</example>
+		///<example>
+		///	<code>themediconmanager.GetIcon&lt;QydowydThemedIconsThemedIcons.Godot&gt;()        // Icon image for rendering</code>
+		///</example>
+		[global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsAttribute()]
+		public sealed class Godot : global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsClass
+		{
+			
+			/// <inheritdoc cref="Godot">identifier class</inheritdoc>
+			public static global::JetBrains.UI.Icons.IconId Id = new global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsId(typeof(Godot));
+			
+			/// <summary>Loads the image for Themed Icon Godot theme aspect Default.</summary>
+			public global::JetBrains.Util.Icons.TiImage Load_Default()
+			{
+				return global::JetBrains.Util.Icons.TiImageConverter.FromTiSvg("<svg ti:v=\'1\' width=\'16\' height=\'16\' viewBox=\'0,0,16,16\' xmlns=\'http://www.w3.org" +
+						"/2000/svg\' xmlns:ti=\'urn:schemas-jetbrains-com:tisvg\'><g><path d=\'M14.363,10.52C" +
+						"14.363,10.52,14.343,10.387,14.328,10.389999999999999L11.977,10.616999999999999C1" +
+						"1.886258240560052,10.625529479490032,11.801428692765096,10.666010119183081,11.73" +
+						"7718207116005,10.731185213697668C11.674007721466914,10.796360308212254,11.635465" +
+						"230475132,10.882087846128629,11.629000000000001,10.972999999999999L11.566,11.898" +
+						"L9.746,12.028L9.621,11.188C9.6074170474508112,11.097009395978455,9.5617417260147" +
+						"04,11.013805845548937,9.4922676153048453,10.953497184800801C9.4227935045949867,1" +
+						"0.893188524052665,9.333996471888991,10.859660136453813,9.242,10.859L6.758,10.859" +
+						"C6.6658312063569412,10.859422371374107,6.5767938132209727,10.892843426980464,6.5" +
+						"071118875319085,10.953173304748102C6.4374299618428443,11.013503182515739,6.39160" +
+						"95928519949,11.09684055780339,6.3779999999999992,11.188L6.254,12.028L4.433999999" +
+						"9999993,11.898L4.3709999999999996,10.972999999999999C4.3645347695248686,10.88208" +
+						"7846128629,4.3259922785330858,10.796360308212252,4.2622817928839956,10.731185213" +
+						"697666C4.1985713072349053,10.666010119183079,4.1137417594399484,10.6255294794900" +
+						"3,4.023,10.616999999999997L1.6679999999999997,10.390999999999996C1.6559999999999" +
+						"997,10.386999999999997,1.6479999999999997,10.519999999999996,1.6369999999999998," +
+						"10.519999999999996L1.6329999999999998,11.026999999999996L3.625,11.34699999999999" +
+						"6L3.691,12.284999999999997C3.707,12.472999999999997,3.859,12.624999999999996,4.0" +
+						"47,12.640999999999996L6.555,12.820999999999996L6.582,12.820999999999996C6.673996" +
+						"47188899,12.820339863546183,6.7627935045949874,12.78681147594733,6.8322676153048" +
+						"452,12.726502815199193C6.9017417260147029,12.666194154451057,6.94741704745081,12" +
+						".582990604021541,6.9609999999999994,12.491999999999996L7.09,11.628999999999996L8" +
+						".91,11.628999999999996L9.0400000000000009,12.491999999999996C9.0537717613755486," +
+						"12.582640016543563,9.0993953581095148,12.665474169479648,9.1686408674085662,12.7" +
+						"25560219876709C9.2378863767076176,12.785646270273769,9.3263237507432812,12.81914" +
+						"0155465828,9.418000000000001,12.819999999999995L9.445,12.819999999999995L11.953," +
+						"12.639999999999995C12.044517221514548,12.631940091683196,12.130351229467324,12.5" +
+						"91958380234406,12.19540546123668,12.527086885071144C12.260459693006036,12.462215" +
+						"389907882,12.300682691670586,12.376494187454563,12.309000000000001,12.2849999999" +
+						"99995L12.375000000000002,11.347999999999995L14.367,11.027999999999995ZM14.363,10" +
+						".52M14.363,10.52Z\' fill=\'#FFFFFF\'/><path d=\'M1.637,6.68L1.637,10.52L1.657,10.52L" +
+						"4.0120000000000005,10.746C4.1320000000000006,10.758000000000001,4.23,10.856,4.23" +
+						"8,10.98L4.312,12.02L6.3670000000000009,12.168L6.5070000000000006,11.206999999999" +
+						"999C6.5158876229184877,11.147122347770081,6.546059473508925,11.092406589019967,6" +
+						".591955192667494,11.052936270543597C6.6378509118260629,11.013465952067227,6.6964" +
+						"666021824364,10.991824425603085,6.7570000000000006,10.991999999999999L9.242,10.9" +
+						"91999999999999C9.367,10.991999999999999,9.4720000000000013,11.081999999999999,9." +
+						"492,11.206999999999999L9.6320000000000014,12.168L11.688000000000002,12.02L11.762" +
+						"000000000002,10.98C11.765751365346313,10.920528290839403,11.790561604096663,10.8" +
+						"64293204602312,11.8319589635092,10.821430451936234C11.873356322921737,10.7785676" +
+						"99270155,11.928694698106213,10.751817052495081,11.988000000000003,10.74599999999" +
+						"9999L14.344000000000003,10.519999999999998L14.364000000000003,10.519999999999998" +
+						"L14.364000000000003,6.68L14.371000000000002,6.68C14.684000000000003,6.281,14.973" +
+						"000000000003,5.8599999999999994,15.250000000000002,5.414C14.881387737949149,4.79" +
+						"97292102279632,14.44535224341818,4.2285227123923983,13.95,3.7110000000000003C13." +
+						"504,3.934,13.069999999999999,4.1880000000000006,12.66,4.461C12.457,4.258,12.227," +
+						"4.09,12,3.914C11.777,3.738,11.523,3.605,11.285,3.454C11.359,2.926,11.395,2.406,1" +
+						"1.406,1.864C10.791429824904572,1.5637776184121779,10.142199931340333,1.340426413" +
+						"4353454,9.473,1.1989999999999998C9.211,1.6449999999999998,8.9690000000000012,2.1" +
+						"29,8.7580000000000009,2.598C8.5080000000000009,2.5549999999999997,8.258000000000" +
+						"0009,2.5389999999999997,8.0040000000000013,2.5389999999999997L7.9960000000000013" +
+						",2.5389999999999997C7.7420000000000009,2.5389999999999997,7.4920000000000009,2.5" +
+						"549999999999997,7.2420000000000009,2.598C7.0295646301328478,2.1181666967848174,6" +
+						".7894952774496238,1.6510498339143953,6.5229999999999979,1.198999999999999C5.8549" +
+						"638676428808,1.3406749494146353,5.2067967133179334,1.5636713175347214,4.593,1.86" +
+						"29999999999978C4.6049999999999995,2.4059999999999979,4.641,2.9259999999999975,4." +
+						"715,3.4529999999999976C4.477,3.6049999999999978,4.223,3.7379999999999978,4,3.913" +
+						"9999999999975C3.773,4.0899999999999972,3.543,4.2579999999999973,3.34,4.460999999" +
+						"9999976C2.9299999999999997,4.1869999999999976,2.496,3.9339999999999975,2.05,3.71" +
+						"09999999999976C1.5546477565818217,4.2285227123923956,1.1186122620508547,4.799729" +
+						"2102279614,0.75000000000000178,5.413999999999997C1.0270000000000019,5.8589999999" +
+						"999973,1.3160000000000016,6.280999999999997,1.6290000000000018,6.679999999999997" +
+						"1ZM1.637,6.68M1.637,6.68Z\' fill=\'#478CBF\'/><path d=\'M12.25,11.23L12.18,12.273C12" +
+						".175183411848279,12.334768002421294,12.148443827902872,12.392825500544491,12.104" +
+						"634664223681,12.436634664223682C12.060825500544491,12.480443827902873,12.0027680" +
+						"02421293,12.507183411848279,11.940999999999999,12.512L9.437,12.687000000000001C9" +
+						".43,12.687000000000001,9.4219999999999988,12.691,9.418,12.691C9.3570772251234828" +
+						",12.690863358035283,9.2982073925099655,12.66872571281805,9.2522900164787671,12.6" +
+						"28685760918845C9.2063726404475688,12.58864580901964,9.1764279198239009,12.533337" +
+						"163814048,9.1679999999999975,12.473L9.0229999999999979,11.496L6.977,11.496L6.832" +
+						"0000000000007,12.473C6.8230288353424617,12.536469001751458,6.7899824054043636,12" +
+						".594118560340492,6.7397477981934681,12.633934137907648C6.6895131909825718,12.673" +
+						"749715474804,6.6258406710358937,12.692758880127776,6.5620000000000012,12.6870000" +
+						"00000003L4.0590000000000011,12.512000000000002C3.997231997578707,12.507183411848" +
+						"281,3.9391744994555107,12.480443827902873,3.89536533577632,12.436634664223682C3." +
+						"8515561720971294,12.392825500544491,3.8248165881517218,12.334768002421296,3.8200" +
+						"000000000012,12.273000000000001L3.7500000000000013,11.230000000000002L1.63300000" +
+						"00000013,11.027000000000003C1.6330000000000013,11.254000000000003,1.637000000000" +
+						"0013,11.504000000000003,1.6370000000000013,11.551000000000002C1.6370000000000013" +
+						",13.789000000000001,4.4730000000000008,14.863000000000001,7.9970000000000017,14." +
+						"875000000000002L8.0040000000000013,14.875000000000002C11.527000000000001,14.8630" +
+						"00000000001,14.364,13.789000000000001,14.364,11.551000000000002C14.364,11.500000" +
+						"000000002,14.367,11.254000000000001,14.367,11.027000000000001ZM12.25,11.23M12.25" +
+						",11.23Z\' fill=\'#478CBF\'/><path d=\'M6.082,8.238C6.082,8.613932748810667,5.9325020" +
+						"116766467,8.9748528197684028,5.6666774157225248,9.2406774157225247C5.40085281976" +
+						"84029,9.5065020116766465,5.0399327488106671,9.6559999999999988,4.664,9.655999999" +
+						"9999988C4.2880672511893323,9.6559999999999988,3.9271471802315974,9.5065020116766" +
+						"465,3.6613225842774755,9.2406774157225247C3.3954979883233536,8.9748528197684028," +
+						"3.2459999999999996,8.613932748810667,3.2459999999999996,8.238C3.2459999999999996" +
+						",7.862067251189333,3.3954979883233536,7.5011471802315972,3.6613225842774746,7.23" +
+						"53225842774753C3.927147180231596,6.9694979883233534,4.2880672511893323,6.8199999" +
+						"999999994,4.664,6.8199999999999994C5.0399327488106671,6.8199999999999994,5.40085" +
+						"2819768402,6.9694979883233525,5.6666774157225239,7.2353225842774744C5.9325020116" +
+						"766458,7.5011471802315963,6.082,7.8620672511893321,6.082,8.238Z\' fill=\'#FFFFFF\'/" +
+						"><path d=\'M5.738,8.32C5.7473263109719372,8.5246196870981574,5.6896629651525714,8" +
+						".72680255254869,5.5738028074769232,8.8957185680352833C5.4579426498012751,9.06463" +
+						"4583521876,5.2900900518845653,9.1912382086891018,5.0958401616400852,9.2562241807" +
+						"484646C4.9015902713956052,9.3212101528078275,4.6913452713291512,9.32109843920524" +
+						",4.4971645512953931,9.2559060746855817C4.3029838312616349,9.1907137101659231,4.1" +
+						"352658696656617,9.0639317797067136,4.0195852842854762,8.89489273513242C3.9039046" +
+						"989052908,8.7258536905581252,3.8464562451664315,8.52360966049571,3.8560000000000" +
+						"012,8.319C3.8672866806518305,8.0770235518863469,3.9714875452736038,7.84848688722" +
+						"41469,4.1467662036622048,7.6812822745027018C4.3220448620508058,7.514077661781256" +
+						"8,4.5552379784036345,7.4207620801857681,4.7974774756673488,7.4208907940525393C5." +
+						"0397169729310631,7.42101950791931,5.2728107912368243,7.5145828509040964,5.447911" +
+						"6624843646,7.6819736376582917C5.623012533731905,7.8493644244124869,5.72697047384" +
+						"01694,8.0780116941781568,5.7380000000000022,8.32Z\' fill=\'#414042\'/><path d=\'M8,9" +
+						".785C7.746,9.785,7.543,9.598,7.543,9.371L7.543,8.062C7.543,7.8359999999999994,7." +
+						"746,7.648,8,7.648C8.254,7.648,8.457,7.8359999999999994,8.457,8.0629999999999988L" +
+						"8.457,9.37C8.457,9.597,8.2540000000000013,9.7839999999999989,8,9.783999999999998" +
+						"9ZM9.918,8.238C9.9179999911246046,8.5374056732570036,10.012827652267077,8.829255" +
+						"2283738654,10.188813887152037,9.07147950938115C10.364800122036996,9.313703790388" +
+						"4359,10.613062177962643,9.4940767366060825,10.897813893980924,9.58659817954297C1" +
+						"1.182565609999205,9.6791196224798561,11.489434390000794,9.6791196224798561,11.77" +
+						"4186106019075,9.58659817954297C12.058937822037354,9.4940767366060825,12.30719987" +
+						"7963,9.3137037903884377,12.48318611284796,9.0714795093811524C12.65917234773292,8" +
+						".8292552283738654,12.754000008875392,8.5374056732570036,12.753999999999998,8.238" +
+						"C12.753999988856084,7.8620672584583895,12.604501995615243,7.5011471983245626,12." +
+						"338677400861151,7.2353226114504094C12.072852806107059,6.9694980245762554,11.7119" +
+						"32741541609,6.8200000420343043,11.335999999999999,6.8200000420343043C10.96006725" +
+						"8458388,6.8200000420343043,10.599147193892938,6.9694980245762554,10.333322599138" +
+						"846,7.2353226114504094C10.067498004384754,7.5011471983245617,9.9180000111439153," +
+						"7.8620672584583895,9.918,8.238Z\' fill=\'#FFFFFF\'/><path d=\'M10.262,8.32C10.252673" +
+						"689028059,8.52461968709816,10.310337034847421,8.7268025525486959,10.426197192523" +
+						"07,8.8957185680352922C10.542057350198718,9.0646345835218884,10.709909948115429,9" +
+						".191238208689116,10.904159838359911,9.25622418074848C11.098409728604393,9.321210" +
+						"1528078453,11.308654728670851,9.32109843920526,11.50283544870461,9.2559060746856" +
+						"C11.69701616873837,9.1907137101659391,11.864734130334345,9.063931779706726,11.98" +
+						"0414715714529,8.8948927351324283C12.096095301094714,8.72585369055813,12.15354375" +
+						"4833573,8.5236096604957119,12.143999999999998,8.319C12.132713319348163,8.0770235" +
+						"518863522,12.028512454726386,7.84848688722416,11.853233796337786,7.6812822745027" +
+						"205C11.677955137949187,7.5140776617812808,11.444762021596361,7.4207620801857965," +
+						"11.202522524332652,7.4208907940525677C10.960283027068943,7.4210195079193388,10.7" +
+						"27189208763187,7.5145828509041213,10.552088337515647,7.6819736376583112C10.37698" +
+						"7466268107,7.8493644244125012,10.27302952615984,8.0780116941781621,10.262,8.32Z\'" +
+						" fill=\'#414042\'/></g></svg>");
+			}
+			
+			/// <summary>Returns the set of theme images for Themed Icon Godot.</summary>
+			public override global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsIdOwner.ThemedIconThemeImage[] GetThemeImages()
+			{
+				return new global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsIdOwner.ThemedIconThemeImage[] {
+						new global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsIdOwner.ThemedIconThemeImage("Default", new global::JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsIdOwner.LoadImageDelegate(this.Load_Default))};
+			}
+		}
+		#endregion
+	}
+}
diff --git a/resharper/src/Application/Settings/GodotSettings.cs b/resharper/src/Application/Settings/GodotSettings.cs
new file mode 100644
index 00000000..2539a697
--- /dev/null
+++ b/resharper/src/Application/Settings/GodotSettings.cs
@@ -0,0 +1,27 @@
+using JetBrains.Application.Settings;
+using JetBrains.ReSharper.Resources.Settings;
+using JetBrains.Rider.Model.Godot.FrontendBackend;
+
+namespace JetBrains.ReSharper.Plugins.Godot.Application.Settings
+{
+    [SettingsKey(typeof(CodeEditingSettings), "Godot plugin settings")]
+    public class GodotSettings
+    {
+        // LSP 
+        [SettingsEntry(LanguageServerConnectionMode.Never, "Different ways to connect LSP")]
+        public LanguageServerConnectionMode LanguageServerConnectionMode;
+
+        [SettingsEntry("127.0.0.1", "RemoteHost")]
+        public string RemoteHost;
+        
+        [SettingsEntry(6005, "Remote host port")]
+        public int RemoteHostPort;
+
+        [SettingsEntry(false, "Use a random free port, supported with Godot 4.3+")]
+        public bool UseDynamicPort;
+        
+        // Debugging
+        [SettingsEntry(true, "Enable debugger extensions")]
+        public bool EnableDebuggerExtensions;
+    }
+}
diff --git a/resharper/src/Settings/SettingsSynchronizer.cs b/resharper/src/Application/Settings/SettingsSynchronizer.cs
similarity index 71%
rename from resharper/src/Settings/SettingsSynchronizer.cs
rename to resharper/src/Application/Settings/SettingsSynchronizer.cs
index fec4586a..6cf157a8 100644
--- a/resharper/src/Settings/SettingsSynchronizer.cs
+++ b/resharper/src/Application/Settings/SettingsSynchronizer.cs
@@ -10,7 +10,7 @@
 using JetBrains.ReSharper.Psi.Util;
 using JetBrains.Rider.Model.Godot.FrontendBackend;
 
-namespace JetBrains.ReSharper.Plugins.Godot.Settings
+namespace JetBrains.ReSharper.Plugins.Godot.Application.Settings
 {
     [SolutionComponent]
     public class SettingsSynchronizer
@@ -23,6 +23,16 @@ public SettingsSynchronizer(Lifetime lifetime, ISolution solution, FrontendBacke
             BindSettingToProperty(lifetime, solution, host, boundStore,
                 (GodotSettings s) => s.EnableDebuggerExtensions,
                 (model, args) => model.BackendSettings.EnableDebuggerExtensions.Value = args.New);
+            
+            BindSettingToProperty(lifetime, solution, host, boundStore,
+                (GodotSettings s) => s.LanguageServerConnectionMode,
+                (model, args) => model.BackendSettings.LspConnectionMode.Value = args.New);
+            BindSettingToProperty(lifetime, solution, host, boundStore,
+                (GodotSettings s) => s.RemoteHostPort,
+                (model, args) => model.BackendSettings.RemoteHostPort.Value = args.New);
+            BindSettingToProperty(lifetime, solution, host, boundStore,
+                (GodotSettings s) => s.UseDynamicPort,
+                (model, args) => model.BackendSettings.UseDynamicPort.Value = args.New);
         }
 
         private static void BindSettingToProperty<TKeyClass, TEntryMemberType>(
diff --git a/resharper/src/Application/UI/Options/GodotOptionsPage.cs b/resharper/src/Application/UI/Options/GodotOptionsPage.cs
new file mode 100644
index 00000000..abba981b
--- /dev/null
+++ b/resharper/src/Application/UI/Options/GodotOptionsPage.cs
@@ -0,0 +1,83 @@
+#nullable enable
+
+using System;
+using System.Linq.Expressions;
+using JetBrains.Application.Settings;
+using JetBrains.Application.UI.Options;
+using JetBrains.Application.UI.Options.OptionsDialog;
+using JetBrains.Application.UI.Options.OptionsDialog.SimpleOptions;
+using JetBrains.Application.UI.Options.OptionsDialog.SimpleOptions.ViewModel;
+using JetBrains.DataFlow;
+using JetBrains.IDE.UI.Options;
+using JetBrains.Lifetimes;
+using JetBrains.ReSharper.Feature.Services.OptionPages.CodeEditing;
+using JetBrains.ReSharper.Plugins.Godot.Application.Settings;
+using JetBrains.Rider.Model.Godot.FrontendBackend;
+using JetBrains.Rider.Model.UIAutomation;
+using JetBrains.UI.ThemedIcons;
+
+namespace JetBrains.ReSharper.Plugins.Godot.Application.UI.Options
+{
+    [OptionsPage(PID, Name, typeof(QydowydThemedIconsThemedIcons.Godot), ParentId = CodeEditingPage.PID, 
+        HelpKeyword = "Settings_Godot_Engine")]
+    public class GodotOptionsPage : BeSimpleOptionsPage
+    {
+        public const string PID = "GodotPluginSettings";
+        public const string Name = "Godot Engine";
+
+        private static readonly Expression<Func<GodotSettings, LanguageServerConnectionMode>> ourLanguageServerConnectionMode =
+            s => s.LanguageServerConnectionMode;
+        
+        private static readonly Expression<Func<GodotSettings, bool>> ourUseDynamicPort = s => s.UseDynamicPort;
+        
+        private static readonly Expression<Func<GodotSettings, int>> ourHostPortAccessor =
+            s => s.RemoteHostPort;
+
+        public GodotOptionsPage(Lifetime lifetime,
+                                OptionsPageContext pageContext,
+                                OptionsSettingsSmartContext settingsStore)
+            : base(lifetime, pageContext, settingsStore)
+        {
+            AddNetworkSection();
+        }
+
+        private void AddNetworkSection()
+        {
+            AddHeader("Network");
+            using (Indent())
+            {
+                AddComboOption((GodotSettings s) => s.LanguageServerConnectionMode,
+                    "Connecting LSP server:", string.Empty, string.Empty,
+                    new RadioOptionPoint(LanguageServerConnectionMode.StartEditorHeadless, "Automatically start headless LSP server"),
+                    // new RadioOptionPoint(LanguageServerConnectionMode.ConnectRunningEditor, "Attempt to connect the running Godot Editor"), // todo: commented because need some tricky waiting and probing the port
+                    new RadioOptionPoint(LanguageServerConnectionMode.Never, "Never use LSP")
+                );
+                AddKeyword("Language server");
+                
+                // AddTextBox(ourHostNameAccessor, "Host"); // host is always localhot, lets not allow changing it.
+                
+                // Godot 4.3 and later
+                var useDynamic = AddBoolOption(ourUseDynamicPort, "Use a random free port (supported in Godot 4.3+)",
+                    toolTipText: "Only supported by the Godot 4.3+");
+
+                var portOption = AddIntOption(ourHostPortAccessor, "Port");
+                
+                // AddBinding(portOption, BindingStyle.IsEnabledProperty, ourUseDynamicPort, enable => !enable);
+                
+                var sourceProperty = OptionsSettingsSmartContext.GetValueProperty(Lifetime, ourUseDynamicPort);
+                sourceProperty
+                    .Change.Advise(Lifetime, () =>
+                    {
+                        // RIDER-104651 Visibility of a BeControl based on other settings works inconsistently
+                        portOption.Enabled.Value = !sourceProperty.Value; // this always works
+                        portOption.Visible.Value = sourceProperty.Value ? ControlVisibility.Collapsed: ControlVisibility.Visible; // this doesn't work initially, but starts working when you change sourceProperty back and forth
+                    });
+                
+                // AddBinding(portOption, BindingStyle.IsEnabledProperty, ourLanguageServerConnectionMode,
+                //     mode => mode is not LanguageServerConnectionMode.Never);
+                AddBinding(useDynamic, BindingStyle.IsEnabledProperty, ourLanguageServerConnectionMode,
+                    mode => mode is LanguageServerConnectionMode.StartEditorHeadless);
+            }
+        }
+    }
+}
diff --git a/resharper/src/ProjectModel/GodotMessagingClient.cs b/resharper/src/ProjectModel/GodotMessagingClient.cs
index aad52b29..cdee4cca 100644
--- a/resharper/src/ProjectModel/GodotMessagingClient.cs
+++ b/resharper/src/ProjectModel/GodotMessagingClient.cs
@@ -3,14 +3,12 @@
 using GodotTools.IdeMessaging;
 using GodotTools.IdeMessaging.Requests;
 using JetBrains.Application.Threading;
-using JetBrains.Application.Threading.Tasks;
 using JetBrains.Collections.Viewable;
 using JetBrains.Lifetimes;
 using JetBrains.ProjectModel;
 using JetBrains.Rd.Base;
 using JetBrains.ReSharper.Feature.Services.Protocol;
 using JetBrains.Rider.Model.Godot.FrontendBackend;
-using JetBrains.Threading;
 using JetBrains.Util;
 using ILogger = JetBrains.Util.ILogger;
 
@@ -30,9 +28,11 @@ public GodotMessagingClient(ISolution solution, ILogger logger, Lifetime lifetim
             myLogger = logger; 
             var model = solution.GetProtocolSolution().GetGodotFrontendBackendModel();
             
-            model.MainProjectBasePath.AdviseOnce(lifetime, baseDir =>
+            model.GodotDescriptor.AdviseOnce(lifetime, descriptor =>
             {
-                myClient = new Client(Identity, baseDir, this, this);
+                if (descriptor.IsPureGdScriptProject) return;
+                
+                myClient = new Client(Identity, descriptor.MainProjectBasePath, this, this);
                 SubscribeConnected(logger, threading, model);
                 SubscribeDisconnected(logger, threading, model); 
                 myClient.Start();
@@ -42,7 +42,7 @@ public GodotMessagingClient(ISolution solution, ILogger logger, Lifetime lifetim
         private void SubscribeDisconnected(ILogger logger, IThreading threading, GodotFrontendBackendModel model)
         {
             // it looks like it subscribes to be called just once
-            myClient.AwaitDisconnected().ContinueWith(task =>
+            myClient.AwaitDisconnected().ContinueWith(_ =>
             {
                 logger.Info("Godot Editor disconnected...");
                 model.EditorState.SetValue(GodotEditorState.Disconnected);
@@ -52,7 +52,7 @@ private void SubscribeDisconnected(ILogger logger, IThreading threading, GodotFr
 
         private void SubscribeConnected(ILogger logger, IThreading threading, GodotFrontendBackendModel model)
         {
-            myClient.AwaitConnected().ContinueWith(task =>
+            myClient.AwaitConnected().ContinueWith(_ =>
             {
                 logger.Info("Godot Editor connected...");
                 model.EditorState.SetValue(GodotEditorState.Connected);
diff --git a/resharper/src/ProjectModel/GodotTracker.cs b/resharper/src/ProjectModel/GodotTracker.cs
index 88fbfaa1..12febbd1 100644
--- a/resharper/src/ProjectModel/GodotTracker.cs
+++ b/resharper/src/ProjectModel/GodotTracker.cs
@@ -15,6 +15,11 @@ public class GodotTracker
         public GodotTracker(ISolution solution, ILogger logger, ISolutionLoadTasksScheduler tasksScheduler)
         {
             var model = solution.GetProtocolSolution().GetGodotFrontendBackendModel();
+            if (solution.SolutionFile == null && solution.SolutionDirectory.Combine("project.godot").ExistsFile)
+            {
+                model.GodotDescriptor.SetValue(new GodotDescriptor(true, solution.SolutionDirectory.FullPath));
+            }
+            
             tasksScheduler.EnqueueTask(new SolutionLoadTask(GetType(),
                 SolutionLoadTaskKinds.Done,
                 () =>
@@ -25,7 +30,7 @@ public GodotTracker(ISolution solution, ILogger logger, ISolutionLoadTasksSchedu
                         if (!file.ExistsFile) continue;
                         MainProjectBasePath = file.Directory;
                         logger.Verbose($"Godot MainProjectBasePath: {file.Directory}");
-                        model.MainProjectBasePath.SetValue(file.Directory.FullPath);
+                        model.GodotDescriptor.SetValue(new GodotDescriptor(false, file.Directory.FullPath));
                         break;
                     }
                 }));
diff --git a/resharper/src/ProjectModel/ProjectExtensions.cs b/resharper/src/ProjectModel/ProjectExtensions.cs
index 7634a804..83fa9ccf 100644
--- a/resharper/src/ProjectModel/ProjectExtensions.cs
+++ b/resharper/src/ProjectModel/ProjectExtensions.cs
@@ -16,4 +16,13 @@ public static bool IsGodotProject([CanBeNull] this IProject project)
                 configuration.DefineConstants.Contains("GODOT;"));
         }
     }
+
+    public static class SolutionExtensions
+    {
+        public static bool IsGdScriptSolution([CanBeNull] this ISolution solution)
+        {
+            if (solution == null || !solution.IsValid()) return false;
+            return solution.SolutionFile == null && solution.SolutionDirectory.Combine("project.godot").ExistsFile;
+        }
+    }
 }
\ No newline at end of file
diff --git a/resharper/src/Settings/GodotSettings.cs b/resharper/src/Settings/GodotSettings.cs
deleted file mode 100644
index fd7a84de..00000000
--- a/resharper/src/Settings/GodotSettings.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using JetBrains.Application.Settings;
-using JetBrains.ReSharper.Resources.Settings;
-
-namespace JetBrains.ReSharper.Plugins.Godot.Settings
-{
-    [SettingsKey(typeof(CodeEditingSettings), "Godot plugin settings")]
-    public class GodotSettings
-    {
-        // Debugging
-        [SettingsEntry(true, "Enable debugger extensions")]
-        public bool EnableDebuggerExtensions;
-    }
-}
diff --git a/resharper/src/UsageStatistics/GodotProjectTechnologyProvider.cs b/resharper/src/UsageStatistics/GodotProjectTechnologyProvider.cs
index be61c3a4..70b1e72d 100644
--- a/resharper/src/UsageStatistics/GodotProjectTechnologyProvider.cs
+++ b/resharper/src/UsageStatistics/GodotProjectTechnologyProvider.cs
@@ -17,4 +17,27 @@ public IEnumerable<string> GetProjectTechnology(IProject project)
             }
         }
     }
+    
+    [SolutionComponent]
+    public class GodotSolutionTechnologyProvider : ISolutionTechnologyProvider
+    {
+        public IEnumerable<string> GetProjectTechnology(IProject project)
+        {
+            if (project.IsGodotProject())
+            {
+                yield return "Godot";
+                yield return "GameDev";
+            }
+        }
+
+        public IEnumerable<string> GetSolutionTechnology(ISolution solution)
+        {
+            if (solution.IsGdScriptSolution())
+            {
+                yield return "Godot";
+                yield return "GameDev";
+                yield return "GDScript";
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/rider/protocol/src/kotlin/model/frontendBackend/GodotFrontendBackendModel.kt b/rider/protocol/src/kotlin/model/frontendBackend/GodotFrontendBackendModel.kt
index 24ee2ef0..d91d6f0c 100644
--- a/rider/protocol/src/kotlin/model/frontendBackend/GodotFrontendBackendModel.kt
+++ b/rider/protocol/src/kotlin/model/frontendBackend/GodotFrontendBackendModel.kt
@@ -23,6 +23,17 @@ object GodotFrontendBackendModel : Ext(SolutionModel.Solution) {
         +"Connected"
     }
 
+    val GodotDescriptor = structdef("GodotDescriptor"){
+        field("isPureGdScriptProject", bool).documentation = "True for pure GdScript project"
+        field("mainProjectBasePath", string).documentation = "Path to the folder with the project.godot"
+    }
+
+    private val LanguageServerConnectionMode = enum {
+        +"Never"
+        +"ConnectRunningEditor"
+        +"StartEditorHeadless"
+    }
+
     init {
         setting(Kotlin11Generator.Namespace, "com.jetbrains.rider.model.godot.frontendBackend")
         setting(CSharp50Generator.Namespace, "JetBrains.Rider.Model.Godot.FrontendBackend")
@@ -34,13 +45,18 @@ object GodotFrontendBackendModel : Ext(SolutionModel.Solution) {
 
         // Misc backend/fronted context
         property("godotPath", string).documentation = "Path to GodotEditor"
-        property("mainProjectBasePath", string).documentation = "Path to the folder with the project.godot"
 
         // Settings stored in the backend
         field("backendSettings", aggregatedef("GodotBackendSettings") {
             property("enableDebuggerExtensions", bool)
+
+            property("lspConnectionMode", LanguageServerConnectionMode)
+            property("remoteHostPort", int)
+            property("useDynamicPort", bool)
         })
 
+        property("godotDescriptor", GodotDescriptor)
+
         property("editorState", GodotEditorState)
     }
 }
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/FrontendBackendHost.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/FrontendBackendHost.kt
index f1e362fb..e498daf8 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/FrontendBackendHost.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/FrontendBackendHost.kt
@@ -95,16 +95,15 @@ class FrontendBackendHost(project: Project) : LifetimedService() {
                 task
             }
 
-            GodotProjectDiscoverer.getInstance(project).godotMonoPath.adviseNotNull(lifetime){
+            GodotProjectDiscoverer.getInstance(project).godot3Path.adviseNotNull(lifetime){
                 model.godotPath.set(it)
             }
 
-            GodotProjectDiscoverer.getInstance(project).godotCorePath.adviseNotNull(lifetime){ s ->
-
+            GodotProjectDiscoverer.getInstance(project).godot4Path.adviseNotNull(lifetime){ s ->
+                // for Godot3 this is done in a separate place
                 RiderDebuggerWorkerModelManager.getModels().adviseNotNull(lifetime){
                     model.backendSettings.enableDebuggerExtensions.flowInto(lifetime,
                         it.value.godotDebuggerWorkerModel.showCustomRenderers)
-
                 }
 
                 model.godotPath.set(s)
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/GodotProjectDiscoverer.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/GodotProjectDiscoverer.kt
index 83c38ebd..eaf4ce4c 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/GodotProjectDiscoverer.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/GodotProjectDiscoverer.kt
@@ -12,7 +12,8 @@ import com.jetbrains.rd.util.lifetime.Lifetime
 import com.jetbrains.rd.util.reactive.IProperty
 import com.jetbrains.rd.util.reactive.Property
 import com.jetbrains.rd.util.reactive.adviseNotNull
-import com.jetbrains.rider.model.godot.frontendBackend.GodotFrontendBackendModel
+import com.jetbrains.rd.util.reactive.flowInto
+import com.jetbrains.rider.model.godot.frontendBackend.*
 import com.jetbrains.rider.plugins.godot.run.GodotRunConfigurationGenerator
 import com.jetbrains.rider.plugins.godot.run.configurations.GodotDebugRunConfiguration
 import com.jetbrains.rider.plugins.godot.run.configurations.GodotDebugRunConfigurationType
@@ -24,18 +25,30 @@ import java.io.File
 @Service(Service.Level.PROJECT)
 class GodotProjectDiscoverer(project: Project) : LifetimedService() {
 
-    val mainProjectBasePath : IProperty<String?> = Property(null)
+    val godotDescriptor : IProperty<GodotDescriptor?> = Property(null)
+    val lspConnectionMode: IProperty<LanguageServerConnectionMode?> = Property(null)
+    val remoteHostPort: IProperty<Int?> = Property(null)
+    val useDynamicPort: IProperty<Boolean?> = Property(null)
     private val logger = Logger.getInstance(GodotProjectDiscoverer::class.java)
-    val godotMonoPath : IProperty<String?> = Property(null)
-    val godotCorePath : IProperty<String?> = Property(null)
+    val godot3Path : IProperty<String?> = Property(null)
+    val godot4Path : IProperty<String?> = Property(null)
+    val godotPath : IProperty<String?> = Property(null)
 
     init {
-        mainProjectBasePath.adviseNotNull(project.lifetime){
-            logger.info("Godot mainProjectBasePath: $it")
-            godotMonoPath.set(
-                MetadataMonoFileWatcher.Util.getFromMonoMetadataPath(it)
-                    ?: MetadataMonoFileWatcher.Util.getGodotPath(it) ?: getGodotPathFromPlayerRunConfiguration(project))
-            godotCorePath.set(MetadataCoreFileWatcher.Util.getGodotPath(it) ?: getGodotPathFromCorePlayerRunConfiguration(project))
+        godot3Path.adviseNotNull(project.lifetime){
+            godotPath.set(it)
+        }
+        godot4Path.adviseNotNull(project.lifetime){
+            godotPath.set(it)
+        }
+
+        godotDescriptor.adviseNotNull(project.lifetime){
+            logger.info("Godot godotDescriptor: $it")
+            val basePath = File(it.mainProjectBasePath)
+            godot3Path.set(
+                MetadataMonoFileWatcher.Util.getFromMonoMetadataPath(basePath)
+                    ?: MetadataMonoFileWatcher.Util.getGodotPath(basePath) ?: getGodotPathFromPlayerRunConfiguration(project))
+            godot4Path.set(MetadataCoreFileWatcher.Util.getGodotPath(basePath) ?: getGodotPathFromCorePlayerRunConfiguration(project))
         }
     }
 
@@ -78,9 +91,10 @@ class GodotProjectDiscoverer(project: Project) : LifetimedService() {
             session: ClientProjectSession,
             model: GodotFrontendBackendModel
         ) {
-            model.mainProjectBasePath.adviseNotNull(lifetime) {
-                getInstance(session.project).mainProjectBasePath.set(it)
-            }
+            model.godotDescriptor.adviseNotNull(lifetime){ getInstance(session.project).godotDescriptor.set(it) }
+            model.backendSettings.lspConnectionMode.adviseNotNull(lifetime){ getInstance(session.project).lspConnectionMode.set(it) }
+            model.backendSettings.remoteHostPort.adviseNotNull(lifetime) { getInstance(session.project).remoteHostPort.set(it) }
+            model.backendSettings.useDynamicPort.adviseNotNull(lifetime) { getInstance(session.project).useDynamicPort.set(it) }
         }
     }
 }
\ No newline at end of file
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataCoreFileWatcher.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataCoreFileWatcher.kt
index 78668a57..427ad2b0 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataCoreFileWatcher.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataCoreFileWatcher.kt
@@ -26,8 +26,7 @@ import kotlin.io.path.isDirectory
 class MetadataCoreFileWatcher : ProjectActivity {
 
     object Util {
-        fun getGodotPath(mainProjectBasePath: String): String? {
-            val projectPath = File(mainProjectBasePath)
+        fun getGodotPath(projectPath: File): String? {
             val projectMetadataCfg = projectPath.resolve(cfgDir).resolve(cfgFileName)
 
             if (projectMetadataCfg.exists()) {
@@ -53,10 +52,11 @@ class MetadataCoreFileWatcher : ProjectActivity {
         withContext(Dispatchers.EDT) {
             project.solution.isLoaded.whenTrue(project.lifetime) {l->
                 val godotDiscoverer = GodotProjectDiscoverer.getInstance(project)
-                godotDiscoverer.mainProjectBasePath.viewNotNull(l) { lt, mainProjectBasePath ->
+                godotDiscoverer.godotDescriptor.viewNotNull(l) { lt, descriptor ->
+                    val mainProjectBaseFile = File(descriptor.mainProjectBasePath)
                     lt.launchBackground {
                         val watchService: WatchService = FileSystems.getDefault().newWatchService()
-                        val metaFileDir = File(mainProjectBasePath).resolve(cfgDir).toPath()
+                        val metaFileDir = mainProjectBaseFile.resolve(cfgDir).toPath()
 
                         withTimeout(Duration.ofMinutes(5)) {
                             while (!(metaFileDir.isDirectory())) {
@@ -81,11 +81,11 @@ class MetadataCoreFileWatcher : ProjectActivity {
                                     val context = event.context() ?: continue
                                     if (context.toString() == cfgFileName) {
                                         logger.info("GodotCoreProjectDiscoverer.getInstance(project).godotPath.set()")
-                                        val newPath = Util.getGodotPath(mainProjectBasePath) ?: continue
+                                        val newPath = Util.getGodotPath(mainProjectBaseFile) ?: continue
                                         logger.info("GodotCoreProjectDiscoverer.getInstance(project).godotPath.set($newPath)")
                                         application.invokeLater {
                                             logger.info("application.invokeLater GodotProjectDiscoverer.getInstance(project).godotPath.set($newPath)")
-                                            GodotProjectDiscoverer.getInstance(project).godotCorePath.set(newPath)
+                                            GodotProjectDiscoverer.getInstance(project).godot4Path.set(newPath)
                                         }
                                     }
                                 }
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataMonoFileWatcher.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataMonoFileWatcher.kt
index feb876c7..c607a87b 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataMonoFileWatcher.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/MetadataMonoFileWatcher.kt
@@ -30,7 +30,7 @@ class MetadataMonoFileWatcher : ProjectActivity {
         //Windows: %APPDATA%\Godot\projects\{PROJECT_NAME}_{MD5_OF_PROJECT_PATH}\
         //macOS: $XDG_DATA_HOME/Godot/projects/{PROJECT_NAME}_{MD5_OF_PROJECT_PATH}/ or $HOME/Library/Application Support/Godot/projects/{PROJECT_NAME}_{MD5_OF_PROJECT_PATH}/
         //Linux: $XDG_DATA_HOME/godot/projects/{PROJECT_NAME}_{MD5_OF_PROJECT_PATH}/ or $HOME/.local/share/godot/projects/{PROJECT_NAME}_{MD5_OF_PROJECT_PATH}/
-        fun getGodotPath(projectPath: String): String? {
+        fun getGodotPath(projectPath: File): String? {
             val projectsSettingsPath = if (SystemInfo.isMac) {
                 val home = Paths.get(System.getenv("HOME"))
                 home.resolve("Library/Application Support/Godot/projects")
@@ -43,8 +43,8 @@ class MetadataMonoFileWatcher : ProjectActivity {
             } else
                 throw Exception("Unexpected OS.")
 
-            val md5 = projectPath.md5()
-            val projectSettingsPath = projectsSettingsPath.resolve("${Paths.get(projectPath).fileName}-$md5")
+            val md5 = projectPath.path.md5()
+            val projectSettingsPath = projectsSettingsPath.resolve("${projectPath.toPath().fileName}-$md5")
             val projectMetadataCfg = projectSettingsPath.resolve("project_metadata.cfg").toFile()
 
             if (projectMetadataCfg.exists()) {
@@ -63,8 +63,7 @@ class MetadataMonoFileWatcher : ProjectActivity {
             return BigInteger(1, md.digest(toByteArray())).toString(16).padStart(32, '0')
         }
 
-        fun getFromMonoMetadataPath(mainProjectBasePath: String): String? {
-            val basePath = File(mainProjectBasePath)
+        fun getFromMonoMetadataPath(basePath: File): String? {
             var metaFile = basePath.resolve(metaFileDir).resolve(metaFileName)
             if (!metaFile.exists())
                 metaFile = basePath.resolve(metaFileDir).resolve(oldMetaFileName)
@@ -92,10 +91,12 @@ class MetadataMonoFileWatcher : ProjectActivity {
         withContext(Dispatchers.EDT) {
             project.solution.isLoaded.whenTrue(project.lifetime) { l ->
                 val godotDiscoverer = GodotProjectDiscoverer.getInstance(project)
-                godotDiscoverer.mainProjectBasePath.viewNotNull(l) { lt, mainProjectBasePath ->
+                godotDiscoverer.godotDescriptor.viewNotNull(l) { lt, descriptor ->
+                    if (descriptor.isPureGdScriptProject) return@viewNotNull
+                    val mainProjectBasePath = File(descriptor.mainProjectBasePath)
                     thread(name = "MetadataFileWatcher") {
                         val watchService: WatchService = FileSystems.getDefault().newWatchService()
-                        val metaFileDir = File(mainProjectBasePath).resolve(metaFileDir).toPath()
+                        val metaFileDir = mainProjectBasePath.resolve(metaFileDir).toPath()
 
                         if (!(metaFileDir.isDirectory()))
                             return@thread
@@ -117,7 +118,7 @@ class MetadataMonoFileWatcher : ProjectActivity {
                                         logger.info("GodotProjectDiscoverer.getInstance(project).godotPath.set($newPath)")
                                         application.invokeLater {
                                             logger.info("application.invokeLater GodotProjectDiscoverer.getInstance(project).godotPath.set($newPath)")
-                                            GodotProjectDiscoverer.getInstance(project).godotMonoPath.set(newPath)
+                                            GodotProjectDiscoverer.getInstance(project).godot3Path.set(newPath)
                                         }
                                     }
                                 }
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/Util.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/Util.kt
new file mode 100644
index 00000000..7f135417
--- /dev/null
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/Util.kt
@@ -0,0 +1,16 @@
+package com.jetbrains.rider.plugins.godot
+
+import com.intellij.openapi.vfs.VirtualFile
+
+class Util {
+    companion object {
+        private const val GD = "gd"
+        private const val TSCN = "tscn"
+        const val GDSCRIPT = "GDScript"
+
+        fun isGdFile(file: VirtualFile?) = isMatchingFile(file, GD)
+        fun isTscnFile(file: VirtualFile?) = isMatchingFile(file, TSCN)
+
+        private fun isMatchingFile(file: VirtualFile?, extension: String) = file?.extension?.equals(extension, true) ?: false
+    }
+}
\ No newline at end of file
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/lang/service/GodotLspServerSupportProvider.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/lang/service/GodotLspServerSupportProvider.kt
new file mode 100644
index 00000000..a89691e5
--- /dev/null
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/lang/service/GodotLspServerSupportProvider.kt
@@ -0,0 +1,149 @@
+package com.jetbrains.rider.plugins.godot.lang.service
+
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.service
+import com.intellij.openapi.diagnostic.thisLogger
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.rd.util.lifetime
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.platform.lsp.api.LspCommunicationChannel
+import com.intellij.platform.lsp.api.LspServerManager
+import com.intellij.platform.lsp.api.LspServerSupportProvider
+import com.intellij.platform.lsp.api.ProjectWideLspServerDescriptor
+import com.intellij.util.ui.update.MergingUpdateQueue
+import com.intellij.util.ui.update.Update
+import com.jetbrains.rd.platform.util.idea.LifetimedService
+import com.jetbrains.rd.util.lifetime.SequentialLifetimes
+import com.jetbrains.rd.util.lifetime.isAlive
+import com.jetbrains.rd.util.reactive.adviseNotNull
+import com.jetbrains.rider.model.godot.frontendBackend.LanguageServerConnectionMode
+import com.jetbrains.rider.plugins.godot.Util
+import com.jetbrains.rider.plugins.godot.GodotProjectDiscoverer
+import com.jetbrains.rider.util.NetUtils
+import java.io.IOException
+import java.net.InetSocketAddress
+import java.net.Socket
+import java.util.concurrent.atomic.AtomicBoolean
+
+@Service(Service.Level.PROJECT)
+class LspProjectService(val project: Project) : LifetimedService() {
+    var isScheduled: AtomicBoolean = AtomicBoolean(false)
+
+    companion object {
+        fun getInstance(project: Project) = project.service<LspProjectService>()
+    }
+
+    val sequentialLifetimes = SequentialLifetimes(project.lifetime)
+    val mergingUpdateQueue: MergingUpdateQueue = MergingUpdateQueue("GodotLspServerSupportProviderMergingUpdateQueue", 1000, true, null).setRestartTimerOnAdd(true)
+    val mergingUpdateQueueAction: Update = object : Update("restartServerIfNeeded") {
+        override fun run() {
+            restartServer(project)
+        }
+    }
+
+    private fun restartServer(project: Project) {
+        LspServerManager.getInstance(project).stopServers(GodotLspServerSupportProvider::class.java)
+        thisLogger().info("startServersIfNeeded")
+        LspServerManager.getInstance(project).startServersIfNeeded(GodotLspServerSupportProvider::class.java)
+    }
+
+    private fun pingSocket(port: Int): Boolean {
+        return try {
+            thisLogger().info("pingSocket1")
+            Socket().use { socket ->
+                thisLogger().info("pingSocket2")
+                socket.connect(InetSocketAddress("127.0.0.1", port))
+                true
+            }
+        } catch (e: IOException) {
+            false
+        }
+    }
+}
+
+class GodotLspServerSupportProvider : LspServerSupportProvider {
+
+    override fun fileOpened(project: Project, file: VirtualFile, serverStarter: LspServerSupportProvider.LspServerStarter) {
+        if (Util.isGdFile(file)) {
+            val discoverer = GodotProjectDiscoverer.getInstance(project)
+            val lspService = LspProjectService.getInstance(project)
+            if (allReady(discoverer)) {
+                thisLogger().info("ensureServerStarted")
+                serverStarter.ensureServerStarted(GodotLspServerDescriptor(project)) // this does not start the server, if fileOpened already ended
+            } else if (lspService.isScheduled.compareAndSet(false, true)) {
+                val lifetime = lspService.sequentialLifetimes.next()
+                project.lifetime.onTerminationIfAlive { if (lifetime.isAlive) lifetime.terminate() }
+                discoverer.lspConnectionMode.adviseNotNull(lifetime) { lspConnectionMode ->
+                    if (lspConnectionMode == LanguageServerConnectionMode.Never) {
+                        LspServerManager.getInstance(project).stopServers(this.javaClass)
+                        return@adviseNotNull
+                    }
+
+                    scheduleStartIfNeeded(project)
+                }
+                discoverer.useDynamicPort.adviseNotNull(lifetime) {
+                    scheduleStartIfNeeded(project)
+                }
+                discoverer.godotDescriptor.adviseNotNull(lifetime) {
+                    scheduleStartIfNeeded(project)
+                }
+                discoverer.godotPath.adviseNotNull(lifetime) {
+                    scheduleStartIfNeeded(project)
+                }
+
+// todo: restore
+//                            if (lspConnectionMode == LanguageServerConnectionMode.ConnectRunningEditor) {
+//                                thisLogger().info("fileOpened6 ${remoteHostPort}")
+//                                project.lifetime.startNonUrgentBackgroundAsync {
+//                                    thisLogger().info("fileOpened7 ${remoteHostPort}")
+//                                    while (!pingSocket(remoteHostPort)) {
+//                                        delay(1000)
+//                                        thisLogger().info("fileOpened - delay")
+//                                    }
+//                                    thisLogger().info("ensureServerStarted1")
+//                                    delay(500)
+//                                    serverStarter.ensureServerStarted(GodotLspServerDescriptor(project))
+//                                }.noAwait()
+//                            }
+            }
+        }
+    }
+
+    private fun allReady(discoverer: GodotProjectDiscoverer) = (
+        discoverer.lspConnectionMode.value != LanguageServerConnectionMode.Never
+            && discoverer.godotPath.value != null
+            && discoverer.remoteHostPort.value != null
+            && discoverer.godotDescriptor.value != null)
+
+    private fun scheduleStartIfNeeded(project: Project) {
+        val lspProjectService = LspProjectService.getInstance(project)
+        val discoverer = GodotProjectDiscoverer.getInstance(project)
+        if (!allReady(discoverer)) return
+        lspProjectService.mergingUpdateQueue.queue(lspProjectService.mergingUpdateQueueAction)
+    }
+
+    private class GodotLspServerDescriptor(project: Project) : ProjectWideLspServerDescriptor(project, "Godot") {
+        val discoverer = GodotProjectDiscoverer.getInstance(project)
+        val lspConnectionMode by lazy { discoverer.lspConnectionMode.value }
+        val remoteHostPort by lazy { if (useDynamicPort!!) NetUtils.findFreePort(500050, setOf()) else discoverer.remoteHostPort.value }
+        val useDynamicPort by lazy { discoverer.useDynamicPort.value }
+
+        override fun isSupportedFile(file: VirtualFile) = Util.isGdFile(file)
+        override fun createCommandLine(): GeneralCommandLine {
+            val basePath = discoverer.godotDescriptor.value?.mainProjectBasePath
+            val godotPath = discoverer.godotPath.value
+            val headlessArg = if (discoverer.godot4Path.value != null) "--headless" else "--no-window"
+            val commandLine = GeneralCommandLine(godotPath, "--path", "$basePath", "--editor", headlessArg, "--lsp-port", remoteHostPort.toString())
+            thisLogger().info("createCommandLine commandLine=$commandLine")
+            return commandLine
+            // https://github.com/godotengine/godot-proposals/issues/7558#issuecomment-1693765359
+        }
+
+        override val lspCommunicationChannel: LspCommunicationChannel
+            get() {
+                thisLogger().info("lspCommunicationChannel port=$remoteHostPort, mode=$lspConnectionMode")
+                return LspCommunicationChannel.Socket(remoteHostPort!!, lspConnectionMode == LanguageServerConnectionMode.StartEditorHeadless)
+            }
+    }
+}
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotDotNetRuntimeAutodetect.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotDotNetRuntimeAutodetect.kt
index 5bf1bae5..af82a077 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotDotNetRuntimeAutodetect.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotDotNetRuntimeAutodetect.kt
@@ -14,7 +14,7 @@ class GodotDotNetRuntimeAutodetect(private val project: Project): DotNetRuntimeA
         if (dotNetCoreRuntime == null)
             return null
 
-        if (GodotProjectDiscoverer.getInstance(project).godotCorePath.value != null)
+        if (GodotProjectDiscoverer.getInstance(project).godot4Path.value != null)
             return RuntimeDetectionResult.create(dotNetCoreRuntime)
 
         return null
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotRunConfigurationGenerator.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotRunConfigurationGenerator.kt
index 4cc20b13..839f25ae 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotRunConfigurationGenerator.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/GodotRunConfigurationGenerator.kt
@@ -3,6 +3,7 @@ package com.jetbrains.rider.plugins.godot.run
 import com.intellij.execution.RunManager
 import com.intellij.execution.configurations.ConfigurationTypeUtil
 import com.intellij.openapi.client.ClientProjectSession
+import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.jetbrains.rd.platform.util.idea.LifetimedService
@@ -18,10 +19,13 @@ import com.jetbrains.rider.plugins.godot.run.configurations.GodotDebugRunConfigu
 import com.jetbrains.rider.projectView.solution
 import com.jetbrains.rider.run.configurations.dotNetExe.DotNetExeConfiguration
 import com.jetbrains.rider.run.configurations.dotNetExe.DotNetExeConfigurationType
+import com.jetbrains.rider.run.configurations.exe.ExeConfiguration
+import com.jetbrains.rider.run.configurations.exe.ExeConfigurationType
 import com.jetbrains.rider.run.configurations.remote.DotNetRemoteConfiguration
 import com.jetbrains.rider.run.configurations.remote.MonoRemoteConfigType
 import com.jetbrains.rider.runtime.dotNetCore.DotNetCoreRuntimeType
 
+@Service
 class GodotRunConfigurationGenerator : LifetimedService() {
 
     companion object {
@@ -38,11 +42,12 @@ class GodotRunConfigurationGenerator : LifetimedService() {
             val project = session.project
             project.solution.isLoaded.whenTrue(lifetime){
                 val godotDiscoverer = GodotProjectDiscoverer.getInstance(project)
-                godotDiscoverer.mainProjectBasePath.viewNotNull(lifetime) { lt, mainProjectBasePath ->
-                    logger.info("isGodotProject = true")
+                godotDiscoverer.godotDescriptor.viewNotNull(lifetime) { lt, descriptor ->
+                    logger.info("descriptor = $descriptor")
+                    val basePath = descriptor.mainProjectBasePath
                     val runManager = RunManager.getInstance(project)
 
-                    GodotProjectDiscoverer.getInstance(project).godotCorePath.advise(lt) { corePath->
+                    GodotProjectDiscoverer.getInstance(project).godot4Path.advise(lt) { corePath->
                         if (corePath != null) {
                             val toRemove = runManager.allSettings.filter {
                                 it.type is MonoRemoteConfigType && it.name == ATTACH_CONFIGURATION_NAME
@@ -63,14 +68,23 @@ class GodotRunConfigurationGenerator : LifetimedService() {
                         }
                     }
 
-                    GodotProjectDiscoverer.getInstance(project).godotMonoPath.adviseNotNull(lt){ path ->
-                        createOrUpdateRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${mainProjectBasePath}\"", runManager, path, project)
-                        createOrUpdateRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${mainProjectBasePath}\" --editor", runManager, path, project)
+                    GodotProjectDiscoverer.getInstance(project).godot3Path.adviseNotNull(lt) { path ->
+                        if (descriptor.isPureGdScriptProject){
+                            createOrUpdateGdScriptRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${basePath}\"", runManager, path, project)
+                            createOrUpdateGdScriptRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${basePath}\" --editor", runManager, path, project)
+                            return@adviseNotNull
+                        }
+                        createOrUpdateRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${basePath}\"", runManager, path, project)
+                        createOrUpdateRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${basePath}\" --editor", runManager, path, project)
                     }
-
-                    GodotProjectDiscoverer.getInstance(project).godotCorePath.adviseNotNull(lt){ path ->
-                        createOrUpdateCoreRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${mainProjectBasePath}\"", runManager, path, project)
-                        createOrUpdateCoreRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${mainProjectBasePath}\" --editor", runManager, path, project)
+                    GodotProjectDiscoverer.getInstance(project).godot4Path.adviseNotNull(lt) { path ->
+                        if (descriptor.isPureGdScriptProject){
+                            createOrUpdateGdScriptRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${basePath}\"", runManager, path, project)
+                            createOrUpdateGdScriptRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${basePath}\" --editor", runManager, path, project)
+                            return@adviseNotNull
+                        }
+                        createOrUpdateCoreRunConfiguration(PLAYER_CONFIGURATION_NAME, "--path \"${basePath}\"", runManager, path, project)
+                        createOrUpdateCoreRunConfiguration(EDITOR_CONFIGURATION_NAME, "--path \"${basePath}\" --editor", runManager, path, project)
                     }
 
                     // make configuration selected if nothing is selected
@@ -91,7 +105,7 @@ class GodotRunConfigurationGenerator : LifetimedService() {
             godotPath: String,
             project: Project
         ) {
-            val configs = runManager.allSettings.filter { it.type is DotNetExeConfiguration && it.name == configurationName }
+            val configs = runManager.allSettings.filter { it.type is DotNetExeConfigurationType && it.name == configurationName }
             if (configs.any()) {
                 configs.forEach{
                     (it.configuration as DotNetExeConfiguration).parameters.exePath = godotPath
@@ -132,5 +146,30 @@ class GodotRunConfigurationGenerator : LifetimedService() {
                 runManager.addConfiguration(runConfiguration)
             }
         }
+
+        private fun createOrUpdateGdScriptRunConfiguration(
+            configurationName: String,
+            programParameters:String,
+            runManager: RunManager,
+            godotPath: String,
+            project: Project
+        ) {
+            val configs = runManager.allSettings.filter { it.type is ExeConfigurationType && it.name == configurationName }
+            if (configs.any()) {
+                configs.forEach{
+                    (it.configuration as ExeConfiguration).parameters.exePath = godotPath
+                }
+            } else {
+                val configurationType = ConfigurationTypeUtil.findConfigurationType(ExeConfigurationType::class.java)
+                val runConfiguration = runManager.createConfiguration(configurationName, configurationType.factory)
+                val config = runConfiguration.configuration as ExeConfiguration
+                config.parameters.exePath = godotPath
+                config.parameters.programParameters = programParameters
+                config.parameters.workingDirectory = "${project.basePath}"
+                config.beforeRunTasks.removeIf { true }
+                runConfiguration.storeInLocalWorkspace()
+                runManager.addConfiguration(runConfiguration)
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducer.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducer.kt
index c4df776d..7d3eee44 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducer.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducer.kt
@@ -8,30 +8,31 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.jetbrains.rdclient.util.idea.toIOFile
 import com.jetbrains.rider.plugins.godot.GodotProjectDiscoverer
+import com.jetbrains.rider.plugins.godot.Util
 import java.io.File
 
 class DebugSceneRunConfigurationProducer : LazyRunConfigurationProducer<GodotDebugRunConfiguration>() {
     companion object{
-        internal fun extractResPath(basePath:String, context: ConfigurationContext): String? {
+        internal fun extractResPath(basePath:File, context: ConfigurationContext): String? {
             val file = getContainingFile(context) ?: return null
-            val relPath = file.virtualFile.toIOFile().relativeTo(File(basePath))
+            val relPath = file.virtualFile.toIOFile().relativeTo(basePath)
             return "res://$relPath"
         }
 
         internal fun getContainingFile(context: ConfigurationContext): PsiFile? {
             val location = context.psiLocation ?: return null
             val file = location.containingFile ?: return null
-            if (file.virtualFile.extension != "tscn") return null
+            if (!Util.isTscnFile(file.virtualFile)) return null
             return file
         }
     }
     override fun getConfigurationFactory() = runConfigurationType<GodotDebugRunConfigurationType>().factory
 
     override fun isConfigurationFromContext(configuration: GodotDebugRunConfiguration, context: ConfigurationContext): Boolean {
-        if (GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value == null) return false
-        if (GodotProjectDiscoverer.getInstance(context.project).godotMonoPath.value == null) return false
+        val basePath = GodotProjectDiscoverer.getInstance(context.project).godotDescriptor.value?.mainProjectBasePath ?: return false
+        if (GodotProjectDiscoverer.getInstance(context.project).godot3Path.value == null) return false
 
-        val resPath = extractResPath(GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value!!, context) ?: return false
+        val resPath = extractResPath(File(basePath), context) ?: return false
         return configuration.parameters.programParameters.contains(resPath)
     }
 
@@ -39,15 +40,16 @@ class DebugSceneRunConfigurationProducer : LazyRunConfigurationProducer<GodotDeb
                                                context: ConfigurationContext,
                                                sourceElement: Ref<PsiElement>): Boolean {
         val file = getContainingFile(context) ?: return false
-        val resPath = extractResPath(GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value!!, context) ?: return false
+        val basePath = GodotProjectDiscoverer.getInstance(context.project).godotDescriptor.value?.mainProjectBasePath ?: return false
+        val resPath = extractResPath(File(basePath), context) ?: return false
 
-        val path = GodotProjectDiscoverer.getInstance(context.project).godotMonoPath.value
+        val path = GodotProjectDiscoverer.getInstance(context.project).godot3Path.value
 
         if (path == null || !File(path).exists()) {
             return false
         }
         configuration.parameters.exePath = path
-        configuration.parameters.programParameters = "--path \"${GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value}\" \"$resPath\""
+        configuration.parameters.programParameters = "--path \"${basePath}\" \"$resPath\""
 
         configuration.parameters.workingDirectory = "${context.project.basePath}"
         configuration.name = file.name
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducerCor.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducerCor.kt
index d2730a98..31f4b013 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducerCor.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/run/configurations/DebugSceneRunConfigurationProducerCor.kt
@@ -8,32 +8,35 @@ import com.intellij.psi.PsiElement
 import com.jetbrains.rider.plugins.godot.GodotProjectDiscoverer
 import com.jetbrains.rider.run.configurations.dotNetExe.DotNetExeConfiguration
 import com.jetbrains.rider.run.configurations.dotNetExe.DotNetExeConfigurationType
+import com.jetbrains.rider.runtime.dotNetCore.DotNetCoreRuntimeType
 import java.io.File
 
 class DebugSceneRunConfigurationProducerCor : LazyRunConfigurationProducer<DotNetExeConfiguration>() {
     override fun getConfigurationFactory() = runConfigurationType<DotNetExeConfigurationType>().factory
 
     override fun isConfigurationFromContext(configuration: DotNetExeConfiguration, context: ConfigurationContext): Boolean {
-        if (GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value == null) return false
-        if (GodotProjectDiscoverer.getInstance(context.project).godotCorePath.value == null) return false
+        val basePath = GodotProjectDiscoverer.getInstance(context.project).godotDescriptor.value?.mainProjectBasePath ?: return false
+        if (GodotProjectDiscoverer.getInstance(context.project).godot4Path.value == null) return false
 
-        val resPath = DebugSceneRunConfigurationProducer.extractResPath(GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value!!, context) ?: return false
+        val resPath = DebugSceneRunConfigurationProducer.extractResPath(File(basePath), context) ?: return false
         return configuration.parameters.programParameters.contains(resPath)
     }
 
     override fun setupConfigurationFromContext(configuration: DotNetExeConfiguration, context: ConfigurationContext, sourceElement: Ref<PsiElement>): Boolean {
         val file = DebugSceneRunConfigurationProducer.getContainingFile(context) ?: return false
-        val resPath = DebugSceneRunConfigurationProducer.extractResPath(GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value!!, context) ?: return false
+        val basePath = GodotProjectDiscoverer.getInstance(context.project).godotDescriptor.value?.mainProjectBasePath ?: return false
+        val resPath = DebugSceneRunConfigurationProducer.extractResPath(File(basePath), context) ?: return false
 
-        val path = GodotProjectDiscoverer.getInstance(context.project).godotCorePath.value
+        val path = GodotProjectDiscoverer.getInstance(context.project).godot4Path.value
 
         if (path == null || !File(path).exists()) {
             return false
         }
         configuration.parameters.exePath = path
-        configuration.parameters.programParameters = "--path \"${GodotProjectDiscoverer.getInstance(context.project).mainProjectBasePath.value}\" \"$resPath\""
+        configuration.parameters.programParameters = "--path \"${File(basePath)}\" \"$resPath\""
 
         configuration.parameters.workingDirectory = "${context.project.basePath}"
+        configuration.parameters.runtimeType = DotNetCoreRuntimeType
         configuration.name = file.name
         return true
     }
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/settings/GodotPluginOptionsPage.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/settings/GodotPluginOptionsPage.kt
new file mode 100644
index 00000000..87438cb3
--- /dev/null
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/settings/GodotPluginOptionsPage.kt
@@ -0,0 +1,13 @@
+package com.jetbrains.rider.plugins.godot.settings
+
+import com.jetbrains.rider.settings.simple.SimpleOptionsPage
+
+class GodotPluginOptionsPage : SimpleOptionsPage("Godot Engine", "GodotPluginSettings") {
+    override fun getId(): String {
+        return "preferences.build.godotPlugin"
+    }
+
+    override fun getHelpTopic(): String {
+        return "Settings_Godot_Engine"
+    }
+}
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GDScriptFileIndentOptionsProvider.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GDScriptFileIndentOptionsProvider.kt
new file mode 100644
index 00000000..8c0434fb
--- /dev/null
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GDScriptFileIndentOptionsProvider.kt
@@ -0,0 +1,23 @@
+package com.jetbrains.rider.plugins.godot.textMate
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.codeStyle.CodeStyleSettings
+import com.intellij.psi.codeStyle.CommonCodeStyleSettings
+import com.intellij.psi.codeStyle.FileIndentOptionsProvider
+import com.jetbrains.rider.plugins.godot.Util
+
+class GdScriptFileIndentOptionsProvider : FileIndentOptionsProvider() {
+    override fun getIndentOptions(
+        project: Project,
+        settings: CodeStyleSettings,
+        file: VirtualFile
+    ): CommonCodeStyleSettings.IndentOptions? {
+        if (Util.isGdFile(file)) {
+            val indentOptions = settings.indentOptions
+            indentOptions.USE_TAB_CHARACTER = true
+            return indentOptions
+        }
+        return null
+    }
+}
\ No newline at end of file
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GdScriptTemplateContextType.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GdScriptTemplateContextType.kt
new file mode 100644
index 00000000..73e15ac2
--- /dev/null
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/textMate/GdScriptTemplateContextType.kt
@@ -0,0 +1,11 @@
+package com.jetbrains.rider.plugins.godot.textMate
+
+import com.intellij.codeInsight.template.TemplateActionContext
+import com.intellij.codeInsight.template.TemplateContextType
+import com.jetbrains.rider.plugins.godot.Util
+
+class GdScriptTemplateContextType : TemplateContextType(Util.GDSCRIPT) {
+
+    override fun isInContext(context: TemplateActionContext): Boolean =
+        Util.isGdFile(context.editor?.virtualFile)
+}
diff --git a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/ui/ToolbarActionsGroup.kt b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/ui/ToolbarActionsGroup.kt
index 4524904e..216149dc 100644
--- a/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/ui/ToolbarActionsGroup.kt
+++ b/rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/ui/ToolbarActionsGroup.kt
@@ -18,7 +18,8 @@ class ToolbarActionsGroup : DefaultActionGroup(), DumbAware, TooltipDescriptionP
             return
         }
 
-        e.presentation.isVisible = GodotProjectDiscoverer.getInstance(project).mainProjectBasePath.value != null
+        val descriptor = GodotProjectDiscoverer.getInstance(project).godotDescriptor.value
+        e.presentation.isVisible = descriptor != null && !descriptor.isPureGdScriptProject
 
         if (e.presentation.isVisible) {
             e.presentation.isEnabled = true
diff --git a/rider/src/main/resources/Icons/Godot.svg b/rider/src/main/resources/Icons/Godot.svg
index d5704442..c1afa90d 100644
--- a/rider/src/main/resources/Icons/Godot.svg
+++ b/rider/src/main/resources/Icons/Godot.svg
@@ -1,13 +1,9 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="16" height="16" viewBox="0 0 16 16" version="1.1">
-<g id="surface1">
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 14.363281 10.519531 C 14.363281 10.519531 14.34375 10.386719 14.328125 10.390625 L 11.976562 10.617188 C 11.789062 10.632812 11.644531 10.785156 11.628906 10.972656 L 11.566406 11.898438 L 9.746094 12.027344 L 9.621094 11.1875 C 9.59375 11 9.429688 10.859375 9.242188 10.859375 L 6.757812 10.859375 C 6.570312 10.859375 6.40625 11 6.378906 11.1875 L 6.253906 12.027344 L 4.433594 11.898438 L 4.371094 10.972656 C 4.355469 10.785156 4.210938 10.632812 4.023438 10.617188 L 1.667969 10.390625 C 1.65625 10.386719 1.648438 10.519531 1.636719 10.519531 L 1.632812 11.027344 L 3.625 11.347656 L 3.691406 12.285156 C 3.707031 12.472656 3.859375 12.625 4.046875 12.640625 L 6.554688 12.820312 C 6.5625 12.820312 6.574219 12.820312 6.582031 12.820312 C 6.769531 12.820312 6.933594 12.679688 6.960938 12.492188 L 7.089844 11.628906 L 8.910156 11.628906 L 9.039062 12.492188 C 9.066406 12.679688 9.230469 12.820312 9.417969 12.820312 C 9.425781 12.820312 9.4375 12.820312 9.445312 12.820312 L 11.953125 12.640625 C 12.140625 12.625 12.292969 12.472656 12.308594 12.285156 L 12.375 11.347656 L 14.367188 11.027344 Z M 14.363281 10.519531 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(27.843137%,54.901961%,74.901961%);fill-opacity:1;" d="M 1.636719 6.679688 L 1.636719 10.519531 C 1.644531 10.519531 1.648438 10.519531 1.65625 10.519531 L 4.011719 10.746094 C 4.132812 10.757812 4.230469 10.855469 4.238281 10.980469 L 4.3125 12.019531 L 6.367188 12.167969 L 6.507812 11.207031 C 6.527344 11.082031 6.632812 10.992188 6.757812 10.992188 L 9.242188 10.992188 C 9.367188 10.992188 9.472656 11.082031 9.492188 11.207031 L 9.632812 12.167969 L 11.6875 12.019531 L 11.761719 10.980469 C 11.769531 10.855469 11.867188 10.757812 11.988281 10.746094 L 14.34375 10.519531 C 14.347656 10.519531 14.355469 10.519531 14.363281 10.519531 L 14.363281 6.679688 L 14.371094 6.679688 C 14.683594 6.28125 14.972656 5.859375 15.25 5.414062 C 14.882812 4.789062 14.433594 4.226562 13.949219 3.710938 C 13.503906 3.933594 13.070312 4.1875 12.660156 4.460938 C 12.457031 4.257812 12.226562 4.089844 12 3.914062 C 11.777344 3.738281 11.523438 3.605469 11.285156 3.453125 C 11.359375 2.925781 11.394531 2.40625 11.40625 1.863281 C 10.792969 1.554688 10.136719 1.347656 9.472656 1.199219 C 9.210938 1.644531 8.96875 2.128906 8.757812 2.597656 C 8.507812 2.554688 8.257812 2.539062 8.003906 2.539062 C 8.003906 2.539062 8 2.539062 8 2.539062 C 8 2.539062 7.996094 2.539062 7.996094 2.539062 C 7.742188 2.539062 7.492188 2.554688 7.242188 2.597656 C 7.03125 2.128906 6.789062 1.644531 6.523438 1.199219 C 5.863281 1.347656 5.207031 1.554688 4.59375 1.863281 C 4.605469 2.40625 4.640625 2.925781 4.714844 3.453125 C 4.476562 3.605469 4.222656 3.738281 4 3.914062 C 3.773438 4.089844 3.542969 4.257812 3.339844 4.460938 C 2.929688 4.1875 2.496094 3.933594 2.050781 3.710938 C 1.566406 4.226562 1.117188 4.789062 0.75 5.414062 C 1.027344 5.859375 1.316406 6.28125 1.628906 6.679688 Z M 1.636719 6.679688 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(27.843137%,54.901961%,74.901961%);fill-opacity:1;" d="M 12.25 11.230469 L 12.179688 12.273438 C 12.167969 12.402344 12.070312 12.5 11.941406 12.511719 L 9.4375 12.6875 C 9.429688 12.6875 9.421875 12.691406 9.417969 12.691406 C 9.292969 12.691406 9.183594 12.597656 9.167969 12.472656 L 9.023438 11.496094 L 6.976562 11.496094 L 6.832031 12.472656 C 6.8125 12.605469 6.695312 12.699219 6.5625 12.6875 L 4.058594 12.511719 C 3.929688 12.5 3.832031 12.402344 3.820312 12.273438 L 3.75 11.230469 L 1.632812 11.027344 C 1.632812 11.253906 1.636719 11.503906 1.636719 11.550781 C 1.636719 13.789062 4.472656 14.863281 7.996094 14.875 L 8.003906 14.875 C 11.527344 14.863281 14.363281 13.789062 14.363281 11.550781 C 14.363281 11.5 14.367188 11.253906 14.367188 11.027344 Z M 12.25 11.230469 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 6.082031 8.238281 C 6.082031 9.019531 5.445312 9.65625 4.664062 9.65625 C 3.878906 9.65625 3.246094 9.019531 3.246094 8.238281 C 3.246094 7.453125 3.878906 6.820312 4.664062 6.820312 C 5.445312 6.820312 6.082031 7.453125 6.082031 8.238281 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(25.490196%,25.098039%,25.882353%);fill-opacity:1;" d="M 5.738281 8.320312 C 5.738281 8.839844 5.320312 9.261719 4.796875 9.261719 C 4.277344 9.261719 3.855469 8.839844 3.855469 8.320312 C 3.855469 7.800781 4.277344 7.378906 4.796875 7.378906 C 5.320312 7.378906 5.738281 7.800781 5.738281 8.320312 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 8 9.785156 C 7.746094 9.785156 7.542969 9.597656 7.542969 9.371094 L 7.542969 8.0625 C 7.542969 7.835938 7.746094 7.648438 8 7.648438 C 8.253906 7.648438 8.457031 7.835938 8.457031 8.0625 L 8.457031 9.371094 C 8.457031 9.597656 8.253906 9.785156 8 9.785156 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;" d="M 9.917969 8.238281 C 9.917969 9.019531 10.554688 9.65625 11.335938 9.65625 C 12.121094 9.65625 12.753906 9.019531 12.753906 8.238281 C 12.753906 7.453125 12.121094 6.820312 11.335938 6.820312 C 10.554688 6.820312 9.917969 7.453125 9.917969 8.238281 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:rgb(25.490196%,25.098039%,25.882353%);fill-opacity:1;" d="M 10.261719 8.320312 C 10.261719 8.839844 10.679688 9.261719 11.203125 9.261719 C 11.722656 9.261719 12.144531 8.839844 12.144531 8.320312 C 12.144531 7.800781 11.722656 7.378906 11.203125 7.378906 C 10.679688 7.378906 10.261719 7.800781 10.261719 8.320312 "/>
-</g>
+<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
+  <path fill="#fff" d="M14.363 10.52s-.02-.133-.035-.13l-2.351.227a.385.385 0 0 0-.348.356l-.063.925-1.82.13-.125-.84a.386.386 0 0 0-.379-.329H6.758a.386.386 0 0 0-.38.329l-.124.84-1.82-.13-.063-.925a.385.385 0 0 0-.348-.356l-2.355-.226c-.012-.004-.02.129-.031.129l-.004.507 1.992.32.066.938c.016.188.168.34.356.356l2.508.18h.027a.386.386 0 0 0 .379-.329l.129-.863h1.82l.13.863a.386.386 0 0 0 .378.328h.027l2.508-.18a.392.392 0 0 0 .356-.355l.066-.937 1.992-.32Zm0 0"/>
+  <path fill="#478cbf" d="M1.637 6.68v3.84h.02l2.355.226c.12.012.218.11.226.234l.074 1.04 2.055.148.14-.961a.252.252 0 0 1 .25-.215h2.485c.125 0 .23.09.25.215l.14.961 2.056-.148.074-1.04a.251.251 0 0 1 .226-.234l2.356-.226h.02V6.68h.007c.313-.399.602-.82.879-1.266a9.626 9.626 0 0 0-1.3-1.703c-.446.223-.88.477-1.29.75-.203-.203-.433-.371-.66-.547-.223-.176-.477-.309-.715-.46.074-.528.11-1.048.121-1.59a8.326 8.326 0 0 0-1.933-.665c-.262.446-.504.93-.715 1.399-.25-.043-.5-.059-.754-.059h-.008c-.254 0-.504.016-.754.059a13.58 13.58 0 0 0-.719-1.399 8.36 8.36 0 0 0-1.93.664c.012.543.048 1.063.122 1.59-.238.152-.492.285-.715.461-.227.176-.457.344-.66.547-.41-.274-.844-.527-1.29-.75a9.626 9.626 0 0 0-1.3 1.703c.277.445.566.867.879 1.266Zm0 0"/>
+  <path fill="#478cbf" d="m12.25 11.23-.07 1.043a.26.26 0 0 1-.239.239l-2.504.175c-.007 0-.015.004-.019.004a.253.253 0 0 1-.25-.218l-.145-.977H6.977l-.145.977a.25.25 0 0 1-.27.214l-2.503-.175a.26.26 0 0 1-.239-.239l-.07-1.043-2.117-.203c0 .227.004.477.004.524 0 2.238 2.836 3.312 6.36 3.324h.007c3.523-.012 6.36-1.086 6.36-3.324 0-.051.003-.297.003-.524Zm0 0"/>
+  <path fill="#fff" d="M6.082 8.238a1.418 1.418 0 1 1-2.836 0 1.418 1.418 0 0 1 2.836 0"/>
+  <path fill="#414042" d="M5.738 8.32a.942.942 0 1 1-1.882-.001.942.942 0 0 1 1.882.001"/>
+  <path fill="#fff" d="M8 9.785c-.254 0-.457-.187-.457-.414V8.062c0-.226.203-.414.457-.414s.457.188.457.415V9.37c0 .227-.203.414-.457.414m1.918-1.546a1.418 1.418 0 1 0 2.836 0 1.418 1.418 0 0 0-2.836 0"/>
+  <path fill="#414042" d="M10.262 8.32a.942.942 0 1 0 1.882-.001.942.942 0 0 0-1.882.001"/>
 </svg>
diff --git a/rider/src/main/resources/META-INF/plugin.xml b/rider/src/main/resources/META-INF/plugin.xml
index 95367815..bbcb2ed9 100644
--- a/rider/src/main/resources/META-INF/plugin.xml
+++ b/rider/src/main/resources/META-INF/plugin.xml
@@ -20,6 +20,8 @@
   </extensions>
 
   <extensions defaultExtensionNs="com.intellij">
+    <liveTemplateContext contextId="GDSCRIPT" implementation="com.jetbrains.rider.plugins.godot.textMate.GdScriptTemplateContextType" order="first" />
+    <defaultLiveTemplates file="templates/GdScript.xml" />
 
     <postStartupActivity implementation="com.jetbrains.rider.plugins.godot.MetadataMonoFileWatcher"/>
     <postStartupActivity implementation="com.jetbrains.rider.plugins.godot.MetadataCoreFileWatcher"/>
@@ -28,7 +30,6 @@
     <rd.solutionExtListener endpoint="IDE Frontend"
                             listener="com.jetbrains.rider.plugins.godot.FrontendBackendHost$ProtocolListener"/>
 
-    <projectService serviceImplementation="com.jetbrains.rider.plugins.godot.run.GodotRunConfigurationGenerator"/>
     <rd.solutionExtListener endpoint="IDE Frontend"
                             listener="com.jetbrains.rider.plugins.godot.run.GodotRunConfigurationGenerator$ProtocolListener"/>
 
@@ -36,6 +37,18 @@
                             listener="com.jetbrains.rider.plugins.godot.GodotProjectDiscoverer$ProtocolListener"/>
 
     <rider.runtime.dotNetRuntimeAutodetect implementation="com.jetbrains.rider.plugins.godot.run.GodotDotNetRuntimeAutodetect"/>
+
+    <!-- Options pages -->
+    <applicationConfigurable groupId="language"
+                             id="preferences.build.godotPlugin"
+                             instance="com.jetbrains.rider.plugins.godot.settings.GodotPluginOptionsPage"
+                             displayName="Godot Engine"/>
+
+    <platform.lsp.serverSupportProvider
+      implementation="com.jetbrains.rider.plugins.godot.lang.service.GodotLspServerSupportProvider"/>
+    <fileIndentOptionsProvider
+      implementation="com.jetbrains.rider.plugins.godot.textMate.GdScriptFileIndentOptionsProvider"
+      id="GdScriptFileIndentOptionsProvider"/>
   </extensions>
 
 
diff --git a/rider/src/main/resources/templates/GdScript.xml b/rider/src/main/resources/templates/GdScript.xml
new file mode 100644
index 00000000..82dcc55a
--- /dev/null
+++ b/rider/src/main/resources/templates/GdScript.xml
@@ -0,0 +1,74 @@
+<templateSet group="GDScript">
+
+  <template name="for" value="for $VAR$ in $ITERABLE$:&#10;&#9;$END$" description="for loop" toReformat="false">
+    <variable name="ITERABLE" expression="" alwaysStopAt="true" />
+    <variable name="VAR" expression="" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true" />
+    </context>
+  </template>
+  <template name="forrange" value="for $VAR$ in range($RANGE_START$, $RANGE_END$):&#10;&#9;$END$"
+            description="for range loop" toReformat="false">
+    <variable name="RANGE_START" alwaysStopAt="true" />
+    <variable name="RANGE_END" alwaysStopAt="true" />
+    <variable name="VAR" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true" />
+    </context>
+  </template>
+  <template name="while" value="while $CONDITION$:&#10;&#9;$END$" description="while">
+    <variable name="CONDITION" expression="condition()" defaultValue="expr" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true" />
+    </context>
+  </template>
+  <template name="if" value="if $CONDITION$:&#10;&#9;$END$" description="if" toReformat="false">
+    <variable name="CONDITION" expression="" defaultValue="expr" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true"/>
+    </context>
+  </template>
+  <template name="print" value="print($END$)" description="Print messages to console" toReformat="false">
+    <context>
+      <option name="GDSCRIPT" value="true"/>
+    </context>
+  </template>
+  <template name="func" value="func $NAME$($ARGS$):&#10;&#9;$END$" description="define function" toReformat="false">
+    <variable name="NAME" defaultValue="name" alwaysStopAt="true" />
+    <variable name="ARGS" defaultValue="args" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true"/>
+    </context>
+  </template>
+  <template name="signal" value="signal $NAME$($ARGS$)" description="signal declaration">
+    <variable name="NAME" expression="" alwaysStopAt="true" />
+    <variable name="ARGS" expression="" alwaysStopAt="true" />
+    <context>
+      <option name="GDSCRIPT" value="true"/>
+    </context>
+  </template>
+
+
+<!--  <template name="Inner class" value="class $1 extends ${2:Reference}&#10;&#9;$3" description="Inner class"/>-->
+<!--  <template name="if elif else"-->
+<!--            value="if ${1:condition}:&#10;&#9;${3:pass}&#10;elif ${2:condition}:&#10;&#9;${4:pass}&#10;else:&#10;&#9;${5:pass}"-->
+<!--            description="if elif else"/>-->
+<!--  <template name="if else" value="if ${1:condition}:&#10;&#9;${2:pass}&#10;else:&#10;&#9;${3:pass}"-->
+<!--            description="if else"/>-->
+<!--  <template name="match"-->
+<!--            value="match ${1:expression}:&#10;&#9;${2:pattern}:&#10;&#9;&#9;${3}&#10;\t_:\n\t\t${0:default}"-->
+<!--            description="match"/>-->
+<!--  <template name="var" value="var ${1:name}${2: = default}${3: setget }" description="define variables"/>-->
+<!--  <template name="export"-->
+<!--            value="export(${1:type}${2:,other_configs}) var ${3:name}${4: = default}${5: setget }"-->
+<!--            description="export variables"/>-->
+<!--  <template name="var" value="var ${1:name}${2: = default}${3: setget }" description="define variables"/>-->
+<!--  <template name="onready" value="onready var ${1:name} = get_node($2)"-->
+<!--            description="define onready variables"/>-->
+<!--  <template name="Is instance of a class or script" value="${1:instance} is ${2:class}"-->
+<!--            description="Is instance of a class or script"/>-->
+<!--  <template name="element in array" value="${1:element} in ${$2:array}" description="element in array"/>-->
+<!--  <template name="GDScript template"-->
+<!--            value="extends ${1:BaseClass}&#10;&#10;# class member variables go here, for example:&#10;# var a = 2&#10;# var b = &quot;textvar&quot;&#10;&#10;func _ready():&#10;&#9;# Called every time the node is added to the scene.&#10;&#9;# Initialization here&#10;&#9;pass&#10;"-->
+<!--            description="GDScript template"/>-->
+</templateSet>