Graphite VS wgpu

A tool which looks at this sort of thing which was mentioned here recently:

https://news.ycombinator.com/item?id=44118159

but which didn't seem to get much traction is:

https://pontus.granstrom.me/scrappy/

but it pretty much only works for JavaScript programmers and their friends (or folks interested in learning JavaScript).

Other tools which I'd like to put forward as meriting discussion in this context include:

- LyX --- making new layout files allows a user to create a customized tool for pretty much any sort of document they might wish to work on --- a front-end for LaTeX

- pyspread --- every cell being either a Python program or the output of a program, and the possibility of cells being an image allows one to do pretty much anything without the overhead of making or reading a file

- Ipe https://ipe.otfried.org/ --- an extensible drawing program, this really needs a simpler mechanism for that and I'd love to see a tool in the vector drawing space which addressed that --- perhaps the nascent https://graphite.rs/ ?

https://graphite.rs/ (still early in development) offers node-based editing.

2D Content Creation Tool (Open Source Photoshop?)

I was referring to the link posted to HN: https://graphite.rs/

I love Inkscape so much. I use it every other week to make presentations, slides or just simple graphics when I need it. I illustrated my thesis with it.

Another piece of 2D vector software that I use and recommend is Graphite [1]. It too is open source. Graphite has nodes and can be procedural in nature. Have them both in your graphics toolbox.

[1] https://github.com/GraphiteEditor/Graphite

There is also Graphite (https://graphite.rs/) which, unlike Gimp, has a modern architecture and very ambitious goals (Blender for 2D basically).

If you're interested in either computational geometry, layout/packing/constraints, or functional programming language concepts, those are all the math-related concepts that we're currently interacting with for Graphite, a 2D vector graphics editor that's aiming to become the next Blender (but for 2D instead of 3D). If that sounds interesting, I'd love to help get you started if you want to join our Discord and I can explain the math-related work that we need to get done. Cheers!

that's an exciting feature to have available, as raytracing hardware is now in mobile iGPUs and phones.

There is a tracking issue[1], although I ma not sure how much of that makes it to the browser.

[1] https://github.com/gfx-rs/wgpu/issues/6762

People have already mentioned Metal, but if you want cross platform, https://github.com/gfx-rs/wgpu has a vulkan-like API and cross compiles to all the various GPU frameworks. I believe it uses https://github.com/KhronosGroup/MoltenVK to run on Macs. You can also see the metal shader transpilation results for debugging.

This is in reference to [1].

[1] https://github.com/gfx-rs/wgpu/issues/6434

> Did they actually write that somewhere?

wgpu.rs for comments about "general purpose", "modern" is my own interjection, and [1] about the difference in priorities between the WGPU maintainers and (funnily enough) you.

I do believe a cross-platform and modern interface is difficult to square with high performance. I don't think either side is wrong to choose the priorities it has, but someone will be underserved. They probably need far more manpower/talent than they have to improve performance proportionately.

[1] https://github.com/gfx-rs/wgpu/discussions/5525

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 the exact same underlying graphics 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

Everything will be using compute shaders for the foreseeable future. [WGPU](https://wgpu.rs/) abstracts that to work with WebGPU on browsers, DirectX/Vulkan on Windows, Metal on Mac, and Vulkan on Linux and Android. There may be opportunities to explore vendor-specific options like CUDA in the far future to leverage a further increase in performance, but compute shaders are portable and nearly as good.

Instead of building their GPU support atop CUDA/NVIDIA [0], I’m wondering why they didn’t instead go with WebGPU [1] via something like wgpu [2]. Using wgpu, they could offer cross-platform compatibility across several graphics API’s, covering a wide range of hardware including NVIDIA GeForce and Quadro, AMD Radeon, Intel Iris and Arc, ARM Mali, and Apple’s integrated GPU’s.

They note the following [0]:

> The GPU module is under active development. APIs and semantics might change between Codon releases.

The thing is, based on the current syntax and semantics I see, it’ll almost certainly need to change to support non-NVIDIA devices, so I think it might be a better idea to just go with WebGPU compute pipelines sooner rather than later.

Just my two pennies…

[0]: https://docs.exaloop.io/codon/advanced/gpu

[1]: https://www.w3.org/TR/webgpu

[2]: https://wgpu.rs

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

> While WebGPU does not support any shading language other than WGSL, we will automatically convert your non-WGSL shaders if you're running on WebGPU.