# PyVISA puts a Python front end on top of a VISA library

> PyVISA is a Python wrapper around the Virtual Instrument Software Architecture, letting scripts drive instruments over GPIB, RS232, Ethernet, or USB without vendor specific code. It is MIT licensed and actively pushed, and it still needs a VISA implementation underneath it.

**pyvisa/pyvisa** — A Python package with bindings to the "Virtual Instrument Software Architecture" VISA library, in order to control measurement devices and test equipment via GPIB, RS232, or USB.

- Repository: https://github.com/pyvisa/pyvisa
- Website: https://pyvisa.readthedocs.io
- Stars: 972 · Forks: 273
- Language: Python
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/pyvisa-pyvisa

## The pain PyVISA addresses is one library per language per device

The README states the problem plainly: programming measurement instruments can be real pain, because there are many different protocols sent over many different interfaces and bus systems, and for every programming language you want to use you have to find libraries that support both your device and its bus system. The Virtual Instrument Software Architecture was defined in the middle of the 90s to smooth this over, and VISA is now implemented on all significant operating systems, with a couple of vendors offering libraries, partly as free download. Those libraries work together with arbitrary peripheral devices, although they may be limited to certain interface devices such as the vendor's own GPIB card. PyVISA's role is to give Python a way in. The specification has explicit bindings to Visual Basic, C, and G, LabVIEW's graphical language, but not to Python, so PyVISA calls functions from a VISA shared library (.dll, .so, .dylib) and lets you leverage those standard implementations directly.

## One front end over several possible VISA implementations

The architectural point is that PyVISA is both a wrapper and a front end. The README describes it as a Python wrapper for VISA shared libraries that can also serve as a front end for other VISA implementations, and it names PyVISA-Py as the pure Python route. That layering exists because Python can also access most bus systems used by instruments directly, which is why one can envision implementing the VISA standard in Python rather than calling out to a vendor library. The practical consequence for a user is that PyVISA is not the thing that talks to the hardware by itself. Something beneath it does, and your choice of that lower layer determines which instruments you can reach. The distinction between wrapping and front ending is what lets the same application code sit on top of a vendor runtime in the lab and on top of a pure Python implementation in a container or on a platform where no vendor runtime exists.

## Installing PyVISA with pip, and what it does not install for you

The installation section of the README is short. The package is on PyPI under the name pyvisa:

```bash
$ pip install pyvisa
```

If you prefer to work from the source distribution, the README describes unzipping it and installing from that directory:

```bash
$ pip install .
```

For restricted networks, the README notes that pip can install without accessing PyPI if the build and runtime dependencies are already available locally, using the --no-build-isolation option together with --no-index --find-links pointed at a local wheel path.

What none of this installs is a VISA implementation. The requirements list names Python, tested with 3.10 and later, and VISA, tested with NI-VISA 17.5 on Win7 from www.ni.com/visa and Keysight-VISA. That second line is the one to read twice. PyVISA on its own gives you a Python API and no hardware access, which is the most common reason a first script fails to find an instrument.

## A pure Python VISA implementation for machines without a vendor runtime

The README points to PyVISA-Py as the project that implements the VISA standard directly in Python, and the two projects are linked from the same document. The distinction is about where the bus handling happens. With PyVISA over a vendor library, the heavy lifting is done in vendor code, which usually means better coverage of the instrument's quirks and a licence you have to accept. With PyVISA-Py underneath, the implementation is in Python, which means it installs anywhere Python runs without a separate vendor runtime or its licence. The trade is that a pure Python implementation has to reimplement the parts of the standard that vendor libraries handle in optimised native code. PyVISA's design accommodates both because it presents the same front end either way, so the layer under it is a configuration choice rather than an architectural rewrite of your script.

## The command line entry points for inspecting a backend

The package ships console scripts defined in pyproject.toml under the project scripts table. The one visible in full is pyvisa-shell, bound to the visa_shell entry point in the cmd_line_tools module:

```bash
pyvisa-shell
```

