diff --git a/README.md b/README.md
index 807be0a..e53ac4e 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@
 [![Validate 'setup-go'](https://github.com/actions/setup-go/actions/workflows/versions.yml/badge.svg)](https://github.com/actions/setup-go/actions/workflows/versions.yml)
 
 This action sets up a Go environment for use in GitHub Actions by:
+
 - Optionally downloading and caching a version of Go by version and adding to PATH
 - Registering problem matchers for error output
 - Providing intelligent caching for Go modules and build outputs
@@ -21,30 +22,53 @@ steps:
 
 ## Breaking Changes
 
-### V6 - Major Updates
+### V6 Changes
 
-#### Critical Requirements
-- **Node Runtime**: Upgraded from Node 20 to Node 24
-- **⚠️ Action Required**: Ensure your runner is on version **v2.327.1 or later** for compatibility
-- See [Release Notes](https://github.com/actions/setup-go/releases)
+#### Node Runtime Upgrade
+- **Upgraded from Node 20 to Node 24**
+- ⚠️ **Action Required**: Ensure your runner is on version v2.327.1 or later for compatibility
+- See [Release Notes](https://github.com/actions/runner/releases/tag/v2.327.1) for more details
 
-#### Enhanced Toolchain Management
-V6 significantly improves toolchain handling for more reliable and consistent Go version selection:
+#### Enhanced Go Toolchain Management
 
-**Now supports `toolchain` directive from go.mod:**
+V6 introduces significant improvements for reliable and consistent Go version selection:
+
+**Toolchain Directive Support**
+Now correctly interprets both `go` and `toolchain` directives from `go.mod`:
 ```go
 go 1.21.0           // Minimum required version
-toolchain go1.21.6  // V6 uses this exact version when specified
+toolchain go1.21.6  // V6 uses this exact version
 ```
 
-### V5 - Previous Updates
-- Upgraded Node.js runtime from node16 to node20
-- See [full release notes](https://github.com/actions/setup-go/releases)
+**Advanced Version Resolution**
+Supports comprehensive version patterns:
+- Comparison operators: `>=1.21.0`, `<1.22.0`
+- Semantic versioning: `~1.21.0` (patch updates), `^1.21.0` (minor updates)
+- Wildcards: `1.21.x`, `1.*`
+
+**Intelligent Caching**
+Cache keys now incorporate toolchain-specific metadata, eliminating version conflicts when switching between Go versions in your workflows.
+
+For more details, see the [full release notes](https://github.com/actions/setup-go/releases/tag/v6.0.0).
+
+### V5 Changes
+
+- **Upgraded Node.js runtime from node16 to node20**
+- See [full release notes](https://github.com/actions/setup-go/releases) for complete details
+
+## Version Resolution Behavior
+
+The action follows this resolution order:
+1. **Local cache** - Checks for a cached version match
+2. **go-versions repository** - Pulls from the main branch of the [go-versions repository](https://github.com/actions/go-versions/blob/main/versions-manifest.json)
+3. **Direct download** - Falls back to downloading directly from [go.dev](https://storage.googleapis.com/golang)
+
+To change the default behavior, use the `check-latest` input.
+
+> **Note**: The setup-go action uses executable binaries built by the Golang team. The action does not build Go from source code.
 
 ## Usage
 
-See [action.yml](action.yml)
-
 ### Basic Setup
 
 ```yaml
@@ -52,39 +76,37 @@ steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: '1.16.1' # The Go version to download (if necessary) and use
+      go-version: '1.21'
   - run: go run hello.go
 ```
 
-### Version Selection
+### Version Specifications
 
 #### Semantic Versioning
 
 ```yaml
-# Using caret notation (latest patch release)
 steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: '^1.13.1' # The Go version to download (if necessary) and use
+      go-version: '^1.21.1' # The Go version to download (if necessary) and use.
   - run: go version
 ```
 
 ```yaml
-# Using comparison operators
 steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: '>=1.17.0'
+      go-version: '>=1.20.0'
   - run: go version
 ```
 
-> **Note**: Due to YAML parsing behavior, always wrap version numbers in single quotes:
+> **Important**: Due to YAML parsing behavior, always wrap version numbers in single quotes:
 > ```yaml
 > go-version: '1.20'  # Correct
+> go-version: 1.20    # Incorrect - YAML parser interprets as 1.2
 > ```
-> Without quotes, YAML interprets `1.20` as `1.2`, which may cause unexpected behavior.
 
 #### Pre-release Versions
 
@@ -94,7 +116,7 @@ steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: '1.18.0-rc.1' # The Go version to download (if necessary) and use
+       go-version: '1.22.0-rc.1' # The Go version to download (if necessary) and use
   - run: go version
 ```
 
@@ -108,89 +130,53 @@ steps:
   - run: go version
 ```
 
-### Check Latest Version
+#### Version Aliases
 
-The `check-latest` flag defaults to `false`. Use the default or set `check-latest` to `false` if you prefer stability and want to ensure a specific Go version is always used.
-
-If `check-latest` is set to `true`, the action first checks if the cached version is the latest one. If the locally cached version is not the most up-to-date, a Go version will then be downloaded.
-
-> **Note**: Setting `check-latest` to `true` has performance implications as downloading Go versions is slower than using cached versions.
-
-```yaml
-steps:
-  - uses: actions/checkout@v5
-  - uses: actions/setup-go@v6
-    with:
-      go-version: '1.14'
-      check-latest: true
-  - run: go run hello.go
-```
-
-### Using stable/oldstable Aliases
+**Stable Release**
 
 If `stable` is provided, action will get the latest stable version from the go-versions repository manifest.
+```yaml
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: 'stable' # Latest stable version
+  - run: go version
+```
+
+**Previous Stable Release**
 
 If `oldstable` is provided, when current release is 1.19.x, action will resolve version as 1.18.x, where x is the latest patch release.
-
-> **Note**: Using these aliases will result in same version as using corresponding minor release with `check-latest` input set to `true`
-
 ```yaml
-# Latest stable version
 steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: 'stable'
-  - run: go run hello.go
+      go-version: 'oldstable' # Previous stable version
+  - run: go version
 ```
 
-```yaml
-# Previous stable version
-steps:
-  - uses: actions/checkout@v5
-  - uses: actions/setup-go@v6
-    with:
-      go-version: 'oldstable'
-  - run: go run hello.go
-```
+> **Note**: Using aliases is equivalent to using the corresponding minor release with `check-latest: true`
 
-### Caching Dependencies and Build Outputs
+### Version from go.mod File
 
-The action has built-in functionality for caching and restoring go modules and build outputs. It uses `toolkit/cache` under the hood but requires less configuration settings. The cache input is optional, and caching is turned on by default.
-
-The action defaults to search for the dependency file - `go.sum` in the repository root, and uses its hash as a part of the cache key. Use `cache-dependency-path` input for cases when multiple dependency files are used, or they are located in different subdirectories. The input supports glob patterns.
-
-If some problem that prevents success caching happens then the action issues the warning in the log and continues the execution of the pipeline.
-
-#### Caching in Monorepos
+The action can automatically detect the Go version from your project's `go.mod` or `go.work` file:
 
 ```yaml
 steps:
   - uses: actions/checkout@v5
   - uses: actions/setup-go@v6
     with:
-      go-version: '1.17'
-      check-latest: true
-      cache-dependency-path: |
-        subdir/go.sum
-        tools/go.sum
-      # Alternative: cache-dependency-path: "**/*.sum"
-  - run: go run hello.go
+      go-version-file: 'go.mod'
+  - run: go version
 ```
 
-### Getting Go Version from go.mod File
+**Version Resolution from go.mod:**
+1. Uses the `toolchain` directive version if present
+2. Falls back to the `go` directive version
+3. If no patch version is specified, uses the latest available patch
 
-The `go-version-file` input accepts a path to a `go.mod` file or a `go.work` file that contains the version of Go to be used by a project. The version taken from this file will be:
-
-1. The version from the `toolchain` directive, if there is one, otherwise
-2. The version from the `go` directive
-
-The version can specify a patch version or omit it altogether (e.g., `go 1.22.0` or `go 1.22`).
-
-- If a patch version is specified, that specific patch version will be used
-- If no patch version is specified, it will search for the latest available patch version in the cache, versions-manifest.json, and the official Go language website, in that order
-
-> **Note**: If both `go-version` and `go-version-file` inputs are provided then the `go-version` input is used.
+> **Note**: If both `go-version` and `go-version-file` are provided, `go-version` takes precedence.
 
 The action will search for the `go.mod` file relative to the repository root:
 
@@ -203,45 +189,156 @@ steps:
   - run: go version
 ```
 
+### Check Latest Version
+
+The check-latest flag defaults to false for stability. This ensures your workflow uses a specific, predictable Go version.
+When check-latest: true: The action verifies if your cached Go version is the latest available. If not, it downloads and uses the newest version.
+
+```yaml
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.21'
+      check-latest: true # Always check for the latest patch release
+  - run: go version
+```
+
+**Performance Considerations:**
+- `check-latest: false` (default) - Uses cached versions for faster builds
+- `check-latest: true` - Downloads the latest version, slower but ensures up-to-date releases
+
+### Caching
+
+Caching is enabled by default. The action automatically caches and restores Go modules and build outputs using toolkit/cache with minimal configuration.
+
+#### Automatic Caching
+
+Default behavior: Searches for go.sum in the repository root and uses its hash for the cache key.
+
+```yaml
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.21'
+      # cache: true (default)
+  - run: go run hello.go
+```
+
+#### Advanced Caching Scenarios
+
+For advanced scenarios, use `cache-dependency-path` to specify:
+- **Multiple dependency files**: When your project has dependencies in different directories
+- **Custom locations**: When your `go.sum` files are not in the repository root
+- **Monorepos**: When managing multiple Go modules in a single repository
+- **Glob patterns**: For flexible file matching
+
+```yaml
+# Example: Monorepo with multiple go.sum files
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.17'
+      check-latest: true
+      cache-dependency-path: |
+        subdir/go.sum
+        tools/go.sum
+  - run: go run hello.go
+```
+
+```yaml
+# Example: Using glob patterns to match all go.sum files
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.17'
+      cache-dependency-path: "**/*.sum"
+  - run: go run hello.go
+```
+
+#### Disable Caching
+
+```yaml
+steps:
+  - uses: actions/checkout@v5
+  - uses: actions/setup-go@v6
+    with:
+      go-version: '1.21'
+      cache: false
+  - run: go run hello.go
+```
+
+> **Note**: If caching fails, the action logs a warning but continues execution without interrupting your workflow.
+
 ### Matrix Testing
 
+Test across multiple Go versions:
+
 ```yaml
 jobs:
-  build:
+  test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go: [ '1.14', '1.13' ]
-    name: Go ${{ matrix.go }} sample
+        go-version: ['1.20', '1.21', '1.22']
     steps:
       - uses: actions/checkout@v5
-      - name: Setup go
-        uses: actions/setup-go@v6
+      - uses: actions/setup-go@v6
         with:
-          go-version: ${{ matrix.go }}
-      - run: go run hello.go
+          go-version: ${{ matrix.go-version }}
+      - run: go test ./...
 ```
 
-## Version Resolution
+## Advanced Configuration
 
-The action will first check the local cache for a version match. If a version is not found locally, it will pull it from the main branch of the [go-versions](https://github.com/actions/go-versions) repository. On miss or failure, it will fall back to downloading directly from [go dist](https://go.dev/dl/). To change the default behavior, please use the `check-latest` input.
+### Supported Version Syntax
 
-> **Note**: The setup-go action uses executable binaries which are built by Golang side. The action does not build golang from source code.
+| Syntax Type | Example | Description |
+|-------------|---------|-------------|
+| Specific version | `1.21.5` | Exact version |
+| Semantic range | `^1.21.0` | Compatible with 1.21.0 |
+| Comparison operators | `>=1.20.0` | Version 1.20.0 or higher |
+| Wildcards | `1.21.x` | Latest patch of 1.21 |
+| Pre-release | `1.22.0-rc.1` | Release candidate |
+| Aliases | `stable`, `oldstable` | Latest stable versions |
 
-## Supported Version Syntax
+For more information about semantic versioning, see the [semver documentation](https://semver.org/).
 
-The `go-version` input supports the following syntax:
+### Complete Input Reference
 
-- **Specific versions**: `1.15`, `1.16.1`, `1.17.0-rc.2`, `1.16.0-beta.1`
-- **SemVer's version range syntax**: `^1.13.1`, `>=1.18.0-rc.1`
-
-For more information about semantic versioning, please refer to [semver documentation](https://semver.org/).
+```yaml
+- uses: actions/setup-go@v6
+  with:
+    # Version or version range of Go to use
+    go-version: '1.21'
+    
+    # Path to go.mod or go.work file
+    go-version-file: 'go.mod'
+    
+    # Check for latest version
+    check-latest: false
+    
+    # GitHub token for authentication
+    token: ${{ github.token }}
+    
+    # Enable/disable caching
+    cache: true
+    
+    # Path to dependency files for caching
+    cache-dependency-path: 'go.sum'
+    
+    # Architecture to install (auto-detected if not specified)
+    architecture: 'x64'
+```
 
 ## Using setup-go on GHES
 
-`setup-go` comes pre-installed on the appliance with GHES if Actions is enabled. When dynamically downloading Go distributions, `setup-go` downloads distributions from `actions/go-versions` on github.com (outside of the appliance).
+setup-go comes pre-installed on GHES when Actions is enabled. For dynamic Go version downloads, the action fetches distributions from actions/go-versions on github.com (external to your appliance).
 
-These calls to `actions/go-versions` are made via unauthenticated requests, which are limited to 60 requests per hour per IP. If more requests are made within the time frame, then the action leverages the raw API to retrieve the version-manifest. This approach does not impose a rate limit and hence facilitates unrestricted consumption. This is particularly beneficial for GHES runners, which often share the same IP, to avoid the quick exhaustion of the unauthenticated rate limit. If that fails as well the action will try to download versions directly from https://storage.googleapis.com/golang.
+These calls to `actions/go-versions` are made via unauthenticated requests, which are limited to 60 requests per hour per IP. If more requests are made within the time frame, then the action leverages the raw API to retrieve the version-manifest. This approach does not impose a rate limit and hence facilitates unrestricted consumption. This is particularly beneficial for GHES runners, which often share the same IP, to avoid the quick exhaustion of the unauthenticated rate limit. If that fails as well the action will try to download versions directly from [go.dev](https://storage.googleapis.com/golang).
 
 If that fails as well you can get a higher rate limit with generating a personal access token on github.com and passing it as the token input to the action:
 
@@ -252,7 +349,9 @@ with:
   go-version: '1.18'
 ```
 
-If the runner is not able to access github.com, any Go versions requested during a workflow run must come from the runner's tool cache. See ["Setting up the tool cache on self-hosted runners without internet access"](https://docs.github.com/en/enterprise-server@latest/admin/github-actions/managing-access-to-actions-from-githubcom/setting-up-the-tool-cache-on-self-hosted-runners-without-internet-access) for more information.
+### Offline Runners
+
+For runners without github.com access, Go versions must be pre-cached in the runner's tool cache. See "Setting up the tool cache on self-hosted runners without internet access".
 
 ## Recommended Permissions
 
@@ -260,17 +359,17 @@ When using the setup-go action in your GitHub Actions workflow, it is recommende
 
 ```yaml
 permissions:
-  contents: read # access to check out code and install dependencies
+  contents: read # Required to checkout code and install dependencies
 ```
 
 ## License
 
-The scripts and documentation in this project are released under the [MIT License](LICENSE)
+The scripts and documentation in this project are released under the [MIT License](LICENSE).
 
 ## Contributions
 
-Contributions are welcome! See [Contributor's Guide](docs/contributors.md)
+Contributions are welcome! See our [Contributor's Guide](docs/contributors.md) for details.
 
 ## Code of Conduct
 
-👋 Be nice. See our [code of conduct](CODE_OF_CONDUCT.md)
\ No newline at end of file
+👋 Be nice. See our [Code of Conduct](CODE_OF_CONDUCT.md).
\ No newline at end of file