How to get the CUDA version?

Question

Is there any quick command or script to check for the version of CUDA installed?

I found the manual of 4.0 under the installation directory but I'm not sure whether it is of the actual installed version or not.

Answer 1

As Jared mentions in a comment, from the command line:

nvcc --version

(or /usr/local/cuda/bin/nvcc --version) gives the CUDA compiler version (which matches the toolkit version).

From application code, you can query the runtime API version with

cudaRuntimeGetVersion()

or the driver API version with

cudaDriverGetVersion()

As Daniel points out, deviceQuery is an SDK sample app that queries the above, along with device capabilities.

As others note, you can also check the contents of the version.txt (.json in recent CUDA versions) using (e.g., on Mac or Linux)

cat /usr/local/cuda/version.txt

However, if there is another version of the CUDA toolkit installed other than the one symlinked from /usr/local/cuda, this may report an inaccurate version if another version is earlier in your PATH than the above, so use with caution.

Answer 2

[Edited answer. Thanks for everyone who corrected it]

If you run

nvidia-smi

You should find the CUDA Version *highest CUDA version the installed driver supports on the top right corner of the comand's output. At least I found that output for CUDA version 10.0 e.g.,

Note that this does not mean that CUDA 10.0 is installed. It may or may not be.

You can check via nvcc --version command if CUDA is really installed.

Note - Sometimes installing CUDA via some methods (.run file) by default also installs an NVIDIA driver or replaces the existing installed driver, and many people get confused regarding this. However, installing a driver via CUDA installation may not get you the most updated or suitable driver for your GPU. This is a more complex topic.

Answer 3

On Ubuntu Cuda V8:

$ cat /usr/local/cuda/version.txt
  

You can also get some insights into which CUDA versions are installed with:

$ ls -l /usr/local | grep cuda

which will give you something like this:

lrwxrwxrwx  1 root root    9 Mar  5  2020 cuda -> cuda-10.2
drwxr-xr-x 16 root root 4096 Mar  5  2020 cuda-10.2
drwxr-xr-x 16 root root 4096 Mar  5  2020 cuda-8.0.61

Given a sane PATH, the version cuda points to should be the active one (10.2 in this case).

NOTE: This only works if you are willing to assume CUDA is installed under /usr/local/cuda (which is true for the independent installer with the default location, but not true e.g. for distributions with CUDA integrated as a package). Ref: comment from @einpoklum.

Answer 4

For CUDA version:

nvcc --version

Or use,

nvidia-smi

For cuDNN version:

For Linux:

Use following to find path for cuDNN:

$ whereis cuda
cuda: /usr/local/cuda

Then use this to get version from header file,

$ cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2

For Windows,

Use following to find path for cuDNN:

C:\>where cudnn*
C:\Program Files\cuDNN7\cuda\bin\cudnn64_7.dll

Then use this to dump version from header file,

type "%PROGRAMFILES%\cuDNN7\cuda\include\cudnn.h" | findstr CUDNN_MAJOR

If you're getting two different versions for CUDA on Windows - Different CUDA versions shown by nvcc and NVIDIA-smi

Answer 5

Other respondents have already described which commands can be used to check the CUDA version. Here, I'll describe how to turn the output of those commands into an environment variable of the form "10.2", "11.0", etc.

To recap, you can use

nvcc --version

to find out the CUDA version. I think this should be your first port of call. If you have multiple versions of CUDA installed, this command should print out the version for the copy which is highest on your PATH.

The output looks like this:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2020 NVIDIA Corporation
Built on Thu_Jun_11_22:26:38_PDT_2020
Cuda compilation tools, release 11.0, V11.0.194
Build cuda_11.0_bu.TC445_37.28540450_0

We can pass this output through sed to pick out just the MAJOR.MINOR release version number.

CUDA_VERSION=$(nvcc --version | sed -n 's/^.*release \([0-9]\+\.[0-9]\+\).*$/\1/p')

If nvcc isn't on your path, you should be able to run it by specifying the full path to the default location of nvcc instead.

/usr/local/cuda/bin/nvcc --version

The output of which is the same as above, and it can be parsed in the same way.

Alternatively, you can find the CUDA version from the version.txt file.

cat /usr/local/cuda/version.txt

The output of which

CUDA Version 10.1.243

can be parsed using sed to pick out just the MAJOR.MINOR release version number.

