Some screenshots from the glumpy examples directory.
You will need the latest glumpy for the github repository to run them.
This example demonstrates simulation of fireworks using point
sprites and has been adapted from the OpenGL ES 2.0 Programming
This is a simulation of a galaxy using the density wave theory as
explained by Ingo Berg. All simulation details can be found on his
This example shows dynamic voronoi based on an old technique
where the hardware is used to compute the diagram using 3D occluded cones.
This example explains how to plot high-frequency functions by
resampling the signal. More details on the Syntopia website and Shadertoy
This example shows a 10x10 numpy array represented as a heightfield
that is generated entirely on the GPU (using a default mesh).
This example shows a 3D cloud of a million anti-aliased and stroked
points animated in real-time. Most of them are hidden though !
The mandatory Mandelbrot set computed in the GPU with single float
precision even tough double precision is possible.
Just because we can ! This example demonstrates parametric surface
generation and visualization with uv mapping.
Using GPU power, we can litteraly draw a quiver plot using a
single quad. Adapted from Morgan McGuire original idea on
Pixel perfect anti-aliased projected frame drawn by the GPU using a
single quad. This can be adapted to any projection actually.
This example simulates a Reaction diffusion using Gray-Scott model
largely inspired from this great site that gives all the details.
Post processing filters
Post-processing is applied through python context manager. This
example combines two filters to produce Gaussian blur.
Most colormaps can be computed just in time within GPU. But color
lookup tables are also available through 1D textures.
This is a fast & failsafe terminal that allows to quickly display
information on screen. It uses the UCS 6x13 bitmap character sets.
From an idea by Cyrille Rossant, this example shows 320 signals
with 10,000 points each. Each signal can be zoomed in/out
Porting the fluid simulation from the little
grasshopper, this example
shows a very nice smoke simulation using GPU.
A magnigying glass to help the visualization of a scatter
plot. The position and level of zoom is controlled by the
Isocurves can be direcly computed on the GPU (no need to
precompute them). This is a very fast and accurate technique.
Collections (glyphs, paths and segments) allow for efficient batch
rendering of several objects with a few GL calls.
SVG rendering using polygons and paths collections allow for efficient batch
rendering of the tiger.
Graphs can be rendered using collections of markers and line
segments allowing very fast display.
Named colors are easily accessible using colon notation
and namespace such as material, web and svg.
Molecules can be rendered very efficiently using sphere impostors
and screen space ambient occlusion.
Matplotlib API is slowly building up.
Virtually any kind of transform can be used.
Animated spherical harmonics computed on the GPU.
Rendering of the USA states and counties using Albers projection.
Standard skyboxes (texture cube).
Order independent transparency
Mesh reading and specular light
Dynamic textured earth with national capitals.
Choropleth with Albers projection