Pygfx - Hacker News

Posted by figomore 10/22/2024

Pygfx(docs.pygfx.org)

253 points | 54 comments

fulafel 10/26/2024|

As this is using wgpu, it will be interesting if in the future they get it to run in the browser (Python already does, with Pyodide).

There are some tickets about it: https://github.com/pygfx/pygfx/issues/650 https://github.com/pygfx/wgpu-py/issues/407

almarklein 10/26/2024|

It's definitely still our intention to make it run in the browser. We're not actively working on that yet, but we've recently been able to remove some hurdles on that path, in particular the issue related to Webgpu being async.

nmstoker 10/26/2024||

Great to hear that - I was impressed by pygfx but my immediate thought was that in this age of near universal browser access, it's a shame there's no ability to interact from there!

MiliasGeiger 10/25/2024||

I used to love making physics visualizations using VPython[1]! It's awesome to see similar tools pop up. I gave up on VPython after python3, since it was a pain to migrate.

[1]: https://vpython.org/

an1sotropy 10/26/2024||

Suppose I'm using PySide6 and starting to use QRhi[1]. Is there a way to compare the portability and speed of pygfx (as within PySide6) with QRhi?

[1] https://doc.qt.io/qtforpython-6/PySide6/QtWidgets/QRhiWidget...

almarklein 10/26/2024|

From what I understand, QRhi has a very different purpose then Pygfx, so I'm not sure how to answer this question.

jcelerier 10/26/2024|||

QRhi + Qt3D & / QtQuick3D is pretty much the exact same goal than pygfx with a different implementation: https://github.com/qt/qtbase/tree/dev/src/gui/rhi ; https://doc.qt.io/qt-6/qt3d-index.html ; https://doc.qt.io/qt-6/qtquick3d-index.html ; QRhi itself pretty much sits at the "wgpu" abstraction layer.

I've been using it for 4-ish years now in https://ossia.io (just the RHI part)

Pros:

- Integrates with Qt (of course).

- Really really easy API compared to the average C++ API.

- Works absolutely everywhere.

- Many provided examples: https://github.com/qt/qtbase/tree/dev/tests/manual/rhi

