If you're new to Python
and VPython: Introduction

A VPython tutorial

Pictures of 3D objects

What's new

Classic VPython web site
VPython license
Python web site


GlowScript VPython and
Jupyter VPython


Using VPython to create 3D animations

VPython makes it unusually easy to write programs that generate navigable real-time 3D animations. It is based on the Python programming language which is widely used in introductory programming courses thanks to its clean design, and it is also widely used in science and business.

Classic VPython was originated by David Scherer in 2000. In 2011 David Scherer and Bruce Sherwood initiated the development of GlowScript, a similar programming environment but which runs in a browser. In 2014 it became possible to use RapydScript, a programming language very similar to Python, to support VPython programs in the GlowScript environment.

Here is an overview of the project, and here is a log of developments. Here is the open source for this project. There is also technical documentation about the GlowScript environment, including how to use JavaScript or RapydScript for your programs.

There is also a "Jupyter VPython" originated by John Coady in 2014 and under continuing development by John Coady, Ruth Chabay, Bruce Sherwood, Steve Spicklemire, and Matt Craig. It runs in a Jupyter notebook and uses GlowScript VPython syntax with standard Python, thereby providing access to standard Python modules. For details see vpython.org. Also of interest is a discussion about plans for the future evolution of VPython.

This documentation describes both the GlowScript and Jupyter versions of VPython.

For a quick introduction, see the following YouTube videos. These were created for Classic VPython but are just as useful for learning the more recent versions.

3D Objects

Variable Assignment

Beginning Loops

Loops and Animation

Scale Factors

Debugging Syntax Errors

Lists, Part 1

Lists, Part 2

There is a series of GlowScript VPython tutorials by Rhett Allain in the context of predicting motion computationally, at the level of an introductory physics course.

Getting started

To write a VPython program, sign in at glowscript.org.

* You will see the sentence "You are signed in as <your user name> and your programs are here." Click on here.

* Click Create New Program. (You may wish to click on the Public tab before creating your program, as programs in your Private folder are not accessible to others.) Choose a name for the program, which should not include spaces or underscores.

* Below the line GlowScript 2.0 VPython, type box(). Click Run this program to run your program. You will see a white box on a black background.

* Use the right button (or CTRL-drag left button) of the mouse to rotate the camera to view the scene from different angles.

* To zoom in and out use two buttons, or ALT/OPTION-drag, or the mouse scrollwheel. Touch screen: swipe or two-finger rotate; pinch/extend to zoom.

See the start of the technical documentation for details about how to use the text editor to search, replace, etc. Note that you can press ctrl-1 to run your program instead of clicking "Run this program". Or press ctrl-2 to run your program in a separate window, which lets you view your program and its execution side by side. After making a change to your program press ctrl-2 to see the effect of your changes; it isn't necessary to close the execution window.

It is recommended to use the Chrome browser for developing programs, as it provides the most useful error messages, though programs can be written and run in all browsers, including on smartphones and tablets.

Letting others run your programs

On the GlowScript edit page, click Share this program to see how to let other people run your program. For people to run your program by linking to it, the program must be in a public folder or be exported to your own web site. In fact, the code available on the share page can simply be pasted into a file and saved with the extension ".html", and then you can run the program simply by doubleclicking the html file.

Descriptions of the options available in the left margin

Introduction: The basics of Python and VPython.

Tutorial: More on VPython, including making an animation

Pictures of 3D objects: What the objects look like

Choose a 3D object: Details of cylinder, box, etc. Start with cylinder for an overview.

Work with 3D objects: Issues that apply to all 3D objects: color, material, etc.

Windows, Events, & Files: Creating/modifying windows; handling mouse/ keyboard events; reading/writing files

Vector operations: Magnitude, dot and cross product, rotation, etc.

Graphs: Making graphs of data.

factorial/combin: Special functions used in probability calculations.

What's new: VPython in GlowScript, plus the history of VPython..

Be sure to explore the many GlowScript example programs, written using JavaScript, RapydScript, or VPython. The VPython option is based on the RapydScript Python-to-JavaScript compiler. For most programs, RapydScript is nearly the same as Python, but there are differences which can be seen in the RapydScript documentation.


Do not use "wait" as a variable name. All GlowScript languages (VPython, RapydScrpt, JavaScript) use "wait" as a special signal for the compilation process. In the VPython case this signal is inserted for you where needed.

For experienced programmers

As a convenience to novice programmers to provide everything that is needed to get started, GlowScript VPython by default imports all of the VPython features and includes standard math functions such as sqrt. The documentation is written as though "from vpython import *" were present.

You can however import selectively, as shown in the following examples, which are compatible with Jupyter VPython. (To help with converting from Classic VPython, you can refer to "vis" or "visual" instead of "vpython".)

import vpython
import vpython as vp # "vp" is any name of your choice
from vypthon import box, color # or (box, color)

For those who have used Classic VPython