CUDA_VERSION=$(cat /usr/local/cuda/version.txt | sed 's/.* \([0-9]\+\.[0-9]\+\).*/\1/')

Note that sometimes the version.txt file refers to a different CUDA installation than the nvcc --version. In this scenario, the nvcc version should be the version you're actually using.

We can combine these three methods together in order to robustly get the CUDA version as follows:

if nvcc --version 2&> /dev/null; then
    # Determine CUDA version using default nvcc binary
    CUDA_VERSION=$(nvcc --version | sed -n 's/^.*release \([0-9]\+\.[0-9]\+\).*$/\1/p');

elif /usr/local/cuda/bin/nvcc --version 2&> /dev/null; then
    # Determine CUDA version using /usr/local/cuda/bin/nvcc binary
    CUDA_VERSION=$(/usr/local/cuda/bin/nvcc --version | sed -n 's/^.*release \([0-9]\+\.[0-9]\+\).*$/\1/p');

elif [ -f "/usr/local/cuda/version.txt" ]; then
    # Determine CUDA version using /usr/local/cuda/version.txt file
    CUDA_VERSION=$(cat /usr/local/cuda/version.txt | sed 's/.* \([0-9]\+\.[0-9]\+\).*/\1/')

else
    CUDA_VERSION=""

fi

This environment variable is useful for downstream installations, such as when pip installing a copy of pytorch that was compiled for the correct CUDA version.

python -m pip install \
    "torch==1.9.0+cu${CUDA_VERSION/./}" \
    "torchvision==0.10.0+cu${CUDA_VERSION/./}" \
    -f https://download.pytorch.org/whl/torch_stable.html

Similarly, you could install the CPU version of pytorch when CUDA is not installed.

if [ "$CUDA_VERSION" = "" ]; then
    MOD="+cpu";
    echo "Warning: Installing CPU-only version of pytorch"
else
    MOD="+cu${CUDA_VERSION/./}";
    echo "Installing pytorch with $MOD"
fi

python -m pip install \
    "torch==1.9.0${MOD}" \
    "torchvision==0.10.0${MOD}" \
    -f https://download.pytorch.org/whl/torch_stable.html

But be careful with this because you can accidentally install a CPU-only version when you meant to have GPU support. For example, if you run the install script on a server's login node which doesn't have GPUs and your jobs will be deployed onto nodes which do have GPUs. In this case, the login node will typically not have CUDA installed.

Answer 6

Use the following command to check CUDA installation by Conda:

conda list cudatoolkit

And the following command to check CUDNN version installed by conda:

conda list cudnn

If you want to install/update CUDA and CUDNN through CONDA, please use the following commands:

conda install -c anaconda cudatoolkit
conda install -c anaconda cudnn

Alternatively you can use following commands to check CUDA installation:

nvidia-smi

OR

nvcc --version

If you are using tensorflow-gpu through Anaconda package (You can verify this by simply opening Python in console and check if the default python shows Anaconda, Inc. when it starts, or you can run which python and check the location), then manually installing CUDA and CUDNN will most probably not work. You will have to update through conda instead.

If you want to install CUDA, CUDNN, or tensorflow-gpu manually, you can check out the instructions here https://www.tensorflow.org/install/gpu

Answer 7

On Ubuntu :

Try

$ cat /usr/local/cuda/version.txt or $ cat /usr/local/cuda-8.0/version.txt

Sometimes the folder is named "Cuda-version".

If none of above works, try going to $ /usr/local/ And find the correct name of your Cuda folder.

Output should be similar to: CUDA Version 8.0.61

Answer 8

If you have installed CUDA SDK, you can run "deviceQuery" to see the version of CUDA

Answer 9

If you have PyTorch installed, you can simply run the following code in your IDE:

import torch

print(torch.version.cuda)

Answer 10

You might find CUDA-Z useful, here is a quote from their Site:

"This program was born as a parody of another Z-utilities such as CPU-Z and GPU-Z. CUDA-Z shows some basic information about CUDA-enabled GPUs and GPGPUs. It works with nVIDIA Geforce, Quadro and Tesla cards, ION chipsets."

http://cuda-z.sourceforge.net/

On the Support Tab there is the URL for the Source Code: http://sourceforge.net/p/cuda-z/code/ and the download is not actually an Installer but the Executable itself (no installation, so this is "quick").