- Shader language is SPIRV-compatible GLSL 4.x thus it makes it fairly trivial to import existing GL shaders (one of my requirements was support for https://editor.isf.video shaders).

Cons:

- Was developed before Vulkan Dynamic Rendering was introduced so the whole API is centered around the messy renderpass thing which while powerful is sometimes a bit more tedious than necessary when your focus is desktop app development. However, Qt also has a huge focus on embedded so it makes sense to keep the API this way.

- Most likely there are some unnecessary buffer copies here and there compared to doing things raw.

- Does not abstract many texture formats. For instance still no support for YUV textures e.g. VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM and friends :'(

an1sotropy 10/26/2024|||

Sorry, I'll try to be clearer. QRhi docs[1] say "The Qt Rendering Hardware Interface is an abstraction for hardware accelerated graphics APIs, such as, OpenGL, OpenGL ES, Direct3D, Metal, and Vulkan." And PySide6 includes a (python) wrapper for QRhi[2]. Meanwhile, pygfx builds on wgpu-py[3] which builds on wgpu[4] which is a "is a cross-platform, safe, pure-rust graphics API. It runs natively on Vulkan, Metal, D3D12, and OpenGL".

So, from the standpoint of someone using PySide6, QRhi and pygfx seem to be alternative paths to doing GPU-enabled rendering, on the exact same range of GPU APIs.

Thus my question: How do they compare? How should I make an informed comparison between them?

[1] https://doc.qt.io/qt-6/qrhi.html

[2] https://doc.qt.io/qtforpython-6/PySide6/QtWidgets/QRhiWidget...

[3] https://github.com/pygfx/wgpu-py/

[4] https://github.com/gfx-rs/wgpu

Calavar 10/26/2024|||

> How should I make an informed comparison between them?

Pygfx provides higher level rendering primitives. The more apples to apples comparison would be wgpu-py versus QtRhi, both of which are middleware that abstract the underlying graphics API.

The natural question is are you already using Qt? You say you are, so IMHO the pros and cons of the specific implementations don't matter unless you have some very specific exotic requirements. Stick with the solution that "just works" in the existing ecosystem and you can jump into implementing your specific business logic right away. The other option is getting lost in the weeds writing glue code to blit a wgpu-py render surface into your Qt GUI and debugging that code across multiple different render backends.

almarklein 10/26/2024|||

Yeah, sounds like QRhi is about at the level of WebGPU/wgpu-py.

It sounds to me that Qt created their own abstraction over Vulkan and co, because wgpu did not exist yet.

I can't really compare them from a technical pov, because I'd have to read more into QRhi. But QRhi is obviously tight to / geared towards Qt, which has advantages, as well as disadvantages.

Wgpu is more geared towards the web, so it likely has more attention to e.g. safety. WebGPU is also based on a specification, there is a spec for the JS API as well as a spec for webgpu.h. There's actually two implementations (that I know of) that implement webgpu.h: wgpu-native (which runs WebGPU in firefox) and Dawn (which runs WebGPU in Chrome).

westurner 10/25/2024||

pygfx/pygfx: https://github.com/pygfx/pygfx :

> Pygfx (pronounced “py-graphics”) is built on wgpu, enabling superior performance and reliability compared to OpenGL-based solutions.

pygfx/wgpu-py: https://github.com/pygfx/wgpu-py/ :

> A Python implementation of WebGPU

gfx-rs/wgpu: https://github.com/gfx-rs/wgpu :

> wgpu is a cross-platform, safe, pure-rust graphics API. It runs natively on Vulkan, Metal, D3D12, and OpenGL; and on top of WebGL2 and WebGPU on wasm.

> The API is based on the WebGPU standard. It serves as the core of the WebGPU integration in Firefox and Deno

the__alchemist 10/25/2024|

I was/am a bit confused: I think this is unrelated to the wgpu cross-API toolkit in rust, it just abbreviated WebGpu the same way?

samtheprogram 10/25/2024|||

Per the `wgpu-py` README:

> Technically speaking, wgpu-py is a wrapper for wgpu-native, exposing its functionality with a Pythonic API closely resembling the WebGPU spec.

`wgpu-native` is a wrapper with FFI/bindings for the Rust `wgpu` per their READMEs

westurner 10/25/2024|||

Same, I had assumed they weren't independent.

/?PyPI wgpu: https://pypi.org/search/?q=wgpu

Looks like xgpu is where it's actually at.

xgpu: https://github.com/pyrym/xgpu :

> xgpu is an aggressively typed, red-squiggle-free Python binding of wgpu-native, autogenerated from the upstream C headers

wgpu-py has a conda-forge package: https://anaconda.org/conda-forge/wgpu-py

blt 10/25/2024||

this looks similar to VisPy (https://vispy.org/), are there any major differences?

mardifoufs 10/25/2024||

From my experience with vispy, it is more limited than pygfx. I mean, you can always use gloo to get whatever you want but the "built ins" are much more limited than what pygfx seems to have. I really like vispy anyways, I think this seems like an evolution with some lessons learnt from vispy.

cipherself 10/25/2024|||

Pygfx uses webgpu while VisPy uses OpenGL.

almarklein 10/26/2024||

This is indeed one of the major differences. Many of the problems that are plaguing Vispy are related to OpenGL. The use of wgpu solves many of them.

Also, wgpu forces you to prepare visualizations in pipeline objects, which at drawtime require just a few calls. In OpenGL there is way more work for each object being visualized at drawtime. This overhead is particularly bad on Python. So this particular advantage of wgpu is extra advantageous for Python.

hmaarrfk 10/25/2024|||

From the same developer ;)

nighthawk454 10/26/2024||

Oh thanks, I didn’t realize that. Having recently evaluated Vispy that really helps me place what this tool might be for

fulafel 10/26/2024|||

Seems this needs a newish graphics driver stack to work.

almarklein 10/26/2024||

Apart from being based on wgpu, Pygfx also has a better design IMO. Korijn deserves the credit for this. It's inspired by ThreeJS, based on the idea to keep things modular.

We deliberately don't try to create an API that allows you to write visualizations with as few lines as possible. We focus on a flexible generic API instead, even if it's sometimes a bit verbose.

We leave it up to others to create higher level (domain specific) APIs. Fastplotlib is one example: https://github.com/fastplotlib/fastplotlib

kelsolaar 10/27/2024||

Pygfx is awesome!

For years, we have looked at something solid to be able to implement 3D colour science visualisation. We used Vispy, but encountered some issues when interacting with the scenegraph, then a quick stint with Three.js which required doing dirty things to pass Python data to Javascript, and finally, Pygfx is the one that enabled us to do what we wanted: https://github.com/colour-science/colour-visuals

sevensor 10/25/2024||

Suppose I want to wrap a GUI around my visualization. Can I hand pygfx a surface I created with a GUI tool kit?

figomore 10/25/2024||

It's possible to use Pygfx with Qt and WX.

sevensor 10/25/2024||

Nice! That’s what I was hoping to hear!

raytopia 10/26/2024||

If someone is looking for a renderer that also has tools for game development in Python. Panda3D is another good choice. It has a task and event system along with multiplayer and physics.

mdaniel 10/27/2024|

linky-linky: https://github.com/panda3d/panda3d#readme (BSD-3 clause, more or less, saying one cannot use CMU's name to promote your product)

federicotdn 10/26/2024||

Question slightly related to this topic: how do native (e.g. Qt, GTK, etc.) desktop applications usually embed 3D views? Say for example, a desktop application for visualizing .obj files. Or something like AutoCAD, maybe (though I’m not sure which UI framework it uses).

almarklein 10/26/2024|

Not sure if this is what you're asking :) but the UI framework will somehow provide access to the OS-level surface object, so that the GPU API can render directly to the screen.

federicotdn 10/26/2024||

Makes sense!

actinium226 10/26/2024|

Very cool, I wonder how this compares to Panda3D?

More comments...