To ensure optimal GPU performance when using Onshape, browse the recommendations below and compare to your configuration.
You have the ability to let Onshape determine whether your browser is compatible with Onshape here: browser compatibility (opens in new tab).
The browser compatibility checks for and displays the following information:
- Browser and version
- WebGL and extensions
- Performance check
- Geographical Data
- Onshape server region
This is for informational purposes only, Onshape’s compatibility check does not resolve any issues.
Onshape currently supports these tested and approved browsers:
- Google Chrome
- Mozilla Firefox
- Safari (Mac OS only)
- Microsoft Edge
Microsoft Internet Explorer is currently not supported.
Onshape suggests that you run the 64-bit version of browsers on operating systems that are able to run both 64-bit and 32-bit (i.e., Windows, Linux).
Vivaldi browsers will work with Onshape, however, you need to disable "Allow Gestures" in your browser Mouse settings as this setting conflicts with Onshape's mouse settings.
Onshape requires WebGL. To ensure that you are taking advantage of the highest performing configuration, first update your graphics drivers to the most recent version from the and manufacturer and make sure your preferred browser has WebGL enabled. Most modern browsers enable it by default, but certain hardware or graphics driver configurations will turn it off. If you see an error in Onshape (“It looks like your browser doesn’t have WebGL enable”, or “Rats! WebGL hit a snag.”) or the browser compatibility (opens in new tab) check page says WebGL is disabled, try the following steps in your browser of choice.
Some graphics cards are blacklisted because of poor WebGL support. A list is available at https://www.khronos.org/webgl/wiki/BlacklistsAndWhitelists (opens in new tab) and steps are listed below to override the blacklist in Chrome and Firefox. Legacy operating systems, such as Windows XP, can lack modern driver and browser support, and hence may not run Onshape, even with these work-arounds.
If you make these changes while running Onshape, simply refresh your browser for the changes to take effect.
Ensure WebGL is on and hardware accelerated is checked first:
- Go to chrome://settings.
- Click the Show advanced settings link.
- Scroll down to the System section and ensure the Use hardware acceleration when available checkbox is checked.
- Relaunch Chrome so any changes take effect.
Check Onshape at this point. If it’s still not working, try to force WebGL hardware rendering via the following:
- Go to chrome://flags.
- Enable the flag called Override software rendering list.
- Go to about:config.
- Search for webgl.disabled and ensure its value is false.
- Go to about:support.
- Inspect the WebGL Renderer row in the Graphics table:
- If the status contains a graphics card manufacturer, model and driver (eg: “NVIDIA Corporation -- NVIDIA GeForce GT 650M OpenGL Engine”), then WebGL is enabled.
- If the status is something like “Blocked for your graphics card because of unresolved driver issues” or “Blocked for your graphics driver version”, then your graphics card/driver is blacklisted.
- If your graphics card/drivers are blacklisted, you may override the blacklist:
- Go to about:config.
- Search for webgl.force-enabled.
- Set to true.
- Like Chrome, Firefox has a Use hardware acceleration when available checkbox:
- Go to Preferences > Advanced > General > Browsing.
- However, unlike Chrome, Firefox does not require this checkbox to be checked for WebGL to work.
- Click Safari and select Preferences from the menu.
- Click the Security tab.
- Select Allow WebGL.
- Go to opera://settings.
- Navigate to Browser and scroll down to System.
- Ensure that Use hardware acceleration when available is checked.
- Restart your browser for changes to take effect.
More information for all of these browser settings is available at: https://superuser.com/questions/836832/how-can-i-enable-webgl-in-my-browser (opens in new tab).
Many computers have more than one graphics card installed (GPU). Often, on Windows machines with NVIDIA graphics cards, Optimus technology is also involved, meant to optimize the workload between GPUs -- to assign the proper graphics card to applications needing a high performing graphics card and applications needing more battery life and lower performing graphics card.
If you do not have NVIDIA or NVIDIA with Optimus technology, you may skip this topic.
To get the most out of your graphics cards:
- Make sure the graphics card you use is not on the WebGL blacklist, as some video graphics cards do not support WebGL.
See https://www.khronos.org/webgl/wiki/BlacklistsAndWhitelists (opens in new tab) for more information.
- Onshape performs best when Optimus technology is not involved in the management of graphics cards. To ensure that Optimus technology, if present, does not interfere with the best performance of the graphics card when working with Onshape:
Determine whether or not your computer uses Optimus technology:
- Open the NVIDIA control panel.
Select System Information and then Components. If Optimus technology is present, it will be listed somewhere in the right column.
- If Optimus technology is present, make the NVIDIA graphics card the default card for Onshape (for the browser you use with Onshape), through the NVIDIA control panel.
- Open the NVIDIA control panel.
To make the NVIDIA graphics card the default GPU for Onshape, or rather, the browser you want to use for Onshape:
- Open the NVIDIA control panel.
- Navigate to 3D Settings > Manage 3D Settings and then the Program Settings tab.
- Locate the browser you use for Onshape.
- Set Select the preferred graphics processor for this program option to High-performance NVIDIA processor.
If this method doesn't work, see below for more options.
In a nutshell
You want to use your high performance GPU when an application (like Onshape) demands it. Having a management technology involved (like Optimus) doesn't always result in the performance you are hoping for.
If you don't know what your computer has by way of GPUs, you have the ability to download and use a utility such as Speccy (for Windows) or gfxCardStatus (for Mac) to discover what is installed on your machine.
You want to use the faster, discrete NVIDIA GPU (when available) for Onshape, always. For applications that don't require high performance graphics or require longer battery life, you have the option to use an integrated GPU such as Intel's integrated GPU. To this end, assign the appropriate GPU to a specific browser.
As a last resort, you could try to go into the machine's BIOS settings and switch off Optimus technology completely and run using the discrete NVIDIA GPU all the time. This carries serious risk, however, so make sure you know what you're doing here, or seek help before attempting this solution.
Onshape uses a WebGL rendering context in order to display 3D data in the browser. There are occasions when a browser will take away the rendering context. For instance, when changing the display connected to your computer, the browser may need to update the context for the new display. Typically, the context is quickly restored after being taken away.
Occasionally a browser may take away the WebGL context and never return it. One known cause of this situation is when the GPU runs out of memory. This may occur if the GPU has relatively little video RAM to begin with (less than 1 GB), or if the loaded tab has sufficient complexity to exceed the limits of the GPU's RAM. If context loss issues persist, try loading the document on another device with more video RAM to see if the issue recurs there. Video RAM memory usage may be reduced by lowering tessellation quality for parts contained within the tab.
Speed of page loading and tessellation quality
In very large documents, Chrome may run out of memory before the tab (Part Studio or Assembly, for example) is fully loaded. This may occur due to the large number of entities and volume of display data involved.
One way Onshape speeds the loading of the tab is by deferring the loading of 'less important' bodies, for example, parts that are out of view or too small to be used. These bodies are loaded when they become 'important' enough for viewing as the need arises, for example, when hovering over the part, zooming in, or when hiding some parts so others are visible.
In order to stay under the browser memory threshold, Onshape may unload other unimportant bodies after loading more important ones. If this is necessary, small or invisible, memory intensive parts are unloaded first.
Unloaded parts will appear as semi-transparent boxes that take up the bounds of the part. Parts become 'important' as they come into view and take up a significant part of the screen. When this happens, the system automatically starts loading the part. Once it is loaded, the part resolves to its fully-loaded state, and all geometry is visible.
Onshape progressively pulls down finer tessellation for part data in Part Studios and Assemblies, when finer tessellation exists.
The mechanism works by sampling the Part Studio or Assembly to detect poor-quality parts after view manipulation is stopped. If poor quality parts are detected, Onshape requests better representations from the server.
This automatic tessellation refinement might be hindered under the following conditions:
1) The interactive frame rate becomes too slow (the current threshold is 20 FPS)
2) The amount of data exceeds the memory limit
In the case of exceeding the memory limit, Onshape compensates by swapping out older, unused body representations for refined representations of what is currently in view.
If the performance check was not executed due to a low refresh rate (less than 60hz), or the check resulted in an unexpectedly low triangle/line count, these troubleshooting steps may lead to better results:
- Ensure that the performance check page window is in focus throughout the test.
- Limit the amount of other activity going on in the test system. If another CPU/GPU-intensive program is running simultaneously, it could steal resources from the test and affect the results.
- In case of dual graphics systems, ensure that you are getting the expected GPU. On some systems the browser is limited to the integrated GPU, which may not perform as well as the discrete GPU. Consult the GPU documentation or the operating system help to ensure the browser is able to access the GPU of your choice.
- The performance test will not be run if the browser is not updating at (at least ) 60 frames per second. Certain combinations of displays, cables, and GPUs will result in a reduced refresh rate. Check your GPU specifications to ensure that the GPU can support a 60 hz refresh rate at the native resolution of your display. Also ensure that your display cable (e.g., HDMI) supports the given resolution and refresh rate. A reduced refresh rate does not affect the overall number of triangles Onshape can display, however you may experience some drop in interactive performance. You can use this site to test the refresh rate on your browser: https://www.testufo.com/refreshrate
Improving rendering performance
When browser frame rate has dropped below the Onshape threshold for more than three minutes, Onshape displays the message: Reduced rendering performance detected:
Before proceeding, it's best to check system compatibility to make sure you are using the best GPU on your system. Click the link in the message or here. Once you have determined that you're using the best GPU, you can also try the following to improve performance:
- Change render mode to “Shaded without edges.” For large assemblies that contain many components, edges can add a significant amount of time to the render loop. If edges are not needed, you can opt for the “Shaded without edges” rendering mode in the View cube dropdown. Remember that you can still select edges even when in “Shaded without edges” mode.
- Disable “Match pixel density.” If your computer has a high-DPI display, significant time can be spent matching the pixel density of the monitor. Improve performance by sacrificing some quality through disabling the “Match pixel density” option. See "Environment profile settings" in the Preferences help topic for more details.
- Disable tessellation overrides. When tessellation is being forced to a higher level of detail, it results in the GPU having to render more triangles and can affect performance. Consider removing the override to avoid this overhead, or force detail to the coarse setting, to lower the total triangle count. See the "Specifying tessellation quality" heading within the Specifying tessellation quality of parts help topic for more details.
- Make sure your browser is up-to-date. Browser vendors, such as Chrome and Firefox, are continually updating their own code base in order to optimize performance and add functionality. If your browser has not been updated recently, you may be missing out on updates that can have real effects on Onshape performance.
Devices with older GPUs and older implementations of OpenGL ES 2.0 sometimes lack the necessary capabilities to run Onshape's 3D graphics. This most often happens on devices with a Mali 400 GPU.
When using devices with older GPUs or implementations of OpenGL ES 2.0 an error message will alert you when you open a Part Studio or an Assembly. The error message offers a link to more information as well as a link to continue.
If you elect to proceed after receiving the error message, you will likely notice graphics glitches or a blank, white screen. Eventually, the app may crash.
Why doesn't it work?
The Onshape graphics library uses Vertex Array Objects (VAOs). VAOs are supported natively in OpenGL ES 3.0 and above, but are not supported in the OpenGL ES 2.0 library. Often, implementations of OpenGL ES 2.0 contain extensions that support VAOs, but the support of these extensions is not guaranteed by Android and depend on the service of the manufacturer.
By default, Onshape allows a device with OpenGL ES 2.0 or higher to install the application but it is not until the app is running on a device that it can detect if the device has the necessary capabilities or extensions.
How can I fix this?
Use a device that supports, at the very least, OpenGL ES 2.0 with Vertex Array Object extensions.
A device running the latest version of Android does not necessarily support OpenGL ES 3.0. We recommend that you avoid running Onshape on devices with a Mali 400 or Mali 450 GPU, as these are unable to render 3D graphics properly.
It is recommended that you use a device that runs OpenGL ES 3.
How do I find out what GPU I have?
The most direct way to find out what GPU your device uses is to search for your device and/or serial number on the Internet. For example; you might try browsing or searching for your device on a website such as gsmarena.com or phonearena.com.
More resources include:
- http://alteredqualia.com/texts/optimus/ (opens in new tab) -- more information and specific instructions
- http://alteredqualia.com/tmp/webgl-maxparams-test/ (opens in new tab) -- for immediate and install-less detection of graphics cards on your machine using WebGL