This Utility provides lots of information and if you need to know how it was derived there is the Source to look at. There are other Utilities similar to this that you might search for.

Answer 11

One can get the cuda version by typing the following in the terminal:

$ nvcc -V

# below is the result
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2017 NVIDIA Corporation
Built on Fri_Nov__3_21:07:56_CDT_2017
Cuda compilation tools, release 9.1, V9.1.85

---

Alternatively, one can manually check for the version by first finding out the installation directory using:

$ whereis -b cuda         
cuda: /usr/local/cuda

And then cd into that directory and check for the CUDA version.

Answer 12

On Windows 10, I found nvidia-smi.exe in 'C:\Program Files\NVIDIA Corporation\NVSMI'; after cd into that folder (was not in the PATH in my case) and '.\nvidia-smi.exe' it showed

Answer 13

if nvcc --version is not working for you then use cat /usr/local/cuda/version.txt

Answer 14

First you should find where Cuda installed.

If it's a default installation like here the location should be:

for ubuntu:

/usr/local/cuda

in this folder you should have a file

version.txt

open this file with any text editor or run:

cat version.txt

from the folder

OR

 cat /usr/local/cuda/version.txt 

Answer 15

We have three ways to check Version: In my case below is the output:- Way 1:-

cat /usr/local/cuda/version.txt

Output:-

CUDA Version 10.1.243

Way2:-

nvcc --version

Output:-

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2017 NVIDIA Corporation
Built on Fri_Nov__3_21:07:56_CDT_2017
Cuda compilation tools, release 9.1, V9.1.85

Way3:-

/usr/local/cuda/bin/nvcc --version

Output:-

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2019 NVIDIA Corporation
Built on Sun_Jul_28_19:07:16_PDT_2019
Cuda compilation tools, release 10.1, V10.1.243

Way4:-

nvidia-smi
NVIDIA-SMI 450.36.06    Driver Version: 450.36.06    CUDA Version: 11.0

Outputs are not same. Don't know why it's happening.

Answer 16

If you have multiple CUDA installed, the one loaded in your system is CUDA associated with "nvcc". Therefore, "nvcc --version" shows what you want.

Answer 17

On Windows 11 with CUDA 11.6.1, this worked for me:

cat "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.6\version.json"

Answer 18

After installing CUDA one can check the versions by: nvcc -V

I have installed both 5.0 and 5.5 so it gives

Cuda Compilation Tools,release 5.5,V5.5,0

This command works for both Windows and Ubuntu.

Answer 19

Apart from the ones mentioned above, your CUDA installations path (if not changed during setup) typically contains the version number

doing a which nvcc should give the path and that will give you the version

PS: This is a quick and dirty way, the above answers are more elegant and will result in the right version with considerable effort

Answer 20

If you are running on linux:

dpkg -l | grep cuda

Answer 21

Using tensorflow:

import tensorflow as tf
from tensorflow.python.platform import build_info as build
print(f"tensorflow version: {tf.__version__}")
print(f"Cuda Version: {build.build_info['cuda_version']}")
print(f"Cudnn version: {build.build_info['cudnn_version']}")

tensorflow version: 2.4.0

Cuda Version: 11.0

Cudnn version: 8

Answer 22

I wanted to know this info as well so that I could install PyTorch such that it could take advantage of my GPUs on my Window 10 system. I was able to find this information from my NVidia Control Panel. If you have a Windows system and don't have this installed, you can get it here:

https://nvidia.custhelp.com/app/answers/detail/a_id/4733/~/nvidia-control-panel-windows-store-app

Once this is installed, find and launch the NVIDIA Control Panel:

Once it's up, at the bottom left corner, click on the **onc sec, ** link:

From this page, click the Components tab. This is how I found out I had CUDA 11.7 installed.

Answer 23

i get /usr/local - no such file or directory. Though nvcc -V gives

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2016 NVIDIA Corporation
Built on Sun_Sep__4_22:14:01_CDT_2016
Cuda compilation tools, release 8.0, V8.0.44

Answer 24

