======== Release 535 Entries ========

    * Fixed a bug that could cause 32-bit x86 applications running on
      recent builds of glibc to crash on dlopen().

    * Fixed an issue that could cause render-offloaded applications using
      KDE Frameworks 6 to crash.

2025-04-17 version 535.247.01

2025-01-16 version 535.230.02

    * Updated the kernel module build process to use CONFIG_CC_VERSION_TEXT
      from the Linux kernel's Kconfig to detect the compiler used to build
      the kernel. This may help select the correct compiler on systems where
      the kernel was built with a compiler other than the default one.

    * Fixed a bug that prevented kernel modules linked using precompiled
      kernel interface files from loading on recent Debian systems.

2024-10-22 version 535.216.01

    * In linux-next commit 446d0f4849b1, intended to be included in Linux
      kernel 6.12, output_poll_changed is removed from struct
      drm_mode_config_funcs. Do not implement the function pointer member
      when not present to ensure the driver can compile with newer kernels.
      Populating modes for DRM connectors during hotplug events will not be
      supported with r535 and kernels containing the relevant commit.

    * Fixed a bug that caused the nvidia-powerd service to fail on some
      ADA notebooks with the error message "Error in getting the NvPCF
      static configuration".

    * Fixed a bug that could cause external displays to become frozen until
      the next modeset when using PRIME Display Offloading with the NVIDIA
      dGPU acting as the display offload sink.

    * Fixed a bug that caused OpenGL triple buffering to behave like double
      buffering.

2024-06-04 version 535.183.01

    * Improved the ability of nvidia-modprobe to detect whether kernel
      modules are already loaded. This corrects an issue that prevented
      nvidia-persistenced from setting persistence mode on some systems.

    * Fixed a bug that could cause additional X screens to claim displays
      that should have been assigned to a prior X screen based on the given X
      configuration.

2024-03-21 version 535.171.04

    * Updated the nvidia-settings control panel to ensure that the entire
      Display Configuration page can be used when the Layout window is shown.

    * Updated the nvidia-settings control panel to allow the primary display
      to be set on any GPU in a multi-GPU system.

    * Fixed Xid error when playing Alan Wake 2 with ray tracing enabled.

    * Fixed a regression which prevented some Vulkan applications from
      receiving VK_DEVICE_LOST upon a VT switch, which could lead to the
      application hanging or behaving incorrectly.

2024-02-22 version 535.161.07

    * Fixed a bug that prevented nvidia-installer from honoring the
      --gbm-backend-dir command line option.

2024-01-16 version 535.154.05

2023-12-07 version 535.146.02

    * Fixed a bug that could cause some multi-GPU systems to crash on suspend.

    * Fixed a bug that could cause the system to crash when an application
      is run with __NV_PRIME_RENDER_OFFLOAD=1.

    * Fixed a bug which prevented application profiles from getting applied
      to PRIME Render Offloaded applications running via Wine.

    * Disabled PRIME Display Offload Sink support for virtual displays on
      datacenter GPUs. This prevents unusable desktop layouts from getting
      automatically configured on systems with a mix of physical and virtual
      displays.

    * Fixed a bug that caused high CPU usage during system suspend, which could
      lead to the system not entering s2idle in some cases.

    * Fixed a bug that caused the nvidia-settings control panel to crash
      when running on Wayland with newer versions of libwayland-client.

2023-10-31 version 535.129.03

    * Fixed a bug that could cause modes to fail validation when
      Option "ModeValidation" "NoExtendedGpuCapabilitiesCheck" is specified in
      xorg.conf.

2023-09-21 version 535.113.01

    * Fixed a bug that intermittently caused the display to freeze when
      resuming from suspend on some Ada GPUs.

2023-08-22 version 535.104.05

2023-08-08 version 535.98

    * Fixed an issue which caused the following error message to appear
      spuriously when using SLI with the NVIDIA Open GPU Kernel Modules:

      (EE) NVIDIA: Unable to disable FB size compare

2023-07-18 version 535.86.05

    * Fixed a bug that caused excessive memory consumption when OpenGL and
      Vulkan applications were running while VT-switched away from X.

    * Fixed a bug that could cause the kernel to panic when video memory
      is full.

    * Fixed a bug that prevented displays from refreshing when using an
      NVIDIA PRIME Display Offload sink.

    * Fixed a bug that could cause some Variable Refresh Rate (VRR)
      monitors to flicker by allowing the refresh rate to drop below
      the monitor's minimum.

    * Fixed a bug that caused corruption when running Vulkan applications.

    * Fixed a regression that could cause a system hang when running windowed
      Vulkan applications with sync-to-vblank enabled.

    * Fixed a video memory leak observed when turning off a connected
      monitor while using certain Wayland compositors.

2023-06-14 version 535.54.03

    * Fixed a bug that caused modesets to fail in some Wayland configurations.

    * Fixed a bug that caused head-mounted displays (HMDs) to display black
      after a modeset.

    * Fixed a bug that prevented SLI Mosaic controls from being displayed in
      the nvidia-settings control panel when using GSP Firmware.

    * Fixed a bug that could cause image corruption when unbinding Vulkan
      sparse textures.

2023-05-30 version 535.43.02

    * Added support for the VK_EXT_memory_priority, and VK_EXT_pageable_device_memory
      extensions for Turing+ GPUs.

    * Improved the performance of Minecraft Java Edition on RTX 3000
      series GPUs.

    * Fixed a memory leak in the NVIDIA GLX driver, as reported at:
      https://forums.developer.nvidia.com/t/222697

    * Added support for driving very high pixel clock mode timings such as 8K @
      60Hz.  Please see the "MaxOneHardwareHead" X11 ModeValidation token in the
      README for details.

    * Extended Dynamic Boost support on notebooks to include older Renoir
      and Cezanne chipsets, in addition to Rembrandt and newer AMD chipsets.

    * Fixed a bug that caused Vulkan X11 swapchain creation to fail on GPUs
      without a display engine when the VK_KHR_present_id extension is used.

    * Fixed console restore on legacy VGA consoles when using the NVIDIA
      Open GPU Kernel Modules.

    * Added nvoptix.bin to the driver package.  This data file is used by the
      OptiX ray tracing engine library, libnvoptix.so.1.

    * Removed libnvidia-compiler.so.VERSION from the driver package.  This
      functionality is now provided by other driver libraries.

    * Added power usage and power limits information to nvidia-settings
      PowerMizer page.

    * Updated NV_CTRL_GPU_POWER_SOURCE NV-CONTROL API to report undersized
      power source.

    * Add support for version 4 of the linux-dmabuf wayland protocol.

======== Release 530 Entries ========

2023-03-23 version 530.41.03

    * Added NV-CONTROL attributes NV_CTRL_FRAMELOCK_MULTIPLY_DIVIDE_MODE
      and NV_CTRL_FRAMELOCK_MULTIPLY_DIVIDE_VALUE to allow syncing a
      Quadro Sync II card to different House Sync signal rates. This
      feature requires firmware version 2.18 or later; to download the
      latest firmware version, please visit:

      https://www.nvidia.com/en-us/drivers/firmware/quadro-sync-firmware-driver/

2023-02-28 version 530.30.02

    * Added support for the VK_KHR_video_queue, VK_KHR_video_decode_queue,
      VK_KHR_video_decode_h264 and VK_KHR_video_decode_h265 extensions.

    * Added an application profile to avoid performance problems in Xfce 4
      when the OpenGL compositor backend is enabled along with G-SYNC.

    * Added support for suspend and resume when using GSP firmware.

    * Moved the nvidia-settings application icon into the 'hicolor' icon theme,
      which allows it to be customized by other icon themes selected in the
      desktop environment.

    * Fixed a bug that prevented PRIME render offload from working for
      Wayland applications when running on a system with an AMD iGPU.

    * Fixed a bug that prevented nvidia-installer from recording kernel log
      output to the installer log in some module loading failure paths.

    * Changed nvidia-installer to no longer use the $XDG_DATA_DIRS environment
      variable. XDG data files are now installed to a path specified by the
      --xdg-data-dir option, or /usr/share if not specified.

      This fixes a problem when Flatpak is installed that caused the installer
      to place the nvidia-settings.desktop file in
      /root/.local/share/flatpak/exports/share/applications.

    * Changed the behavior of glXGetRefreshRateSGI() for non-integer
      refresh rates to round to the nearest whole number rather than
      truncating.

    * Changed the compression format of the .run installer package from xz
      to zstd. This results in a smaller compressed package, and faster
      decompression performance. A fallback zstd decompressor is embedded
      into the installer package for systems which do not already have a
      zstd decompression program installed.

    * Fixed a bug that caused nvidia-installer to mistakenly unload some
      already loaded non-NVIDIA kernel modules.

======== Release 525 Entries ========

2023-10-31 version 525.147.05

    * Fixed a bug which could cause some DisplayPort monitors to flicker.

    * Fixed a bug which prevented DKMS from registering kernel modules.

    * Fixed a bug that could cause monitors to flicker when the performance
      state changes on Turing GPUs.

2023-06-26 version 525.125.06

    * Updated the bundled copy of the GBM EGL external platform library:

      https://github.com/NVIDIA/egl-gbm

      The updated version includes the fix for a bug which caused the number
      of free GBM surface buffers to be reported incorrectly. 

    * Fixed a bug which prevented running a Wayland compositor in headless
      mode on GPUs without display hardware.

2023-05-09 version 525.116.04

2023-04-25 version 525.116.03

    * Fixed a regression in Luxmark performance between 525.89.02 and
      525.105.17.

    * Fixed a bug that could cause an unexpected
      VK_ERROR_NATIVE_WINDOW_IN_USE_KHR error in certain circumstances when
      recreating Vulkan surfaces.

    * Fixed a regression that caused brightness control to not vary
      smoothly across the range of values.

2023-03-30 version 525.105.17

    * Added compatibility for Linux kernels with Indirect Branch Tracking
      (IBT).

2023-02-08 version 525.89.02

    * Fixed a bug that could cause banding or flickering of color
      gradients on DisplayPort monitors.

2023-01-19 version 525.85.05

    * Improved the reliability of suspend and resume on UEFI systems
      when using certain display panels.

    * Fixed a bug that prevented some controls in the nvidia-settings
      control panel from working when running an X server as an
      unprivileged user.

    * Fixed a bug that could cause VK_ERROR_DEVICE_LOST when using
      VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT to allocate
      memory.

2023-01-05 version 525.78.01

    * Fixed a bug that could cause the nvidia-settings control panel to
      crash when using a newer control panel with an older driver.

    * Fixed a regression that prevented the G-SYNC/G-SYNC Compatible Visual
      Indicator from being displayed when running Vulkan X11 applications.

    * Fixed a bug where usage of VK_KHR_present_id could cause applications to
      crash with Xid 32 errors.

    * Fixed excess CPU usage in hybrid graphics configurations where an
      external display is connected to an NVIDIA discrete GPU and configured
      as a PRIME Display Offload sink (also known as "Reverse Prime").

2022-11-28 version 525.60.11

    * Improved the performance of PRIME render-offloaded applications.

    * Fixed a bug which caused suspend to fail on systems running GNOME 3
      as a Wayland compositor with NVreg_PreserveVideoMemoryAllocations
      enabled.

2022-11-10 version 525.53

    * Fixed a bug which caused Dynamic Boost to not engage on certain Ampere
      GPU based notebooks.

    * Added support for Dynamic Boost on notebooks with AMD CPUs.

    * Fixed a regression that prevented Warp & Blend from working correctly.

    * Fixed a bug that resulted in stutter when moving windows in GNOME.

    * Added support for the EGL_MESA_platform_surfaceless extension.

    * Updated the nvidia-settings control panel to prevent the creation
      of display layouts that exceed hardware size limitations when using
      the SLI Mosaic configuration page, and to display a warning if such
      a layout is created manually in the Display Configuration page.

    * Removed the hard dependency on GTK 2 when building nvidia-settings
      from source. nvidia-settings may now be built with support for GTK 2
      only, GTK 3 only, or both GTK 2 and GTK 3.

    * Updated the open kernel modules to support Quadro Sync, Stereo,
      rotation in X11, and YUV 4:2:0 on Turing.

    * Updated an error message that nvidia-installer displays when kernel
      header files cannot be found to print full paths for the missing files.

    * Updated nvidia-installer to use "command -v" in place of depending on
      "which" to determine the availability and location of certain tools.

======== Release 520 Entries ========

    * Implemented support for over-the-air updates in the Proton and Wine NVIDIA
      NGX build. This feature is disabled by default and can be enabled by
      setting the "PROTON_ENABLE_NGX_UPDATER" environment variable to a value of
      "1".

    * Updated the Vulkan driver so that the following extensions no longer
      depend on nvidia-uvm.ko being loaded at runtime:
        * VK_KHR_acceleration_structure
        * VK_KHR_deferred_host_operations
        * VK_KHR_ray_query
        * VK_KHR_ray_tracing_pipeline
        * VK_NV_cuda_kernel_launch
        * VK_NV_ray_tracing
        * VK_NV_ray_tracing_motion_blur
        * VK_NVX_binary_import
        * VK_NVX_image_view_handle

    * Updated nvidia-installer to allow use of the "--add-this-kernel"
      feature by non-root users.

    * Updated nvidia-installer to display a more accurate progress bar when
      building the kernel modules.

    * Updated nvidia-installer to display a warning message if a Vulkan
      ICD loader is not detected.

    * Reworked nvidia-installer's support for DKMS: the kernel modules will
      now be optionally registered with DKMS after the installer has already
      built and installed them on its own. nvidia-installer will now register
      the kernel modules with DKMS by default when the dkms(8) utility is
      detected on the system.

    * Fixed a bug in the Vulkan driver which could lead to corruption in
      geometry and tessellation control shaders.

    * Added a new CUDA Debugger implementation for Pascal and newer
      architectures as a part of the driver package: libcudadebugger.so
      (previously released separately as "CUDA GDB Developer Preview").

======== Release 515 Entries ========

2022-11-22 version 515.86.01

    * Fixed a bug that caused nvidia-settings to find incorrect fan speed
      ranges on some GPUs.  Lower-level layers of the driver protected
      the hardware from programming incorrect fan speeds, so the symptom
      was only incorrect reporting.  Now, reporting in nvidia-settings
      matches what actually gets programmed in hardware.

    * Fixed a regression in 515.76 that caused blank screens and hangs when
      starting an X server on RTX 30 series GPUs in some configurations where
      the boot display is connected via HDMI.

    * Fixed a bug where Marvel's Spider-Man Remastered would sometimes crash
      with Xid 13 errors on Turing and later.

2022-09-20 version 515.76

    * Turing and later: fixed possible excessive GPU power draw on an idle
      X11 or Wayland desktop when driving high resolutions or refresh rates.

2022-08-02 version 515.65.01

    * Fixed a bug that caused the X server to hang when VT-switching with
      stereo enabled.

    * Fixed an issue that caused OpenGL applications to be unresponsive in SLI
      Mosaic mode with no monitors enabled on the primary GPU.

2022-06-28 version 515.57

    * Fixed a bug that could cause some graphics applications to crash when
      they are started while nvidia-drm.ko is not loaded.

    * Fixed an issue where NvFBC could return an incorrect frame if a capture
      request timed out.

    * Fixed an issue where NvFBC direct capture would wait for multiple queued
      frames to finish rendering, instead of returning the next rendered frame.

    * Added support for NvFBC direct capture to composite the mouse cursor onto
      frames.

    * Fixed an issue where Vulkan direct to display could not drive more than
      4 displays from a single VkInstance.

2022-05-31 version 515.48.07

    * Improved performance of GLX and Vulkan applications running in gamescope.

    * Added a "kernelopen" feature tag to the supported-gpus.json file,
      to indicate which GPUs are compatible with open-gpu-kernel-modules.

    * Improved Vulkan swapchain creation failure reporting. Applications can use the
      VK_EXT_debug_utils extension to receive additional information when an error was
      encountered in vkCreateSwapchainKHR().

2022-05-11 version 515.43.04

    * Published the source code to a variant of the NVIDIA Linux kernel
      modules dual-licensed as MIT/GPLv2. The source is available here:
          https://github.com/NVIDIA/open-gpu-kernel-modules
      and will be updated each driver release. Please see the "Open
      Linux Kernel Modules" chapter in the README for details.

    * Added support for the VK_EXT_external_memory_dma_buf and
      VK_EXT_image_drm_format_modifier Vulkan extensions. To use this
      functionality, the nvidia-drm kernel module must be loaded with DRM KMS
      mode setting enabled. See the DRM KMS section of the README for guidance
      on enabling mode setting.

    * Changed nvidia-suspend.service, nvidia-resume.service, and
      nvidia-hibernate.service to use WantedBy= rather than RequiredBy=
      dependencies for systemd-suspend.service and systemd-hibernate.service.
      This avoids a problem where suspend or hibernate fails if the NVIDIA
      driver is uninstalled without disabling these services first.

      See https://github.com/systemd/systemd/issues/21991

      If these services were manually enabled, it may be necessary to update
      their dependencies by running

        sudo systemctl reenable nvidia-suspend.service nvidia-resume.service nvidia-hibernate.service

    * Interlaced modes are now disabled when active stereo is enabled.

    * NVIDIA X Server Settings will now display the quit confirmation dialog
      automatically if only there are pending changes that need to be manually
      saved. The corresponding configuration option to control the appearance
      of the quit dialog was thus also removed.

    * Removed the warning message about mismatches between the compiler
      used to build the Linux kernel and the compiler used to build the
      NVIDIA kernel modules from nvidia-installer. Modern compilers are less
      likely to cause problems when this type of mismatch occurs, and it has
      become common in many distributions to build the Linux kernel with a
      different compiler than the default system compiler.

    * Updated nvidia-installer to skip test-loading the kernel modules
      on systems where no supported NVIDIA GPUs are detected.

    * Updated nvidia-installer to avoid a race condition which could cause
      the kernel module test load to fail due to udev automatically loading
      kernel modules left over from an existing NVIDIA driver installation.
      This failure resulted in an installation error message "Kernel module
      load error: File exists".

    * Updated the RTD3 Video Memory Utilization Threshold
      (NVreg_DynamicPowerManagementVideoMemoryThreshold) maximum value from
      200 MB to 1024 MB.

======== Release 510 Entries ========

2022-11-22 version 510.108.03

2022-08-02 version 510.85.02

2022-05-16 version 510.73.05

    * Added a new configuration option for NVIDIA NGX to allow disabling the DSO
      signature check. See the "NGX" chapter of the README for more information.

2022-03-22 version 510.60.02

    * Fixed a bug that could cause displays with HDMI or DisplayPort audio
      to be deselected as the default audio output device after resuming
      from suspend.

    * Fixed a regression that could cause OpenGL applications to hang or
      render incorrectly after suspend/resume cycles or VT-switches

    * Fixed a bug, introduced in 495.29.05, that caused GPU "Model:" in
      /proc/driver/nvidia/gpus/<Bus:Device.Function>/information to be
      "Unknown" for some GPUs.

2022-02-14 version 510.54

    * Fixed a bug that caused the nvidia-settings control panel to print
      spurious error messages.

    * Fixed a bug that could cause GPU exceptions when minimizing a fullscreen
      Vulkan application on certain desktops, such as Plasma.

2022-02-01 version 510.47.03

    * Added support for Vulkan 1.3.

2022-01-11 version 510.39.01

    * Added a new daemon, nvidia-powerd, to provide support for
      the Dynamic Boost feature on supported systems. Dynamic Boost
      balances power between the CPU and the GPU for improved performance.
      For more details, see the "Dynamic Boost on Linux" chapter in the README.

    * Updated nvidia-bug-report.sh to search the systemd journal for
      nvidia-powerd logs.

    * Fixed several issues which caused the supported-gpus.json file to
      contain incorrect product information.

    * Fixed a bug that caused the nvidia-settings control panel to report
      inaccurate ECC error counts, and completely prevented the reporting
      of aggregate ECC error counts. ECC error counts reported by nvidia-smi
      were not affected.

    * Added a new module parameter, "peerdirect_support", to the
      nvidia-peermem.ko kernel module, to correctly support GPUDirect RDMA on
      MOFED 5.0 and older releases.

    * Added a GUI control for setting Image Sharpening values in the app
      profiles page of the nvidia-settings control panel.

    * Fixed a bug which caused Vulkan applications to hang when the
      __GL_THREADED_OPTIMIZATIONS environment variable was set to enable
      threaded optimizations in the NVIDIA driver.

    * Fixed a bug where calls to vkWaitForPresentKHR would fail with
      VK_TIMEOUT on Maxwell and Pascal GPUs.

    * Added support for nvidia-settings to use NVML for NV-CONTROL attributes.

    * Added support for the VK_EXT_depth_clip_control extension.

    * Added support for the VK_EXT_border_color_swizzle extension.

    * Added support for the VK_EXT_image_view_min_lod extension.

    * Fixed a bug in the Vulkan compiler where 64-bit atomics were partially broken.

    * Fixed a bug in the Vulkan driver where VK_NULL_HANDLE was not properly
      handled as input to
      VkRenderingFragmentShadingRateAttachmentInfoKHR.imageView.

    * Added support for the VK_KHR_dynamic_rendering extension.

    * Added support for the bufferDeviceAddressCaptureReplay Vulkan feature.

    * Optimized the Vulkan fullscreen presentation path for X11 and
      direct-to-display swapchains.

    * Added AV1 decode support to the NVIDIA VDPAU driver. See the
      VDPAU Support appendix in the README for supported AV1 decoder
      profiles.

    * Added support for the VK_KHR_format_feature_flags2 extension.

    * Added support for the VK_KHR_maintenance4 extension.

    * Fixed a bug in the Vulkan driver where the SPIR-V Centroid interpolation
      decoration was not ignored when used in conjunction with FragCoord.

    * Fixed a bug in the Vulkan driver where unreferenced descriptor bindings
      were sometimes not ignored properly.

    * Fixed a bug in the Vulkan driver where vkCmdBindDescriptorSets would not
      properly handle pDynamicOffsets for compute pipelines.

    * Added support for the VK_KHR_shader_integer_dot_product extension.

    * Added support for the VK_EXT_primitive_topology_list_restart extension.

    * Added support for the VK_EXT_load_store_op_none extension.

    * Fixed a bug which caused OpenGL and Vulkan applications to generate
      excessive traffic over dbus while attempting to communicate with
      nvidia-powerd, even though nvidia-powerd was not running.

    * Removed the runtime loader (rtld) sanity test from nvidia-installer.
      This test has been made largely obsolete by GLVND.

    * Updated nvidia-xconfig to add a BusID to the "Device" section by
      default on systems with both NVIDIA and non-NVIDIA GPUs. This
      behavior can be suppressed by using the --no-busid option.

    * Enabled GSP Firmware by default on NVIDIA T4, A100, A30, A40, A16, A2,
      and several other Tesla products.  Please see the "GSP Firmware"
      chapter in the README for details.

