diff --git a/CHANGELOG.md b/CHANGELOG.md
index 528f564..d586d47 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,14 @@
-> 📣 &nbsp;&nbsp;Announcement:
->
-> * The language server, `gopls`, will be enabled by default in the next release. ([Issue 1037](https://github.com/golang/vscode-go/issues/1037)). Please test and provide us your feedback on the `#vscode-dev` [Gophers Slack](https://gophers.slack.com/) channel.
->
-> * Some workspace or folder-level settings that affect tools location will not be used by default until users explicitly opt in by running `Go: Toggle Workspace Trust Flag`. See [Issue 1094](https://github.com/golang/vscode-go/issues/1094) for more information.
+## v0.22.0 - 26th Jan, 2021
+
+- The language server, `gopls`, is enabled by default. ([Issue 1037](https://github.com/golang/vscode-go/issues/1037))
+
+### Enhancements
+- Added the new Go welcome page. ([Issue 949](https://github.com/golang/vscode-go/issues/949))
+- Updated documentation. (troubleshooting, customization, settings guide)
+- Updated the hardcoded latest gopls version to 0.6.4.
+
+### Thanks
+Thank you for your contribution, @suzmue, @stamblerre, @findleyr, @heschik, @hyangah!
 
 ## v0.21.1 - 21st Jan, 2021
 A list of all issues and changes can be found in the [v0.21.1 milestone](https://github.com/golang/vscode-go/milestone/22?closed=1).
diff --git a/README.md b/README.md
index 45ad02a..f323bf9 100644
--- a/README.md
+++ b/README.md
@@ -6,9 +6,9 @@
 
 [The VS Code Go extension](https://marketplace.visualstudio.com/items?itemName=golang.go) provides rich language support for the [Go programming language](https://golang.org/).
 
-> 📣 We will enable the language server ([`gopls`]) by default in the end of Jan 2021.
-> We recommend switching to the language server now (`"go.useLanguageServer": true`) to confirm it works well for you.
-> Please [file a new issue](https://github.com/golang/vscode-go/issues/new/choose) if you notice bugs or missing features.
+> 📣 Gopls, the official Go language server, is now enabled in VS Code by default.
+> Gopls replaces several legacy tools to provide IDE features while editing Go code.
+> See [issue 1037](https://github.com/golang/vscode-go/issues/1037) for more information.
 
 ## Quick Start
 
