Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
raphlinus
-
Moving from Rust to C++
That's surprising, given the legendary sense of humor of the C++ community.
-
Announcing Bezier-rs: computational geometry algorithms for Bézier paths (seeking code review and boolean ops help)
I have some ideas on how to do boolean ops, some of which is written up in a blog post issue, and for which I have some code locally. In particular, the parabola estimate seems much more efficient than the usual fat line approach. I also have a sketch of quadratic/quadratic intersection in kurbo#230.
-
The Beauty of Bézier Curves
I am. It is relevant to the topic, and I cite it in the (now two year old) outline for the blog post I intend to write on the topic[1].
[1]: https://github.com/raphlinus/raphlinus.github.io/issues/40
-
Raph’s reflections and wishes for 2023
I rewrote that paragraph, as I realize it comes across too contentious. Thanks all for the feedback!
-
Rust GUI library for video playback?
To do video properly requires integration with the platform compositor. This is a fiendishly difficult problem, and I know of no serious effort to solve it. I have an outline of a blog post on the topic, and hope to publish it before too long.
-
Parallel curves of cubic Béziers
I am working on this problem too, and have an issue on my blog with an outline of the writeup. Stay tuned!
-
The Toxic Culture of Rejection in Computer Science
> PS, is your monoid work online, is it this https://arxiv.org/abs/2205.11659 ? I'm interested in monoids on GPUs.
Yes, the draft is on arXiv, and I have a blog post in the pipeline[1] explaining it to a more general audience.
And thanks for the other advice, I'll consider it!
[1] https://github.com/raphlinus/raphlinus.github.io/issues/66
-
Druid app for public transport data
The new xilem async architecture is designed to integrate much more finely with async. I have an outline of a blog post in the queue but am juggling a lot of things right now. Expect to see some updates, but not super soon.
-
Bevy and Dioxus are collaborating on stretch2: a revived UI layout algorithm
This is a hard problem and one of the hardest parts is figuring out scope. I have an upcoming blog post which will touch on some of the issues. In any case I'd love to see some progress on larger ecosystem collaboration.
-
Removing characters from strings faster with AVX-512
The short answer is no, but the long answer is that this is a very complex tradeoff space. Going forward, we may see more of these types of tasks moving to GPU, but for the moment it is generally not a good choice.
The GPU is incredible at raw throughput, and this particular problem can actually implemented fairly straightforwardly (it's a stream compaction, which in turn can be expressed in terms of prefix sum). However, where the GPU absolutely falls down is when you want to interleave CPU and GPU computations. To give round numbers, the roundtrip latency is on the order of 100µs, and even aside from that, the memcpy back and forth between host and device memory might actually be slower than just solving the problem on the CPU. So you only win when the strings are very large, again using round numbers about a megabyte.
Things change if you are able to pipeline a lot of useful computation on the GPU. This is an area of active research (including my own). Aaron Hsu has been doing groundbreaking work implementing an entire compiler on the GPU, and there's more recent work[1], implemented in Futhark, that suggests that that this approach is promising.
I have a paper in the pipeline that includes an extraordinarily high performance (~12G elements/s) GPU implementation of the parentheses matching problem, which is the heart of parsing. If anyone would like to review a draft and provide comments, please add a comment to the GitHub issue[2] I'm using to track this. It's due very soon and I'm on a tight timeline to get all the measurements done, so actionable suggestions on how to improve the text would be most welcome.
[1]: https://theses.liacs.nl/pdf/2020-2021-VoetterRobin.pdf
[2]: https://github.com/raphlinus/raphlinus.github.io/issues/66#i...
vello
-
Rive Renderer – now open source and available on all platforms
I'm looking forward to doing careful benchmarking, as this renderer absolutely looks like it will be competitive. It turns out that is really hard to do, if you want meaningful results.
My initial take is that performance will be pretty dependent on hardware, in particular support for pixel local storage[1]. From what I've seen so far, Apple Silicon is the sweet spot, as there is hardware support for binning and sorting to tiles, and then asking for fragment shader execution to be serialized within a tile works well. On other hardware, I expect the cost of serializing those invocations to be much higher.
One reason we haven't done deep benchmarking on the Vello side is that our performance story is far from done. We know one current issue is the use of device atomics for aggregating bounding boxes. We have a prototype implementation [2] that uses monoids for segmented reduction. Additionally, we plan to do f16 math (which should be a major win especially on mobile), as well as using subgroups for various prefix sum steps (subgroups are in the process of landing in WebGPU[3]).
Overall, I'm thrilled to see this released as open source, and that there's so much activity in fast GPU vector graphics rendering. I'd love to see a future in which CPU path rendering is seen as being behind the times, and this moves us closer to that future.
[1]: https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/da...
[2]: https://github.com/linebender/vello/issues/259
[3]: https://github.com/gpuweb/gpuweb/issues/4306
- WebKit Switching to Skia for 2D Graphics Rendering
-
Looking for this. html + css rendering through wgpu.
Dioxus is working on this with blitz. It's leveraging wgpu through the linebender group's Vello renderer. Still in early stages.
-
A note on Metal shader converter
If you're doing advanced compute work (including lock-free data structures), then it's best effort.
https://github.com/linebender/vello/issues/42 is an issue from when Vello (then piet-gpu) had a single-pass prefix sum algorithm. Looking back, I'm fairly confident that it's a shader translation issue and that it wouldn't work with MoltenVK either, but we stopped investigating when we moved to a more robustly portable approach.
- Vello: An experimental WebGPU-based compute-centric 2D renderer in Rust
-
XUL Layout has been removed from Firefox
There are a number of up-and-coming Rust-based frameworks in this niche:
- https://github.com/iced-rs/iced (probably the most usable today)
- https://github.com/vizia/vizia
- https://github.com/marc2332/freya
- https://github.com/linebender/xilem (currently very incomplete but exciting because it's from a team with a strong track record)
What is also exciting to me is that the Rust GUI ecosystem is in many cases building itself up with modular libraries. So while we have umpteen competing frameworks they are to a large degree all building and collaborating on the same foundations. For example, we have:
- https://github.com/rust-windowing/winit (cross-platform window creation)
- https://github.com/gfx-rs/wgpu (abstraction on top of vulkan/metal/dx12)
- https://github.com/linebender/vello (a canvas like imperative drawing API on top of wgpu)
- https://github.com/DioxusLabs/taffy (UI layout algorithms)
- https://github.com/pop-os/cosmic-text (text rendering and editing)
- https://github.com/AccessKit/accesskit (cross-platform accessibility APIs)
In many cases there a see https://blessed.rs/crates#section-graphics-subsection-gui for a more complete list of frameworks and foundational libraries)
-
Drawing and Annotation in Rust
blessed.rs lists these three crates for 2D drawing: - https://lib.rs/crates/femtovg - https://lib.rs/crates/skia-safe - https://github.com/linebender/vello
-
Recommended UI framework to draw many 2D lines?
Vello (https://github.com/linebender/vello) which uses wgpu to render Edit: just saw you require images. Vello doesn't support those yet
-
Announcing piet-glow, a GL-based implementation of Piet for 2D rendering
How does this relate to Vello? Both target raw-window-handle for winit compatibility. Vello uses WGPU vs piet-glow using GL.
-
Is WGPU actually a good idea yet?
Finally, maybe vello could help you with ideas. It's not production ready yet, but they have some interesting ideas for 2D rendering using wgpu.
What are some alternatives?
sprawl - A high performance Rust-powered layout library [Moved to: https://github.com/DioxusLabs/taffy]
nanovg - Antialiased 2D vector drawing library on top of OpenGL for UI and visualizations.
morphorm - A UI layout engine written in Rust
msdfgen - Multi-channel signed distance field generator
gtfs_manager - A GUI for viewing and editing GTFS data
Vrmac - Vrmac Graphics, a cross-platform graphics library for .NET. Supports 3D, 2D, and accelerated video playback. Works on Windows 10 and Raspberry Pi4.
Graphite - 2D raster & vector editor that melds traditional layers & tools with a modern node-based, non-destructive, procedural workflow.
troika - A JavaScript framework for interactive 3D and 2D visualizations
maplibre-rs - Experimental Maps for Web, Mobile and Desktop
tinyraytracer - A brief computer graphics / rendering course
rusty-dos - A Rust skeleton for an MS-DOS program for IBM compatibles and the PC-98, including some PC-98-specific functionality
gpuweb - Where the GPU for the Web work happens!