======== Release 495 Entries ========

    * Fixed a bug in the Vulkan driver where some Ray Tracing shaders would
      timeout, resulting in device loss.

2021-10-26 version 495.44

    * Fixed a bug in the Vulkan driver where unused input attributes to a vertex
      shader would corrupt the interpolation qualifiers for the shader.

    * Fixed a bug in the Vulkan driver where individual components of
      barycentric inputs could not be read.

    * Added support for the VK_KHR_present_id extension.

    * Added support for the VK_KHR_present_wait extension.

    * Added support for the VK_KHR_shader_subgroup_uniform_control_flow
      extension.

    * Fixed a bug where VK_NVX_binary_import was advertised as supported on
      unsupported platforms. This caused calls to vkCreateDevice to fail if
      applications attempted to enable VK_NVX_binary_import on such platforms.

2021-10-14 version 495.29.05

    * Added support for the GBM API. This adds the new symlink
      nvidia-drm_gbm.so pointing to the file libnvidia-allocator.so.VERSION to
      implement a GBM backend driver usable with the GBM loader from the Mesa
      project version 21.2 and above, as well as the files
      libnvidia-egl-gbm.so.1.1.0 and 15_nvidia_gbm.json, which implement EGL
      support for the GBM platform (EGL_KHR_platform_gbm).

    * Add indicator for Resizable BAR support on compatible systems.

    * Fixed a bug that could cause the X server to crash when starting a
      new server generation on PRIME configurations.

    * Removed support for NvIFROpenGL. This functionality was deprecated
      in the 470.xx driver release.

    * Removed libnvidia-cbl.so from the driver package.  This
      functionality is now provided by other driver libraries.

    * Changed the minimum required Linux kernel version from 2.6.32 to 3.10.

    * Updated nvidia.ko to load even if no supported NVIDIA GPUs are present
      when an NVIDIA NVSwitch device is detected in the system. Previously,
      nvidia.ko would fail to load into the kernel if no supported GPUs were
      present.

======== Release 470 Entries ========

    * Fixed a bug that caused driver build failure when using separate
      kernel source and output directories on Linux v6.6 and later.

2024-06-04 version 470.256.02

    * Fixed a bug that could cause the X server to crash when graphics
      applications requested single-buffered drawables while certain
      features (such as Vulkan sharpening) are enabled.

2024-02-22 version 470.239.06

    * Minor bug fixes and improvements

2023-10-31 version 470.223.02

    * Fixed a bug which caused incorrect reporting of presentation
      times when using the VK_NV_present_barrier Vulkan extension.

2023-03-30 version 470.182.03

    * Fixed a bug that could cause fullscreen PRIME Render Offload
      applications and/or X to crash when an NVIDIA GPU is driving
      multiple displays with Reverse PRIME.

    * Added support for console restoration when using simpledrm.

    * Disabled Fixed Rate Link (FRL) when using passive DisplayPort
      to HDMI dongles, which are incompatible with FRL.

2022-11-22 version 470.161.03

    * Fixed a bug that caused the Xorg server to crash if an NvFBC capture
      session is started while video memory is full.

2022-08-02 version 470.141.03

    * Added support for the following GPU:
        * GeForce RTX 3050 OEM

    * Fixed a bug that prevented nvidia-settings from accurately reflecting
      changes to some configuration properties.

    * Fixed an issue where HDMI audio output was not working in some cases,
      especially with high display refresh rates (120Hz, 100Hz, etc.) using
      Fixed Rate Link (FRL) transmission mode.

2022-05-13 version 470.129.06

    * Added support for the following GPUs:
        * GeForce RTX 3050
        * GeForce RTX 3070 Ti Laptop GPU
        * GeForce RTX 3080 Ti Laptop GPU
        * GeForce RTX 3090 Ti
        * RTX A500 Laptop GPU
        * RTX A1000 Embedded GPU
        * RTX A2000 Embedded GPU
        * RTX A1000 Laptop GPU
        * RTX A2000 8GB Laptop GPU
        * RTX A3000 12GB Laptop GPU
        * RTX A4500 Embedded GPU
        * RTX A4500 Laptop GPU
        * RTX A5500 Laptop GPU
        * T550 Laptop GPU

    * Fixed an issue where NvFBC was requesting Vulkan 1.0 while using
      Vulkan 1.1 core features. This caused NvFBC to fail to initialize with
      Vulkan loader versions 1.3.204 or newer.

2022-01-31 version 470.103.01

    * Added an application profile to avoid an image corruption issue in
      Blender, as described at https://developer.blender.org/T76874

    * Added support for the following GPUs:
        * NVIDIA GeForce MX550
        * NVIDIA GeForce MX570
        * NVIDIA GeForce RTX 2050

    * Fixed a bug that could lead to a kernel panic, due to a failure to
      release a spinlock under some conditions.

    * Fixed a race condition which could lead to crashes when Xid errors
      occur concurrently on multiple GPUs.

2021-12-13 version 470.94

    * Added support for the following GPU:
        * NVIDIA PG509-210

    * Worked around an issue that prevented some games from flipping (and
      therefore taking advantage of G-SYNC and G-SYNC Compatible monitors) on
      certain desktops such as GNOME.

2021-11-10 version 470.86

    * Added support for the following GPUs:
        * RTX A2000 12GB
        * RTX A4500
        * T400 4GB
        * T1000 8GB

    * Added a new command line option, "--no-peermem", to nvidia-installer.
      Selecting this option prevents the installation of the nvidia-peermem
      kernel module.

2021-10-26 version 470.82.00

    * Added support for the following GPUs:
        * Matrox D-Series D2450
        * Matrox D-Series D2480
        * NVIDIA A2

    * Fixed a regression which prevented DisplayPort and HDMI 2.1 variable
      refresh rate (VRR) G-SYNC Compatible monitors from functioning correctly
      in variable refresh rate mode, resulting in issues such as flickering.

    * Fixed a bug that can cause a kernel crash in SLI Mosaic configurations.

    * Added support for the EGL_NV_robustness_video_memory_purge extension

2021-09-20 version 470.74

    * Fixed a bug that could cause GPU applications to exit when resuming
      from suspend.

    * Fixed a regression which resulted in very-high system memory usage for
      Direct3D 12 games when run through vkd3d-proton.

2021-08-10 version 470.63.01

    * Added an application profile to disable FXAA for Firefox to prevent
      visual corruption.

    * Added support for the VK_KHR_wayland_surface extension.

    * Fixed a Vulkan performance regression that affected rFactor2.

2021-07-19 version 470.57.02

    * Updated the nvidia-settings command line interface to confirm successful
      assignment of string attributes. This makes the behavior more consistent
      with other types of attribute assignments.

    * Fixed a bug that could cause flickering in Blender and Steam when
      running on Xwayland.

    * Fixed a bug that caused GTK+3 applications using the GtkGLArea class
      to crash when running on Xwayland.

    * Added a workaround for DOOM Eternal, which avoids an application bug where
      Vulkan swapchain recreation events are not properly handled. On desktops
      like GNOME where the window is initially redirected to the compositor,
      this may prevent the game from flipping (and thus enabling G-SYNC).

    * Added a workaround for Far Cry 5 when run through DXVK, which avoids a
      shader race condition bug that was previously exposed by new compiler
      optimizations.

    * Added support for the following GPUs:
        * NVIDIA A100 80GB PCIe
        * NVIDIA A16
        * NVIDIA PG506-243
        * NVIDIA PG506-242
        * NVIDIA CMP 90HX
        * NVIDIA CMP 70HX
        * NVIDIA RTX A2000
        * NVIDIA T4G

2021-06-22 version 470.42.01

    * Added support for the following GPUs:
        * A100-PG506-207
        * A100-PG506-217

    * Increased the maximum limit on concurrent OpenGL contexts. This
      limit was previously constrained by a fixed-size internal driver
      resource, and is now constrained by available system memory.

    * Applications that exceed the maximum limit on concurrent OpenGL
      contexts will now receive a BadAlloc X error rather than crashing.

    * Fixed a bug that could cause the X server to crash upon shutdown
      with some configurations using GPU screens.

    * Fixed a bug that could cause rendering errors when displaying scaled
      MetaModes using the "Nearest" resampling method.

    * Fixed a bug that could cause OpenGL applications run in PID namespaces to
      hang upon exit, generating warnings such as the following in the X log:
      (WW) NVIDIA: Wait for channel idle timed out.

    * Added support for PRIME Display Offload where both the display offload
      source and display offload sink are driven by the NVIDIA X Driver.

    * Added support for PRIME Display Offload where the display offload source
      is AMDGPU.

    * Fixed a bug that could prevent the driver from applying application
      profiles when running applications through Proton or Wine on a PRIME
      Render Offload configuration.

    * Fixed a bug that could cause NvFBC's "direct capture" to crash the X
      server when certain GLX calls are made during a capture.

    * Removed usage of the sysctl(2) system call as a fallback for procfs in
      nvidia-installer. This system call has been deprecated since Linux
      2.6.24, and has been removed completely with recent versions of Linux
      and glibc.

    * Added an NVIDIA NGX build for use with Proton and Wine. A new library,
      nvngx.dll, has been added to enable driver-side support for running
      Windows applications which make use of DLSS. Changes to Proton, Wine, and
      other third-party software are needed for this feature.

    * Added support for VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT from the
      VK_EXT_global_priority extension. This enables support for asynchronous
      reprojection in SteamVR.

      VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT is supported on Pascal GPUs and
      newer.

      Global priorities other than VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT require
      root privileges or the CAP_SYS_NICE capability.

    * Added support for the VK_EXT_global_priority_query extension.

    * Added the nvidia-peermem.ko kernel module. This module provides
      Mellanox InfiniBand HCAs (Host Channel Adapters) direct peer-to-peer access
      access to NVIDIA GPU memory without need without needing to copy data to
      to host memory.
      See the chapter "GPUDirect RDMA Peer Memory Client" in the README
      for details.

    * Added support for the VK_EXT_provoking_vertex extension.

    * Initial support for hardware accelerated OpenGL and Vulkan rendering
      on Xwayland. See the chapter "OpenGL and Vulkan on Xwayland" in the
      README for details.

    * Fixed a bug that could cause intermittent corruption in Wolfenstein:
      Youngblood when using NVIDIA Kepler, Maxwell, Pascal, and Volta GPUs.

    * Fixed a bug that could cause games running with DXVK to crash with Xid 31
      (MMU Fault) errors when using NVIDIA Pascal GPUs.

    * Added support for the VK_EXT_extended_dynamic_state2 extension.

    * Added support for the VK_EXT_color_write_enable extension.

    * Added support for the VK_EXT_vertex_input_dynamic_state extension.

    * Added support for the VK_EXT_ycbcr_2plane_444_formats extension.

    * Added support for the VK_NV_inherited_viewport_scissor extension.

    * NvFBC's "direct capture" mode no longer causes flipping to be
      disabled for applications being captured. G-SYNC can now also be
      used simultaneously with NvFBC direct capture.

    * Deprecated NvIFROpenGL support.  Release 470 will be the last to
      support this functionality.  NvIFROpenGL header files, samples
      and documentation were removed from the NVIDIA Capture SDK 7.1.9
      release.  Future drivers will remove libnvidia-ifr.so and any
      other reference to NvIFROpenGL.
      For details please see:
        https://developer.nvidia.com/nvidia-video-codec-sdk

    * Fixed a bug that prevented Vulkan direct-to-display from working when
      DRM KMS is enabled.

    * Enabled the NVIDIA driver, by default, to attempt to initialize SLI when
      using GPUs with different amounts of video memory.  Previously, this was
      only available when bit 1 was set in the "Coolbits" X config option.

    * Updated GPU fan control to be available by default in
      nvidia-settings and NV-CONTROL, for GPU boards that support
      programmable fan control.  Previously, this was only available
      when bit 2 was set in the "Coolbits" X config option.

    * Fixed an issue where vkCreate{Graphics,Compute}Pipeline would sometimes
      crash when the shaders contained resources with no set/binding.

    * Fixed a memory fault in the Vulkan driver when using some smaller
      dimensions of sparse images.

    * Fixed an issue with vkCmdSetViewport when firstViewport is non-zero.

    * Fixed handling of VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT for
      variable size descriptor bindings.

======== Release 465 Entries ========

2021-05-18 version 465.31

2021-04-29 version 465.27

2021-04-14 version 465.24.02

2021-03-30 version 465.19.01

    * Added gsp.bin firmware file which is used to offload the GPU initialization
      and management tasks on some GPUs. See the "GSP Firmware" chapter in the
      README for more information.

    * Updated the nvidia-settings control panel to be more consistent about
      displaying layout controls which are only applicable for some displays
      or GPUs connected to the system.

    * Improved X11 DrawText() performance when rendering stippled text.

    * Fixed a bug that could prevent some hardware configurations with large
      numbers of displays connected to the same GPU from working correctly.

    * Fixed a bug that could cause multi-threaded GLX applications to hang
      while attempting to handle an XError.

    * Fixed a potential crash in the Vulkan driver when clearing images with
      multiple layers.

    * Fixed a bug with the host-visible device-local memory heap, where if an
      allocation failed due to space constraints, it could cause the application
      to crash on future Vulkan function calls.

    * Fixed corruption in the Vulkan driver that sometimes occurred with shadow
      rendering with image arrays.

    * Added support for the VK_KHR_synchronization2 extension.

    * Added support for the VK_KHR_workgroup_memory_explicit_layout extension.

    * Added support for the VK_KHR_zero_initialize_workgroup_memory extension.

    * Added support for linear images for use with host-visible video memory in
      Vulkan.

    * Fixed an issue with OpenGL where imported Vulkan buffers would fail with
      GL_OUT_OF_MEMORY when marked as resident.

    * Fixed a bug that caused the NVIDIA driver to retain an incorrect
      memory mapping of the UEFI system console when booting with the
      kernel parameter pci=realloc. This could cause the console to corrupt
      memory in use by the NVIDIA driver, and vice versa.

    * Runtime D3 Power Management is now enabled by default on supported
      notebook systems with Ampere or newer GPUs. See the chapter titled
      "PCI-Express Runtime D3 (RTD3) Power Management" in the README for
      further details.

    * Updated the .run package installer to install and enable the
      nvidia-suspend.service, nvidia-hibernate.service, and
      nvidia-resume.service systemd units. These units are used when the
      NVreg_PreserveVideoMemoryAllocations=1 nvidia module parameter is
      specified to provide advanced suspend, hibernate, and resume
      functionality.

      See the chapter titled "Configuring Power Management Support" in the
      README for more information.

      This functionality can be disabled by passing the --no-systemd parameter
      to the installer.

    * Updated the NVIDIA X driver to allow OpenGL applications running on an X
      server that has left the active virtual terminal (VT) to continue running
      on the GPU, but with a limited frame rate.

      This functionality is only enabled when the
      NVreg_PreserveVideoMemoryAllocations=1 nvidia module parameter is enabled.

    * Fix a Vulkan clamping bug where fragment depth values would not be clamped
      to the range [0,1] if VK_EXT_depth_range_unrestricted was not enabled.

    * Fix a bug related to SPIR-V 1.4 non-Input/Output entry point variables.

    * Fixed a bug in compilation of SPIR-V intersection shaders when modules
      with multiple entry points are used.

======== Release 460 Entries ========

2021-07-20 version 460.91.03

    * Added support for the following GPUs:
        * GeForce RTX 3070 Ti
        * CMP 50HX

2021-06-03 version 460.84

    * Added support for the following GPU:
        * GeForce RTX 3080 Ti

2021-05-11 version 460.80

    * Fixed a bug that could cause AddressSanitizer to report a
      heap-buffer-overflow during initialization of the OpenGL and Vulkan
      libraries.

    * Added support for the following GPUs:
        * GeForce RTX 3050 Ti Laptop GPU
        * GeForce RTX 3050 Laptop GPU
        * T600 Laptop GPU
        * T1200 Laptop GPU
        * RTX A5000 Laptop GPU
        * RTX A4000 Laptop GPU
        * RTX A3000 Laptop GPU
        * RTX A2000 Laptop GPU

    * Fixed a bug that could prevent a system from resuming from suspend
      when DisplayPort activity occurred while the system was suspended.

    * Fixed a regression that prevented eglQueryDevicesEXT from correctly
      enumerating GPUs on systems with multiple GPUs where access to the
      GPU device files was restricted for some GPUs.

    * Fixed a regression that could cause system hangs when changing display
      resolution on SLI Mosaic configurations.

2021-04-14 version 460.73.01

    * Added support for the following GPUs:
        * A10
        * A10G
        * A30
        * PG506-232
        * RTX A4000
        * RTX A5000
        * T400
        * T600

2021-03-18 version 460.67

    * Fixed a bug where using ray tracing extensions on multi-GPU setups could
      result in application instability if the GPUs did not match.

    * Fixed an issue that prevented G-SYNC from working properly after a mode
      switch on Kepler-based GPUs.

2021-02-25 version 460.56

    * Added support for the following GPUs:
        * GeForce RTX 3060
        * CMP 40HX
        * CMP 30HX

    * Fixed a bug with indexed ray payloads in Vulkan.

2021-01-26 version 460.39

    * Updated the NVIDIA driver to restore functionality of some features,
      including runtime power management, hotplugging audio-capable display
      devices, and S0ix-based system suspend, with recent kernels such as
      Linux 5.10.

    * Fixed a bug that caused bindless texture samplers to be incorrectly
      counted towards the MAX_COMPUTE_TEXTURE_IMAGE_UNITS limit.

    * Fixed a bug that could cause the GPU to hang when attempting to
      perform link training on an HDMI 2.1 Fixed Rate Link (FRL) display,
      while the display is powered off.

    * Added support for the following GPUs:
        * GeForce RTX 3080 Laptop GPU
        * GeForce RTX 3070 Laptop GPU
        * GeForce RTX 3060 Laptop GPU
        * GeForce GT 1010

2021-01-07 version 460.32.03

    * Added a new "NoInterlacedModes" token to the NVIDIA X driver's
      "ModeValidation" option, to allow preventing interlaced modes from
      being validated. Refer to the "X Config Options" appendix of the
      driver README for further details.

    * Added support for the following GPU:
        * A40

2020-12-15 version 460.27.04

    * Fixed a bug that could cause detailed timing information for displays
      with a large number of detailed timings to be truncated in the X log.

    * Fixed a bug that prevented scaled display resolutions configured via
      the nvidia-settings control panel from being reported by RandR.

    * Added support for the following GPUs:
        * GeForce RTX 3060 Ti
        * RTX A6000

    * Fixed a bug with the SLI Mosaic Mode configuration dialog in
      nvidia-settings that left displays enabled when they were not needed in
      the selected configuration.

    * Added support for RandR rotation and reflection while using an
      NVIDIA-driven display as a PRIME Display Offload sink.

    * Added support for "Reverse PRIME Bypass", an optimization that bypasses
      the bandwidth overhead of PRIME Render Offload and PRIME Display Offload
      in conditions where a render offload application is fullscreen,
      unredirected, and visible only on a given NVIDIA-driven PRIME Display
      Offload output. Use of the optimization is reported in the X log when
      verbose logging is enabled in the X server.

    * Add support for the VK_KHR_acceleration_structure extension.
    * Add support for the VK_KHR_ray_tracing_pipeline extension.
    * Add support for the VK_KHR_ray_query extension.
    * Add support for the VK_KHR_pipeline_library extension.
    * Add support for the VK_KHR_deferred_host_operations extension.

    * Removed the MetaMode string truncation warning for older X Servers when
      saving the X Configuration file from nvidia-settings.

    * Add support for the VK_NV_fragment_shading_rate_enums extension.

    * Fixed a bug where copying from an X11 pixmap to an RGB overlay window
      would exhibit corruption.

    * Fixed an issue with VK_ACCESS_MEMORY_READ_BIT and
      VK_ACCESS_MEMORY_WRITE_BIT when used as part of a render pass.

    * Add support for the VK_KHR_fragment_shading_rate extension.

    * Add support for the VK_KHR_shader_terminate_invocation extension.

    * Reduce host memory consumption for descriptor memory in cases where the
      pNext chain contains a structure of type
      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO.

    * Increased the default size for new OpenGL/Vulkan Shader Disk Cache
      location to 1024MB. Note that caches with paths containing "/.nv/ will
      continue to use the previous default of 128MB unless the size is manually
      overridden. For more information see the "OpenGL Shader Disk Cache"
      section in the "Specifying OpenGL Environment Variable Settings" chapter
      of the README.

    * Changed the default location for new OpenGL/Vulkan Shader Disk Caches.
      If the location is not manually overridden and a cache is detected in the
      previous default location, that location will be used instead of the new
      default location. For more information see the "OpenGL Shader Disk Cache"
      section in the "Specifying OpenGL Environment Variable Settings" chapter
      of the README.

    * Add support for the VK_EXT_shader_image_atomic_int64 extension.

    * Add support for the VK_KHR_copy_commands2 extension.

    * Allow importing cached memory via VK_EXT_external_memory_host.

    * Removed support for the following deprecated frame lock NV-CONTROL
      attributes:

        NV_CTRL_FRAMELOCK_MASTER
        NV_CTRL_FRAMELOCK_SLAVES
        NV_CTRL_FRAMELOCK_MASTERABLE
        NV_CTRL_FRAMELOCK_SLAVEABLE

    * Default AllowEmptyInitialConfiguration to True such that the NVIDIA X
      driver succeeds when launching the X server even if there are no display
      devices connected.

    * RRGetCrtcInfo will now return Rotate_0 instead of 0 as the active
      rotation for disabled CRTCs.

    * Improved the NVIDIA VDPAU implementation of
      VdpVideoSurfaceGetBitsYCbCr and VdpVideoSurfacePutBitsYCbCr when
      using planar or semi-planar formats.  This helps applications that
      transfer data between VDPAU video surfaces and system memory.

    * Added initial experimental support for S0ix-based system suspend
      (suspend-to-idle). This feature is platform and GPU dependent,
      so the feature will be disabled by default. To enable this feature,
      refer to the 'powermanagement' section of the README.

======== Release 455 Entries ========

2020-11-17 version 455.45.01

    * Fixed an issue where Vulkan applications would fail to initialize if the
      connected X11 Server did not expose support for GLX.

    * Fixed a bug in a Vulkan blending optimization that could produce incorrect
      results. Some of the Vulkan titles affected by this bug were:
        * Life is Strange 2
        * Shadow of the Tomb Raider

    * Fixed an issue that caused Vulkan swapchain creation to fail for
      full-screen windows when a G-SYNC monitor is connected.

2020-10-29 version 455.38

    * Added support for the following GPU:
        * GeForce RTX 3070

    * Fixed a bug in nvidia-settings that caused the SLI Mosaic Configuration
      dialog to position available displays incorrectly when enabling SLI
      Mosaic.

    * Added support for using an NVIDIA-driven display as a PRIME Display
      Offload sink with a PRIME Display Offload source driven by the
      xf86-video-intel driver.

    * Fixed a bug in a Vulkan barrier optimization that allowed some
      back-to-back copies to run unordered.

2020-10-07 version 455.28

    * Fixed a bug that caused X to crash when the NVIDIA RandR provider was
      disabled while using an NVIDIA-driven display as a PRIME Display Offload
      sink.

    * Moved layout configuration of SLI Mosaic displays in nvidia-settings from
      its own dedicated page to a dialog available on the X Server Display
      Configuration page.

2020-09-17 version 455.23.04

    * Added support for the following GPUs:
        * GeForce RTX 3080
        * GeForce RTX 3090

    * Fixed a bug that prevented 8K displays from being used in portrait
      orientation on Pascal and earlier GPUs.

    * Fixed a bug which caused excessive CPU usage in Vulkan applications
      which create a large number of VkFence objects. This was particularly
      prevalent in the Steam Play title Red Dead Redemption 2.

    * Added support for a new device-local VkMemoryType which is host-coherent
      and host-visible. This may result in improved performance in some
      applications. Applications which are known to benefit from this new
      VkMemoryType include: DXVK Title DiRT Rally 2.0, Steam Play Title
      DOOM: Eternal, and DXVK title World of Warcraft.

    * Fixed a bug that caused WebKit-based applications to crash when
      running on Wayland.

    * Fixed a bug that led to display corruption at some resolutions when
      using an NVIDIA-driven display as a PRIME Display Offload sink.

    * Fixed a bug in a SPIR-V optimization that may cause conditional blocks to
      not execute.

    * Fixed a bug where calls to vkGetRandROutputDisplayEXT with unexpected
      inputs would generate X11 protocol errors.
      (https://bugs.winehq.org/show_bug.cgi?id=49407)

    * Fixed a small memory leak during exit of the NVIDIA EGL driver.

    * Implemented support for the NVIDIA NGX Updater. See the "NGX" chapter in
      the README for information on how to configure this feature.

    * Removed support for the SLI modes "SFR", "AFR", and "AA".  SLI Mosaic,
      Base Mosaic, GL_NV_gpu_multicast, and GLX_NV_multigpu_context are still
      supported.

    * Updated Base Mosaic support on GeForce to allow a maximum of
      five simultaneous displays, rather than three.

    * Fixed several synchronization bugs that could momentarily lock
      up the X server when moving/resizing/focusing OpenGL and Vulkan
      windows when PRIME Sync was enabled.

    * Added NVIDIA VDPAU driver support for decoding VP9 10- and 12-bit bitstreams.
      Note that VDPAU's presentation pipeline and OpenGL-VDPAU interop
      does not support 10- and 12-bit video surfaces yet. See the "VDPAU Support"
      appendix in the README for supported decoder profiles.

    * Fixed a bug that could cause dual-link DVI to be driven over a
      connector that only supports single-link DVI, when "NoMaxPClkCheck" is
      specified in the "ModeValidation" X configuration option.  Note this fix
      may cause behavioral changes for configurations using this option.

======== Release 450 Entries ========

    * Updated nvidia-modprobe to create symbolic links in /dev/char when
      creating the /dev/nvidia* device nodes. This resolves an issue that
      prevented the device nodes from working with newer versions of runc:

      https://github.com/opencontainers/runc/issues/3708

    * Improved performance on GPUs which are experiencing a high number
      of correctable ECC memory errors.

    * Fixed a bug that caused nvidia-drm.ko to crash when loading with
      DRM-KMS enabled (modeset=1) on Linux v5.14.

    * Fixed a bug that could cause the /proc/driver/nvidia/suspend power
      management interface to fail to preserve and restore video memory
      allocations when the NVreg_TemporaryFilePath module parameter for
      nvidia.ko specified an invalid path.

    * Fixed a bug that could result in blank displays when driving multiple
      displays at the same resolution using active DisplayPort dongles.

2021-04-19 version 450.119.03

    * Fixed a driver installation failure on Linux kernel 5.11 release
      candidates, where the NVIDIA kernel module failed to build with error
      "error: implicit declaration of function 'sys_close'".

    * Fixed a bug where calls to vkCreateDevice could fail on Ampere GPUs when
      ray tracing extensions were enabled and the application was running within
      the Steam Linux Runtime.

    * Fixed a regression that could cause display corruption when using
      a scaled resolution after resuming from power management suspend.

    * Fixed a bug that could intermittently cause NvFBC applications to fail
      with the error message "Unable to send exported fds".

2021-01-07 version 450.102.04

    * Fixed the X driver's composition pipeline (used, e.g., for X desktop
      rotation, "ForceCompositionPipeline", and some OpenGL Swap Group
      configurations) to correctly preserve color precision in depth 30.

    * Fixed a bug that could cause X clients to crash when closing display
      connections to the X server.

    * Fixed a bug that could cause the X server to configure DisplayPort
      Multi-Stream Transport displays in an inconsistent order.

    * Added support for the following GPUs:
        * T500
        * A100-SXM4-80GB

    * Improved the memory allocation strategy in nvidia-modeset.ko to reduce
      the likelihood of out-of-memory errors, which typically manifest as
      "page allocation failure" messages in the kernel log.

    * Fixed a performance regression in the NVIDIA X driver which affected
      some X11 RENDER extension use cases.

    * Added AMD Secure Memory Encryption compatibility.

    * Fixed a bug where glGetGraphicsResetStatusARB would incorrectly
      return GL_PURGED_CONTEXT_RESET_NV immediately after application
      start-up if the system had previously been suspended.

2020-09-30 version 450.80.02

    * Added support for the following GPUs:
        * A100-PCIE-40GB
        * A100 Graphics Device
        * DGX Display
        * GeForce MX450

2020-08-18 version 450.66

    * Added support for the following GPUs:
        * EIZO Quadro MED-XN31LP
        * EIZO Quadro MED-XN50LP
        * EIZO Quadro MED-XN51LP
        * EIZO Quadro MED-XN70
        * EIZO Quadro MED-XN71
        * EIZO Quadro MED-XN72
        * EIZO Quadro MED-XN90
        * EIZO Quadro MED-XN91
        * EIZO Quadro MED-XN92
        * Matrox D-Series D1450
        * Matrox D-Series D1480

    * Fixed triple buffering support of Vulkan X11 swapchains when applications
      are syncing to vblank.

2020-07-09 version 450.57

    * Fixed a bug that caused a brief orange flash on some platforms when a
      display mode is being set.

