BranchesTags

Repository files navigation

VisPy: interactive scientific visualization in Python

Main website: http://vispy.org

Build StatusCoverage StatusZenodo LinkContributor Covenant

VisPy is a high-performance interactive 2D/3D data visualization library. VisPy leverages the computational power of modern Graphics Processing Units (GPUs) through the OpenGL library to display very large datasets. Applications of VisPy include:

  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or IPython notebook with WebGL).

Releases

See CHANGELOG.md.

Announcements

See the VisPy Website.

Using VisPy

VisPy is a young library under heavy development at this time. It targets two categories of users:

  1. Users knowing OpenGL, or willing to learn OpenGL, who want to create beautiful and fast interactive 2D/3D visualizations in Python as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a high-level, high-performance plotting toolkit.

If you're in the first category, you can already start using VisPy. VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL ES 2.0 called gloo. You can focus on writing your GLSL code instead of dealing with the complicated OpenGL API - VisPy takes care of that automatically for you.

If you're in the second category, we're starting to build experimental high-level plotting interfaces. Notably, VisPy now ships a very basic and experimental OpenGL backend for matplotlib.

Installation

Please follow the detailed installation instructions on the VisPy website.

Structure of VisPy

Currently, the main subpackages are:

  • app: integrates an event system and offers a unified interface on top of many window backends (Qt4, wx, glfw, jupyter notebook, and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively stable API.
  • scene: this is the system underlying our upcoming high level visualization interfaces. Under heavy development and still experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both CPU and GPU.
    • Shaders implements a shader composition system for plumbing together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation graph.
  • plot: high-level plotting interfaces.

The API of all public interfaces are subject to change in the future, although app and gloo are relatively stable at this point.

Code of Conduct

The VisPy community requires its members to abide by the Code of Conduct. In this CoC you will find the expectations of members, the penalties for violating these expectations, and how violations can be reported to the members of the community in charge of enforcing this Code of Conduct.

Genesis

VisPy began when four developers with their own visualization libraries decided to team up: Luke Campagnola with PyQtGraph, Almar Klein with Visvis, Cyrille Rossant with Galry, Nicolas Rougier with Glumpy.

Now VisPy looks to build on the expertise of these developers and the broader open-source community to build a high-performance OpenGL library.

External links

About

Main repository for Vispy

vispy.org

Resources

Readme
License

Code of conduct

Code of conduct

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
VisPy: interactive scientific visualization in Python
Main website: http://vispy.org
Build StatusCoverage StatusZenodo LinkContributor Covenant
VisPy is a high-performance interactive 2D/3D data visualization
library. VisPy leverages the computational power of modern Graphics
Processing Units (GPUs) through the OpenGL library to display very
large datasets. Applications of VisPy include:
  • High-quality interactive scientific plots with millions of points.
  • Direct visualization of real-time data.
  • Fast interactive visualization of 3D models (meshes, volume
rendering).
  • OpenGL visualization demos.
  • Scientific GUIs with fast, scalable visualization widgets (Qt or
IPython notebook with WebGL).
Releases
See CHANGELOG.md.
Announcements
See the VisPy Website.
Using VisPy
VisPy is a young library under heavy development at this time. It
targets two categories of users:
  1. Users knowing OpenGL, or willing to learn OpenGL, who want to
create beautiful and fast interactive 2D/3D visualizations in Python
as easily as possible.
  2. Scientists without any knowledge of OpenGL, who are seeking a
high-level, high-performance plotting toolkit.
If you're in the first category, you can already start using VisPy.
VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
ES 2.0 called gloo. You can focus on writing your GLSL code instead
of dealing with the complicated OpenGL API - VisPy takes care of that
automatically for you.
If you're in the second category, we're starting to build experimental
high-level plotting interfaces. Notably, VisPy now ships a very basic
and experimental OpenGL backend for matplotlib.
Installation
Please follow the detailed
installation instructions
on the VisPy website.
Structure of VisPy
Currently, the main subpackages are:
  • app: integrates an event system and offers a unified interface on
top of many window backends (Qt4, wx, glfw, jupyter notebook,
and others). Relatively stable API.
  • gloo: a Pythonic, object-oriented interface to OpenGL. Relatively
stable API.
  • scene: this is the system underlying our upcoming high level
visualization interfaces. Under heavy development and still
experimental, it contains several modules.
    • Visuals are graphical abstractions representing 2D shapes, 3D
meshes, text, etc.
    • Transforms implement 2D/3D transformations implemented on both
CPU and GPU.
    • Shaders implements a shader composition system for plumbing
together snippets of GLSL code.
    • The scene graph tracks all objects within a transformation
graph.
  • plot: high-level plotting interfaces.
The API of all public interfaces are subject to change in the future,
although app and gloo are relatively stable at this point.
Code of Conduct
The VisPy community requires its members to abide by the
Code of Conduct. In this CoC you will find the
expectations of members, the penalties for violating these expectations, and
how violations can be reported to the members of the community in charge of
enforcing this Code of Conduct.
Genesis
VisPy began when four developers with their own visualization libraries
decided to team up:
Luke Campagnola with PyQtGraph,
Almar Klein with Visvis,
Cyrille Rossant with Galry,
Nicolas Rougier with Glumpy.
Now VisPy looks to build on the expertise of these developers and the
broader open-source community to build a high-performance OpenGL library.
External links
About
Main repository for Vispy
vispy.org
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages