diff --git a/VSFSharpExtension.sln b/VSFSharpExtension.sln
index a4e19ff2fae..126e0cf5476 100644
--- a/VSFSharpExtension.sln
+++ b/VSFSharpExtension.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
+# Visual Studio Version 18
+VisualStudioVersion = 18.0.10806.39 main
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{B4A1E626-4A48-4977-B291-219882DB3413}"
 EndProject
@@ -17,6 +17,8 @@ Project("{6EC3EE1D-3C4E-46DD-8F32-0CC8E7565705}") = "FSharp.DependencyManager.Nu
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FSharp.Editor", "vsintegration\src\FSharp.Editor\FSharp.Editor.fsproj", "{3D4A95CB-1563-CD9A-3949-FE01922CD5BD}"
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FSharp.Compiler.LanguageServer.Tests", "tests\FSharp.Compiler.LanguageServer.Tests\FSharp.Compiler.LanguageServer.Tests.fsproj", "{ECB3A7E8-824B-6769-6A01-754555E89E27}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -61,6 +63,12 @@ Global
 		{3D4A95CB-1563-CD9A-3949-FE01922CD5BD}.Proto|Any CPU.Build.0 = Debug|Any CPU
 		{3D4A95CB-1563-CD9A-3949-FE01922CD5BD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3D4A95CB-1563-CD9A-3949-FE01922CD5BD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Proto|Any CPU.ActiveCfg = Debug|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Proto|Any CPU.Build.0 = Debug|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ECB3A7E8-824B-6769-6A01-754555E89E27}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/FSharp.Compiler.LanguageServer/Common/CapabilitiesManager.fs b/src/FSharp.Compiler.LanguageServer/Common/CapabilitiesManager.fs
index 556a1d96edc..d85debebb1b 100644
--- a/src/FSharp.Compiler.LanguageServer/Common/CapabilitiesManager.fs
+++ b/src/FSharp.Compiler.LanguageServer/Common/CapabilitiesManager.fs
@@ -31,21 +31,9 @@ type CapabilitiesManager(config: FSharpLanguageServerConfig, scOverrides: IServe
                         InterFileDependencies = true,
                         Identifier = "potato",
                         WorkspaceDiagnostics = true
-                    )),
+                    ))
             //CompletionProvider = CompletionOptions(TriggerCharacters = [| "."; " " |], ResolveProvider = true, WorkDoneProgress = true),
             //HoverProvider = SumType<bool, HoverOptions>(HoverOptions(WorkDoneProgress = true))
-            SemanticTokensOptions =
-                addIf
-                    config.EnabledFeatures.SemanticHighlighting
-
-                    (SemanticTokensOptions(
-                        Legend =
-                            SemanticTokensLegend(
-                                TokenTypes = (SemanticTokenTypes.AllTypes |> Seq.toArray), // XXX should be extended
-                                TokenModifiers = (SemanticTokenModifiers.AllModifiers |> Seq.toArray)
-                            ),
-                        Range = false
-                    ))
         )
 
     interface IInitializeManager<InitializeParams, InitializeResult> with
diff --git a/src/FSharp.Compiler.LanguageServer/Common/FSharpRequestContext.fs b/src/FSharp.Compiler.LanguageServer/Common/FSharpRequestContext.fs
index fd096d3e582..2ca2d10ddc3 100644
--- a/src/FSharp.Compiler.LanguageServer/Common/FSharpRequestContext.fs
+++ b/src/FSharp.Compiler.LanguageServer/Common/FSharpRequestContext.fs
@@ -17,150 +17,11 @@ open FSharp.Compiler.CodeAnalysis.Workspace
 
 #nowarn "57"
 
-module TokenTypes =
-
-    [<return: Struct>]
-    let (|LexicalClassification|_|) (tok: FSharpToken) =
-        if tok.IsKeyword then
-            ValueSome SemanticTokenTypes.Keyword
-        elif tok.IsNumericLiteral then
-            ValueSome SemanticTokenTypes.Number
-        elif tok.IsCommentTrivia then
-            ValueSome SemanticTokenTypes.Comment
-        elif tok.IsStringLiteral then
-            ValueSome SemanticTokenTypes.String
-        else
-            ValueNone
-
-    // Tokenizes the source code and returns a list of token ranges and their SemanticTokenTypes
-    let GetSyntacticTokenTypes (source: FSharp.Compiler.Text.ISourceText) (fileName: string) =
-        let mutable tokRangesAndTypes = []
-
-        let tokenCallback =
-            fun (tok: FSharpToken) ->
-                match tok with
-                | LexicalClassification tokType -> tokRangesAndTypes <- (tok.Range, tokType) :: tokRangesAndTypes
-                | _ -> ()
-
-        FSharpLexer.Tokenize(
-            source,
-            tokenCallback,
-            flags =
-                (FSharpLexerFlags.Default
-                 &&& ~~~FSharpLexerFlags.Compiling
-                 &&& ~~~FSharpLexerFlags.UseLexFilter),
-            filePath = fileName
-        )
-
-        tokRangesAndTypes
-
-    let FSharpTokenTypeToLSP (fst: SemanticClassificationType) =
-        // XXX kinda arbitrary mapping
-        match fst with
-        | SemanticClassificationType.ReferenceType -> SemanticTokenTypes.Class
-        | SemanticClassificationType.ValueType -> SemanticTokenTypes.Struct
-        | SemanticClassificationType.UnionCase -> SemanticTokenTypes.Enum
-        | SemanticClassificationType.UnionCaseField -> SemanticTokenTypes.EnumMember
-        | SemanticClassificationType.Function -> SemanticTokenTypes.Function
-        | SemanticClassificationType.Property -> SemanticTokenTypes.Property
-        | SemanticClassificationType.Module -> SemanticTokenTypes.Type
-        | SemanticClassificationType.Namespace -> SemanticTokenTypes.Namespace
-        | SemanticClassificationType.Interface -> SemanticTokenTypes.Interface
-        | SemanticClassificationType.TypeArgument -> SemanticTokenTypes.TypeParameter
-        | SemanticClassificationType.Operator -> SemanticTokenTypes.Operator
-        | SemanticClassificationType.Method -> SemanticTokenTypes.Method
-        | SemanticClassificationType.ExtensionMethod -> SemanticTokenTypes.Method
-        | SemanticClassificationType.Field -> SemanticTokenTypes.Property
-        | SemanticClassificationType.Event -> SemanticTokenTypes.Event
-        | SemanticClassificationType.Delegate -> SemanticTokenTypes.Function
-        | SemanticClassificationType.NamedArgument -> SemanticTokenTypes.Parameter
-        | SemanticClassificationType.LocalValue -> SemanticTokenTypes.Variable
-        | SemanticClassificationType.Plaintext -> SemanticTokenTypes.String
-        | SemanticClassificationType.Type -> SemanticTokenTypes.Type
-        | SemanticClassificationType.Printf -> SemanticTokenTypes.Keyword
-        | _ -> SemanticTokenTypes.Comment
-
-    let toIndex (x: string) =
-        SemanticTokenTypes.AllTypes |> Seq.findIndex (fun y -> y = x)
-
 type FSharpRequestContext(lspServices: ILspServices, logger: ILspLogger, workspace: FSharpWorkspace) =
     member _.LspServices = lspServices
     member _.Logger = logger
     member _.Workspace = workspace
 
-    member this.GetSemanticTokensForFile(file) =
-        task {
-            let! scv = this.Workspace.Query.GetSemanticClassification file
-            let! source = this.Workspace.Query.GetSource file
-
-            match scv, source with
-            | Some view, Some source ->
-
-                let tokens = ResizeArray()
-
-                view.ForEach(fun item ->
-                    let range = item.Range
-                    let tokenType = item.Type |> TokenTypes.FSharpTokenTypeToLSP |> TokenTypes.toIndex
-                    tokens.Add(range, tokenType))
-
-                let syntacticClassifications =
-                    TokenTypes.GetSyntacticTokenTypes source file.LocalPath
-                    |> Seq.map (fun (r, t) -> (r, TokenTypes.toIndex t))
-
-                let allTokens = Seq.append tokens syntacticClassifications
-
-                let lspFormatTokens =
-                    allTokens
-                    |> Seq.map (fun (r, tokType) ->
-                        let length = r.EndColumn - r.StartColumn // XXX Does not deal with multiline tokens?
-
-                        {|
-                            startLine = r.StartLine - 1
-                            startCol = r.StartColumn
-                            length = length
-                            tokType = tokType
-                            tokMods = 0
-                        |})
-                    //(startLine, startCol, length, tokType, tokMods))
-                    |> Seq.sortWith (fun x1 x2 ->
-                        let c = x1.startLine.CompareTo(x2.startLine)
-                        if c <> 0 then c else x1.startCol.CompareTo(x2.startCol))
-
-                let tokensRelative =
-                    lspFormatTokens
-                    |> Seq.append
-                        [|
-                            {|
-                                startLine = 0
-                                startCol = 0
-                                length = 0
-                                tokType = 0
-                                tokMods = 0
-                            |}
-                        |]
-                    |> Seq.pairwise
-                    |> Seq.map (fun (prev, this) ->
-                        {|
-                            startLine = this.startLine - prev.startLine
-                            startCol =
-                                (if prev.startLine = this.startLine then
-                                     this.startCol - prev.startCol
-                                 else
-                                     this.startCol)
-                            length = this.length
-                            tokType = this.tokType
-                            tokMods = this.tokMods
-                        |})
-
-                return
-                    tokensRelative
-                    |> Seq.map (fun tok -> [| tok.startLine; tok.startCol; tok.length; tok.tokType; tok.tokMods |])
-                    |> Seq.concat
-                    |> Seq.toArray
-
-            | _ -> return [||]
-        }
-
 type ContextHolder(workspace, lspServices: ILspServices) =
 
     let logger = lspServices.GetRequiredService<ILspLogger>()
diff --git a/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs b/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs
index 3aadb29b2b7..459b8530dc0 100644
--- a/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs
+++ b/src/FSharp.Compiler.LanguageServer/FSharpLanguageServer.fs
@@ -1,10 +1,12 @@
 namespace FSharp.Compiler.LanguageServer
 
+open System
+open System.Diagnostics
 open System.Runtime.CompilerServices
+
 open FSharp.Compiler.LanguageServer.Common
 open FSharp.Compiler.LanguageServer.Handlers
 
-open System
 open Microsoft.CommonLanguageServerProtocol.Framework.Handlers
 open Microsoft.CommonLanguageServerProtocol.Framework
 open Microsoft.Extensions.DependencyInjection
@@ -12,7 +14,6 @@ open Microsoft.VisualStudio.LanguageServer.Protocol
 
 open StreamJsonRpc
 open Nerdbank.Streams
-open System.Diagnostics
 open FSharp.Compiler.CodeAnalysis.Workspace
 
 #nowarn "57"