Programmatically with the CUDA Runtime API C++ wrappers (caveat: I'm the author):

auto v1 = cuda::version::maximum_supported_by_driver();
auto v2 = cuda::version::runtime();

This gives you a cuda::version_t structure, which you can compare and also print/stream e.g.:

if (v2 < cuda::version_t{ 8, 0 } ) {
    std::cerr << "CUDA version " << v2 << " is insufficient." std::endl;
}

Answer 25

Found mine after:

whereis cuda

at

cuda: /usr/lib/cuda /usr/include/cuda.h

with

nvcc --version

CUDA Version 9.1.85

Answer 26

Open a terminal and run these commands:

cd /usr/local/cuda/samples/1_Utilities/deviceQuery
sudo make
./deviceQuery

You can get the information of CUDA Driver version, CUDA Runtime Version, and also detailed information for GPU(s). An image example of the output from my end is as below.

You can find the image here.

Answer 27

On my cuda-11.6.0 installation, the information can be found in /usr/local/cuda/version.json. It contains the full version number (11.6.0 instead of 11.6 as shown by nvidia-smi.

The information can be retrieved as follows:

python -c 'import json; print(json.load(open("/usr/local/cuda/version.json"))["cuda"]["version"])'

Answer 28

Assuming CUDA was installed on Ubuntu (arguably the most common system for ML/DL), we can use apt to get both CUDA and cuDNN library versions installed in the current (container) system:

$ apt list --installed | grep cud

---

Sample output:

$ docker run -it --rm mirekphd/cuda-11.2-cudnn8-devel-ubuntu22.04:latest apt list --installed | grep cud

cuda-command-line-tools-11-2/now 11.2.2-1 amd64 [installed,local]
cuda-compat-11-2/now 460.106.00-1 amd64 [installed,local]
cuda-compiler-11-2/now 11.2.2-1 amd64 [installed,local]
cuda-cudart-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-cudart-dev-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-cuobjdump-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-cupti-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-cupti-dev-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-cuxxfilt-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-driver-dev-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-gdb-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-keyring/now 1.1-1 all [installed,local]
cuda-libraries-dev-11-2/now 11.2.2-1 amd64 [installed,local]
cuda-memcheck-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-minimal-build-11-2/now 11.2.2-1 amd64 [installed,local]
cuda-nvcc-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvdisasm-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvml-dev-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvprof-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvprune-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvrtc-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvrtc-dev-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-nvtx-11-2/now 11.2.152-1 amd64 [installed,local]
cuda-sanitizer-11-2/now 11.2.152-1 amd64 [installed,local]
libcudnn8-dev/now 8.1.1.33-1+cuda11.2 amd64 [installed,local]
libcudnn8/now 8.1.1.33-1+cuda11.2 amd64 [installed,local]
libnccl-dev/now 2.18.1-1+cuda12.1 amd64 [installed,local]
libnccl2/now 2.18.1-1+cuda12.1 amd64 [installed,local]

Answer 29

You can check the version of CUDA using

nvcc -V

or you can use

nvcc --version

or You can check the location of where the CUDA is using

whereis cuda 

and then do

cat location/of/cuda/you/got/from/above/command

Answer 30

To verify the CUDA version installed on your machine, you can use the nvidia-smi command in the terminal.

The output should look something like this:

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 535.54.03              Driver Version: 535.54.03    CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA GeForce GT 1030         Off | 00000000:43:00.0 Off |                  N/A |
| 35%   28C    P8              N/A /  30W |    255MiB /  2048MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|    0   N/A  N/A      4396      G   /usr/libexec/Xorg                            63MiB |
|    0   N/A  N/A      4521      G   /usr/bin/gnome-shell                        190MiB |
+---------------------------------------------------------------------------------------+

Answer 31

If there is a version mismatch between nvcc and nvidia-smi then different versions of cuda are used as driver and run time environemtn.

To ensure same version of CUDA drivers are used what you need to do is to get CUDA on system path.

First run whereis cuda and find the location of cuda driver.

Then go to .bashrc and modify the path variable and set the directory precedence order of search using variable 'LD_LIBRARY_PATH'.

for instance

$ whereis cuda
cuda: /usr/lib/cuda /usr/include/cuda.h /usr/local/cuda

CUDA is installed at /usr/local/cuda, now we need to to .bashrc and add the path variable as:

vim  ~/.bashrc
export PATH="/usr/local/cuda/bin:${PATH}"

and after this line set the directory search path as:

export LD_LIBRARY_PATH="/usr/local/cuda/lib64:${LD_LIBRARY_PATH}"

Then save the .bashrc file. And refresh it as:

$ source ~/.bashrc

This will ensure you have nvcc -V and nvidia-smi to use the same version of drivers.