2020-06-24 version 450.51

    * Added support for Vulkan direct-to-display on DisplayPort displays which
      are connected via DisplayPort Multi-Stream Transport (DP-MST).

    * Added a new documentation file, supported-gpus.json, which exposes a
      machine-readable list of supported GPUs and features.

    * Added an implementation of glNamedBufferPageCommitmentARB, which was
      missing from the NVIDIA driver's support for the GL_ARB_sparse_buffer
      extension.

    * Fixed a bug that could cause a KDE Plasma session to crash when running
      under Wayland.

    * Fixed a bug that could cause some Swap Group configurations to present
      at half of the display refresh rate.

    * Fixed a bug that prevented X11 EGL displays from being reinitialized.

    * The 450 driver series is the last that supports NvFBC's
      NVFBC_CAPTURE_TO_HW_ENCODER capture interface, which has been deprecated
      since NVIDIA Capture SDK 6.0 released in 2017. Future NVIDIA drivers
      after the 450 series will return NVFBC_ERR_UNSUPPORTED if that capture
      interface is requested.
      The recommended way to encode captured frames with NVENC is by using the
      NVIDIA Video Codec SDK.
      See: https://developer.nvidia.com/nvidia-video-codec-sdk

    * Implemented support for NVIDIA NGX. A new library, libnvidia-ngx.so, has
      been added to support the new functionality. This new library is needed by
      applications which link against any of the following SDKs:
        * NVIDIA DLSS SDK
        * NVIDIA NGX SDK

    * Fixed a bug which caused Vulkan applications to leak file descriptors
      when destroying Vulkan instances.

    * Added a fallback presentation path for PRIME Render Offload
      configurations where the DRI3 and/or Present extension are unavailable.

    * Fixed a bug where vkCreateSampler would fail with no borderColor data,
      even though it wasn't needed.

    * Fixed a bug where vkUpdateDescriptorSetWithTemplate would ignore the
      stride parameter for some VkDescriptorType values.

    * Fixed a bug causing the Plasma desktop panel to freeze when
      compositing is disabled (https://bugs.kde.org/show_bug.cgi?id=353983)

    * Added support for the following GPUs:
        * A100-PCIE-40GB
        * A100-PG509-200
        * A100-SXM4-40GB

    * Improved Vulkan device enumeration under an X.Org X server environment.
      See the "Known Issues" in the README for more information.

    * Fixed a visual glitch of Vulkan applications when they stop flipping
      due to a window change, such as when alt-tab is used to change
      window focus.

    * Fixed a bug where XGetImage requests would return stale data for
      flipping Vulkan applications. In particular, this fixes screen-scraping
      tools such as VNC and import.

    * Removed libnvidia-fatbinaryloader.so from the driver package.  This
      functionality is now built into other driver libraries.

    * Extended the dynamic runtime power management support in the NVIDIA
      driver to shut off power to video memory under certain conditions.
      See the chapter titled "PCI-Express Runtime D3 (RTD3) Power Management"
      in the README for more information.

    * Added HEVC 10/12 bit "decode only" support to the NVIDIA VDPAU driver. 
      Note that VDPAU's presentation pipeline and OpenGL-VDPAU interop
      does not support 10- and 12-bit video surfaces yet. See the "VDPAU Support"
      appendix in the README for supported HEVC decoder profiles.

    * Added support for Image Sharpening for OpenGL and Vulkan applications

    * Added new VdpYCbCrFormats VDP_YCBCR_FORMAT_Y_U_V_444_16,
      VDP_YCBCR_FORMAT_P010 and VDP_YCBCR_FORMAT_P016 for accessing 16-bit
      surfaces via VdpVideoSurfaceGetBitsYCbCr() and VdpVideoSurfacePutBitsYCbCr()
      in the NVIDIA VDPAU driver.

    * Added support to create 16-bit video surfaces in the NVIDIA VDPAU driver.

    * Modified nvidia-persistenced and libnvidia-ml (NVML) to use libtirpc for
      communication instead of relying on the deprecated glibc RPC
      implementation.

    * Enabled GPU screens by default on X.Org xserver version 1.20.7 and higher.

    * Fixed a bug where rendering in a separate user namespace (unshare -U)
      would show black window and produce Xid 13 errors.

======== Release 445 Entries ========

    * Removed support for "IgnoreDisplayDevices" X configuration option.

    * Added support for PRIME Synchronization when using displays driven by
      the xf86-video-amdgpu driver as PRIME display offload sinks.

    * Added support for displays connected to NVIDIA GPUs to act as PRIME
      display offload sinks, also known as "Reverse PRIME". See the chapter
      titled "Offloading Graphics Display with RandR 1.4" in the README for
      additional information.

    * Removed 'libGL.la' libtool archive from the install package.

======== Release 440 Entries ========

    * Fixed a bug that could cause the X server to crash when using large
      cursor images with PRIME display offloading.

    * Fixed an interaction problem with 5.4 and newer Linux kernels that caused
      a performance regression when allocating system memory.

    * Fixed a bug where a Vulkan application under PRIME render
      offload would not always be correctly throttled to vsync despite
      the application's request for VK_PRESENT_MODE_FIFO_KHR. This was
      particularly prevalent on DXVK titles.

2020-06-24 version 440.100

    * Added a workaround for some Pascal based notebooks, where the GPU
      could fall off the bus when idle.

    * Added support for the following GPUs:
        * GeForce GTX 1650 Ti
        * GeForce GTX 1650 Ti with Max-Q Design
        * GeForce RTX 2060 with Max-Q Design
        * Quadro T1000 with Max-Q Design

    * Added new "Connector-N" display device aliases to the X driver's
      X configuration option parser.  This is useful in conjunction with
      the "ConnectedMonitor" X configuration option, for emulating the
      presence of connected monitors without knowing what specific
      connectors are available.  See the "Display Device Names" appendix
      in the README for details.

2020-04-07 version 440.82

    * Added a workaround for Steam Play title DOOM Eternal, which overrides
      application requested memory locations, to ensure performance-critical
      resources be placed in video memory.

    * Allow presenting from queue families which only expose
      VK_QUEUE_COMPUTE_BIT when using XCB in addition to Xlib surfaces.

    * Fixed a bug that caused render-offloaded applications to crash on exit.

2020-02-28 version 440.64

    * Added support for the following GPUs:
        * GeForce MX330
        * GeForce MX350

    * Fixed a regression that allowed displays to enter DPMS mode even
      when DPMS is disabled in the X server settings.

2020-02-03 version 440.59

    * Disabled frame rate limiting for configurations without active
      displays when HardDPMS is enabled.

    * Restricted the maximum number of GPU Screens to one GPU Screen per
      GPU device, to prevent X from crashing when more than one GPU Screen
      is configured for a single GPU device.

    * Fixed a bug that could cause the X server to crash while exiting
      DPMS with HardDPMS enabled.

    * Added support for the following GPUs:
        * Tesla PG500-216
        * Tesla PG503-216

    * Added a default filename when saving the Display Configuration file
      in nvidia-settings if an existing configuration file is not detected.

    * Added support for audio over DisplayPort Multi-Stream. This support
      requires Linux kernel version 5.5 or newer.

    * Updated the NVIDIA driver to allow NVIDIA High Definition Audio (HDA)
      controllers to respond to display hotplug events while the HDA is
      runtime-suspended.

    * Fixed a bug that caused DXVK titles to endlessly loop during shader
      compilation if no OpSource instruction was present.

2019-12-11 version 440.44

    * Added support for the following GPU:
        * GeForce GTX 1650 SUPER

    * Added support for the __GL_SYNC_DISPLAY_DEVICE environment variable for Vulkan applications.

    * Fixed a bug that caused applications running directly on a display
      (such as VR HMDs) to tear when a G-SYNC or G-SYNC Compatible monitor
      is plugged in the system.

2019-11-22 version 440.36

    * Fixed graphical corruption that can occur when using
      glslang SPIR-V Generator Version <= 2.

2019-11-04 version 440.31

    * Added support for the following GPUs:
        * Tesla V100S-PCIE-32GB
        * GeForce GTX 1660 SUPER

    * Fixed a regression in the 440.26 driver that could prevent the NVIDIA
      kernel modules from building correctly on systems localized to a
      language other than English.

2019-10-17 version 440.26

    * Updated the confirmation dialog box that is displayed when quitting
      the nvidia-settings control panel to report when there are pending
      configuration changes which will be lost if they are not applied or
      saved before quitting.

    * Enabled parallel GLSL shader linking by default; i.e., allow
      GL_ARB_parallel_shader_compile to work without first calling
      glMaxShaderCompilerThreadsARB().

    * Added support for HDMI 2.1 variable refresh rate (VRR) G-SYNC Compatible
      monitors on supported GPUs.  For more details, see "Configuring Multiple
      Display Devices on One X Screen" in the README.

    * Added support for the GLX_NV_multigpu_context and GL_NV_gpu_multicast
      extensions.  For more details, see the "Configuring SLI and Multi-GPU
      FrameRendering" chapter of the README, and the extension specifications:

        https://www.khronos.org/registry/OpenGL/extensions/NV/GLX_NV_multigpu_context.txt
        https://www.khronos.org/registry/OpenGL/extensions/NV/NV_gpu_multicast.txt

    * Fixed a bug that prevented Vulkan applications running on systems
      configured for SLI. Vulkan applications can now run while SLI is
      enabled; however, they will only be able to use a single GPU.

    * Simplified the nvidia-sleep.sh sample script to no longer depend on
      unreliable detection of the current VT through X server logs.

    * Added EGL support for PRIME render offload. Please see the PRIME Render
      Offload chapter in the README for configuration details.

    * Fixed a regression introduced in 435.19.02 that would cause some
      applications which use the VK_KHR_DISPLAY extension to result in a 
      segmentation fault.

    * Enabled HardDPMS by default. See the README entry on the X configuration
      option "HardDPMS" for more information.

    * Fixed a bug which caused corruption in the following DXVK titles:
        * Saints Row IV
        * Saints Row: The Third

    * Added VP9 decode support to the NVIDIA VDPAU driver. See the
      VDPAU Support appendix in the README for supported VP9 decoder
      profiles.

    * Fixed a bug that could cause heapUsage values reported by
      VK_EXT_memory_budget to not immediately update after vkFreeMemory was
      called.

    * Changed GPU clock management strategy to more quickly ramp down clocks
      after a drop in GPU utilization.

    * Added X configuration option, "SidebandSocketPath", which
      controls the directory in which the X driver will create a
      pathname UNIX domain socket used to communicate with the NVIDIA
      OpenGL, Vulkan and VDPAU driver components.

    * The X driver will now create a fallback pathname UNIX domain
      socket in the directory specified by the "SidebandSocketPath"
      option, or /var/run by default, which will be used by other
      NVIDIA driver components if they are unable to connect to the
      default abstract socket.  This fixes a bug where graphics
      applications run within a network namespace (which prevents the
      use of abstract sockets) were unable to take advantage of some
      driver features, such as G-Sync.

======== Release 435 Entries ========

2019-08-29 version 435.21

    * Fixed a bug that caused the X server to crash when using HardDPMS with
      an NVIDIA-driven GPU Screen.

2019-08-13 version 435.17

    * Fixed a bug which caused the kernel to panic when exiting a single X
      server when multiple X servers were active and in an SLI configuration.

    * Fixed a regression introduced in the 430.* series of releases that
      caused a segmentation fault in libnvcuvid.so while using Video Codec
      SDK APIs on certain graphics boards.

    * Added initial experimental support for runtime D3 (RTD3) power 
      management on Turing notebook GPUs.

    * Improved nvidia-bug-report.sh to collect runtime D3 (RTD3) power
      management information.

    * Improved nvidia-bug-report.sh to collect ACPI tables when the acpidump
      tool is available.

    * Added Vulkan and OpenGL+GLX support for PRIME render offload.
      Please see the PRIME Render Offload chapter in the README for
      system requirements and configuration details.

    * Added support for changing Digital Vibrance in the display controls
      section of nvidia-settings on Turing hardware.

    * Fixed the cuvidParseVideoData API in the NVCUVID driver to
      correctly propagate errors returned by the PFNVIDSEQUENCECALLBACK
      callback function to the application.

    * Fixed a bug that caused the NVIDIA X driver to behave incorrectly or
      crash when a client queried Xinerama information on X servers with a
      non-NVIDIA X screen as screen 0.

    * Fixed the "Image Settings" options in the "OpenGL Settings" page of
      nvidia-settings for Quadro GPUs.  Previously, OpenGL rendering on Quadro
      would behave as if the "High Quality" option were selected regardless of
      the selection.  Now, the setting will default to "High Quality" for
      Quadro but selecting a lower option will affect rendering accordingly.
      (Other GPUs are unchanged: the default remains "Quality", but other
      options can be selected if desired.)

    * Fixed a bug that could cause Vulkan applications to generate spurious
      warning messages about a missing NV-GLX extension.

    * Removed the non-GLVND OpenGL libraries from the NVIDIA Linux driver
      installation package. The GLVND OpenGL libraries were introduced in
      release 361.16, and have been installed by default since release
      364.12, with the non-GLVND versions available as an alternative via
      the "--no-glvnd-glx-client" and "--no-glvnd-egl-client" installer
      options. As the non-GLVND libraries are no longer included in the
      installation package, these options will no longer have any effect.

    * Fixed a bug that prevented nvidia-drm from marking preferred modes
      properly when reporting display information via the DRM-KMS API.

    * Updated nvidia-installer to make compiler mismatches non-fatal
      when adding precompiled kernel interfaces to an installer package
      using the "--add-this-kernel" option, to be more consistent with
      the behavior when installing without precompiled interfaces.

    * Fixed the NvEncodeAPI driver to correctly reject the encoding of
      sequences with resolutions smaller than what the NVENC supports.

======== Release 430 Entries ========

 
    * Fixed a bug in an error handling path that could cause a kernel crash
      while loading nvidia.ko.

2019-11-05 version 430.64

    * Fixed a bug that could cause the X server to crash when running
      applications using GLX indirect rendering.

    * Fall back to system memory when video memory is full for some
      driver-internal allocations. This can help fix Xid 13 and 
      Xid 31 cases in Vulkan applications when video memory is full.

    * Fixed a bug that could cause a blank screen on some DisplayPort
      monitors when logging in to GNOME, if the nvidia-drm kernel module
      parameter modeset=1 is specified.

2019-09-11 version 430.50

2019-07-29 version 430.40

    * Added support for the following GPU:
        * GeForce RTX 2080 SUPER

    * Fixed a driver installation failure in Linux kernel configurations
      with CONFIG_HOTPLUG_CPU.

2019-07-09 version 430.34

    * Added support for the following GPUs:
        * GeForce RTX 2060 SUPER
        * GeForce RTX 2070 SUPER

2019-06-10 version 430.26

2019-05-14 version 430.14

    * Improved performance of the Vulkan title, DiRT4.

    * Added support for presentation from queue families which only expose
      VK_QUEUE_COMPUTE_BIT. This improves performance of Steam Play title,
      Wolfenstein II: The New Colossus.

2019-04-23 version 430.09

    * Fixed a bug that could cause the display to be driven at a low
      resolution when configuring PRIME display offloading with
      `nvidia-xconfig --prime`.

    * Added HEVC YUV 4:4:4 decode support to the NVIDIA VDPAU driver.

    * Added the new per-decoder profile capability bit
      VDP_DECODER_PROFILE_SUPPORTED_CHROMA_TYPES to the NVIDIA VDPAU driver.

    * Added new VdpYCbCrFormats VDP_YCBCR_FORMAT_Y_UV_444 and
      VDP_YCBCR_FORMAT_Y_U_V_444 for accessing YUV 4:4:4 surfaces via 
      VdpVideoSurfaceGetBitsYCbCr() and VdpVideoSurfacePutBitsYCbCr()
      in the NVIDIA VDPAU driver.

    * Added support for creation of YUV 4:4:4 video surfaces in 
      the NVIDIA VDPAU driver.

    * Fixed display color range handling on pre-Turing GPUs, such that when
      limited color range is selected through the display controls page in
      nvidia-settings, output pixel values will be correctly clamped to
      Consumer Technology Association (CTA) range.

    * Raised the minimum supported X.Org xserver version to 1.7 (video driver
      ABI version 6).

======== Release 418 Entries ========

    * Added support for the following GPU:
        * Quadro T2000 with Max-Q Design

2019-11-05 version 418.113

    * Updated the Module.symvers sanity check, which is part of the NVIDIA
      kernel module build process, to accommodate the recent addition of a
      new field in the Module.symvers file format. This fixes the error
      "The Module.symvers file is missing [...]" seen during driver
      installation or DKMS rebuilds with Linux 5.4 RC kernels.

    * Fixed a bug that prevented NVIDIA GPUs from entering the low-power
      D3 state when entering suspend-to-idle (s2idle). Note that on some
      systems this may expose an existing timing issue in the Linux kernel;
      see the "Known Issues and Workarounds" section of the "Configuring
      Power Management Support" chapter of the README for more details.

2019-07-29 version 418.88

    * Added support for the following GPUs:
        * Quadro P520
        * Quadro RTX 3000
        * Quadro RTX 3000 with Max-Q Design
        * Quadro RTX 4000 with Max-Q Design
        * Quadro RTX 5000 with Max-Q Design
        * Quadro T1000
        * Quadro T2000

    * Fixed a bug, introduced in 415.13, that caused audio over DisplayPort to
      not work in some configurations.

2019-05-07 version 418.74

    * Added support for the following GPUs:
        * Quadro P2200
        * GeForce GTX 1650
        * GeForce GTX 1650 with Max-Q Design
        * GeForce GTX 1660 Ti with Max-Q Design

2019-03-20 version 418.56

    * Updated nvidia-settings to disable line wrapping when outputting to a
      non-terminal in command-line mode. From GitHub pull request:

          https://github.com/NVIDIA/nvidia-settings/pull/37

    * Updated the nvidia-settings control panel to more accurately reflect the
      current availability of G-SYNC or G-SYNC compatible display settings.

    * Added support for the following GPUs:
        * GeForce GTX 1660
        * GeForce MX230
        * GeForce MX250

    * Fixed a bug which could sometimes cause Vulkan applications to lock up the
      GPU when freeing large chunks of memory on systems with PRIME enabled.

    * Added support for the following GPU:
        * GeForce GTX 1660 Ti

    * Updated the driver to restrict use of the GPU performance counters to
      system administrators by default. The previous more permissive behavior
      can be restored by setting NVreg_RestrictProfilingToAdminUsers=0 when
      loading nvidia.ko.

    * Fixed a bug that would occasionally cause visual corruption on some
      Vulkan titles. This bug was particularly prevalent on DXVK titles.

    * Fixed a bug that caused vkCmdPushConstants to generate Xid 13 messages
      when executed with VK_SHADER_STAGE_ALL on a compute queue.

2019-01-30 version 418.30

    * Added initial support for G-SYNC Compatible monitors.  See the README
      for details.

    * Added support for the following GPUs:
        * GeForce RTX 2070 with Max-Q Design
        * GeForce RTX 2080 with Max-Q Design

    * Added support for stereo presentation in Vulkan.

    * Fixed a bug that could cause OpenGL applications to crash after
      repeated VT-switches.

    * Fixed a bug that could sometimes prevent PRIME displays from being
      selected in the display settings page of nvidia-settings.

    * NVIDIA Video Codec SDK 9.0

      A new release of the Video Codec SDK will be available in Q1 2019.
      For more information and early access sign-up, refer to
        https://developer.nvidia.com/nvidia-video-codec-sdk

      The main features available in this release are listed below:
      o Support for Turing NVENC/NVDEC.
      o The NVDECODE API (also known as the NVCUVID API) has been updated to
        support YUV 4:4:4 decoding for HEVC on Turing GPUs.
      o NvEncodeAPI has been updated to support HEVC B-frames on Turing GPUs.
      o NvEncodeAPI adds the capability to output the encoded bitstream, and
        motion vectors from motion estimation-only mode, to video memory.
        This avoids the overhead of copying the output from system to video
        memory for processing pipelines operating directly on video memory.
      o NvEncodeAPI now accepts CUarrays as input buffers. The SDK contains
        a sample application to demonstrate how to feed a Vulkan image to
        NVENC using the Vulkan-CUDA interop.

    * Updated the NVIDIA VDPAU driver to support allocating VDPAU video
      surfaces with explicit field or frame picture structure.

    * Added support for the GL_NV_vdpau_interop2 OpenGL extension,
      which allows VDPAU/OpenGL surface sharing with explicit field or
      frame picture structure. Picture structure selection by applications
      can avoid the need for implicit surface structure conversion by
      the OpenGL implementation.

    * Added NVIDIA optical flow support.

      A new library libnvidia-opticalflow.so is included in the driver package.
      The NVIDIA optical flow library can be used for hardware-accelerated
      computation of optical flow vectors and stereo disparity values.
      The API header files, sample applications and documentation will be
      available in a separate Optical Flow SDK package in Q1 2019.

      For more information and early access sign-up, refer to
        https://developer.nvidia.com/opticalflow-sdk

    * Removed libnvidia-wfb.so from the driver package.  This module was only
      used on X servers that did not provide their own implementation of
      libwfb, and all X.Org xserver versions now supported by the driver do
      so.

    * Updated the VDPAU driver to reject decoding to YUV 4:2:2 video
      surfaces.  The NVIDIA VDPAU driver always produces YUV 4:2:0
      content.  Previously, the VDPAU driver implicitly converted a YUV
      4:2:2 video surface to YUV 4:2:0 during decode.  Now, the VDPAU
      driver will fail the decode request.

    * Optimized nvidia-installer to only run depmod(1) once when installing,
      rather than twice (once during the uninstall phase and again when
      installing new kernel modules).

    * Removed the NVreg_UseThreadedInterrupts kernel module parameter from
      nvidia.ko. This removes the ability to forcibly fall back to an older
      mechanism (tasklets) for running the bottom-half interrupt handler.
      Instead, threaded IRQs (the default since 367.44) are always used.

======== Release 415 Entries ========

2019-01-15 version 415.27

    * Added support for the following GPU:
        * GeForce RTX 2060

2018-12-18 version 415.25

    * Added support for the following GPU:
        * TITAN RTX

2018-12-12 version 415.23

2018-12-07 version 415.22

    * Fixed a regression that prevented applications based on the Unity engine
      from starting.

    * Added support for VK_EXT_transform_feedback.

2018-11-20 version 415.18

    * Fixed a bug that caused corruption on vkCmdCopyImage calls for non-2D
      texture targets.

2018-11-08 version 415.13

    * Improved error reporting in eglSwapBuffers() by generating codes for
      some missing error types, and adding additional detail to the already
      existing ones.

    * Improved the appearance and functionality of the nvidia-settings
      control panel when it is resized to small sizes.

    * Updated the nvidia-settings control panel to prevent some icons from
      being displayed incorrectly while using some GTK+ themes.

    * Fixed a bug that could cause WINE to crash on recent OS releases.

    * Fixed a bug that could cause an X server crash when exiting Vulkan
      applications running on X servers with UBB enabled.

    * Fixed an X driver bug that caused the "NoEdidModes" token of the
      "ModeValidation" X configuration option to reject non-EDID modes
      whose timings matched EDID modes.

    * Changed the NvEncCreateBitstreamBuffer API call in the NvEncodeAPI
      library to return NV_ENC_ERR_UNIMPLEMENTED instead of NV_ENC_SUCCESS when
      the encoder instance is configured to run in motion estimation-only mode.
      As an indirect consequence of this change, users running the AppEncME
      sample application from the Video Codec SDK prior to SDK version 8.2.16
      will observe a segmentation fault due to bugs in the NvEncoder class. It
      is recommended that users download the latest version of the SDK, where
      these bugs have been fixed, from
      https://developer.nvidia.com/nvidia-video-codec-sdk.

    * Fixed an OpenGL driver bug that caused the upper bounds of
      floating-point viewports, specified through the ARB_viewport_array
      extension, to be clipped incorrectly.

    * Added a new X configuration option "HardDPMS" which
      is disabled by default, but can be enabled to put displays to sleep with
      modesets rather than VESA DPMS. This may fix some displays that fail to
      sleep when DPMS becomes active. "HardDPMS" will be enabled by default in a
      future release.

    * Raised the minimum supported X.Org xserver version to 1.5 (video driver
      ABI version 4).

    * Enabled the NVreg_EnableBacklightHandler kernel module option by default.

    * Removed the LinuxThreads version of the /usr/lib/libnvidia-tls.so library
      and replaced it with the NPTL one that was previously installed in
      /usr/lib/tls/. This fixes crashes on Debian systems when the
      /etc/ld.so.nohwcap file is present.

    * Updated nvidia-installer to allow the --no-cc-version-check option to
      disable the compiler version check when installing with DKMS.

    * Changed the minimum required Linux kernel version from 2.6.9 to 2.6.32.

    * Fixed an OpenGL bug where conditional rendering (NV_conditional_render)
      was incorrectly affecting mipmap generation.

======== Release 410 Entries ========

    * Updated nvidia-settings to allow continued interaction with other
      pages and help content while editing application profiles.

    * Added support for the following GPU:
        * Tesla V100-SXM3-32GB-H

    * Fixed a bug where destroying a direct-to-display swapchain could
      crash Vulkan applications.

    * Fixed a bug that prevented Vulkan applications from using the
      VK_EXT_display_control extension on a display that is driven by X.

2019-01-03 version 410.93

    * Fixed a bug that could prevent display detection from working on
      displays connected to some notebook docking stations.

    * Added support for the following GPU:
        * Quadro RTX 8000

2018-11-15 version 410.78

    * Fixed a bug that could cause the X server to hang on systems booted in
      legacy VGA mode when using a DisplayPort Multi-Stream link.

    * Added support for the following GPUs:
        * Quadro RTX 4000
        * Tesla T4

2018-10-25 version 410.73

2018-10-16 version 410.66

    * Added a USB-C display connector type identifier, such that a display
      connected using Turing's USB-C connector will be named, e.g., "USB-C-0"
      rather than "DP-5". Scripts and configuration files that use the DP
      identifier for this connector will be affected.

    * Added support for the following GPUs:
        * Quadro RTX 5000
        * Quadro RTX 6000
        * GeForce RTX 2070

2018-09-19 version 410.57

    * Added a graphics API visual indicator.  It can be toggled through
      nvidia-settings' "OpenGL Settings" panel, the
      __GL_SHOW_GRAPHICS_OSD environment variable, or the
      GLShowGraphicsOSD application profile.  See the README for more
      information.

    * Added support for X11 RandR transformations on outputs where the NVIDIA X
      driver is used as a synchronized RandR 1.4 output source (i.e., "PRIME
      Sync").

    * Fixed a bug that caused OpenGL corruption on outputs where the NVIDIA X
      driver was used as an RandR 1.4 output source (i.e., "PRIME"), and the
      output sink required a software cursor.

    * Fixed an X driver RandR output source (i.e., "PRIME") bug that could cause
      a duplicate cursor to appear on such outputs.

    * Exposed EGL 1.5 in the EGL version string. This does not add
      any extra functionality to the EGL driver. All EGL 1.5 features
      were already supported through EGL 1.4 plus extensions.

    * Added support for the following GPUs:
        * GeForce RTX 2080 Ti
        * GeForce RTX 2080
        * Tesla V100-SXM2-16GB-LS
        * Tesla V100-PCIE-16GB-LS
        * Tesla V100-SXM2-32GB-LS
        * Tesla V100-SXM3-32GB

    * Added the OptiX ray tracing engine, libnvoptix.so.1, to the driver
      package.

      This library is loaded by the liboptix.so.* library bundled with
      applications that use the OptiX API.

    * Updated nvidia-installer to allow the --no-cc-version-check option to
      disable the compiler version check when installing with DKMS.

    * Added experimental support for VK_EXT_global_priority.

    * Removed support for the VK_NV_glsl_shader Vulkan extension.
      This extension was added before the Vulkan ecosystem had mature
      SPIR-V compilers and tools.  Now that the SPIR-V compilers and
      tools have advanced, Vulkan developers are encouraged to use SPIR-V
      instead of GLSL.

    * Fixed a bug that caused VDPAU-decoded H.265/HEVC content to have
      interlaced artifacts when shared with OpenGL through the
      GL_NV_vdpau_interop extension.

    * Implemented support for Vulkan real-time ray tracing extensions
      (VK_NV_raytracing). Two new libraries, libnvidia-rtcore.so and
      libnvidia-cbl.so, have been added to support the new functionality.
      These new libraries are needed by Vulkan at run-time to expose the
      new extension. If they are not found, Vulkan will continue to work
      without VK_NV_raytracing support.

    * Removed OpenGL header files from the installer package, which were
      deprecated and not installed by default since release 260.19.04, but
      could still be installed with the '--opengl-headers' option.
      If your distribution doesn't provide a package with headers, up-to-date
      headers can be found at these locations:
      https://www.khronos.org/registry/OpenGL/index_gl.php
      https://github.com/NVIDIA/libglvnd/tree/master/include/GL

======== Release 396 Entries ========

    * Added support for the following GPU:
        * Quadro P5200 with Max-Q Design
        * Quadro P4200 with Max-Q Design
        * Quadro P2000 with Max-Q Design

2018-08-21 version 396.54

2018-08-03 version 396.51

    * Added a new command line option, --override-file-type-destination, to
      nvidia-installer. This option can be used to override the destination
      of installed files by file type at installation time.

    * Added support for VK_EXT_vertex_attribute_divisor.

    * Added support for the following GPU:
        * Quadro P3200 with Max-Q Design

2018-07-19 version 396.45

    * Improved recovery of Vulkan direct-to-display applications after an
      application hang or crash.

    * Fixed a bug that could cause multi-threaded EGL applications to crash
      when exiting.

    * Added support for the following GPU:
        * TITAN V JHH Special Edition

2018-05-02 version 396.24

    * Fixed a regression that caused the current MetaMode's ViewPortIn and
      ViewPortOut settings to be preserved across RandR modesets. The driver now
      clears ViewPortIn and ViewPortOut when the mode is set through RandR,
      restoring the behavior that existed prior to the regression.

    * Improved error reporting in the Vulkan driver if
      libnvidia-glvkspirv.so, the new Vulkan SPIR-V compiler added in
      396.18, cannot be found at run time.

    * Fixed performance regressions and corruption issues in the new Vulkan
      SPIR-V compiler.

    * Added support for 32-bit PCI domains throughout the NVIDIA driver stack.
      This support is required for running Linux VMs with recent versions of
      the pci_hyperv driver on top of Hyper-V.

2018-04-10 version 396.18

    * Updated the SLI Mosaic configuration page in nvidia-settings to make
      more layout configurations available, including configurations that
      do not utilize all of the available displays.

    * Added reporting of EGL information to nvidia-settings.

    * Added support for a new Vulkan SPIR-V compiler which reduces shader
      compilation time and shader system memory consumption.

      A new environment variable can be used to enable (1) (default) or
      disable (0) the new compiler if errors in existing applications
      are found:

          __GL_NextGenCompiler=<int>

      The following application profile setting with the same definition
      is also available:

          { "pattern" : [], "profile" : [ "NextGenCompiler", <int> ] }

      The old compiler is deprecated and will be removed in a future
      release.

    * Updated nvidia-installer to recognize partial libglvnd installations
      which are missing only optional libraries. This allows the installer
      to continue installation by default when libglvnd is installed without
      libOpenGL.so, as is frequently the case with distribution-provided
      libglvnd installations.

    * Improved performance of the following Vulkan APIs:
        * vkAllocateMemory()
        * vkBindBufferMemory()
        * vkBindImageMemory()

    * Fixed a bug that caused the NV_CTRL_STEREO_SWAP_MODE setting for
      quad-buffered stereo visuals to not be preserved across modesets
      or VT switches.

    * Added a new global X configuration option "AllowExternalGpus", which
      defaults to disabled, but can be enabled to allow eGPUs and other
      surprise-removable GPUs to be configured with X screens.

======== Release 390 Entries ========

2022-11-22 version 390.157

2022-08-02 version 390.154

2022-05-16 version 390.151

    * Fixed a bug that could prevent nvidia-installer from detecting the
      scripts/sign-file kernel module signing tool when using separate
      kernel source and output directories.

    * Fixed a bug which prevented kernel modules linked from precompiled
      kernel interface object files from being loaded on recent Linux
      kernels. This affected custom packages which were prepared with
      nvidia-installer's --add-this-kernel option, for example.

    * Fixed a driver installation failure on Linux kernel 5.17 release
      candidates, where the NVIDIA kernel module failed to build with error
      "implicit declaration of function 'PDE'".

2021-12-16 version 390.147

    * Worked around a bug in Meson builds of libglvnd 1.3.0 that caused the
      nvidia_icd.json file to be installed in the wrong location.

2021-07-20 version 390.144

2021-04-19 version 390.143

    * Fixed a bug where vkCreateSwapchain could cause the X Server to crash when
      an invalid imageFormat was provided.

2021-01-07 version 390.141

    * Fixed a driver installation failure on Linux kernel 5.11 release
      candidates, where the NVIDIA kernel module failed to build with error
      "fatal error: asm/kmap_types.h: No such file or directory".

    * Fixed a driver installation failure on Linux kernel 5.8 release
      candidates, where the NVIDIA kernel module failed to build with error
      "'struct mm_struct' has no member named 'mmap_sem'". 

    * Fixed a driver installation failure on Linux kernel 5.8 release
      candidates, where the NVIDIA kernel module failed to build with error
      "too many arguments to function '__vmalloc'".

2020-06-24 version 390.138

    * Fixed a driver installation failure on Linux kernel 5.6 release
      candidates, where the NVIDIA kernel module failed to build with error
      "implicit declaration of function 'timespec_to_ns'".

    * Fixed a driver installation failure on Linux kernel 5.6 release
      candidates, where the NVIDIA kernel module failed to build with error
      "implicit declaration of function 'getrawmonotonic'".

    * Fixed a driver installation failure on Linux kernel 5.6 release
      candidates, where the NVIDIA kernel module failed to build with error
      "implicit declaration of function 'getnstimeofday'".

    * Fixed a driver installation failure on Linux kernel 5.6 release
      candidates, where the NVIDIA kernel module failed to build with error
      "dereferencing pointer to incomplete type 'struct timeval'".

    * Fixed a driver installation failure on Linux kernel 5.6 release
      candidates, where the NVIDIA kernel module failed to build with error
      "implicit declaration of function 'jiffies_to_timespec'".

    * Fixed driver installation failure on Linux kernel 5.6 release candidates,
      where the NVIDIA kernel module failed to build with error "passing
      argument 4 of 'proc_create_data' from incompatible pointer type".

    * Fixed driver installation failure on Linux kernel 5.6 release candidates,
      where the NVIDIA kernel module failed to build with error "implicit
      declaration of function 'ioremap_nocache'".

    * Fixed driver installation failure on Oracle Linux 7.7 systems, where the
      NVIDIA kernel module failed to build with error "unknown type name
      'vm_fault_t'".

    * Add PRIME Synchronization support for Linux kernel 5.4 and newer.

2019-11-08 version 390.132

    * Fixed kernel module build problems with Linux kernel 5.4.0 release 
      candidates.

    * Updated nvidia-bug-report.sh to collect information about X server crashes
      from coredumpctl, when available.

2019-07-29 version 390.129

    * Improved nvidia-bug-report.sh to grab the output of the `vulkaninfo`
      command when it is available.

    * Fixed build failures which resulted in errors like "implicit declaration
      of function drm_...", when building the NVIDIA DRM kernel module for Linux
      kernel 5.0 release candidates.

    * Fixed a bug which could cause VK_KHR_external_semaphore_fd operations
      to fail.

    * Fixed a build failure, "implicit declaration of function
      'vm_insert_pfn'", when building the NVIDIA DRM kernel module for Linux
      kernel 4.20 release candidates.

    * Fixed a build failure, "unknown type name 'ipmi_user_t'", when building 
      the NVIDIA kernel module for Linux kernel 4.20 release candidates.

    * Fixed a bug that caused mode switches to fail when an SDI output board was
      connected.

    * Fixed a bug that could cause rendering corruption in Vulkan programs.

    * Added a new hook script, "pre-unload", to the nvidia-installer hook
      script system. This script, if present, will be executed before
      nvidia-installer attempts to unload existing NVIDIA kernel modules.

    * Fixed a bug that caused vkGetPhysicalDeviceDisplayPropertiesKHR() to
      occasionally return incorrect values for physicalResolution.

    * Added the synchronization state for PRIME Displays to nvidia-settings.

2018-08-27 version 390.87

    * Fixed a resource leak introduced in the 390 series of drivers that could
      lead to reduced performance after starting and stopping several OpenGL
      and/or Vulkan applications.

2018-07-16 version 390.77

    * Improved compatibility with recent Linux kernels.

    * Fixed an intermittent hang of Vulkan applications running fullscreen
      when flipping is allowed.

    * Removed informational messages that were printed by nvidia-modeset.ko
      whenever a GPU device was allocated or freed.

    * Fixed a bug that caused kwin OpenGL compositing to crash when
      launching certain OpenGL applications.

2018-06-05 version 390.67

    * Fixed a bug that could cause kernel panics when using Quadro SDI
      Capture hardware.

    * Fixed an intermittent crash when launching Vulkan applications.

    * Fixed an intermittent crash when launching applications through Wine.

    * Fixed a bug that caused the driver, in some low bandwidth DisplayPort
      configurations, to not implicitly enable display dithering.  This
      resulted in visible banding.

2018-05-16 version 390.59

    * Fixed intermittent hangs of fullscreen Vulkan applications when focused
      away (e.g., by using the alt-tab key combination) on non-composited
      desktops.

    * Added support for the following GPUs:
        * GeForce GTX 1050 with Max-Q Design
        * Tesla V100-FHHL-16GB
        * Quadro P3200
        * Quadro P4200

2018-03-28 version 390.48

    * Added support for the following GPUs:
        * Quadro GV100
        * Tesla V100-SXM2-32GB
        * Tesla V100-PCIE-32GB
        * Tesla V100-DGXS-32GB

    * Updated the driver to prevent G-SYNC from being enabled when a
      Quadro Sync board is installed. G-SYNC and Quadro Sync were always
      mutually incompatible features, and this change makes it easier to
      use G-SYNC capable monitors on Quadro Sync configurations, as it is
      now no longer necessary to manually disable G-SYNC.

    * Further improved the fix for occasional flicker when using the X
      driver's composition pipeline.  This was mostly fixed in 390.42,
      but now the fix should be more complete.

2018-03-12 version 390.42

    * Fixed a regression, introduced in 390.12, that caused occasional
      flicker when using the X driver's composition pipeline, for
      example when using screen transformations like rotation, or the
      "ForceCompositionPipeline" or "ForceFullCompositionPipeline"
      options."

    * Fixed a regression introduced in 390.12 that prevented displays from
      working normally when running multiple X screens with emulated overlays.

    * Added support for the following GPUs:
        * GeForce GTX 1060 5GB
        * Quadro P620

    * Fixed a regression introduced in 390.12 that caused occasional hangs and
      hard lockup messages in the system log when screen transformations are in
      use.

2018-01-04 version 390.12

    * Added new application profile settings, "EGLVisibleDGPUDevices" and
      "EGLVisibleTegraDevices", to control which discrete and Tegra GPU
      devices, respectively, may be enumerated by EGL. See the "Application
      Profiles" appendix of the driver README for more details.

    * Corrected the SONAME of the copy of the libnvidia-egl-wayland library
      included in the .run installer package to libnvidia-egl-wayland.so.1.
      The SONAME had previously been versioned incorrectly with the full
      version number of the library.

    * Updated nvidia.ko to veto the ACPI_VIDEO_NOTIFY_PROBE event on
      kernels that allow the handler for this event to be overridden,
      to improve interaction between the NVIDIA driver and acpi_video
      on display hotplug events.

    * Updated the SLI Mosaic layout page in the nvidia-settings control
      panel to support topologies with up to 32 displays.

    * Fixed a bug that prevented Xinerama Info from being handled properly
      in SLI or Base Mosaic layouts with more than 24 displays.

    * Updated the X driver's composition pipeline (used for rotation,
      warp and blend, transformation matrices, etc) to also support stereo.

    * Added an OpenGL stereo preview feature to the screen page in
      nvidia-settings.

    * Fixed a bug where GetTexSubImage() would read incorrect data into
      a pixel buffer object when supplied with a target of
      GL_TEXTURE_1D_ARRAY and a non-zero yoffset value.

    * Added support for generic active stereo with in-band DisplayPort
      signaling. The X configuration option "InbandStereoSignaling" is
      deprecated in favor of this stereo mode. See "Appendix B. X Config
      Options" in the README for more information.

    * Modified the driver to avoid restoring framebuffer console modes
      on virtual reality head-mounted displays.

======== Release 387 Entries ========

    * Added support for the following GPUs:
        * TITAN Xp COLLECTORS EDITION
        * GeForce GTX 1070 Ti
        * TITAN V

    * Fixed a bug that could cause a system crash when using the new
      NVreg_EnableBacklightHandler kernel module parameter on GPUs with no
      displays connected.

    * Fixed a bug that caused Vulkan X11 swapchains to fail on GPUs without a
      display engine, such as some Tesla-branded graphics cards and some Optimus
      laptops.

    * Fixed a bug that caused fullscreen Vulkan applications to hang on some
      Kepler GPUs, such as the GeForce GTX 680.

    * Fixed a bug where the G-SYNC indicator was reporting "normal" instead
      of "G-SYNC" on Vulkan applications when G-SYNC was enabled.

2017-10-30 version 387.22

    * Fixed a regression that could cause driver errors when setting modes
      that include DisplayPort Multi-Stream Transport devices.

    * Added an nvidia.ko kernel module parameter, NVreg_EnableBacklightHandler,
      which can be used to enable experimental handling of laptop backlight
      brightness through /sys/class/backlight/. This handler overrides the
      ACPI-based one provided by the video.ko kernel module.

      NVreg_EnableBacklightHandler is disabled by default.

    * Added G-SYNC to all supported Vulkan swapchains for Maxwell and up.
      G-SYNC is enabled by default when using G-SYNC-ready monitors.  For
      direct-to-display swapchains, an application profile with "GLGSYNCAllowed"
      setting set to 'false' can be used to disable this feature:

        {
          "rules" : [
            { "pattern" : [], "profile" : [ "GLGSYNCAllowed", false ] }
          ]
        }

2017-10-03 version 387.12

    * Fixed a regression that caused some display connectors on some GPUs to not
      report a connected HDMI or DisplayPort audio device even if the connected
      monitor supports audio.

    * Fixed a bug that sometimes prevented the "Reset Default Configuration"
      button in the nvidia-settings "ECC Settings" page from being available
      when the ECC configuration is set to a non-default state.

    * Fixed a bug that caused nvidia-settings to enforce overly aggressive
      limits on display positions in the "X Server Display Configuration"
      page under some circumstances.

    * Fixed a bug that could cause the "Enable Base Mosaic (Surround)"
      checkbox in nvidia-settings to disappear when an X screen, rather than
      a display, is selected in the "X Server Display Configuration" page.

    * Fixed a race condition that could lead to crashes when OpenGL programs
      manipulated vertex buffer objects from multiple threads simultaneously.

    * Fixed a bug that caused the nvidia-settings control panel to retain
      some settings that had been applied, but not confirmed. This resulted
      in unwanted settings being applied to subsequent settings changes.

    * Improved performance of fullscreen Vulkan applications using X11
      swapchains.  This optimization will cause more events that trigger
      an out-of-date swapchain, such as when entering or leaving
      fullscreen mode.  (This is commonly encountered when using the
      alt-tab key combination, for example.)   Applications that do not
      properly respond to the VK_ERROR_OUT_OF_DATE_KHR return code may
      not function properly when these events occur.  See section 30.8
      of the Vulkan specification.

    * Added support for YUV 4:2:0 compression for monitors connected via
      DisplayPort in configurations where either the display or GPU is
      incapable of driving the current mode in RGB 4:4:4.  See the
      description in the "Programming Modes" appendix for details.

    * Added framebuffer console hot plug handling to nvidia-modeset.

      Note that hot plugging is only handled when nvidia-modeset is initialized;
      for example, when Xorg or nvidia-persistenced is running or when
      nvidia-drm is loaded with the "modeset=1" parameter.

    * Added an "AllowGSYNC" MetaMode attribute that can be used to disable
      G-SYNC completely. This can be use to allow enabling features that are
      incompatible with G-SYNC, such as Ultra Low Motion Blur or Frame Lock.

    * Fixed several problems that prevented the "cc_version_check" sanity
      test from running correctly when building the NVIDIA kernel modules.
      As these problems would have masked mismatches between the compiler
      versions used to build the kernel and the NVIDIA kernel modules for
      an extended period of time, nvidia-installer has been updated to
      ignore CC version mismatches by default when they are detected.

    * Updated nvidia-installer to use the init_module syscall directly to
      test load kernel modules instead of libkmod/insmod. This removes
      libkmod as a build dependency of nvidia-installer, and insmod as
      a run-time dependency.

    * Tiled monitors formerly resulted in a separate Xinerama screen being
      reported for each tile. They will now, by default, be combined into a
      single large Xinerama screen.

    * The individual panels in a tiled monitor will now be arranged based
      on the layout information provided in the monitor's EDID. This can be
      overridden by either manually specifying offsets or using the
      "MetaModeOrientation" option.

    * Disabled interlaced modes over DisplayPort by default due to incomplete
      support in the GPU. Added "AllowDpInterlaced" mode validation token to
      override this default behavior and allow interlaced modes over
      DisplayPort protocol anyway.

======== Release 384 Entries ========

2018-03-28 version 384.130

    * Improved compatibility with recent Linux kernels.

    * Fixed a string concatenation bug that caused libGL to accidentally try to
      create the directory "$HOME.nv" rather than "$HOME/.nv" in some cases
      where /tmp isn't accessible.

    * Increased the version numbers of the GLVND libGL, libGLESv1_CM,
      libGLESv2, and libEGL libraries, to prevent concurrently installed
      non-GLVND libraries from taking precedence in the dynamic linker
      cache.

2018-01-04 version 384.111

    * Added support for the following GPUs:
        * GeForce MX130
        * GeForce MX110
        * GeForce GTX 1050 Ti with Max-Q Design
        * Quadro P500

    * Fixed a regression that prevented displays connected via some types of
      passive adapters (e.g. DMS-59 to VGA or DVI) from working correctly.
      The regression was introduced with driver version 384.98.

    * Fixed a bug that caused Quadro M2200 GPUs to enter the lowest available
      PowerMizer performance level when under load.

2017-11-02 version 384.98

    * Added support for the following GPUs:
        * P104-101
        * P106-090
        * Tesla V100-SXM2-16GB
        * Tesla V100-PCIE-16GB

    * Fixed a bug that could cause some eDP G-SYNC displays to flicker at low
      refresh rates.

    * Fixed a bug that could cause OpenGL applications to crash after a
      prolonged DPMS sleep state on a monitor driven with PRIME Sync.

    * Fixed a bug that artificially limited the maximum pixel clock to 300 MHz
      when using certain more capable DisplayPort to HDMI adapters.

    * Fixed a bug that prevented the NVIDIA kernel modules from building for
      non-SMP Linux kernels.

    * Updated the output of `nvidia-smi nvlink --status` to include reporting
      NVLink speed.

    * Fixed a bug that caused incorrect PCI topology reporting in nvidia-smi
      on Intel Skylake systems.

2017-09-21 version 384.90

    * Fixed a regression that caused display flickering at lower PowerMizer
      performance levels on some GPUs.

    * Fixed a regression that prevented console restoration after a VT switch
      on some GPUs.

    * Fixed a bug that could cause a system hang when resuming from suspend
      with some GPUs.

    * Fixed a bug that caused slow or stuttering frame rates in applications
      that use GLX_EXT_swap_control_tear while G-SYNC is active.

    * Added support for the following GPU:
        * Quadro P5200

    * Fixed a bug in the NVIDIA VDPAU driver that caused
      VdpVideoSurfaceGetBitsYCbCr() of H.265/HEVC content to have interlaced
      artifacts.

    * Fixed a bug that caused the X driver to not correctly report the
      "BlendOrder" MetaMode token when querying the MetaMode through, e.g.,
      `nvidia-settings --query CurrentMetaMode`.

    * Fixed a bug that prevented nvidia-installer from displaying a
      targeted error message when optional kernel modules fail to load.

2017-08-18 version 384.69

    * Fixed an intermittent hang when using Vulkan to present directly to
      display with the VK_KHR_display extension.  SteamVR was particularly
      affected by that hang.

    * Added support for the following GPU:
        * Quadro P4000 with Max-Q Design

2017-07-24 version 384.59

    * Added support for the following GPUs:
        * GeForce GT 1030
        * GeForce MX150
        * P104-100
        * P106-100

    * Fixed a bug that prevented changes to stereo eye assignment from
      getting applied from the nvidia-settings control panel.

    * Fixed a bug that caused S4 suspend (also known as "hibernate") to hang
      during suspend when SLI was enabled.

    * Fixed a bug where devices would not be properly enumerated by
      the Vulkan driver.  See the "Known Issues" section of the README
      for more details.

2017-06-29 version 384.47

    * Fixed a bug that could cause OpenGL applications to crash after
      calling glDeleteBuffers on VBOs that have been remapped with
      ARB_vertex_attrib_binding.

    * Fixed a bug that could sometimes cause OpenGL applications to
      lock up until the X server receives input.

    * Fixed a bug that caused nvidia-settings to drop device BusID
      values when making changes to an existing X configuration file.

    * Fixed a regression that prevented nvidia-xconfig from querying
      some GPUs, e.g. when running `nvidia-xconfig -a`.

    * Fixed a bug that caused VDPAU playback to be corrupted when
      extended to coordinates beyond 16384 pixels.

    * Updated nvidia-persistenced to initialize nvidia-modeset.ko in
      addition to nvidia.ko when setting persistence mode.

    * Restored several sanity checks that were inadvertently removed from
      the kernel module build process in the 355.06 driver.

    * Added support for a "Nearest" transform filter in the X driver.
      This causes the X driver to use nearest neighbor filtering when
      performing screen transformations.  The filter can be requested
      through the 'filter' argument to RandR's RRSetCrtcTransform,
      or through the 'ResamplingMethod' MetaMode token.

    * Fixed a bug where nvidia-installer would install a wrong version
      of the Vulkan ICD configuration file when GLVND is disabled for
      the GLX client.

======== Release 381 Entries ========

    * Disabled OpenGL threaded optimizations by default, as they were causing
    * regressions in some cases. Refer to the README for information on how to
    * enable these optimizations on a per-application basis.

2017-05-09 version 381.22

    * Fixed a bug that caused the GLX_EXT_buffer_age buffer age extension to
      return incorrect values for stereo drawables when using passive stereo
      modes 5 through 9.

    * Fixed a bug in Vulkan direct to display where DP1.2 monitors were not
      being enumerated.

2017-04-06 version 381.09

    * Improved compatibility with recent kernels.

    * Fixed a bug that caused "nvidia-settings --query all" to print many
      duplicate entries.

    * Fixed a bug that caused applications to crash in some situations when
      calling glXMakeCurrent while OpenGL threaded optimizations were enabled.

      This frequently occurred when Steam was attempting to make a video appear
      full-screen.

    * Fixed a bug that caused VDPAU applications to use the blit presentation
      queue when a previous VDPAU application didn't shut down cleanly.

    * Fixed hangs and crashes that could occur when an OpenGL context is created
      while the system is out of available memory.

    * Fixed a bug that caused corruption when OpenGL windows were moved or
      resized.

    * Fixed a bug that caused X screens that use Option "UseDisplayDevice"
      "none" to be resized to 640x480 when using "xrandr -s" to change the
      screen configuration.

    * Fixed a kernel crash that occurred when attempting to map large user
      memory allocations into CUDA.

    * Disabled OpenGL threaded optimizations by default, initially
      enabled in 378.09, due to various reports of instability.

    * Added support for the following Vulkan extensions:
        * VK_EXT_acquire_xlib_display
        * VK_EXT_display_control
        * VK_EXT_display_surface_counter
        * VK_EXT_direct_mode_display
        * VK_KHX_external_memory
        * VK_KHX_external_memory_fd
        * VK_KHX_external_semaphore
        * VK_KHX_external_semaphore_fd
      These extensions require a Vulkan loader version >= 1.0.42.

    * Removed the X driver's logo splash screen and the corresponding NoLogo
      and LogoPath xorg.conf options.

    * Added the "ResamplingMethod" MetaMode option, adding support for
      bicubic resampling methods when scaling screen transformations
      are in use.  See the README for more details.

======== Release 378 Entries ========

2017-02-14 version 378.13

    * Disabled OpenGL threaded optimizations by default under Xinerama.

2017-01-18 version 378.09

    * Added support for the ARB_parallel_shader_compile extension to allow
      multi-threaded compilation of GLSL shaders.

    * Updated the X driver to ignore any Virtual Reality Head Mounted
      Displays (HMDs).  See the "AllowHMD" X configuration option in the
      README for details.

    * The driver will now advertise GLX FBConfigs with no depth bits on depth 30
      X screens.

    * Added support in nvidia-settings to view configured PRIME displays. To
      enable PRIME displays, see "Offloading Graphics Display with RandR 1.4"
      in the README.

    * Added infrastructure which enables the NVIDIA EGL driver to load EGL external
      platform libraries that add client-side support for new window systems, beyond
      the existing libnvidia-egl-wayland.so.1. For more details, see:
        - https://github.com/NVIDIA/eglexternalplatform
        - https://github.com/NVIDIA/egl-wayland

    * Added support for the following Vulkan extensions:
        * VK_KHR_display
        * VK_KHR_display_swapchain

    * Enabled OpenGL threaded optimizations by default in the driver. Refer to
      the "Threaded Optimizations" section in the "Specifying OpenGL Environment
      Variable Settings" chapter of the README for details.  These optimizations
      will self-disable when they are degrading performance.  As a result,
      performance should be unchanged for many applications, and increased for
      those that benefit from threaded optimizations and were not already
      forcing them enabled.

======== Release 375 Entries ========

    * Disabled G-SYNC in desktop environments, such as Budgie, that use
      libmutter-0.so.

      An existing rule to disable G-SYNC for libmutter.so no longer applied
      after the library was renamed to libmutter-0.so.

2017-07-24 version 375.82

    * Fix a bug with GLX_EXT_buffer_age where incorrect buffer age values
      would be reported for SLI AFR configurations. In such configurations
      buffer age may now be greater than 3, the previous maximum buffer age.

    * Fixed a bug that could cause hanging and Xids when performing RandR
      transforms with Overlay and SLI enabled.

    * Extended the information reported by the NVIDIA Xinerama X extension to
      report PRIME displays in addition to directly-connected displays.

    * Fixed a bug that caused HDMI audio devices to appear or disappear
      inconsistently when HDMI devices were hotplugged or unplugged.

    * Fixed a bug that could cause driver errors when setting modes on X
      screens running at Depth 8 or Depth 15.

    * Added support for the following GPUs:
        * GeForce GTX 1080 with Max-Q Design
        * GeForce GTX 1070 with Max-Q Design
        * GeForce GTX 1060 with Max-Q Design

    * Fixed a bug that could cause intermittent kernel panics when running with
      PRIME Sync.

    * Fixed a bug that caused a kernel panic when hotplugging HDMI displays
      on some Zotac mini PCs.

2017-05-04 version 375.66

    * Fixed a bug that could cause EGL applications to crash when
      calling eglInitialize() multiple times on X11-backed displays.

    * Fixed a regression that could cause rendering corruption on a
      monitor connected via DisplayPort upon a modeset event (for
      example, changing resolutions or power cycling the monitor).

    * Updated the display configuration page in the nvidia-settings
      control panel to accurately reflect HDMI 3D refresh rates.

    * Fixed a bug that could cause OpenGL applications to crash when
      VT switching between multiple X servers.

    * Fixed a bug that caused the system to become unresponsive after
      resuming from power management suspend/hibernate.  Additional
      symptoms of this bug included display flickering and "Xid 56"
      errors in the kernel log.

    * Fixed a bug that caused backlight brightness to not be controllable
      on some notebooks with DisplayPort internal panels.

    * Added support for the following GPUs:
        * GeForce GTX 1080 Ti
        * Quadro M520
        * TITAN Xp

    * Fixed a bug that left HDMI and DisplayPort audio muted after a framebuffer
      console mode was restored. For some displays, this caused the display to
      remain blank.

    * Fixed a bug that caused audio over DisplayPort to stop working when the
      monitor was unplugged and plugged back in or woken from DPMS power-saving
      mode.

    * Restored support for the following GPU:
        * GRID K520

    * Fixed a regression that caused corruption in certain applications, such as
      window border shadows in Unity, after resuming from suspend.

    * Added support for the following GPU:
        * Quadro P3000

    * Installation of the nvidia-drm kernel module is now optional. The new
      '--no-drm' option can be used to prevent nvidia-installer from building
      and installing nvidia-drm, on systems where this kernel module fails to
      build and/or load.

    * Fixed a bug that could cause some applications to crash when
      running with PRIME Sync.

    * Fixed a bug that prevented PRIME Sync from working on notebooks
      with GeForce GTX 4xx and 5xx series GPUs.

    * Fixed a bug that caused OpenGL applications to have excessive CPU usage
      when running with PRIME Sync but without native displays enabled.

    * Fixed a bug that could cause PRIME Sync to deadlock in the kernel,
      particularly common on Linux 4.10.

    * Fixed a bug that caused PRIME Sync to run slowly on systems with Pascal
      GPUs.

2017-02-14 version 375.39

    * Fixed a bug that caused system hangs when resuming from suspend with
      some GPUs.

    * Fixed a regression that could cause corruption when hot-plugging
      displays.

    * Fixed a regression that prevented systems with multiple DisplayPort
      monitors from resuming correctly from suspend.

    * Added support for the following GPU(s):
        * Quadro GP100
        * Quadro P4000
        * Quadro P2000
        * Quadro P1000
        * Quadro P600
        * Quadro P400
        * Quadro M1200
        * Quadro M2200

2016-12-14 version 375.26

    * Fixed a regression that prevented the backlight on some notebook
      computer displays from turning back on after being shut off.

    * Fixed a regression that prevented the console from being restored
      properly when using SLI.

    * Fixed a bug that caused installer manifest entries for some 32-bit
      compatibility libraries to be duplicated in the installer package.
      These entries led nvidia-installer to issue warning messages when
      installing the 32-bit compatibility libraries, for example:
      'Cannot create symlink /usr/lib/libEGL.so (File exists)'.

    * Fixed a regression that could cause the nvidia-settings control panel
      to crash on startup with certain GPU configurations.

    * Fixed a regression that prevented the GLX_NV_swap_group extension from
      working when using SLI or Quadro Sync.

    * Fixed a long-standing bug that caused the NVIDIA X driver to not
      correctly detect AC/battery hotplug events on notebooks.

    * Added support for the following GPU(s):
        * Quadro M3000 SE

    * Fixed an interaction problem between the Linux kernel's
      CONFIG_HARDENED_USERCOPY feature (new in Linux kernel 4.8)
      and nvidia-drm.ko with modeset=1 enabled.  This problem caused
      CONFIG_HARDENED_USERCOPY to erroneously halt the system, issuing
      reports of the form:

        usercopy: kernel memory overwrite attempt detected to ffff8803e8ec7ce0 (<process stack>) (8 bytes)

2016-11-18 version 375.20

    * Fixed a bug that could cause displays in SLI Mosaic to blank when
      applying a transformation matrix.

    * Added EGL support to the GL Vendor Neutral Dispatch Library (libGLVND).
      The installer package now includes both GLVND and non-GLVND versions of
      the EGL libraries: the --glvnd-egl-client and --no-glvnd-egl-client
      options in nvidia-installer can be used to select which to install.

    * Added support for the following GPUs:
        * GeForce GTX 1050
        * GeForce GTX 1050 Ti
        * Quadro M620
        * Quadro M5000 SE
        * Tesla P100-PCIE-12GB
        * Tesla P100-PCIE-16GB
        * Tesla P100-SXM2-16GB
        * Tesla P4

    * Fixed a bug that prevented G-SYNC from working on notebook displays.

    * Fixed a bug that caused DisplayPort multi-stream devices to go blank after
      the console is restored.

    * Fixed a bug that caused a kernel crash when starting X for the second time
      when more than one DisplayPort multi-stream device is connected to a
      single DisplayPort connector via a branch device.

    * Updated nvidia-settings to not have a build-time dependence on
      an external NVML development package (a regression introduced in
      375.10).

    * Fixed a crash in nvidia-settings when adding Application Profile Rule and
      Profile entries.

    * Removed the "Enable Tooltip" option in nvidia-settings for the GTK 2
      interface.

2016-10-20 version 375.10

    * Added new X configuration options:
        ForceCompositionPipeline
        ForceFullCompositionPipeline
      which override the MetaMode tokens with the same names.

    * Fixed a bug that caused issues with panning and cursor constraining when
      mixing PRIME-driven displays with natively driven displays.

    * Fixed a bug that caused long delays when leaving the VT or disabling a
      display device while an OpenGL application is running.

    * Improved console restore behavior on systems that use the UEFI Graphics
      Output Protocol, and most vesafb modes.

    * Added support for the RandR TILE property added in RandR 1.5.

    * Raised the on-disk OpenGL shader cache size from 64MB to 128MB. Refer to
      the "Specifying OpenGL Environment Variable Settings" section of the
      driver README for details on how to select its location or disable it.

======== Release 370 Entries ========

2016-09-08 version 370.28

    * Improved compatibility with recent Linux kernels.

    * Fixed undefined symbol references in libnvidia-glcore.so.

    * Fixed a potential hang in Vulkan applications such as vkQuake and DOTA2
      that use vkFences for present synchronization.

    * Fixed a bug that caused the driver to not set HDMI YUV 420 4K
      modes correctly on some TVs, such as the VIZIO D40u-D1.

    * Updated CurrentMetaMode reporting via the NV-CONTROL API to reflect
      whether ForceCompositionPipeline or ForceFullCompositionPipeline are
      set in the current MetaMode.

2016-08-15 version 370.23

    * Added the ability to over- and under-clock certain GeForce
      GPUs in the GeForce GTX 1000 series and later.  For GPUs that allow it,
      an offset can be applied to clock values in some clock domains of
      all performance levels.  This clock manipulation is done at the
      user's own risk.  See the README documentation of the "CoolBits"
      X configuration option for more details.

    * Implemented initial support for PRIME Synchronization to synchronize
      flipping between an NVIDIA PRIME display source and a separate PRIME
      display sink. This support is experimental and currently requires a
      pre-release X.org X server.

    * Fixed a bug that prevented Vulkan applications from presenting from
      multiple queues to the same X11 swapchain.

    * Added the "PixelShiftMode" MetaMode option, enabling support for 4K and
      8K pixel shift displays.  See the README for details.

======== Release 367 Entries ========

    * Added a new kernel module parameter, NVreg_RestrictProfilingToAdminUsers,
      to allow restricting the use of GPU performance counters to system
      administrators only.

    * Updated the OpenGL driver to allow the use of integer format (SINT/UINT)
      color attachments with depth attachments in Frame Buffer Objects.

    * Fixed a bug in synchronization primitives shared between X and OpenGL.

2016-10-10 version 367.57

    * Fixed a bug that could prevent systems with GPUs configured in SLI from
      resuming correctly from ACPI S3/S4 sleep/hibernate states.

    * Added support for the following GPUs:
        * Quadro P6000
        * Tesla P40
        * Quadro P5000

    * Added support for NVIDIA 3D Vision 2 Stereo on Linux. This IR emitter can
      be used with stereo mode "10" set in the X configuration file.

    * Fixed a bug in nvidia-persistenced that caused it to incorrectly delete
      the PID file if a second instance of the daemon is started.

2016-08-23 version 367.44

    * Fixed a regression that caused applications using indirect GLX
      to crash.

    * Added support for the following GPUs:
        * TITAN X (Pascal)
        * GeForce GTX 1060 6GB
        * GeForce GTX 1060 3GB

    * Fixed a regression introduced in 367.35 that caused the first
      modeset of the X server to display blank if the features requested
      in the X configuration file enabled the X driver's composition
      pipeline.  This would be triggered, e.g., by MetaMode tokens
      such as ForceCompositionPipeline, ForceFullCompositionPipeline,
      Rotation, Reflection, and Transform.

2016-07-15 version 367.35

    * Fixed a regression that could cause console corruption when resuming
      from suspend.

    * Improved buffer write performance of the nvidia-drm DRM KMS driver by
      using write-combined DRM Dumb Buffers where available.

    * Fixed a bug that caused X to crash when applying changes to the RandR
      CscMatrix property while VT-switched away from X.

    * Fixed a bug that caused a crash when exiting nvidia-settings on displays
      with 8 or 15 bit color depths.

2016-06-13 version 367.27

    * Added support for VDPAU Feature Set H to the NVIDIA VDPAU driver.
      GPUs with VDPAU Feature Set H are capable of hardware-accelerated
      decoding of 8192x8192 (8k) H.265/HEVC video streams.

    * Added support for the following GPUs:
        * GeForce GTX 1080
        * GeForce GTX 1070

    * Fixed a bug that caused the X server to sometimes skip displaying Vulkan
      frames when the Composite extension is enabled.

2016-05-19 version 367.18

    * Fixed a bug that would cause OpenGL applications to crash when creating
      a context on one X display connection, then making it current with no
      associated drawable on another X display connection.  This fixes a crash
      when starting some versions of MATLAB.

    * Fixed OpenGL presentation to SDI through the GLX_NV_video_out and
      GLX_NV_present_video extensions, which was broken by the introduction
      of the nvidia-modeset kernel module in 358.09.

    * Fixed a bug that caused an incorrect offset to be applied when using
      the full composition pipeline on a display whose image has both a
      rotation and a ViewportOut offset applied.

    * Fixed a bug that could cause nvidia-settings to crash on some systems
      when responding to events such as hotplugging DisplayPort devices.

    * Fixed a bug that could cause crashes in OpenGL applications which use
      glTextureView() with a non-zero minimum level.

    * Enhanced the Display Device information page in nvidia-settings with
      additional information for DisplayPort devices to reflect attributes
      which are specific to DisplayPort connections.

    * Fixed a bug which could cause deleted application profiles to appear
      when editing rules in the nvidia-settings control panel.

    * Fixed a bug that caused hangs when a G-SYNC monitor is unplugged and a
      non-G-SYNC monitor is connected while G-SYNC is active.

    * Fixed a bug that caused "nvidia-modeset: ERROR: GPU:0: Activating G-SYNC
      failed" to be printed to the system log if a G-SYNC monitor is connected
      and stereo is enabled in xorg.conf on a configuration that doesn't support
      it.

    * Added the NV_robustness_video_memory_purge OpenGL extension, which
      allows applications to know when a mode switching or power event
      purged the contents of FBOs and buffer objects residing in video memory.

    * Fixed a bug that prevented HDMI 2.0 4K monitors from waking up
      from sleep or hot-re-plug.

======== Release 364 Entries ========

2016-04-22 version 364.19

    * Fixed some locking issues in libnvidia-egl-wayland.so.

    * Fixed several libnvidia-egl-wayland.so interaction problems with
      buffer management Wayland protocols.

2016-04-06 version 364.15

    * Fixed several EGL driver interaction problems with resizing windows
      in Wayland.

    * Fixed a bug that caused some DRM PRIME configurations to fail when
      DRM KMS was enabled (i.e., nvidia-drm.ko's modeset kernel module
      parameter was set to "1").

    * Fixed a bug that could cause a kernel crash when VDPAU was used
      while DRM KMS was enabled.

2016-03-21 version 364.12

    * Changed the default OpenGL installation type to use the GLVND GLX
      client libraries rather than the legacy non-GLVND libraries.

    * Added initial support for Direct Rendering Manager Kernel
      Modesetting (DRM KMS).  See the DRM KMS section of the README for
      details.

    * Added a new kernel module, nvidia-drm.ko, which registers as a DRM
      driver with both PRIME and DRM KMS support.

    * Added support for the following EGL extensions:

        EGL_EXT_platform_wayland

      to enable Wayland applications to run on NVIDIA's EGL implementation,

        EGL_WL_bind_wayland_display

      to enable Wayland compositors to run on NVIDIA's EGL implementation, and

        EGL_EXT_device_drm
        EGL_EXT_output_drm
        EGL_EXT_stream_consumer_egloutput

      to enable Mir and Wayland compositors to display their content
      through EGLDevice, EGLOutput, and EGLStreams.

    * Added a Wayland platform library, libnvidia-egl-wayland.so, to allow
      Wayland compositors that support EGLDevice, EGLOutput, and EGLStreams
      to share EGL buffers with Wayland applications.

    * Fixed a bug that could cause incorrect frame rate reporting on Quadro
      Sync configurations with multiple GPUs.

    * Added support for the Vulkan API version 1.0.

    * Improved X colormap precision from 8 significant bits to 11 on GeForce
      GPUs.  Quadro GPUs already used 11 bits of precision.

    * Added a new RandR property, CscMatrix, which specifies a 3x4 color-space
      conversion matrix.  The matrix is applied after the X colormap and before
      the gamma ramp.  This property is available on GF119 and newer GPUs.

    * Improved handling of the X gamma ramp on GF119 and newer GPUs.  On these
      GPUs, the RandR gamma ramp is always 1024 entries and now applies to the
      cursor and VDPAU or workstation overlays in addition to the X root window.

    * Reworked how the NVIDIA driver registers with the Linux
      kernel's DRM subsystem for PRIME support.  As a result, PRIME
      support requires Linux kernel version 3.13 or newer (previously,
      PRIME support required Linux kernel version 3.10 or newer).

    * Improved the interactivity of applications that use a hardware cursor
      while G-SYNC is active.

======== Release 361 Entries ========

    * Fixed a bug that could cause OpenGL applications to leak open file
      descriptors under some circumstances.

    * Fixed a crash in the OpenGL and OpenGL ES drivers in situations where
      some of the NVIDIA device nodes were not accessible.

    * Fixed a crash when querying the CUDA device handle of an EGLDevice in
      a system with multiple GPUs when the NVIDIA UVM device node or kernel
      module was not accessible.

    * Changed the behavior of nvidia-persistenced to enable persistence mode
      by default for all GPUs when the daemon is started.

    * Added support for querying clock values on Pascal GPUs.

    * Removed the Base Mosaic configuration option from nvidia-settings on
      systems where the feature is not actually supported.

    * Fixed a bug that caused nvidia-smi to report an inaccurate version
      number.

    * Fixed a bug that could lead to a system crash if there was a peer-to-peer 
      mapping still active during CUDA context teardown.

2016-05-24 version 361.45.11

    * Fixed a bug that sometimes prevented flipping from being enabled on
      systems with multiple displays.

    * Fixed a bug that could cause applications to crash when using the 
      EGL_EXT_platform_device extension on a system with multiple GPUs.

    * Fixed a bug that could cause nvidia-installer's runtime loader test
      to fail spuriously on some systems.

    * The NVIDIA Unified Virtual Memory kernel module, nvidia-uvm.ko, now
      has a minimum kernel requirement of Linux 2.6.32. On older kernel
      versions, nvidia-uvm.ko will be compiled as a stub kernel module
      which does not provide any functionality.

    * Added support for the following GPUs:
        * Tesla M40 24GB
        * Quadro M5500
        * Quadro M2000

    * Updated the libglvnd snapshot included in the NVIDIA driver
      package to libglvnd commit b7d75429677eecc00c3701aaa4deac1304bc51ff.
      This contains a new revision of the libglvnd ABI. The driver is not
      compatible with a libglvnd older than commit
      c5bcda3b848fe52d6ae6ef25c917431c06d62d27.

2016-03-30 version 361.42

    * Limited the default concurrency level in nvidia-settings to 32, to
      avoid hitting the maximum tasks limit on systems with many CPUs.

    * Added support for the following GPUs:
        * GeForce 920MX
        * GeForce 930MX
        * Quadro M6000 24GB

    * Fixed a regression that caused GPU exceptions and incorrect rendering
      when using pbuffers with EGLDevice.

    * Fixed a bug that caused nvidia-settings to crash when pairing glasses
      with the 3D Vision Pro transmitter on some systems.

    * Fixed a bug that caused installer manifest entries for some 32-bit
      compatibility libraries to be duplicated in the installer package.

    * Fixed a regression that caused the HSync and VSync mode timing polarity
      flags to be inverted.

2016-02-09 version 361.28

    * Added support for the following GPU:
        * GeForce 945A

    * Added a legacy, non-GLVND libGL.so GLX client library to the NVIDIA
      Linux driver installer package, and the ability to select between a
      GLVND or non-GLVND GLX client library at installation time. This
      allows users to install the legacy non-GLVND GLX client library in
      order to work around compatibility issues which may arise due to GLX
      applications which depend upon behaviors of the NVIDIA GLX client
      driver which are not defined by the Linux OpenGL ABI version 1.0.

      By default, nvidia-installer will install the legacy, non-GLVND GLX
      client libraries. The --glvnd-glx-client command line option can be
      used to override the default, and install the GLVND GLX client
      libraries instead. Please contact the vendors of any applications
      that are not compatible with GLVND to ensure that their applications
      be updated for compatibility with GLVND.

      The presence of multiple GLX client libraries in the package has
      implications for repackagers of the NVIDIA driver; see the libGL.so
      entry in the "Installed Components" chapter of the README for details.

2016-01-13 version 361.18

2016-01-05 version 361.16

    * The OpenGL Vendor-Neutral Driver (GLVND) infrastructure is now included
      and supported by the NVIDIA GLX and OpenGL drivers.  This should not
      cause any visible changes in behavior for end users, but some internal
      driver component libraries have been renamed and/or moved as a result.
      These changes may affect scripts that rely on the presence of NVIDIA
      OpenGL driver components other than those specified in the Linux OpenGL
      ABI version 1.0, maintainers of alternative NVIDIA driver installation
      packages, and applications which rely on the presence of any non-
      OpenGL/GLX symbols in the libGL.so.1 library and its dependencies in
      any way.

      Please see:
      
        https://github.com/NVIDIA/libglvnd

      For more information on the GLVND project.

      The Linux OpenGL ABI version 1.0 specification is available at:

        https://www.opengl.org/registry/ABI

    * Updated nvidia-installer to run ldconfig(8) and depmod(8) after
      uninstalling an existing driver, instead of only running these two
      commands when installing a new driver.

    * Removed the VDPAU wrapper and trace libraries libvdpau.so.1 and
      libvdpau_trace.so.1 from the driver package.  These libraries may be
      available via your distribution's package management system, or can be
      compiled from the sources available at:

        http://people.freedesktop.org/~aplattner/vdpau/

      Please see

        http://freedesktop.org/wiki/Software/VDPAU/

      for more information.

======== Release 358 Entries ========

    * Fixed a regression, introduced in 358.09, that caused incorrect
      rendering of OpenGL stereo applications in combination with
      Quadro Sync on certain GPUs.

    * Fixed a regression, introduced in 358.09, that caused OpenGL
      stereo applications to hang when SLI AFR, SFR, or SLIAA modes
      were enabled.

    * Fixed a regression, introduced in 358.09, that caused the
      system to hang while launching OpenGL applications when some SLI
      Mosaic topologies were in use.

    * Fixed a bug that could cause some G-SYNC monitors to flicker on
      Kepler-based GPUs when running at low frame rates.

    * Fixed a regression that could cause OpenGL or VDPAU applications to
      hang in Xinerama layouts which include multiple X screens that are
      driven by the same GPU.

    * Fixed a bug that could cause nvidia-installer to crash when installing
      from a driver package that has had precompiled kernel interfaces added
      to it (e.g., by using the "--add-this-kernel" option).

    * Fixed a regression from 358.09 that caused G-SYNC monitors configured to
      use 3D Vision stereo to go blank and report an unsupported signal.

    * Fixed a regression from 358.09 that caused OpenGL applications that failed
      to negotiate permission to perform glXSwapBuffers via flipping to stop
      updating the screen.  This was triggered on Fedora 22 where the SELinux
      system policy prevents gnome-shell from communicating with the X server.

      Now, OpenGL applications that fail to negotiate flipping will fall back to
      glXSwapBuffers via blitting.

      See https://bugzilla.redhat.com/show_bug.cgi?id=1271401 for more details.

2015-10-12 version 358.09

    * Fixed a regression that reduced OpenGL performance on headless X
      server configurations.

    * Fixed a memory leak that occurred after destroying a GLXWindow which
      still has the current context attached to it.

    * Fixed a bug which caused EGL pbuffers to be created with both a front
      and back buffer, instead of a back buffer only, as is required for EGL.

    * Added a new kernel module, nvidia-modeset.ko.  This new driver
      component works in conjunction with the nvidia.ko kernel module
      to program the display engine of the GPU.
      nvidia-modeset.ko does not provide any new user-visible
      functionality or interfaces to third party applications.  However,
      in a later release, nvidia-modeset.ko will be used as a basis for
      the modesetting interface provided by the kernel's direct rendering
      manager (DRM).

    * Reduced flickering and delays when transitioning into or out of G-SYNC
      mode.  As part of this change, monitors that have G-SYNC indicators in
      their on-screen displays will now always report that they are in G-SYNC
      mode.  The OpenGL G-SYNC visual indicator can be enabled in
      nvidia-settings to determine when G-SYNC is actually being used.

    * GLX protocol for the following OpenGL
      extension from OpenGL 3.0 has been promoted from
      unofficial to ARB approved official status:

      GL_EXT_draw_buffers2

    * GLX protocol for the following OpenGL 3.0 commands:

      BindBufferRangeNV
      BindBufferBaseNV
      BeginTransformFeedbackNV
      EndTransformFeedbackNV
      GetTransformFeedbackVaryingEXT
      TransformFeedbackVaryingsEXT

      which are part of the following extensions:

      GL_NV_transform_feedback
      GL_EXT_transform_feedback

      has been promoted from unofficial to ARB approved
      official status.

      With the above changes, GLX protocol for
      OpenGL 3.0 has been promoted from unofficial 
      to ARB approved official status.

    * Added a new system memory allocation mechanism for large
      allocations in the OpenGL driver.  This mechanism allows unmapping
      the allocation from the process when it is not in use, making more
      virtual address space available to the application.  It is enabled
      by default on 32 bit OpenGL applications with Linux 3.11+ and glibc
      2.19+.  Memory allocated this way will consume space in /dev/shm.
      Setting the environment variable __GL_DevShmPageableAllocations
      to 2 will disable this feature

======== Release 355 Entries ========

2015-08-31 version 355.11

    * Fixed a bug that could cause GPU exceptions when using glReadPixels()
      on the depth or stencil buffers of multisample windows while resizing
      or moving the windows.

2015-08-03 version 355.06

    * Fixed a bug that could cause data from one texture level to overwrite
      data from the next lowest level, when creating a texture view that
      did not include the higher of the two levels.

    * Fixed a bug that could cause the nvidia-settings control panel to
      crash when updating the display layout.

    * Corrected some erroneous reporting of support for GLX extensions:
      several extensions were being reported as supported for indirect
      GLX, which were in fact only supported under direct rendering.

    * Added support for the following EGL extensions:

          EGL_KHR_swap_buffers_with_damage
          EGL_NV_stream_consumer_gltexture_yuv

    * Replaced the build system for the NVIDIA kernel modules and updated
      the installer package and nvidia-installer to use the new build
      system and kernel module source code layout. For more information
      about the new build system and layout, see the README document at:

      ftp://download.nvidia.com/XFree86/packaging/linux/new-kbuild-for-355/

    * Added experimental full OpenGL support to EGL.

    * Marked the DeleteUnusedDP12Displays option as deprecated.

      Version 1.5.0 of the X Resize and Rotate specification added a note that
      dynamically-created outputs will not be destroyed, so this option is
      deprecated and will be removed in a future driver release.

    * Added support for VDPAU profiles added in VDPAU 0.9:
      VDP_DECODER_PROFILE_H264_BASELINE
      VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE
      VDP_DECODER_PROFILE_H264_EXTENDED
      VDP_DECODER_PROFILE_H264_PROGRESSIVE_HIGH
      VDP_DECODER_PROFILE_H264_CONSTRAINED_HIGH

    * Fixed a bug that prevented more than one RandR output from sharing
      user-added modes.

    * Fixed a bug that caused application-specified swap intervals to be
      ignored on some screens when using Xinerama.

    * Fixed a bug that caused user-supplied RandR modes with nonsensical
      combinations of the +HSync, -HSync, +VSync, and -VSync flags to corrupt
      the mode list.

    * Added support to make an OpenGL 3.0 and above context current without
      making current to any drawable.

======== Release 352 Entries ========

    * Fixed a bug that prevented nvidia-bug-report.sh from finding
      relevant messages in kernel log files.

2016-01-25 version 352.79

    * Added support for the following GPUs:
        * Quadro M500M
        * Tesla M4

    * Fixed a bug in the EGL driver where a mutex was unlocked more than
      once.  This triggers undefined behavior, and in particular, if
      lock elision is enabled in glibc, may result in a segmentation
      fault.

2015-11-16 version 352.63

    * Added support for the following GPUs:
        * GeForce 940MX
        * GeForce 945M
        * Quadro M5000M
        * Quadro M4000M
        * Quadro M3000M
        * Quadro M2000M
        * Quadro M1000M
        * Quadro M600M
        * NVS 810
        * Tesla M40

    * Fixed a regression that prevented DPMS from working correctly on
      some DisplayPort displays.

    * Fixed a bug that could prevent X from starting when configured with
      multiple X screens, some of which scan out to display devices, and
      some of which do not.

2015-10-14 version 352.55

    * Added support for the following GPUs:
        * GeForce 805A
        * GeForce GTX 960A

    * Fixed a bug that caused applications using OpenCL or CUDA with OpenGL
      interoperability to crash when using GLX indirect rendering.

2015-08-28 version 352.41

    * Added support for the following GPUs:
        * GeForce GTX 950
        * Quadro M4000
        * Quadro M5000

    * Fixed a bug that caused VDPAU to only display the top half of a video
      frame when decoding and displaying H.265/HEVC encoded video streams.

2015-07-28 version 352.30

    * Fixed a bug that caused poor video post-processing performance
      in VDPAU when operating on a large number of video streams
      simultaneously.

2015-06-15 version 352.21

    * Fixed a bug that caused the Display Configuration page of the
      nvidia-settings control panel to automatically generate layouts
      with multiple displays occupying the same position when enabling
      or disabling Base Mosaic.

    * Updated nvidia-settings to allow the use of the standard Display
      Configuration page when SLI Mosaic is enabled.

    * Fixed a bug that caused the kernel to report errors when unmapping
      DMA allocations on kernels with CONFIG_DEBUG_DMA_API enabled.

    * Added GLX Protocol support for the following OpenGL extensions:

      GL_ARB_copy_buffer
      GL_ARB_texture_buffer_object

    * Fixed a bug that caused a kernel crash if SLI Mosaic and G-SYNC were used
      at the same time on a configuration with more display devices connected to
      one GPU than another.

2015-05-18 version 352.09

    * Added the ability to configure the swapping behavior for quad-buffered
      stereo visuals. The driver can be configured to independently swap
      each eye as it becomes ready, to wait for both eyes to complete
      rendering before swapping, or to allow applications to specify which
      of these two behaviors is preferred by setting the swap interval.
      This setting can be adjusted in the nvidia-settings control panel, or
      via the NV-CONTROL API.

    * Fixed a regression which caused the GPU fan status display to disappear
      from the nvidia-settings control panel.

    * Added reporting of ECC error counts to the nvidia-settings control panel.

    * Fixed a bug that sometimes prevented OpenGL sampler objects from
      being properly deallocated when destroying OpenGL contexts.

    * Fixed a bug that caused GLX_EXT_framebuffer_sRGB to incorrectly report
      sRGB support in 30 bit-per-pixel framebuffer configurations.

    * Added support for G-SYNC with sync-to-vblank disabled. This allows
      applications to use G-SYNC to eliminate tearing for frame rates below the
      monitor's maximum refresh rate but allow tearing above the maximum refresh
      rate in order to minimize latency.

      When G-SYNC is active and sync-to-vblank is enabled, the frame rate is
      limited to the monitor's maximum refresh rate.

    * GLSL gl_Fog.scale is now +infinity when gl_Fog.end equals gl_Fog.start.
      Previously, the value 0 was used, but this broke certain
      applications such as the game XIII running on Wine (Wine bug #37068).

    * Enabled G-SYNC by default when Unified Back Buffer (UBB) is disabled.

    * Updated the NVIDIA GPU driver to avoid using video memory already
      in use by vesafb.

======== Release 349 Entries ========

2015-03-25 version 349.12

    * Added support for G-SYNC monitors when used together with non-G-SYNC
      monitors.  When G-SYNC is enabled, non-G-SYNC monitors will display with
      tearing.

    * Fixed a bug that caused nvidia-settings to crash when assigning an
      attribute whose value is a display ID on a system with multiple X screens.

    * Updated the reporting of in-use video memory in the nvidia-settings
      control panel to use the same accounting methods used in other tools
      such as nvidia-smi. nvidia-settings was not taking some allocations
      into account, e.g. framebuffer memory for the efifb console on UEFI
      systems, causing discrepancies in the values reported by different tools.

    * Removed the "EnableACPIHotkeys" X configuration option. This option
      has been deprecated and disabled by default since driver version 346.35.
      On modern Linux systems, display change hotkey events are delivered to
      the desktop environment as key press events, and the desktop environment
      handles the display change by issuing requests through the X Resize and
      Rotate extension (RandR).

    * Added support for lossless H.264/AVC video streams to VDPAU.

    * Added support for VDPAU Feature Set F to the NVIDIA VDPAU driver.
      GPUs with VDPAU Feature Set F are capable of hardware-accelerated
      decoding of H.265/HEVC video streams.

    * Fixed a bug that prevented GPU fan speed changes from getting reflected
      in the text box on Thermal settings page.

    * Added nvidia-settings commandline support to query the current and
      targeted GPU fan speed.

    * Added a checkbox to nvidia-settings to enable a visual indicator that
      shows when G-SYNC is being used.  This is helpful for displays that don't
      indicate themselves whether they are operating in G-SYNC mode or normal
      mode.

      This setting can also be enabled by running the command line

        nvidia-settings -a ShowGSYNCVisualIndicator=1

    * Added support for the X.Org X server's "-background none" option. When
      enabled, the NVIDIA driver will try to copy the framebuffer console's
      contents out of /dev/fb0.  If that cannot be done, then the screen is
      cleared to black.

    * Added support for YUV 4:2:0 compression to enable HDMI 2.0 4K@60Hz modes
      when either the display or GPU is incapable of driving these modes in
      RGB 4:4:4.  See NoEdidHDMI2Check in the README for details.

    * Fixed a bug that could cause multi-threaded applications to crash when
      multiple threads used the EGL driver at the same time.

    * Fixed a bug that caused Sync to VBlank to not work correctly with XVideo
      applications in certain configurations.

    * Fixed a bug that prevented the X driver from correctly interpreting
      some X configuration options when a display device name was given
      with a GPU UUID qualifier.

======== Release 346 Entries ========

2015-09-01 version 346.96

    * Added support for the following GPU:
        * Tesla K80

2015-07-21 version 346.87

    * Added support for the following GPU:
        * GeForce 910M

2015-06-23 version 346.82

    * Added support for the following GPUs:
        * Tesla K40t
        * GeForce 720A
        * GeForce 920A
        * GeForce 930A
        * GeForce 940A
        * GeForce GTX 950A
        * GeForce GTX 980 Ti

    * Fixed a bug in nvidia-settings that caused the application to crash
      when saving the EDID to a file.

    * Fixed a bug that prevented the "mkprecompiled" utility included in
      the driver package from reading files correctly.

2015-05-12 version 346.72

    * Added support for the following GPU:
        * GeForce GPU

    * Fixed a bug causing loss of stereo synchronization in certain Quadro
      Sync framelock configurations.

    * Fixed Pixel Buffer Object operations when row length is less than
      width. GL_[UN]PACK_ROW_LENGTH can be set to a value lower than the
      width of the operation being carried out. The OpenGL specification
      allows for this (the source or destination lines will be overlapping).
      Previously, our implementation of Pixel Buffer Objects did not support
      this case and would throw an error.

2015-04-07 version 346.59

    * Fixed a bug that caused corruption when switching display modes in some
      applications that use transform feedback.

    * Added support for the following GPUs:
        * Quadro K1200
        * Quadro M6000
        * GeForce 920M
        * GeForce 930A
        * GeForce 930M
        * GeForce 940M
        * GeForce GTX 950M
        * GeForce GTX 960M
        * GeForce GTX TITAN X

    * Fixed a bug that caused texture corruption on framebuffer depth
      attachments cleared using glClearTexImage().

    * Fixed a bug that artificially limited the maximum pixel clock on
      displays in some SLI Mosaic configurations.

2015-02-24 version 346.47

    * Fixed a bug that could cause quad-buffered stereo applications to
      crash when disabling displays.

    * Fixed a bug that could cause rendering corruption in GLX clients using
      PBOs and/or VBOs when using GLX indirect rendering.

    * Fixed a bug that caused Xinerama layouts which included X screens with
      'Option "UseDisplayDevice" "none"' to be represented incorrectly in
      the nvidia-settings control panel.

    * Fixed a bug that could cause glXSwapBuffers() to block for longer than
      necessary in multi-threaded GLX applications using the
      GLX_NV_delay_before_swap extension.

    * Fixed a bug that caused OpenGL applications using the NV_path_rendering
      extension to crash after a modeswitch event.

    * Added support for the following GPUs:
        * Quadro K620M
        * Quadro K2200M
        * GeForce GTX 960
        * GeForce GTX 965M

    * Fixed a bug that caused DisplayPort audio to stop working after monitors
      are hotplugged.

2015-01-16 version 346.35

    * Added support for the following GPUs:
        * GeForce 800A
        * GeForce 800M

    * Updated the NVIDIA X driver to reject frame packed interlaced HDMI 3D
      modes during mode validation. These modes were being validated by the
      driver, despite never having been supported.

    * Fixed a bug that prevented the console from being restored after
      forcefully terminating X, on some GPUs with multiple DisplayPort
      monitors attached. This bug also subsequently prevented X from being
      started following the failed console restoration.

    * Updated the version of libvdpau shipped with the driver to 0.9.  This
      version honors the VDPAU_DRIVER_PATH environment variable and fixes a race
      condition if multiple threads call VdpDeviceCreateX11 simultaneously.  See

        http://lists.freedesktop.org/archives/vdpau/2014-December/000274.html

      for more information.

      Please note that users are encouraged to use their distribution's libvdpau
      packages rather than relying on the one shipped with the NVIDIA graphics
      driver.

    * Fixed a bug that caused the ACPI hotkey mask to be set incorrectly on some
      laptops even when the EnableACPIHotkeys option is disabled.

    * Disabled the EnableACPIHotkeys option by default.  This option is now
      considered deprecated and will be removed in a future driver release.  On
      modern Linux systems, display change hotkey events are delivered to the
      desktop environment as key press events, and the desktop environment
      handles the display change by issuing requests through the X Resize and
      Rotate extension (RandR).

    * Fixed a bug that caused the screen image to be shifted when screen
      transformations (such as rotations or reflections) were enabled on a
      G-SYNC display attached to a Kepler-based GPU.

2014-12-08 version 346.22

2014-11-13 version 346.16

    * Fixed a bug that caused a blank screen when setting a mode requiring YUV
      4:2:0 compression. These modes are not currently supported.

    * Fixed a bug that caused an incorrect DisplayPort link configuration
      to be displayed after a hotplug or unplug.

    * Added support for the following GPUs:
        * GeForce GTX 970M
        * GeForce GTX 980M

    * Added support for decoding VP8 video streams using the NVCUVID API
      on GPUs with VP8 hardware decode support.

    * Added support for the following EGL extensions:
        * EGL_EXT_device_base
        * EGL_EXT_platform_device
        * EGL_EXT_output_base

    * Added the ability to increase the operating voltage on certain
      GeForce GPUs in the GeForce GTX 400 series and later. Voltage
      adjustments are done at the user's own risk. See the documentation
      on the "CoolBits" X configuration option in the README for details.

    * Added support for NVENC on GeForce GPUs. For more details on the
      NVENC SDK, see:
          https://developer.nvidia.com/nvidia-video-codec-sdk.

    * Removed a sanity check in nvidia-installer that tested the availability
      of POSIX shared memory. The NVIDIA GPU driver has not required POSIX
      shared memory since release 270.xx.

    * Added accelerated support for r8g8b8a8, r8g8b8x8, b8g8r8a8 and b8g8r8x8
      RENDER formats.

    * Updated nvidia-settings to take advantage of GTK+ 3, when available.
      This is implemented by building the nvidia-settings user interface
      into separate shared libraries (libnvidia-gtk2.so, libnvidia-gtk3.so),
      and loading the correct one at run-time.

    * Added the nvidia-settings option --gtk-library to allow specifying
      the path of the directory containing the user interface library or
      the path and filename of the specific library to use.

    * Added support in nvidia-settings for a GTK+ 3 user interface on x86
      and x86_64.

    * Added the nvidia-settings option --use-gtk2 to force the use
      of the GTK+ 2 UI library.

    * Updated nvidia-installer to install a file in the system's xorg.conf.d
      directory, when a sufficiently new X server is detected, to cause the X
      server to load the "nvidia" X driver automatically if it is started after
      the NVIDIA kernel module is loaded.

      This feature is supported in X.Org xserver 1.16 and higher when running on
      Linux 3.9 or higher with CONFIG_DRM enabled.

    * Improved the performance of nvidia-installer by enabling the use of
      parallel make when building the NVIDIA kernel modules. The concurrency
      level can be set with the --concurrency-level option, and defaults to
      the number of detected CPUs.

    * Updated nvidia-installer to determine default installation locations
      for libraries based on the presence of known paths in the ldconfig(8)
      cache and the filesystem, rather than hard-coded distro-specific paths.

    * Fixed a GLSL compiler bug that would produce corruption when 
      running games such as Far Cry 3 in Wine.

    * Fixed the EGL_KHR_stream_cross_process_fd extension.

    * Fixed rendering corruption that sometimes happened when calling 
      DrawElementsInstancedBaseVertexBaseInstance(), 
      DrawElementsInstancedBaseInstance(), 
      or DrawArraysInstancedBaseInstance().

    * Dramatically improved OpenGL Framebuffer Object creation performance.

    * Removed the limit on the maximum number of OpenGL Framebuffer Objects.

    * Updated the NVIDIA OpenGL driver to prefer $XDG_CACHE_HOME over
      $HOME as the default location for storing the GL shader disk cache.

======== Release 343 Entries ========

2014-12-05 version 343.36

    * Fixed a bug that rendered very bright garbage data onto some textures
      in UnrealEngine 4 applications. This issue is known as the "disco bug"
      by the UnrealEngine 4 Linux community.

    * Fixed a bug that prevented the "sync to vblank" setting from being
      honored for EGL applications.

    * Added support for the following GPUs:
        * GeForce GTX 970
        * GeForce GTX 980

    * Fixed a bug that could cause some OpenGL programs to encounter out
      of memory during a mode switch.

    * Fixed a bug that prevented the NVIDIA OpenGL driver from honoring
      the __GL_SHADER_DISK_CACHE_PATH environment variable.

2014-08-06 version 343.13

    * Fixed a bug that caused disabled displays to be implicitly included
      in the target selection for some queries and assignments on the
      nvidia-settings command line interface, in the absence of any
      explicit target selection.

    * Updated the behavior of the nvidia-settings control panel upon closing
      the control panel window to be consistent with clicking the control
      panel's "Quit" button.

    * Added a new attribute to the NV-CONTROL API to query the current
      utilization of the video decode engine.

    * Fixed a bug where the Exchange Stereo Eyes setting in nvidia-settings
      didn't work in certain stereo configurations.

    * Worked around a Unigine Heaven 3.0 shader bug which could cause corruption
      when tessellation is enabled by implementing an application profile that
      uses the "GLIgnoreGLSLExtReqs" setting.  See the documentation for the
      __GL_IGNORE_GLSL_EXT_REQS environment variable for more details.

    * Fixed a memory leak when destroying EGL surfaces.

    * Added support for multiple simultaneous EGL displays.

    * Removed support for G8x, G9x, and GT2xx GPUs, and motherboard
      chipsets based on them. Ongoing support for new Linux kernels
      and X servers, as well as fixes for critical bugs, will be
      included in 340.* legacy releases through the end of 2019.

    * Fixed a bug that could cause nvidia-installer to unsuccessfully
      attempt to delete the directory containing precompiled kernel
      module interfaces, on packages prepared with --add-this-kernel.

    * Updated nvidia-installer to log uninstallation to a separate file
      from the installation log, and to attempt uninstalling previous
      driver installations using the installer program from the previous
      installation, when available.

======== Release 340 Entries ========

2019-12-23 version 340.108

    * Updated the nvidia-drm kernel module for compatibility with the removal
      of the DRIVER_PRIME flag in recent Linux kernel versions.

    * Updated nvidia-bug-report.sh to search the systemd journal for
      gdm-x-session logs.

    * Fixed a bug that could prevent nvidia-xconfig from disabling the X
      Composite extension on version 1.20 of the X.org X server.

    * Added support to nvidia-installer for systems which provide ncurses
      libraries supporting the ncurses widechar ABI only.

    * Updated nvidia-installer to avoid problems with commands whose proper
      functionality may be dependent on system localization (e.g. via the
      LANG environment variable.) For example, some kernel configurations
      may produce unusable kernel modules if LANG is set to a language
      other than English.

    * Updated nvidia-installer for better compatibility with ncurses when
      libncurses.so.6 exposes the ncurses reentrant ABI, such as on openSUSE
      Leap 15 and SUSE Linux Enterprise 15.

    * Fixed a build failure, "too many arguments to function 'get_user_pages'",
      when building the NVIDIA kernel module for Linux kernel v4.4.168.

    * Fixed a build failure, "implicit declaration of function do_gettimeofday",
      when building the NVIDIA kernel module for Linux kernel 5.0 release
      candidates.

2018-06-06 version 340.107

    * Added support for X.Org xserver ABI 24 (xorg-server 1.20).

    * Improved nvidia-bug-report.sh to check for kern.log which is the default
      kernel log-file location for many Debian-based Linux distributions.

    * Fixed a bug which could cause X servers that export a Video Driver
      ABI earlier than 0.8 to crash when running X11 applications which
      call XRenderAddTraps().

2018-01-16 version 340.106

    * Fixed a compatibility problem between the nvidia.ko's Page Attribute
      Table (PAT) support and the kernel Page Table Isolation (PTI) patches.

      To optimize stores to memory, nvidia.ko contains support for
      configuring the CPU's PAT registers, as a fallback for Linux kernels
      that predate kernel native PAT support.  On any recent kernel
      with CONFIG_X86_PAT enabled, the driver will detect that setup has
      already been done and skip its PAT setup.  However, a static inline
      function called by nvidia.ko's PAT fallback support was updated in
      the PTI patches to use the EXPORT_SYMBOL_GPL symbol 'cpu_tlbstate'.
      nvidia.ko was updated to only contain its PAT fallback support,
      at build time, on kernels without CONFIG_X86_PAT.

2017-09-19 version 340.104

2017-02-14 version 340.102

2016-12-14 version 340.101

2016-09-26 version 340.98

    * Added support for the screen_info.ext_lfb_base field, on kernels that have
      it, in order to properly handle UEFI framebuffer consoles with physical
      addresses above 4GB.

2015-11-16 version 340.96

2015-09-02 version 340.93

    * Fixed a bug that caused the X server to crash if an OpenGL application
      tried to allocate a drawable when GPU-accessible memory is exhausted.

    * Fixed a bug that could cause an Xid error when terminating a video
      playback application using the overlay presentation queue in VDPAU.

    * Updated nvidia-installer to avoid recursing too deeply into kernel source
      trees under /usr/lib/modules, mirroring an existing restriction on recursion
      under /lib/modules.

    * Fixed a rare deadlock condition when running applications that use
      OpenGL in multiple threads on a Quadro GPU.

    * Fixed a bug which caused truncation of the EGLAttrib value returned
      by eglQueryDeviceAttribEXT() on 64-bit systems.

    * Fixed a kernel memory leak that occurred when looping hardware-
      accelerated video decoding with VDPAU on Maxwell-based GPUs.

    * Fixed a bug that caused the X server to crash if a RandR 1.4 output
      provided by a Sink Output provider was selected as the primary output on
      X.Org xserver 1.17 and higher.

    * Fixed a bug that caused waiting on X Sync Fence objects in OpenGL to
      hang indefinitely in some cases.

    * Fixed a bug that prevented OpenGL from properly recovering from
      hardware errors or sync object waits that had timed out.

2015-01-27 version 340.76

    * Fixed a bug that caused frequent AMD-Vi page faults on systems with
      some AMD 8xx/9xx-series chipsets when used with some NVIDIA GPUs.

    * Fixed a regression that could cause system crashes when terminating the
      X server on systems with an NVIDIA Quadro SDI Capture card installed.

    * Fixed a bug that caused audio over HDMI to not work on some GPUs while
      using a display that supports HDMI 3D.

2014-12-08 version 340.65

    * Fixed a bug that prevented internal 4K panels on some laptops from being
      driven at a sufficient bandwidth to support their native resolutions.

    * Fixed a regression that prevented the NVIDIA kernel module from loading
      in some virtualized environments such as Amazon Web Services.

    * Fixed a regression that caused displays to be detected incorrectly on
      some notebook systems.

    * Fixed a bug that could cause X to freeze when using Base Mosaic.

    * Fixed a regression that prevented the NVIDIA X driver from recognizing
      Base Mosaic layouts generated by the nvidia-settings control panel.

2014-11-05 version 340.58

    * Added support for the following GPUs:
        * GeForce GT820M
        * GeForce GTX 760A
        * GeForce GTX 850A
        * GeForce 810A
        * GeForce 820A
        * GeForce 840A
        * Tesla K8

    * Fixed a bug that could cause VT-switching to fail following a
      suspend, resume, and driver reload sequence.

    * Fixed a bug that caused incorrect colors to be displayed on X screens
      running at depth 8 on some GPUs.

    * Fixed a bug that prevented GPUs from being correctly recognized in
      MetaMode strings when identified by UUID.

    * Implemented support for disabling indirect GLX context creation using
      the -iglx option available on X.Org server release 1.16 and newer.  Note
      that future X.Org server releases may make the -iglx option the default.
      To re-enable support for indirect GLX on such servers, use the +iglx
      option.

    * Added the "AllowIndirectGLXProtocol" X config option.  This option can
      be used to disallow use of GLX protocol.  See "Appendix B. X Config
      Options" in the README for more details.

2014-09-30 version 340.46

    * Fixed a crash with UnrealEngine 4 when the application was started
      with the -opengl4 commandline switch.

    * Fixed an OpenGL issue that could cause glReadPixels() operations to
      be improperly clipped when resizing composited application windows,
      potentially leading to momentary X freezes.

    * Fixed a bug that could prevent the GLSL compiler from correctly
      evaluating some expressions when compiling shaders.

    * Fixed a bug that could cause nvidia-installer to crash while attempting
      to run nvidia-xconfig on systems where that utility is missing.

    * Added option UseSysmemPixmapAccel to control the use of GPU acceleration
      for X drawing operations on pixmaps allocated in system memory.

2014-08-12 version 340.32

    * Added support for the following GPUs:
        * Quadro K420
        * Quadro K620
        * Quadro K2200
        * Quadro K4200
        * Quadro K5200
        * GeForce 830A

    * Fixed a regression that prevented the internal stereo infrared emitter
      built into some 3D Vision monitors from working.

    * Fixed a bug that could cause some Java-based OpenGL applications using
      JOGL to crash on startup on systems with Xinerama enabled.

    * Fixed a bug that could prevent OpenGL Framebuffer Objects (FBOs)
      from being properly redrawn after a modeswitch.

    * Fixed a memory leak that occurred when starting OpenGL applications.

    * Fixed a bug that prevented the EDID-Like Data (ELD) of audio-capable
      displays from being updated when hotplugged/unplugged.

    * Fixed a bug that caused Xid errors when using stereo mode 12 (HDMI 3D)
      on Quadro boards without an onboard stereo DIN connector.

    * Fixed a video corruption issue for VDPAU decoding of VC-1 and WMV
      video streams utilizing range remapping on Maxwell GPUs.

    * Fixed a "black window" bug in Ubuntu 14.04 when using the Xinerama
      and Composite extensions.

    * Fixed a bug that caused the screen's contents to be shifted downward when
      a G-SYNC monitor is unplugged and replaced by a non-G-SYNC monitor.

    * Fixed a bug that prevented G-SYNC from working when a G-SYNC monitor
      was unplugged and plugged back in without a modeset.

2014-07-08 version 340.24

    * Fixed a regression, introduced in the 340.17 public beta release,
      that caused the NVIDIA X driver to access freed memory when exiting
      a GLX application that used either of the GLX_NV_video_out or
      GLX_NV_present_video extensions.

    * Fixed a bug that prevented 3D Vision stereo and ultra low motion blur
      modes from working on G-SYNC capable monitors in some cases.

    * Fixed a bug that caused the "Allow G-SYNC" checkbox to be displayed in
      nvidia-settings even if the GPUs in the system are not capable of G-SYNC.

    * Fixed a kernel crash when running some applications with IOMMU
      functionality enabled.

    * Fixed a floating point exception in the OpenGL driver when running
      "Risk of Rain" under Wine.

2014-06-09 version 340.17

    * Made various improvements and corrections to the information reported
      to GL applications via the KHR_debug and ARB_debug_output extensions.

    * Fixed a bug that caused GLX applications which simultaneously create
      drawables on multiple X servers to crash when swapping buffers.

    * Updated nvidia-settings to report all valid names for each target
      when querying target types, e.g. `nvidia-settings -q gpus`.

    * Added support for controlling the availability of Fast Approximate
      Antialiasing (FXAA) on a per-application basis via the new
      __GL_ALLOW_FXAA_USAGE environment variable and the corresponding
      GLAllowFXAAUsage application profile key. See the README for details.

    * Fixed a bug where indirect rendering could become corrupted on
      system configurations that disallow writing to executable memory.

    * Updated the nvidia-settings Makefiles to allow nvidia-settings
      to be dynamically linked against the host system's libjansson.
      This option can be enabled by setting the NV_USE_BUNDLED_LIBJANSSON
      Makefile variable to 0.  Please note that nvidia-settings requires
      libjansson version 2.2 or later.

    * Removed the runlevel check from nvidia-installer: the installation
      problems formerly associated with runlevel 1 no longer apply.

    * Added initial support for G-SYNC monitors.  Additional details and system
      requirements can be found at:

        http://www.geforce.com/hardware/technology/g-sync

    * Improved support for running the NVIDIA driver in configurations where
      writing to executable memory is disallowed.  Driver optimizations that
      require writing to executable memory can be forcefully disabled using the
      new __GL_WRITE_TEXT_SECTION environment variable.  See the README for more
      details.

    * Fixed an X driver bug that caused gamma ramp updates of the green
      channel at depth 15, on some recent GPUs, to be ignored.

======== Release 337 Entries ========

2014-05-30 version 337.25

    * Fixed a bug that caused X to crash when querying clock offsets for
      non-existent performance levels.

    * Added support for the following GPUs:
        * GeForce GTX TITAN Z
        * GeForce GT 740

    * Fixed a performance regression when running KDE with desktop effects
      using the OpenGL compositing backend.

    * Fixed a bug that caused duplicate entries to appear in some dropdown
      menus in the "Application Profiles" page of nvidia-settings.

    * Fixed a regression that could cause OpenGL rendering corruption on X
      screens with 30 bit per pixel color.

2014-05-05 version 337.19

    * Fixed a bug causing mode validation to fail for 4K resolutions over HDMI
      in certain situations.

    * Added nvidia-settings command line controls for over- and under-clocking
      attributes.  Please see the nvidia-settings(1) manual page for
      more details.

    * Fixed several cosmetic issues in the clock control user interface
      of nvidia-settings.

    * Added support for the GLX_EXT_stereo_tree extension.  For more
      details, see the extension specification:

        http://www.opengl.org/registry/specs/EXT/glx_stereo_tree.txt

    * Enabled support for using Unified Back Buffer (UBB) and 3D Stereo with
      the composite extension on Quadro cards.  Using stereo with a composite
      manager requires a stereo-aware composite manager.  Otherwise, only the
      left eye of stereo applications will be displayed.  See the
      GLX_EXT_stereo_tree extension specification for more details.

2014-04-08 version 337.12

    * Fixed a bug that could cause OpenGL programs to freeze under some
      low memory conditions.

    * Updated the display configuration page in nvidia-settings to uniquely
      identify DisplayPort 1.2 monitors by displaying the monitor GUIDs.

    * Fixed a bug that could cause ECC settings to be displayed incorrectly
      in nvidia-settings when changing ECC settings on a multi-GPU system.

    * Removed the "OnDemandVBlankInterrupts" X configuration option: this
      option has been enabled by default since version 177.68 of the
      NVIDIA Unix driver, and the documentation had not been updated to
      reflect the new default value.

    * Fixed a bug that caused GPU errors when hotplugging daisy-chained
      DisplayPort 1.2 displays.

    * Updated the color correction settings page in the nvidia-settings
      control panel to reflect gamma changes made by other RandR clients
      while the control panel was already running.

    * Fixed a bug that prevented the use of multiple simultaneous X servers
      on UEFI systems.

    * Updated the nvidia-settings source package to build libXNVCtrl when
      building nvidia-settings, instead of relying on a pre-built library.

    * Added the ability to over- and under-clock certain GeForce
      GPUs in the GeForce GTX 400 series and later.  For GPUs that allow it,
      an offset can be applied to clock values in some clock domains of
      some performance levels.  This clock manipulation is done at the
      user's own risk.  See the README documentation of the "CoolBits"
      X configuration option for more details.

    * Added support for the following GPUs:
        * GeForce 830M
        * GeForce 840M
        * GeForce 845M
        * GeForce GTX 850M

    * Updated the minimum required version of GTK+ from 2.2 to 2.4 for
      nvidia-settings.

    * Renamed the RandR output property _GUID to GUID now that it is an official
      property documented in randrproto.txt:

        http://cgit.freedesktop.org/xorg/proto/randrproto/commit/?id=19fc4c5a72eb9919d720ad66734029d9f8e313b1

    * Reduced CPU utilization and GPU memory utilization of the NVIDIA
      EGL driver.

    * Added support for the following EGL extensions:
      - EGL_EXT_buffer_age;
      - EGL_EXT_client_extensions;
      - EGL_EXT_platform_base;
      - EGL_EXT_platform_x11.

    * Renamed the "Clone" setting of the "MetaModeOrientation" X configuration
      option to "SamePositionAs", to make clear that this setting applies to
      the position only, and not to the resolution of modes in the MetaMode.

    * Added NV-CONTROL attribute NV_CTRL_VIDEO_ENCODER_UTILIZATION to query
      utilization percentage of the video encoder engine.

    * Added support for the GLX_NV_delay_before_swap extension.  For more
      details, see the extension specification:

        http://www.opengl.org/registry/specs/NV/glx_delay_before_swap.txt

    * Report correct buffer sizes for RGB GLX visuals, GLXFBConfigs, and
      EGLConfigs.  Previously, RGB10 and RGB8 formats were reported as having 32
      bits, and RGB5 formats were reported as having 16 bits.  Now they are
      correctly reported as 30, 24, and 15 bit formats respectively as
      required by the GLX and EGL specifications.

======== Release 334 Entries ========

    * Fixed a regression in the NVIDIA kernel module which caused it to
      improperly dereference a userspace pointer. This potential security
      issue was initially reported to the public at:

        http://forums.grsecurity.net/viewtopic.php?f=3&t=3922

      The regression did not affect NVIDIA GPU drivers before release 334.

    * Fixed a bug that could cause OpenGL programs to hang after calling
      fork(2).

    * Fixed a bug that could cause a multi-threaded OpenGL application
      to crash when one of its threads exits after the application has
      unloaded libGL.

    * Added support for the following GPUs:
        * GeForce GTX 750 Ti
        * GeForce GTX 750
        * GeForce GTX 745
        * GeForce GTX TITAN Black

    * Added support for GPUs with VDPAU Feature Set E. See the README
      for details.

    * On GPUs with VDPAU Feature Set E, VDPAU now supports more robust
      decode error handling at the cost of a minor performance impact.
      This can be disabled by setting the
      VDPAU_NVIDIA_DISABLE_ERROR_CONCEALMENT environment variable to 1.

    * Added support for application profile rule patterns which are logical
      operations of subpatterns. See the README for details.

    * Added support for a "findfile" application profile feature which
      allows the driver to apply profiles based on matching files in the
      same directory as the process executable. See the README for details.

    * Fixed a bug that caused nvidia-installer to log the automatically
      selected answers to some user prompts without logging the prompt
      text itself, when running in silent mode.

    * Improved performance of OpenGL applications when used in conjunction
      with the X driver's composition pipeline.  The composition pipeline may
      be explicitly enabled by using the ForceCompositionPipeline or
      ForceFullCompositionPipeline MetaMode options, or implicitly enabled
      when certain features such as some XRandR transformations, rotation,
      Warp & Blend, PRIME, and NvFBC are used.

2014-02-08 version 334.16

    * Fixed a bug that could cause nvidia-settings to compute incorrect
      gamma ramps when adjusting the color correction sliders.

    * Updated the nvidia-settings control panel to allow the selection
      of display devices using RandR and target ID names when making
      queries targeted towards specific display devices.

    * Fixed a bug that prevented some dropdown menus in the
      nvidia-settings control panel from working correctly on older
      versions of GTK+ (e.g. 2.10.x).

    * Updated the nvidia-settings control panel to provide help text
      for application profile keys and suggestions for valid key names
      when configuring application profiles.

    * Updated the nvidia-settings control panel to populate the dropdown
      menu of stereo modes with only those modes which are available.

    * Fixed a bug that could cause applications using the OpenGL
      extension ARB_query_buffer_object to crash under Xinerama.

    * Fixed a bug that caused high pixelclock HDMI modes (e.g. as used
      with 4K resolutions) to be erroneously reported as dual-link in
      the nvidia-settings control panel.

    * Fixed a bug that could cause poor stereo synchronization in large
      multi-monitor setups using 3D Vision, due to failed hardware
      handshaking on some of the monitors.

    * Fixed a bug that prevented some DisplayPort 1.2 displays from being
      properly restored after a VT switch.

    * Renamed per GPU proc directories in /proc/driver/nvidia/gpus/ with GPU's
      bus location represented in "domain:bus:device.function" format.

    * Added 64-bit EGL and OpenGL ES libraries to 64-bit driver packages.

    * Changed format of "Bus Location" field reported in the
      /proc/driver/nvidia/gpus/0..N/information files from
      "domain:bus.device.function" to "domain:bus:device.function" to match
      the lspci format.

    * Fixed a bug in the GLX_EXT_buffer_age extension where incorrect
      ages would be returned unless triple buffering was enabled.

    * Updated the NVIDIA X driver to load the NVIDIA kernel module using
      `nvidia-modprobe`, rather than the XFree86 DDX helper function
      xf86LoadKernelModule().

    * Changed the driver's default behavior to stop deleting RandR 1.2 outputs
      corresponding to unused DisplayPort 1.2 devices.  Deleting these outputs
      can confuse some applications.  Added a new option,
      DeleteUnusedDP12Displays, which can be used to turn this behavior back on.

      This option can be enabled by running

        sudo nvidia-xconfig --delete-unused-dp12-displays

    * Improved support for the __GL_SYNC_DISPLAY_DEVICE and
      VDPAU_NVIDIA_SYNC_DISPLAY_DEVICE environment variables in certain
      configurations.  Both environment variables will now recognize all
      supported display device names.  See "Appendix C. Display Device Names"
      and "Appendix G. VDPAU Support" in the README for more details.

    * Improved performance of the X driver when handling large numbers of
      surface allocations.

======== Release 331 Entries ========

2014-12-05 version 331.113

2014-10-08 version 331.104

    * Fixed a bug that could cause the CUDA debugger to fail after
      exiting X on systems with persistence mode enabled.

    * Fixed a bug that could cause silent and intermittent failures when
      a CUDA application writes to a peer device's memory with GPUDirect.

    * Fixed a bug that could prevent 32-bit GPU-based applications from
      running correctly on 64-bit systems when using GPUs with very
      large memory-mapped I/O regions.

    * Fixed a bug that could cause poor system performance and hangs when
      running large compute workloads on IOMMU-enabled systems.

    * Fixed a bug that could cause a system crash when two or more
      processes try to load the nvidia-uvm driver.

    * Added support for the following GPU:
        * GeForce 810M

    * Fixed a bug that could cause framelock status to be incorrectly
      reported in the nvidia-settings control panel on some multi-GPU
      framelock configurations.

    * Improved the performance of OpenGL applications that request a large
      number of GPU mappings via the GL_NV_shader_buffer_load extension.

    * Fixed a bug that could cause a system crash when killing applications
      that use NVIDIA GPUs on multiple-GPU systems with IOMMU functionality
      enabled.

    * Fixed a bug that caused the NVIDIA kernel module to leak memory for
      DMA mappings on some configurations.

2014-07-04 version 331.89

    * Fixed a race condition in the NVIDIA kernel module that caused some
      GPUs to sporadically become unresponsive.

    * Updated the error reporting in the NVIDIA kernel module to include the
      GPU serial number, when available, in error messages written to the
      system log.

    * Added support for the following GPU:
        * GeForce GT 730

    * Fixed a bug that caused blank screens when transforming or rotating displays
      in an SLI Mosaic layout.

    * Fixed a bug that corrupted certain software rendering on 32-bit systems.

2014-05-20 version 331.79

    * Fixed a bug that caused nvidia-installer to crash in environments
      where /proc is not mounted.

    * Fixed a bug that prevented module signing from working correctly
      for the NVIDIA Unified Memory kernel module when using module
      signing keys generated by nvidia-installer.

    * Fixed a bug that caused blank screens and flickering when rotating
      displays in a Base Mosaic layout.

    * Fixed a bug that caused BadRRCrtc or BadRROutput errors for big-endian
      X11 clients making certain XRandR requests.

    * Fixed a bug that corrupted certain software rendering, notably the
      stippled text used to represent disabled entries in xterm's pop-up menus.

2014-04-09 version 331.67

    * Fixed a bug that could lead to crashes when running Left 4 Dead 2
      with threaded optimizations enabled.

    * Added support for the following GPUs:
        * GeForce GT 705
        * GeForce GT 720
        * GeForce GTX 860M
        * GeForce GTX 870M
        * GeForce GTX 880M

    * Updated the makefile for the NVIDIA kernel module to work around a
      bug in older versions of GNU Make that prevented the NVIDIA kernel
      module from building correctly. This bug was fixed in version 3.81
      of GNU Make.

    * Fixed a bug that causes some X clients to be disconnected from the X
      server when the screen is resized while RandR 1.4 display offloading is in
      use.

    * Fixed a bug that could cause display corruption when resuming from
      suspend on systems using RandR 1.4 display offloading with recent
      Linux kernels.

    * Added support for Tridelity SL stereo mode.

    * Fixed a bug that could cause nvidia-settings to crash or display
      incorrect information after switching virtual terminals while a
      color correction confirmation count down was active.

    * Added a missing 32-bit compatibility library for
      libnvidia-fbc.so to the x86_64 Linux installer package.

2014-02-18 version 331.49

    * Added support for the following GPUs:
        * GeForce GT 710
        * GeForce 825M

    * Fixed a regression that prevented nvidia-installer from cleaning up
      directories created as part of the driver installation.

    * Added a new X configuration option "InbandStereoSignaling" to
      enable/disable DisplayPort in-band stereo signaling. See
      "Appendix B. X Config Options" in the README for more information.

    * Fixed a bug that caused PBO downloads of cube map faces to
      retrieve incorrect data.

    * Fixed a bug in nvidia-installer that resulted in spurious error
      messages when opting out of installing the NVIDIA kernel module
      or source files for the kernel module.

    * Added experimental support for ARGB GLX visuals when Xinerama and
      Composite are enabled at the same time on X.Org xserver 1.15.

2014-01-13 version 331.38

    * Fixed a bug that caused the X server to crash if video memory is
      exhausted and the GPU does not support rendering to system memory.

    * Updated nvidia-installer to make the --multiple-kernel-modules
      option imply the --no-unified-memory option: Unified memory is
      incompatible with multiple kernel modules.

    * Updated the behavior of the nvidia-settings PowerMizer Preferred
      Mode drop-down menu, to make the setting apply consistently
      across all GPUs in an SLI group.

    * Improved the robustness of the NVIDIA X driver in scenarios where
      GPU-accessible memory for allocating pixmaps was exhausted.

    * Added NV-CONTROL attributes to control the brightness of the illuminated
      logos on certain graphics boards.  For example, to turn off the
      illumination of the "GEFORCE GTX" lettering on the GeForce GTX 780, use

        nvidia-settings --assign GPULogoBrightness=0

    * Fixed a bug that prevented screen transformations from being
      applied properly when starting X.

    * GLX protocol for the following OpenGL extensions from
      OpenGL 2.1 and OpenGL 3.0 have been promoted from
      unofficial to ARB approved official status:

      GL_ARB_pixel_buffer_object
      GL_NV_conditional_render
      GL_ARB_map_buffer_range
      GL_EXT_texture_integer
      GL_ARB_vertex_array_object

      GL_ARB_pixel_buffer_object was the last piece of protocol
      needed to have official support for indirect rendering with
      all OpenGL 2.1 commands.

    * GLX Protocol for the miscellaneous OpenGL 3.0 commands not
      associated with specific extensions has also been promoted from
      unofficial to ARB approved status.

    * Deprecated display mask related configuration of display devices via
      NV-CONTROL and nvidia-settings.  Display target specifications should
      be used instead - A display target is one of the display's valid names,
      with an optional GPU or X screen qualifier.

    * Deprecated the following NV-CONTROL attributes:

      NV_CTRL_CONNECTED_DISPLAYS
      NV_CTRL_ENABLED_DISPLAYS
      NV_CTRL_ASSOCIATED_DISPLAYS
      NV_CTRL_NOTEBOOK_INTERNAL_LCD
      NV_CTRL_FRAMELOCK_MASTER
      NV_CTRL_FRAMELOCK_SLAVES
      NV_CTRL_FRAMELOCK_MASTERABLE
      NV_CTRL_FRAMELOCK_SLAVEABLE

      Also, although NV_CTRL_PROBE_DISPLAYS is still operational, the return
      value has been deprecated and should not be used.

    * Added deprecation warning messages in nvidia-settings when deprecated
      attributes are used.  This also includes display mask usage.

2013-11-06 version 331.20

2013-10-22 version 331.17

    * Added support for NVIDIA OpenGL-based Framebuffer Capture (NvFBCOpenGL).
      This library provides a high performance, low latency interface to
      capture and optionally encode the composited framebuffer of an X screen.
      NvFBC and NvIFR are private APIs that are only available to approved
      partners for use in remote graphics scenarios.  Please contact NVIDIA
      at GRIDteam@nvidia.com for more information.

    * Fixed a bug that prevented configuration files containing application
      profiles from being loaded when directories were present in the
      application profile configuration search path.

    * Deferred initialization of libselinux in the NVIDIA OpenGL driver, in
      order to avoid a problem where libselinux might not be ready when the
      NVIDIA libGL shared library is first loaded.

    * Added nvidia-uvm.ko, the NVIDIA Unified Memory kernel module, to the
      NVIDIA Linux driver package. This kernel module provides support for
      the new Unified Memory feature in an upcoming CUDA release.

2013-10-04 version 331.13

    * Fixed a bug that caused the X server to fail to initialize when
      DisplayPort 1.2 monitors were assigned to separate X screens on the same
      GPU.

    * Fixed a bug that could cause a deadlock when forking from OpenGL
      programs which use some malloc implementations, such as TCMalloc.

    * Fixed a bug that prevented Warp & Blend settings from being
      retained across display configuration changes.

    * Fixed a bug that prevented some settings changes made via the
      nvidia-settings command line interface from being reflected in
      the nvidia-settings graphical user interface.

    * Changed the clipping behavior of the NVIDIA X driver on Trapezoids
      and Triangles for some RENDER operations to match the behavior in
      newer versions of Pixman:

      http://lists.freedesktop.org/archives/pixman/2013-April/002755.html

    * Fixed a bug in MetaMode tracking that could cause spurious error
      messages to be printed when attempting to add or delete Metamodes
      via NV-CONTROL.

    * Fixed a bug that caused the NVIDIA X driver to attempt to load the
      X11 "shadow" module unconditionally, even in situations where the
      driver had no need to use the module. This could result in the
      printing of spurious error messages, on X servers where the module
      was not present.

    * Fixed a bug that prevented display configuration changes made
      with xvidtune(1) from working correctly.

    * Fixed a bug that occasionally caused display corruption in GLX
      applications while changing the display configuration.

    * Fixed a bug that prevented glReadPixels from working correctly when
      reading from Pixel Buffer Objects over indirect rendering, when the
      image width is not a multiple of 4.

    * Added a new NV-CONTROL attribute, NV_CTRL_BACKLIGHT_BRIGHTNESS,
      for controlling backlight brightness.

    * Fixed a bug that prevented nvidia-settings from creating display
      device configuration pages for newly connected DisplayPort 1.2
      Multi Stream Transport downstream devices.

    * Added GPU utilization reporting to the nvidia-settings control panel.

    * Fixed a bug in the nvidia-settings control panel that prevented users
      from configuring stereo, when stereo was not already configured.

    * Added support for reporting the tachometer-measured fan speed on
      capable graphics boards via nvidia-settings and the NV-CONTROL API.
      The preexisting mechanism for reporting fan speed reports the speed
      of the fan as programmed by the driver.
      For example, `nvidia-settings --query=[fan:0]/GPUCurrentFanSpeedRPM`.

    * Fixed a regression that caused GPUs that do not support graphics to not
      appear in nvidia-settings.

    * Fixed a bug that caused DisplayPort 1.2 multi-stream devices to stop
      working if they were unplugged and plugged back in while they were active
      in the current MetaMode.

    * Added support for multiple NVIDIA kernel modules. This feature allows
      users to assign different GPUs in the system to different NVIDIA kernel 
      modules, potentially reducing the software overhead of coordinating 
      access to multiple GPUs.

    * Added support for the EGL API on 32-bit platforms.  Currently, the
      supported client APIs are OpenGL ES 1.1, 2.0 and 3.0, and the only
      supported window system backend is X11.

    * Add a new option, AllowEmptyInitialConfiguration, which allows the X
      server to start even if no connected display devices are detected at
      startup.  This option can be enabled by running "sudo nvidia-xconfig
      --allow-empty-initial-configuration"

      This option is useful in RandR 1.4 display offload configurations where no
      display devices are connected to the NVIDIA GPU when the X server is
      started, but might be connected later.

    * Updated nvidia-installer to provide a scrollable text area for
      displaying messages from the /usr/lib/nvidia/alternate-install-present
      and /usr/lib/nvidia/alternate-install-available distro hook files.
      This allows for longer messages to be provided in these files.

    * Updated nvidia-installer to avoid recursing into the per-kernel "build"
      and "source" directories when searching for conflicting kernel modules
      in /lib/modules.

    * Added a system memory cache to improve the performance of certain X
      rendering operations that use software rendering fallbacks.  The X
      configuration option "SoftwareRenderCacheSize" may be used to configure
      the size of the cache.

    * Removed the "DynamicTwinView" X configuration option: dynamic
      reconfiguration of displays is always possible, and can no longer be
      disabled.

    * Fixed a bug that caused nvidia-settings to display incorrect information
      in its display configuration page when all displays on an X screen were
      turned off.

    * Updated nvidia-installer to only install the libraries libvdpau and
      libvdpau_trace if an existing installation of libvdpau is not detected
      on the system. This behavior can be overridden with the
      --install-vdpau-wrapper and --no-install-vdpau-wrapper options.

      Future NVIDIA Linux installer packages will no longer include copies
      of libvdpau or libvdpau_trace: VDPAU users are recommended to install
      these libraries via other means, e.g. from packages provided by their
      distributors, or by building them from the sources available at:

      http://people.freedesktop.org/~aplattner/vdpau/

======== Release 325 Entries ========

2013-08-05 version 325.15

    * Fixed a bug in the nvidia-settings control panel that could cause
      spurious messages about layout inconsistencies to be printed when
      changing the display layout while SLI is enabled.

2013-07-01 version 325.08

    * Fixed a bug that could cause display flickering after setting some
      scaling configurations.

    * Fixed a bug that prevented the status bar on the "PowerMizer" and
      "X Server XVideo Settings" pages in the nvidia-settings control
      panel from being updated when settings were changed by another
      NV-CONTROL client.

    * Fixed a bug that could cause some UI elements to be duplicated in the
      nvidia-settings control panel following a VT switch on X server
      configurations with multiple NVIDIA X screens.

    * Changed the default PCIe interrupt delivery method from virtual-wire
      to MSI. Note that if the NVIDIA Linux driver fails to initialize
      with an error indicating that it is not receiving interrupts,  MSI 
      can be disabled by setting the module parameter "NVreg_EnableMSI=0"
      when loading the NVIDIA kernel module.

    * Removed support for Linux 2.4 kernels. The NVIDIA Linux driver now
      requires Linux 2.6.9 or later.

    * Fixed a bug that prevented the creation of a mode via RandR with the
      same name as a previously created mode, even after the previous mode
      had been deleted.

    * Fixed a bug in nvidia-settings that caused GTK+ theme colors to be
      ignored for some UI elements.

    * Fixed a bug that caused nvidia-settings to write hostname-based color
      correction settings to the .nvidia-settings-rc configuration file, even
      when the "Include X Display Names in the Config File" option was unset.
      This could lead to a long delay when starting nvidia-settings, if a
      hostname saved to the configuration file failed to resolve.

    * Fixed a bug that exposed edge overlap controls on the SLI Mosaic
      page of nvidia-settings on edges where overlap was impossible.

    * Fixed a bug that caused some settings in the nvidia-settings control
      panel to be reset when re-probing displays.

    * Fixed a bug that could cause OpenGL ap                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               