diff --git a/src/FSharp.Compiler.LanguageServer/FSharpLanguageServerConfig.fs b/src/FSharp.Compiler.LanguageServer/FSharpLanguageServerConfig.fs
index a1acd2b88da..4e599902aa0 100644
--- a/src/FSharp.Compiler.LanguageServer/FSharpLanguageServerConfig.fs
+++ b/src/FSharp.Compiler.LanguageServer/FSharpLanguageServerConfig.fs
@@ -3,13 +3,11 @@ namespace FSharp.Compiler.LanguageServer
 type FSharpLanguageServerFeatures =
     {
         Diagnostics: bool
-        SemanticHighlighting: bool
     }
 
     static member Default =
         {
             Diagnostics = true
-            SemanticHighlighting = true
         }
 
 type FSharpLanguageServerConfig =
diff --git a/src/FSharp.Compiler.LanguageServer/Handlers/LanguageFeaturesHandler.fs b/src/FSharp.Compiler.LanguageServer/Handlers/LanguageFeaturesHandler.fs
index 474758924d0..48f1fa38351 100644
--- a/src/FSharp.Compiler.LanguageServer/Handlers/LanguageFeaturesHandler.fs
+++ b/src/FSharp.Compiler.LanguageServer/Handlers/LanguageFeaturesHandler.fs
@@ -48,12 +48,3 @@ type LanguageFeaturesHandler() =
                     )
             }
             |> CancellableTask.start cancellationToken
-
-    interface IRequestHandler<SemanticTokensParams, SemanticTokens, FSharpRequestContext> with
-        [<LanguageServerEndpoint(Methods.TextDocumentSemanticTokensFullName, LanguageServerConstants.DefaultLanguageName)>]
-        member _.HandleRequestAsync(request: SemanticTokensParams, context: FSharpRequestContext, cancellationToken: CancellationToken) =
-            cancellableTask {
-                let! tokens = context.GetSemanticTokensForFile(request.TextDocument.Uri)
-                return SemanticTokens(Data = tokens)
-            }
-            |> CancellableTask.start cancellationToken
diff --git a/src/FSharp.Compiler.LanguageServer/Utils.fs b/src/FSharp.Compiler.LanguageServer/Utils.fs
index c5283b6fb76..031c46e6bb6 100644
--- a/src/FSharp.Compiler.LanguageServer/Utils.fs
+++ b/src/FSharp.Compiler.LanguageServer/Utils.fs
@@ -47,9 +47,16 @@ type FSharpDiagnosticExtensions =
 
     [<Extension>]
     static member ToLspDiagnostic(this: FSharpDiagnostic) =
+        let severity =
+            match this.Severity with
+            | FSharpDiagnosticSeverity.Error -> DiagnosticSeverity.Error
+            | FSharpDiagnosticSeverity.Warning -> DiagnosticSeverity.Warning
+            | FSharpDiagnosticSeverity.Info -> DiagnosticSeverity.Information
+            // TODO consider not emitting this diagnostic if severity is Hidden
+            | FSharpDiagnosticSeverity.Hidden -> DiagnosticSeverity.Hint
         Diagnostic(
             Range = this.Range.ToLspRange(),
-            Severity = DiagnosticSeverity.Error,
+            Severity = severity,
             Message = $"LSP: {this.Message}",
             //Source = "Intellisense",
             Code = SumType<int, _> this.ErrorNumberText
diff --git a/src/FSharp.VisualStudio.Extension/.vsextension/string-resources.json b/src/FSharp.VisualStudio.Extension/.vsextension/string-resources.json
index 5f1633293d7..5e669b53287 100644
--- a/src/FSharp.VisualStudio.Extension/.vsextension/string-resources.json
+++ b/src/FSharp.VisualStudio.Extension/.vsextension/string-resources.json
@@ -1,4 +1,10 @@
 {
-  "FSharpLspExtension.FSharpLanguageServerProvider.DisplayName": "FSharp Analyzer LSP server"
-
+  "FSharpLspExtension.FSharpLanguageServerProvider.DisplayName": "FSharp Analyzer LSP server",
+  "F#": "F# LSP",
+  "FSharpSettings.Old": "Old extension (devenv process)",
+  "FSharpSettings.Both": "Both extensions",
+  "FSharpSettings.LSP": "LSP (separate process)",
+  "FSharpSettings.Unset": "Default",
+  "FSharpSettings.GetDiagnosticsFrom": "Get diagnostics from",
+  "FSharpSettings.GetDiagnosticsFrom.Description": "Which extension provides diagnostics (restart required)"
 }
diff --git a/src/FSharp.VisualStudio.Extension/ExtensionEntrypoint.cs b/src/FSharp.VisualStudio.Extension/ExtensionEntrypoint.cs
index ba47320b925..6611bace471 100644
--- a/src/FSharp.VisualStudio.Extension/ExtensionEntrypoint.cs
+++ b/src/FSharp.VisualStudio.Extension/ExtensionEntrypoint.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using System;
 using Extension = Microsoft.VisualStudio.Extensibility.Extension;
+using System.Diagnostics;
 
 /// <summary>
 /// Extension entrypoint for the VisualStudio.Extensibility extension.
@@ -21,7 +22,11 @@ internal class ExtensionEntrypoint : Extension
                 version: this.ExtensionAssemblyVersion,
                 publisherName: "Publisher name",
                 displayName: "FSharp.VisualStudio.Extension",
-                description: "Extension description"),
+                description: "Extension description")
+        {
+            // TODO: Probably should be replaced by a range of versions
+            InstallationTargetVersion = "[17.14, 18.0]",
+        },
     };
 
     /// <inheritdoc />