A few Classic VPython objects are not currently available in GlowScript: convex, faces, and frame. The GlowScript objects vertex, triangle, and quad represent a more powerful alternative to faces. Many applications of frame can be handled with the GlowScript compound object.

One way to deal with differences is to check the elements of the "version" variable that is available in both Classic VPython and the GlowScript version and do different things in the different environments:

Classic VPython:    version is ['X.Y', 'release']
GlowScript VPython: version is ['X.Y', 'glowscript']
Jupyter VPython:    version is ['X.Y.Z', 'jupyter']
and in Jupyter VPython, the version of the GlowScript
graphics library is given by
                  GSversion is ['X.Y', 'glowscript']

The curve and points objects are somewhat different in the GlowScript environment, but with a little care it is possible to use these objects in such a way that they will also work in Classic VPython. Note that in GlowScript the list of points in a curve object is not a numpy array, so that a loop is required to change all of the points.

To handle mouse events one cannot use scene.getevent() but must use scene.bind(), which is available both in Classic VPython 6 and in GlowScript. Also available are scene.pause() and scene.waitfor('click') and related options.

It is not possible to import arbitrary Python modules such as numpy, and any VPython program that uses numpy will have to be modifed. However, loops are fast in the JavaScript language to which GlowScript programs compile, so if you are using numpy solely for the speed of array manipulation, you may be able to replace a numpy calculation easily and efficiently with a loop.

The difference between RapydScript and VPython programs in the GlowScript context is that the VPython option attempts to mimic the syntax and semantics of Classic VPython programs, whereas the RapydScript option implements the same semantics for 3D objects as that of JavaScript programs. For example, in a RapydScript program the sphere object has a size attribute but no radius attribute, and like box, the default bounding box of the sphere is 1x1x1. Also, changing the length of the axis in a RapydScript program has no effect on the size (except for an arrow, which has a special axis_and_length attribute), but in a VPython program, as in Classic VPython, changing the length of the axis also changes the length of the object (the first component of the object's size).

GlowScript by default processes VPython programs as though they had the following statements at the start of the program (which you don't need to include; they will be ignored):

from __future__ import division, print_function
from vpython import *

GlowScript treats 3/2 as 1.5 as in Python 3.x, not 1 as in the Python 2.x language, and the print statement must take the Python 3.x form of print('hello') rather than the Python 2.x form of print 'hello'.

Many programs written in Classic VPython 6 will run in GlowScript or Jupyter without change after being run through a conversion program written in Python. This program converts (x,y,z) => vector(x,y,z) and obj.x => obj.pos.x. These changes are necessary because GlowScript does not recognize (x,y,z) as a vector nor obj.x as a shorthand for obj.pos.x. The program also converts display => canvas and gdisplay => graph.

In the GlowScript environment pos, size, axis, color, and up are all vectors, and they are somewhat special vectors that track changes in order to trigger correct rendering of the 3D scene when one of these object attributes changes. One result of this architecture is that

         ball.pos += vector(1,2,3)

must be rewritten as

         ball.pos = ball.pos + vector(1,2,3)

The conversion program makes these changes, and similar changes for -=, *=, and /=. The program also converts scene.mouse.getclick() => scene.waitfor('click'), which works in both environments.

In GlowScript and Jupyter you can use the shorthand "vec" for "vector". If you wish to use a GlowScript program containing "vec" in the Classic VPython environment, just add the statement "vec = vector" at the start of the program.


Salvatore di Dio demonstrated in his RapydGlow experiment
how he was able to use the RapydScript Python-to-JavaScript compiler with GlowScript graphics. This inspired the implementation of the VPython (vpython.org) API at glowscript.org. He provided the file papercomp.js for operator overloading, based on the work of
    Jürg Lehni (PaperScript: http://scratchdisk.com/posts/operator-overloading).
He also assembled support for operator overloading and the ability to write synchronous code in the file transform-all.js, based on the work of
    Bruno Jouhier (Streamline: https://github.com/Sage/streamlinejs), and
    Marijn Haverbeke (Acorn.js: https://github.com/marijnh).
Supporting the VPython API in a browser is possible thanks to the work of
    Alexander Tsepkov (RapydScript: https://github.com/atsepkov/RapydScript) and
    Charles Law (browser-based RapydScript: https://github.com/charleslaw/RapydScript_web).

In January 2017 the original RapydScript compiler was replaced with RapydScript-NG by Kovid Goyal, which comes closer to handling true Python syntax.

When the GlowScript project was launched in 2011 by David Scherer and Bruce Sherwood,
Scherer implemented operator overloading and synchronous code using libraries existing at that time. In 2015 it became necessary to upgrade to newer libraries because compilation failed on some browsers; Salvatore di Dio provided crucial help in this update. In January 2017 the operator overloading machinery was further updated.


VPython documentation was produced by Ruth Chabay, David Scherer, and Bruce Sherwood.

Armenian translation by Gajk Melikyan

Estonian translation by Sonja Kulmala

Finnish Translation by Fijavan Brenk