This page lists known issues and workarounds for vector maps and WebGL features.

## Browser/device support

The WebGL feature preview supports the same browsers and devices as the Maps JavaScript API.
To check whether the browser on a particular device will support WebGL, visit [get.webgl.org](https://get.webgl.org/)
or [caniuse.com](https://caniuse.com/?search=webgl). Please also ensure the
hardware acceleration is enabled in the browser settings, otherwise vector maps
will revert to [raster](https://developers.google.com/maps/documentation/javascript/webgl/support.md.txt#raster-fallback).

## Raster or vector?

Occasionally, a vector map may fall back to raster. When this happens, features
depending on the vector map are unavailable. Fallback to a raster map may occur
for a variety of reasons. This section shows you how to correctly configure
your web browser, and how to programmatically check whether vector map
capability is present.

### Check browser capabilities on Chrome

To determine which hardware acceleration capabilities are enabled in a specific
installation of Chrome, navigate to <chrome://gpu/>, and ensure
that the following items are enabled (in green):

- "OpenGL: Enabled"
- "WebGL: Hardware accelerated"
- "WebGL2: Hardware accelerated"

(These are just baseline requirements, there can be other factors which
impact support, see "Known bugs" below.)

### Enable hardware acceleration

In order to support vector maps, hardware acceleration must be enabled in most
browsers. To enable hardware acceleration in Chrome and Microsoft Edge, open
**Settings** , select **System** , and ensure that **Use hardware acceleration
when available** is enabled.

- Learn how to [change websites preferences in Safari](https://support.apple.com/guide/safari/websites-ibrwe2159f50/14.0/mac/11.0).
- Learn about [Firefox's performance settings](https://support.mozilla.org/en-US/kb/performance-settings).

### Programmatically check for raster or vector

You can programmatically check to see whether a map is raster or vector, by
calling `map.getRenderingType()`. The following example shows code to monitor
the `renderingtype_changed` event, and show an info window displaying whether a
raster or vector map is in use.


<iframe src="https://geo-devrel-javascript-samples.web.app/samples/vector-detector/app/dist/" allow="fullscreen; fullscreen"></iframe>


### TypeScript

```typescript
/**
 * This example creates a map with an info window that shows whether
 * the map render type is raster or vector.
 */

 function initMap() {
    const center = {lat: 0, lng: 0};
    const map = new google.maps.Map(document.getElementById('map') as HTMLElement, {
      center,
      zoom: 10,
      heading: 0.0,
      tilt: 0.0,
      // Map ID for a vector map.
      mapId: '6ff586e93e18149f',
    });
    const canvas = document.createElement("canvas");
    const infoWindow = new google.maps.InfoWindow({
      content: '',
      ariaLabel: 'Raster/Vector',
      position: center,
    });
    infoWindow.open({
      map,
    });

    map.addListener('renderingtype_changed', () => {
      infoWindow.setContent(`${map.getRenderingType()}`);
    });
  }

  declare global {
    interface Window {
      initMap: () => void;
    }
  }
  window.initMap = initMap;
```

> [!NOTE]
> **Note:** Read the [guide](https://developers.google.com/maps/documentation/javascript/using-typescript.md.txt) on using TypeScript and Google Maps.

### JavaScript

```javascript
/**
 * This example creates a map with an info window that shows whether
 * the map render type is raster or vector.
 */
function initMap() {
  const center = { lat: 0, lng: 0 };
  const map = new google.maps.Map(document.getElementById("map"), {
    center,
    zoom: 10,
    heading: 0.0,
    tilt: 0.0,
    // Map ID for a vector map.
    mapId: "6ff586e93e18149f",
  });
  const canvas = document.createElement("canvas");
  const infoWindow = new google.maps.InfoWindow({
    content: "",
    ariaLabel: "Raster/Vector",
    position: center,
  });

  infoWindow.open({
    map,
  });
  map.addListener("renderingtype_changed", () => {
    infoWindow.setContent(`${map.getRenderingType()}`);
  });
}

window.initMap = initMap;
```

<br />

You can also use the WebGL rendering context to check support for WebGL 2:

```javascript
const canvas = document.createElement("canvas");
canvas.getContext("webgl2") ? console.log("WebGL 2 is supported") : console.log("WebGL 2 is NOT supported");
```

Learn other ways to [programmatically detect WebGL rendering context](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/By_example/Detect_WebGL).

## Mobile web support

Mobile web support for vector maps is still experimental. Developers can use
client APIs to detect mobile web browsers and use a map ID associated with a
raster map instead of a vector map. We anticipate slower rendering performance
for some mobile devices. If you choose to use vector maps on mobile web, we
would greatly appreciate performance statistics and feedback. As above, if
Vector Maps support is not available, a vector map ID will automatically
fallback to using a raster map.

## Bugs

### Known bugs

- There is a known issue in Chrome on some macOS devices with AMD GPUs. This can be particularly confusing when macOS dynamically switches between GPUs on devices with multiple GPUs, so vector maps may not be available depending on what other apps are running, or whether an external monitor is connected. Turning on Chrome's upcoming ANGLE Metal backend appears to fix this issue in some cases. You can follow general rollout plans for this at <https://bugs.chromium.org/p/chromium/issues/detail?id=1322521>.

### Reporting bugs

- Please update the browser and GPU driver to the latest version before reporting the bug.
- Ensure that the hardware acceleration setting at `chrome://settings/system` (Chrome), `about:preferences#general` (Firefox), `edge://settings/system` (Microsoft Edge) is enabled. In Safari, this setting is enabled automatically in macOS version 10.15 or newer. For older MacOS version(s), please go to the Safari advanced settings and ensure that the "Use hardware acceleration" option is enabled.
- Include [jsfiddle](https://jsfiddle.net/L320szg9/) sample code link in the bug report.
- Please also take a screenshot of `chrome://gpu` (Chrome), `about:support` (Firefox) or `edge://gpu` (Microsoft Edge), attach GPU related info in bug report if you encounter any rendering issues.

## Tell us what you think!

We value your feedback as we strive to make the best vector map experience for
you and your end-users. Please let us know if:

- There are any new JavaScript errors or bugs/crashes that you detect in your web apps.
- Startup latency for vector maps is significantly worse than that for raster maps. If this is the case, metrics for startup latency regression are very helpful. In general, we want to know if startup latency regresses beyond acceptable thresholds.
- The vector maps experience is not as smooth as it could be. If you log FPS or jank metrics, how do they compare between vector and raster maps?
- Performance differs greatly by browser.

If you have set up A/B testing for a comparison of vector maps vs. raster maps,
please share any performance feedback you acquire, as this will be very useful
to help us refine the feature.