diff --git a/src/FSharp.VisualStudio.Extension/FSharp.VisualStudio.Extension.csproj b/src/FSharp.VisualStudio.Extension/FSharp.VisualStudio.Extension.csproj
index fae776deb73..386d3104091 100644
--- a/src/FSharp.VisualStudio.Extension/FSharp.VisualStudio.Extension.csproj
+++ b/src/FSharp.VisualStudio.Extension/FSharp.VisualStudio.Extension.csproj
@@ -4,16 +4,18 @@
 		<Nullable>enable</Nullable>
 		<LangVersion>12</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
+		<CreateVsixContainer>false</CreateVsixContainer>
+		<AssemblyVSIXSubPath>LSPComponent</AssemblyVSIXSubPath>
 		<!-- The VisualStudio.Extensibility preview packages are available from the azure-public/vside/msft_consumption feed -->
 
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.VisualStudio.Extensibility.Sdk" Version="17.13.39620" />
-		<PackageReference Include="Microsoft.VisualStudio.Extensibility.Build" Version="17.13.39620" />
+		<PackageReference Include="Microsoft.VisualStudio.Extensibility.Sdk" Version="17.14.40313" />
+		<PackageReference Include="Microsoft.VisualStudio.Extensibility.Build" Version="17.14.40313" />
 		<PackageReference Include="Microsoft.VisualStudio.LanguageServer.Protocol.Internal" Version="17.13.9" />
-		<PackageReference Include="Microsoft.VisualStudio.ProjectSystem.Query" Version="17.13.66" />
-		<PackageReference Include="Microsoft.VisualStudio.Threading" Version="17.13.2" />
+		<PackageReference Include="Microsoft.VisualStudio.ProjectSystem.Query" Version="17.14.143" />
+		<PackageReference Include="Microsoft.VisualStudio.Threading" Version="$(MicrosoftVisualStudioThreadingVersion)" />
 		<!--<PackageReference Include="Microsoft.VisualStudio.OpenTelemetry.ClientExtensions" Version="0.1.718-beta" />
 		<PackageReference Include="Microsoft.VisualStudio.OpenTelemetry.Collector" Version="0.1.718-beta" />
 		<PackageReference Include="OpenTelemetry" Version="1.10.0" />
diff --git a/src/FSharp.VisualStudio.Extension/FSharpExtensionSettings.cs b/src/FSharp.VisualStudio.Extension/FSharpExtensionSettings.cs
index edc3e7adcff..9279500ef93 100644
--- a/src/FSharp.VisualStudio.Extension/FSharpExtensionSettings.cs
+++ b/src/FSharp.VisualStudio.Extension/FSharpExtensionSettings.cs
@@ -32,24 +32,12 @@ internal static class FSharpExtensionSettings
             ExtensionChoice,
             defaultValue: UNSET)
         {
-            Description = "%Which extension should be used to provide diagnostics%",
-        };
-
-        [VisualStudioContribution]
-        public static Setting.Enum GetSemanticHighlightingFrom { get; } = new(
-            "getSemanticHighlightingFrom",
-            "%FSharpSettings.GetSemanticHighlightingFrom%",
-            FSharpCategory,
-            ExtensionChoice,
-            defaultValue: UNSET)
-        {
-            Description = "%Which extension should be used to provide semantic highlighting%",
+            Description = "%FSharpSettings.GetDiagnosticsFrom.Description%",
         };
 
         public static Setting<string>[] AllStringSettings { get; } =
         [
             GetDiagnosticsFrom,
-            GetSemanticHighlightingFrom,
         ];
     }
 }
