diff --git a/tools/goplssetting/main.go b/tools/goplssetting/main.go
new file mode 100644
index 0000000..5ce729b
--- /dev/null
+++ b/tools/goplssetting/main.go
@@ -0,0 +1,279 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Licensed under the MIT License.
+// See LICENSE in the project root for license information.
+
+// This command updates the gopls.* configurations in vscode-go package.json.
+//
+//   Usage: from the project root directory,
+//      $ go run tools/goplssetting -in ./package.json -out ./package.json
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"sort"
+	"strings"
+)
+
+var (
+	inPkgJSON  = flag.String("in", "", "input package.json location")
+	outPkgJSON = flag.String("out", "", "output package.json location. If empty, output to the standard output.")
+
+	work = flag.Bool("w", false, "if true, do not delete intermediate files")
+)
+
+func main() {
+	flag.Parse()
+
+	if *inPkgJSON == "" {
+		log.Fatalf("-in file must be specified %q %q", *inPkgJSON, *outPkgJSON)
+	}
+	if _, err := os.Stat(*inPkgJSON); err != nil {
+		log.Fatalf("failed to find input package.json (%q): %v", *inPkgJSON, err)
+	}
+
+	out, err := run(*inPkgJSON)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if *outPkgJSON != "" {
+		if err := ioutil.WriteFile(*outPkgJSON, out, 0644); err != nil {
+			log.Fatalf("writing jq output to %q failed: %v", out, err)
+		}
+	} else {
+		fmt.Printf("%s", out)
+	}
+}
+
+// run
+func run(orgPkgJSON string) ([]byte, error) {
+	workDir, err := ioutil.TempDir("", "goplssettings")
+	if err != nil {
+		return nil, err
+	}
+	log.Printf("WORK=%v", workDir)
+
+	if !*work {
+		defer os.RemoveAll(workDir)
+	}
+
+	api, err := readGoplsAPI()
+	if err != nil {
+		return nil, err
+	}
+
+	options, err := extractOptions(api)
+	if err != nil {
+		return nil, err
+	}
+
+	f, err := ioutil.TempFile(workDir, "gopls.settings")
+	if err != nil {
+		return nil, err
+	}
+
+	writeAsVSCodeSettings(f, options)
+
+	if err := f.Close(); err != nil {
+		return nil, err
+	}
+
+	return rewritePackageJSON(f.Name(), orgPkgJSON)
+}
+
+// readGoplsAPI returns the output of `gopls api-json`.
+func readGoplsAPI() (*APIJSON, error) {
+	version, err := exec.Command("gopls", "-v", "version").Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to check gopls version: %v", err)
+	}
+	log.Printf("Reading settings of gopls....\nversion:\n%s\n", version)
+
+	out, err := exec.Command("gopls", "api-json").Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to run gopls: %v", err)
+	}
+
+	api := &APIJSON{}
+	if err := json.Unmarshal(out, api); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal: %v", err)
+	}
+	return api, nil
+}
+
+// extractOptions extracts the options from APIJSON.
+// It may rearrange the ordering and documentation for better presentation.
+func extractOptions(api *APIJSON) ([]*OptionJSON, error) {
+	type sortableOptionJSON struct {
+		*OptionJSON
+		section string
+	}
+	options := []sortableOptionJSON{}
+	for k, v := range api.Options {
+		for _, o := range v {
+			options = append(options, sortableOptionJSON{OptionJSON: o, section: k})
+		}
+	}
+	sort.SliceStable(options, func(i, j int) bool {
+		return priority(options[i].section) < priority(options[j].section)
+	})
+
+	opts := []*OptionJSON{}
+	for _, v := range options {
+		if emoji := sectionEmoji(v.section); emoji != "" {
+			v.OptionJSON.Doc = emoji + " " + v.OptionJSON.Doc
+		}
+		opts = append(opts, v.OptionJSON)
+	}
+	return opts, nil
+}
+
+func priority(section string) int {
+	switch section {
+	case "User":
+		return 0
+	case "Experimental":
+		return 10
+	case "Debugging":
+		return 100
+	}
+	return 1000
+}
+
+func sectionEmoji(section string) string {
+	switch section {
+	case "Experimental":
+		return "🧪"
+	case "Debugging":
+		return "🔍"
+	}
+	return ""
+}
+
+// rewritePackageJSON rewrites the input package.json by running `jq`
+// to update all existing gopls settings with the ones from the newSettings
+// file.
+func rewritePackageJSON(newSettings, inFile string) ([]byte, error) {
+	prog := `walk(if type == "object" then with_entries(select(.key | test("^gopls.[a-z]") | not)) else . end) | .contributes.configuration.properties *= $GOPLS_SETTINGS[0]`
+
+	cmd := exec.Command("jq", "--slurpfile", "GOPLS_SETTINGS", newSettings, prog, inFile)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("jq run failed (%v): %s", err, &stderr)
+	}
+	return stdout.Bytes(), nil
+}
+
+// convertToVSCodeSettings converts the options to the vscode setting format.
+func writeAsVSCodeSettings(f io.Writer, options []*OptionJSON) {
+	line := func(format string, args ...interface{}) {
+		fmt.Fprintf(f, format, args...)
+		fmt.Fprintln(f)
+	}
+
+	line(`{`)
+	for i, o := range options {
+		line(`  "gopls.%v" : {`, o.Name)
+
+		typ := propertyType(o.Type)
+		line(`    "type": %q,`, typ)
+		// TODO: consider 'additionalProperties' if gopls api-json outputs acceptable peoperties.
+
+		line(`    "markdownDescription": %q,`, o.Doc)
+
+		var enums, enumDocs []string
+		for _, v := range o.EnumValues {
+			enums = append(enums, v.Value)
+			enumDocs = append(enumDocs, fmt.Sprintf("%q", v.Doc))
+		}
+		if len(enums) > 0 {
+			line(`    "enum": [%v],`, strings.Join(enums, ","))
+			line(`    "markdownEnumDescriptions": [%v],`, strings.Join(enumDocs, ","))
+		}
+
+		if len(o.Default) > 0 {
+			line(`    "default": %v,`, o.Default)
+		}
+
+		// TODO: are all gopls settings in the resource scope?
+		line(`    "scope": "resource"`)
+		// TODO: deprecation attribute
+
+		if i == len(options)-1 {
+			line(`  }`)
+		} else {
+			line(`  },`)
+		}
+	}
+	line(`}`)
+}
+
+func propertyType(t string) string {
+	switch t {
+	case "string":
+		return "string"
+	case "bool":
+		return "boolean"
+	case "enum":
+		return "string"
+	case "time.Duration":
+		return "string"
+	case "[]string":
+		return "array"
+	case "map[string]string", "map[string]bool":
+		return "object"
+	}
+	log.Fatalf("unknown type %q", t)
+	return ""
+}
+
+func check(err error) {
+	if err == nil {
+		return
+	}
+
+	log.Output(1, err.Error())
+	os.Exit(1)
+}
+
+// APIJSON is the output json type of `gopls api-json`.
+// Types copied from golang.org/x/tools/internal/lsp/source/options.go.
+type APIJSON struct {
+	Options  map[string][]*OptionJSON
+	Commands []*CommandJSON
+	Lenses   []*LensJSON
+}
+
+type OptionJSON struct {
+	Name       string
+	Type       string
+	Doc        string
+	EnumValues []EnumValue
+	Default    string
+}
+
+type EnumValue struct {
+	Value string
+	Doc   string
+}
+
+type CommandJSON struct {
+	Command string
+	Title   string
+	Doc     string
+}
+
+type LensJSON struct {
+	Lens  string
+	Title string
+	Doc   string
+}
diff --git a/tools/goplssetting/main_test.go b/tools/goplssetting/main_test.go
new file mode 100644
index 0000000..368a693
--- /dev/null
+++ b/tools/goplssetting/main_test.go
@@ -0,0 +1,135 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Licensed under the MIT License.
+// See LICENSE in the project root for license information.
+
+package main
+
+import (
+	"bytes"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRun(t *testing.T) {
+	if _, err := exec.LookPath("gopls"); err != nil {
+		t.Skipf("gopls is not found (%v), skipping...", err)
+	}
+	if _, err := exec.LookPath("jq"); err != nil {
+		t.Skipf("jq is not found (%v), skipping...", err)
+	}
+	testfile := filepath.Join("..", "..", "package.json")
+	got, err := run(testfile)
+	if err != nil {
+		t.Fatalf("run failed: %v", err)
+	}
+	t.Logf("%s", got)
+}
+
+func TestWriteAsVSCodeSettings(t *testing.T) {
+	if _, err := exec.LookPath("jq"); err != nil {
+		t.Skipf("jq is not found (%v), skipping...", err)
+	}
+	testCases := []struct {
+		name string
+		in   *OptionJSON
+		out  string
+	}{
+		{
+			name: "boolean",
+			in: &OptionJSON{
+				Name:    "verboseOutput",
+				Type:    "bool",
+				Doc:     "verboseOutput enables additional debug logging.\n",
+				Default: "false",
+			},
+			out: `"gopls.verboseOutput": {
+					"type": "boolean",
+					"markdownDescription": "verboseOutput enables additional debug logging.\n",
+					"default": false,
+					"scope": "resource"
+				}`,
+		},
+		{
+			name: "time",
+			in: &OptionJSON{
+				Name:    "completionBudget",
+				Type:    "time.Duration",
+				Default: "\"100ms\"",
+			},
+			out: `"gopls.completionBudget": {
+					"type": "string",
+					"markdownDescription": "",
+					"default": "100ms",
+					"scope": "resource"
+				}`,
+		},
+		{
+			name: "map",
+			in: &OptionJSON{
+				Name:    "analyses",
+				Type:    "map[string]bool",
+				Default: "{}",
+			},
+			out: `"gopls.analyses":{
+					"type": "object",
+					"markdownDescription": "",
+					"default": {},
+					"scope": "resource"
+		  		}`,
+		},
+		{
+			name: "enum",
+			in: &OptionJSON{
+				Name: "matcher",
+				Type: "enum",
+				EnumValues: []EnumValue{
+					{
+						Value: "\"CaseInsensitive\"",
+						Doc:   "",
+					},
+					{
+						Value: "\"CaseSensitive\"",
+						Doc:   "",
+					},
+					{
+						Value: "\"Fuzzy\"",
+						Doc:   "",
+					},
+				},
+				Default: "\"Fuzzy\"",
+			},
+			out: `"gopls.matcher": {
+ 					"type": "string",
+					"markdownDescription": "",
+					"enum": [ "CaseInsensitive", "CaseSensitive", "Fuzzy" ],
+					"markdownEnumDescriptions": [ "","","" ],
+					"default": "Fuzzy",
+					"scope": "resource"
+				}`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			options := []*OptionJSON{tc.in}
+			buf := &bytes.Buffer{}
+			writeAsVSCodeSettings(buf, options)
+			if got, want := normalize(t, buf.String()), normalize(t, "{ "+tc.out+" }"); got != want {
+				t.Errorf("writeAsVSCodeSettings = %v, want %v", got, want)
+			}
+		})
+	}
+}
+
+func normalize(t *testing.T, in string) string {
+	t.Helper()
+	cmd := exec.Command("jq")
+	cmd.Stdin = strings.NewReader(in)
+	out, err := cmd.Output()
+	if err != nil {
+		t.Fatalf("failed to run jq: %v", err)
+	}
+	return string(out)
+}