A shell like this is where you confirm that PyVISA can find a VISA implementation at all, and which one it discovered, before you blame your own instrument code. The manifest declares a second script, pyvisa-info, whose full target is truncated in the published project metadata, so its exact invocation is best taken from the documentation site rather than assumed. The package also carries the usual packaging metadata around it: pyproject.toml with the project name PyVISA, requires-python set to 3.10 or later, a licence file entry, and a single runtime dependency on typing_extensions at version 4.0.0 or later. The project URLs point to the GitHub repository, the readthedocs documentation, and a changelog in the CHANGES file.

## Python fits measurement work for reasons beyond syntax

The README makes a case for why the language is a good fit for instrument control rather than assuming it. Python is an easy to learn scripting language with short development cycles. It sits at a high abstraction level, which the README says blends with the abstraction level of measurement programs. It has a rich set of native libraries, including numerical and plotting modules for data analysis and visualisation. And a large set of books in many languages plus online publications exists for it. That combination is what makes PyVISA useful in practice rather than merely convenient. A measurement task is usually a short acquisition loop followed by analysis and a plot, and PyVISA is the piece that connects the first step to the rest of a Python pipeline. The documentation is published at pyvisa.readthedocs.io, and the project also has a Journal of Open Source Software paper that the README asks users to cite.

## MIT licence, a journal citation, and a package that ships the documentation

The licence is MIT, as the classifiers in pyproject.toml confirm, so commercial use, modification, and redistribution are all permitted as long as the notice is kept. The repository layout shows a project that takes its own infrastructure seriously: a CHANGES file, a ChangeLog, an AUTHORS file, a CITATION.cff, a CONTRIBUTING guide, a code of conduct, a pre-commit configuration, an Azure pipelines configuration for continuous integration including a Keysight assisted testing pipeline, a dev-requirements file, a docs directory, and a joss-paper directory that produced the 2023 Journal of Open Source Software article by Grecco and colleagues. The last push to the repository was on 2026-10-19, and the recent releases are 1.16.2 from 2026-02-27, 1.16.1 from 2026-01-13, and a 1.16.0 release candidate from 2025-12-18. The package classifiers list Python 3.10 through 3.14 and mark the development status as Production/Stable.

## Conclusion

PyVISA fits laboratories that already own a VISA implementation from a hardware vendor and want their measurement scripts in Python with one API across instruments. It does not fit a machine with no VISA library installed, because the package is a wrapper rather than a bus implementation, and a pure Python route through PyVISA-Py is the answer there. Before you start, check that a VISA runtime is installed on the machine, confirm the backend PyVISA will discover matches your hardware, and read the CHANGES file when upgrading, since a new major version can change which VISA implementation is selected by default.

## FAQ

### What is PyVISA used for?

PyVISA is a Python package for controlling measurement devices and test equipment over GPIB, RS232, Ethernet, or USB, by wrapping the Virtual Instrument Software Architecture shared library.

### How do I install PyVISA?

The README gives pip install pyvisa, or pip install . from an unpacked source distribution. It also notes pip can install without PyPI access using --no-build-isolation together with --no-index --find-links pointing at local wheels.

### Does PyVISA need a VISA library installed separately?

Yes. The requirements list VISA itself, tested with NI-VISA 17.5 and Keysight-VISA, alongside Python 3.10 or later. A pure Python alternative is the separate PyVISA-Py project.

### What is the difference between PyVISA and PyVISA-Py?

PyVISA is a wrapper for VISA shared libraries that can also act as a front end for other implementations. PyVISA-Py implements the VISA standard directly in Python, which the README mentions as the reason one can envision the standard living in Python at all.

## Sources

- [License: MIT](https://github.com/pyvisa/pyvisa/blob/main/LICENSE)
- [Project website](https://pyvisa.readthedocs.io)
- [pyvisa/pyvisa on GitHub](https://github.com/pyvisa/pyvisa)
- [README](https://github.com/pyvisa/pyvisa/blob/main/README.md)
- [Releases](https://github.com/pyvisa/pyvisa/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/pyvisa-pyvisa