diff --git a/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs b/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs
index c4f90a7ca1d..3d75128b572 100644
--- a/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs
+++ b/src/FSharp.VisualStudio.Extension/FSharpLanguageServerProvider.cs
@@ -47,14 +47,14 @@ public ServerCapabilities OverrideServerCapabilities(FSharpLanguageServerConfig
         var capabilities = new VSInternalServerCapabilities
         {
             TextDocumentSync = value.TextDocumentSync,
-            SupportsDiagnosticRequests = true,
+            SupportsDiagnosticRequests = config.EnabledFeatures.Diagnostics,
             ProjectContextProvider = true,
             DiagnosticProvider =
                 config.EnabledFeatures.Diagnostics ?
 
             new()
             {
-                SupportsMultipleContextsDiagnostics = true,
+                SupportsMultipleContextsDiagnostics = false,
                 DiagnosticKinds = [
                         // Support a specialized requests dedicated to task-list items.  This way the client can ask just
                         // for these, independently of other diagnostics.  They can also throttle themselves to not ask if
@@ -72,20 +72,6 @@ public ServerCapabilities OverrideServerCapabilities(FSharpLanguageServerConfig
                         //new(PullDiagnosticCategories.DocumentAnalyzerSemantic),
                     ]
             } : null,
-            SemanticTokensOptions = config.EnabledFeatures.SemanticHighlighting ? new()
-            {
-                Legend = new()
-                {
-                    TokenTypes = [.. SemanticTokenTypes.AllTypes], // XXX should be extended
-                    TokenModifiers = [.. SemanticTokenModifiers.AllModifiers]
-                },
-                Full = new SemanticTokensFullOptions()
-                {
-                    Delta = false
-                },
-                Range = false
-            } : null,
-            //,
             //HoverProvider = new HoverOptions()
             //{
             //    WorkDoneProgress = true
@@ -291,8 +277,7 @@ await this.Extensibility.Settings().WriteAsync(batch =>
 
         var serverConfig = new FSharpLanguageServerConfig(
             new FSharpLanguageServerFeatures(
-                diagnostics: enabled.Contains(settingsReadResult.ValueOrDefault(FSharpExtensionSettings.GetDiagnosticsFrom, defaultValue: FSharpExtensionSettings.BOTH)),
-                semanticHighlighting: enabled.Contains(settingsReadResult.ValueOrDefault(FSharpExtensionSettings.GetSemanticHighlightingFrom, defaultValue: FSharpExtensionSettings.BOTH))
+                diagnostics: enabled.Contains(settingsReadResult.ValueOrDefault(FSharpExtensionSettings.GetDiagnosticsFrom, defaultValue: FSharpExtensionSettings.BOTH))
                 ));
 
         var disposeToEndSubscription =
diff --git a/tests/FSharp.Compiler.LanguageServer.Tests/Protocol.fs b/tests/FSharp.Compiler.LanguageServer.Tests/Protocol.fs
index 9072fbfb460..07d7ff552e6 100644
--- a/tests/FSharp.Compiler.LanguageServer.Tests/Protocol.fs
+++ b/tests/FSharp.Compiler.LanguageServer.Tests/Protocol.fs
@@ -154,34 +154,6 @@ let ``Basic server workflow`` () =
         )
     }
 
-[<Fact>]
-let ``Full semantic tokens`` () =
-
-    task {
-        let! client = initializeLanguageServer None
-        let workspace = client.Workspace
-        let contentOnDisk = "let x = 1"
-        let fileOnDisk = sourceFileOnDisk contentOnDisk
-        let _projectIdentifier =
-            workspace.Projects.AddOrUpdate(ProjectConfig.Create(), [ fileOnDisk.LocalPath ])
-        do!
-            client.JsonRpc.NotifyAsync(
-                Methods.TextDocumentDidOpenName,
-                DidOpenTextDocumentParams(
-                    TextDocument = TextDocumentItem(Uri = fileOnDisk, LanguageId = "F#", Version = 1, Text = contentOnDisk)
-                )
-            )
-        let! semanticTokensResponse =
-            client.JsonRpc.InvokeAsync<SemanticTokens>(
-                Methods.TextDocumentSemanticTokensFullName,
-                SemanticTokensParams(TextDocument = TextDocumentIdentifier(Uri = fileOnDisk))
-            )
-
-        let expected = [| 0; 0; 0; 1; 0; 0; 0; 3; 15; 0; 0; 4; 1; 17; 0; 0; 4; 1; 19; 0 |]
-
-        Assert.Equal<int array>(expected, semanticTokensResponse.Data)
-    }
-
 [<Fact>]
 let ``Shutdown and exit`` () =
     task {
diff --git a/vsintegration/Vsix/VisualFSharpFull/Source.extension.vsixmanifest b/vsintegration/Vsix/VisualFSharpFull/Source.extension.vsixmanifest
index f805558824b..893a538ab34 100644
--- a/vsintegration/Vsix/VisualFSharpFull/Source.extension.vsixmanifest
+++ b/vsintegration/Vsix/VisualFSharpFull/Source.extension.vsixmanifest
@@ -8,7 +8,7 @@
     <PackageId>Microsoft.FSharp.VSIX.Full.Core</PackageId>
     <MoreInfo>https://learn.microsoft.com/dotnet/articles/fsharp/</MoreInfo>
   </Metadata>
-  <Installation Experimental="true">
+  <Installation Experimental="true" ExtensionType="VSSDK+VisualStudio.Extensibility">
     <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[|%CurrentProject%;GetVSGeneralVersion|,)">
       <ProductArchitecture>amd64</ProductArchitecture>
     </InstallationTarget>
diff --git a/vsintegration/Vsix/VisualFSharpFull/VisualFSharp.Core.targets b/vsintegration/Vsix/VisualFSharpFull/VisualFSharp.Core.targets
index 674c3487ac7..a61439a7e12 100644
--- a/vsintegration/Vsix/VisualFSharpFull/VisualFSharp.Core.targets
+++ b/vsintegration/Vsix/VisualFSharpFull/VisualFSharp.Core.targets
@@ -24,6 +24,10 @@
     </Content>
   </ItemGroup>
 
+  <ItemGroup>
+    <VSIXSourceItem Include="$(ArtifactsBinDir)\FSharp.VisualStudio.Extension\$(Configuration)\net8.0-windows\.vsextension\extension.json" VsixSubPath=".vsextension" ExtensionMetadata="true" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(FSharpSourcesRoot)\FSharp.Build\FSharp.Build.fsproj">
       <Project>{702A7979-BCF9-4C41-853E-3ADFC9897890}</Project>
@@ -127,6 +131,15 @@
       <Private>True</Private>
     </ProjectReference>
 
+
+    <ProjectReference Include="$(FSharpSourcesRoot)\FSharp.VisualStudio.Extension\FSharp.VisualStudio.Extension.csproj">
+      <Name>FSharp.VisualStudio.Extension</Name>
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+      <SkipGetTargetFrameworkProperties>true</SkipGetTargetFrameworkProperties>
+      <IncludeInVSIX>true</IncludeInVSIX>
+      <IncludeOutputGroupsInVSIX>ExtensionFilesOutputGroup</IncludeOutputGroupsInVSIX>
+    </ProjectReference>
+
     <ProjectReference Include="$(FSharpSourcesRoot)\..\vsintegration\src\FSharp.UIResources\FSharp.UIResources.csproj">
       <Project>{c4586a06-1402-48bc-8e35-a1b8642f895b}</Project>
       <Name>FSharp.UIResources</Name>
diff --git a/vsintegration/src/FSharp.Editor/Classification/ClassificationService.fs b/vsintegration/src/FSharp.Editor/Classification/ClassificationService.fs
index e6e07761a75..84c94a85a41 100644
--- a/vsintegration/src/FSharp.Editor/Classification/ClassificationService.fs
+++ b/vsintegration/src/FSharp.Editor/Classification/ClassificationService.fs
@@ -32,9 +32,6 @@ type SemanticClassificationLookup = IReadOnlyDictionary<int, ResizeArray<Semanti
 [<Export(typeof<IFSharpClassificationService>)>]
 type internal FSharpClassificationService [<ImportingConstructor>] () =
 
-    static let shouldProduceClassification (document: Document) =
-        document.Project.Solution.GetFSharpExtensionConfig().ShouldProduceSemanticHighlighting()
-
     static let getLexicalClassifications (filePath: string, defines, text: SourceText, textSpan: TextSpan, ct: CancellationToken) =
 
         let text = text.GetSubText(textSpan)
@@ -155,153 +152,145 @@ type internal FSharpClassificationService [<ImportingConstructor>] () =
             (document: Document, textSpan: TextSpan, result: List<ClassifiedSpan>, cancellationToken: CancellationToken)
             =
 
-            if not (document |> shouldProduceClassification) then
-                System.Threading.Tasks.Task.CompletedTask
-            else
-
-                cancellableTask {
-                    use _logBlock = Logger.LogBlock(LogEditorFunctionId.Classification_Syntactic)
-
-                    let! cancellationToken = CancellableTask.getCancellationToken ()
-
-                    let defines, langVersion, strictIndentation = document.GetFsharpParsingOptions()
-
-                    let! sourceText = document.GetTextAsync(cancellationToken)
-
-                    // For closed documents, only get classification for the text within the span.
-                    // This may be inaccurate for multi-line tokens such as string literals, but this is ok for now
-                    //     as it's better than having to tokenize a big part of a file which in return will allocate a lot and hurt find all references performance.
-                    let isOpenDocument = document.Project.Solution.Workspace.IsDocumentOpen document.Id
-
-                    let eventProps: (string * obj) array =
-                        [|
-                            "context.document.project.id", document.Project.Id.Id.ToString()
-                            "context.document.id", document.Id.Id.ToString()
-                            "isOpenDocument", isOpenDocument
-                            "textSpanLength", textSpan.Length
-                        |]
-
-                    use _eventDuration =
-                        TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSyntacticClassifications, eventProps)
-
-                    if not isOpenDocument then
-                        let classifiedSpans =
-                            getLexicalClassifications (document.FilePath, defines, sourceText, textSpan, cancellationToken)
-
-                        result.AddRange(classifiedSpans)
-                    else
-                        Tokenizer.classifySpans (
-                            document.Id,
-                            sourceText,
-                            textSpan,
-                            Some(document.FilePath),
-                            defines,
-                            Some langVersion,
-                            strictIndentation,
-                            result,
-                            cancellationToken
-                        )
-                }
-                |> CancellableTask.startAsTask cancellationToken
+            cancellableTask {
+                use _logBlock = Logger.LogBlock(LogEditorFunctionId.Classification_Syntactic)
+
+                let! cancellationToken = CancellableTask.getCancellationToken ()
+
+                let defines, langVersion, strictIndentation = document.GetFsharpParsingOptions()
+
+                let! sourceText = document.GetTextAsync(cancellationToken)
+
+                // For closed documents, only get classification for the text within the span.
+                // This may be inaccurate for multi-line tokens such as string literals, but this is ok for now
+                //     as it's better than having to tokenize a big part of a file which in return will allocate a lot and hurt find all references performance.
+                let isOpenDocument = document.Project.Solution.Workspace.IsDocumentOpen document.Id
+
+                let eventProps: (string * obj) array =
+                    [|
+                        "context.document.project.id", document.Project.Id.Id.ToString()
+                        "context.document.id", document.Id.Id.ToString()
+                        "isOpenDocument", isOpenDocument
+                        "textSpanLength", textSpan.Length
+                    |]
+
+                use _eventDuration =
+                    TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSyntacticClassifications, eventProps)
+
+                if not isOpenDocument then
+                    let classifiedSpans =
+                        getLexicalClassifications (document.FilePath, defines, sourceText, textSpan, cancellationToken)
+
+                    result.AddRange(classifiedSpans)
+                else
+                    Tokenizer.classifySpans (
+                        document.Id,
+                        sourceText,
+                        textSpan,
+                        Some(document.FilePath),
+                        defines,
+                        Some langVersion,
+                        strictIndentation,
+                        result,
+                        cancellationToken
+                    )
+            }
+            |> CancellableTask.startAsTask cancellationToken
 
         member _.AddSemanticClassificationsAsync
             (document: Document, textSpan: TextSpan, result: List<ClassifiedSpan>, cancellationToken: CancellationToken)
             =
 
-            if not (document |> shouldProduceClassification) then
-                System.Threading.Tasks.Task.CompletedTask
-            else
-
-                cancellableTask {
-                    use _logBlock = Logger.LogBlock(LogEditorFunctionId.Classification_Semantic)
-
-                    let! sourceText = document.GetTextAsync(cancellationToken)
-
-                    // If we are trying to get semantic classification for a document that is not open, get the results from the background and cache it.
-                    // We do this for find all references when it is populating results.
-                    // We cache it temporarily so we do not have to continuously call into the checker and perform a background operation.
-                    let isOpenDocument = document.Project.Solution.Workspace.IsDocumentOpen document.Id
-
-                    if not isOpenDocument then
-                        match! unopenedDocumentsSemanticClassificationCache.TryGetValueAsync document with
-                        | ValueSome classificationDataLookup ->
-                            let eventProps: (string * obj) array =
-                                [|
-                                    "context.document.project.id", document.Project.Id.Id.ToString()
-                                    "context.document.id", document.Id.Id.ToString()
-                                    "isOpenDocument", isOpenDocument
-                                    "textSpanLength", textSpan.Length
-                                    "cacheHit", true
-                                |]
-
-                            use _eventDuration =
-                                TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
-
-                            addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
-                        | ValueNone ->
-                            let eventProps: (string * obj) array =
-                                [|
-                                    "context.document.project.id", document.Project.Id.Id.ToString()
-                                    "context.document.id", document.Id.Id.ToString()
-                                    "isOpenDocument", isOpenDocument
-                                    "textSpanLength", textSpan.Length
-                                    "cacheHit", false
-                                |]
-
-                            use _eventDuration =
-                                TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
-
-                            let! classificationData = document.GetFSharpSemanticClassificationAsync(nameof (FSharpClassificationService))
-
-                            let classificationDataLookup = toSemanticClassificationLookup classificationData
+            cancellableTask {
+                use _logBlock = Logger.LogBlock(LogEditorFunctionId.Classification_Semantic)
+
+                let! sourceText = document.GetTextAsync(cancellationToken)
+
+                // If we are trying to get semantic classification for a document that is not open, get the results from the background and cache it.
+                // We do this for find all references when it is populating results.
+                // We cache it temporarily so we do not have to continuously call into the checker and perform a background operation.
+                let isOpenDocument = document.Project.Solution.Workspace.IsDocumentOpen document.Id
+
+                if not isOpenDocument then
+                    match! unopenedDocumentsSemanticClassificationCache.TryGetValueAsync document with
+                    | ValueSome classificationDataLookup ->
+                        let eventProps: (string * obj) array =
+                            [|
+                                "context.document.project.id", document.Project.Id.Id.ToString()
+                                "context.document.id", document.Id.Id.ToString()
+                                "isOpenDocument", isOpenDocument
+                                "textSpanLength", textSpan.Length
+                                "cacheHit", true
+                            |]
+
+                        use _eventDuration =
+                            TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
+
+                        addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
+                    | ValueNone ->
+                        let eventProps: (string * obj) array =
+                            [|
+                                "context.document.project.id", document.Project.Id.Id.ToString()
+                                "context.document.id", document.Id.Id.ToString()
+                                "isOpenDocument", isOpenDocument
+                                "textSpanLength", textSpan.Length
+                                "cacheHit", false
+                            |]
+
+                        use _eventDuration =
+                            TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
+
+                        let! classificationData = document.GetFSharpSemanticClassificationAsync(nameof (FSharpClassificationService))
+
+                        let classificationDataLookup = toSemanticClassificationLookup classificationData
+                        do! unopenedDocumentsSemanticClassificationCache.SetAsync(document, classificationDataLookup)
+                        addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
+                else
+
+                    match! openedDocumentsSemanticClassificationCache.TryGetValueAsync document with
+                    | ValueSome classificationDataLookup ->
+                        let eventProps: (string * obj) array =
+                            [|
+                                "context.document.project.id", document.Project.Id.Id.ToString()
+                                "context.document.id", document.Id.Id.ToString()
+                                "isOpenDocument", isOpenDocument
+                                "textSpanLength", textSpan.Length
+                                "cacheHit", true
+                            |]
+
+                        use _eventDuration =
+                            TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
+
+                        addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
+                    | ValueNone ->
+
+                        let eventProps: (string * obj) array =
+                            [|
+                                "context.document.project.id", document.Project.Id.Id.ToString()
+                                "context.document.id", document.Id.Id.ToString()
+                                "isOpenDocument", isOpenDocument
+                                "textSpanLength", textSpan.Length
+                                "cacheHit", false
+                            |]
+
+                        use _eventDuration =
+                            TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
+
+                        let! _, checkResults = document.GetFSharpParseAndCheckResultsAsync(nameof (IFSharpClassificationService))
+
+                        let targetRange =
+                            RoslynHelpers.TextSpanToFSharpRange(document.FilePath, textSpan, sourceText)
+
+                        let classificationData = checkResults.GetSemanticClassification(Some targetRange)
+
+                        if classificationData.Length > 0 then
+                            let classificationDataLookup = itemToSemanticClassificationLookup classificationData
                             do! unopenedDocumentsSemanticClassificationCache.SetAsync(document, classificationDataLookup)
-                            addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
-                    else
 
-                        match! openedDocumentsSemanticClassificationCache.TryGetValueAsync document with
-                        | ValueSome classificationDataLookup ->
-                            let eventProps: (string * obj) array =
-                                [|
-                                    "context.document.project.id", document.Project.Id.Id.ToString()
-                                    "context.document.id", document.Id.Id.ToString()
-                                    "isOpenDocument", isOpenDocument
-                                    "textSpanLength", textSpan.Length
-                                    "cacheHit", true
-                                |]
-
-                            use _eventDuration =
-                                TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
-
-                            addSemanticClassificationByLookup sourceText textSpan classificationDataLookup result
-                        | ValueNone ->
-
-                            let eventProps: (string * obj) array =
-                                [|
-                                    "context.document.project.id", document.Project.Id.Id.ToString()
-                                    "context.document.id", document.Id.Id.ToString()
-                                    "isOpenDocument", isOpenDocument
-                                    "textSpanLength", textSpan.Length
-                                    "cacheHit", false
-                                |]
-
-                            use _eventDuration =
-                                TelemetryReporter.ReportSingleEventWithDuration(TelemetryEvents.AddSemanticClassifications, eventProps)
-
-                            let! _, checkResults = document.GetFSharpParseAndCheckResultsAsync(nameof (IFSharpClassificationService))
-
-                            let targetRange =
-                                RoslynHelpers.TextSpanToFSharpRange(document.FilePath, textSpan, sourceText)
-
-                            let classificationData = checkResults.GetSemanticClassification(Some targetRange)
-
-                            if classificationData.Length > 0 then
-                                let classificationDataLookup = itemToSemanticClassificationLookup classificationData
-                                do! unopenedDocumentsSemanticClassificationCache.SetAsync(document, classificationDataLookup)
-
-                                addSemanticClassification sourceText textSpan classificationData result
-                }
-                |> CancellableTask.ifCanceledReturn ()
-                |> CancellableTask.startAsTask cancellationToken
+                            addSemanticClassification sourceText textSpan classificationData result
+            }
+            |> CancellableTask.ifCanceledReturn ()
+            |> CancellableTask.startAsTask cancellationToken
 
         // Do not perform classification if we don't have project options (#defines matter)
         member _.AdjustStaleClassification(_: SourceText, classifiedSpan: ClassifiedSpan) : ClassifiedSpan = classifiedSpan
diff --git a/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs b/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
index b7f7ed3d4cf..d7335255868 100644
--- a/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
+++ b/vsintegration/src/FSharp.Editor/Diagnostics/DocumentDiagnosticAnalyzer.fs
@@ -2,7 +2,8 @@
 
 namespace Microsoft.VisualStudio.FSharp.Editor
 
-open System.Composition
+open System
+open System.ComponentModel.Composition
 open System.Collections.Immutable
 open System.Collections.Generic
 open System.Threading
@@ -12,9 +13,12 @@ open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.Diagnostics
 
+open Microsoft.VisualStudio.Shell
 open FSharp.Compiler.Diagnostics
 open CancellableTasks
 open Microsoft.VisualStudio.FSharp.Editor.Telemetry
+open Microsoft.VisualStudio.Settings
+open Microsoft.Internal.VisualStudio.Shell.Interop
 
 [<Struct; NoComparison; NoEquality; RequireQualifiedAccess>]
 type internal DiagnosticsType =
@@ -22,10 +26,30 @@ type internal DiagnosticsType =
     | Semantic
 
 [<Export(typeof<IFSharpDocumentDiagnosticAnalyzer>)>]
-type internal FSharpDocumentDiagnosticAnalyzer [<ImportingConstructor>] () =
+type internal FSharpDocumentDiagnosticAnalyzer
+    [<ImportingConstructor>]
+    (
+        [<Import(typeof<SVsServiceProvider>)>] serviceProvider: IServiceProvider
+    ) =
+
+    //let settingsReader : Microsoft.VisualStudio.Utilities.UnifiedSettings.ISettingsReader =
+    let produceDiagnostic =
+        let settingsManager = serviceProvider.GetService(typeof<SVsUnifiedSettingsManager>) :?> Microsoft.VisualStudio.Utilities.UnifiedSettings.ISettingsManager
+        let reader = settingsManager.GetReader()
+        let settingValue = reader.GetValueOrThrow<string>("fsharp.getDiagnosticsFrom")
+        match settingValue with
+        | "both"
+        | "old" -> true
+        | "unset"
+        | "lsp" -> false
+        | _ -> failwithf "Unexpected value for 'fsharp.getDiagnosticsFrom': %s" settingValue
+
+
+    let shouldProduceDiagnostics (_document: Document) =
+        //let value = settingsReader.GetValueOrThrow<string>("fsharp.getDiagnosticsFrom")
+        // TODO XXX cast it to enum?
+        produceDiagnostic
 
-    let shouldProduceDiagnostics (document: Document) =
-        document.Project.Solution.GetFSharpExtensionConfig().ShouldProduceDiagnostics()
 
     static let diagnosticEqualityComparer =
         { new IEqualityComparer<FSharpDiagnostic> with
diff --git a/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs b/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
index 518bf88bc74..add4d6410c0 100644
--- a/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
+++ b/vsintegration/src/FSharp.Editor/LanguageService/WorkspaceExtensions.fs
@@ -38,7 +38,6 @@ module internal SolutionConfigCache =
     type FSharpExtensionConfig =
         {
             GetDiagnosticsFrom: string
-            GetSemanticHighlightingFrom: string
         }
 
         static member Old = "old"
@@ -48,14 +47,11 @@ module internal SolutionConfigCache =
         static member Default =
             {
                 GetDiagnosticsFrom = FSharpExtensionConfig.Both
-                GetSemanticHighlightingFrom = FSharpExtensionConfig.Both
             }
 
         member this.ShouldProduceDiagnostics() =
             Set.contains this.GetDiagnosticsFrom (set [ FSharpExtensionConfig.Old; FSharpExtensionConfig.Both ])
 
-        member this.ShouldProduceSemanticHighlighting() =
-            Set.contains this.GetSemanticHighlightingFrom (set [ FSharpExtensionConfig.Old; FSharpExtensionConfig.Both ])
 
     let readFSharpExtensionConfig (solutionPath: string) =
         if String.IsNullOrEmpty(solutionPath) then
@@ -72,7 +68,6 @@ module internal SolutionConfigCache =
 
                     {
                         GetDiagnosticsFrom = jObject["fsharp.getDiagnosticsFrom"].ToString().ToLower()
-                        GetSemanticHighlightingFrom = jObject["fsharp.getSemanticHighlightingFrom"].ToString().ToLower()
                     }
                 with ex ->
                     System.Diagnostics.Trace.TraceError($"Error reading FSharpExtensionConfig from {configFilePath}", ex)