hermet

Check this out: https://thorvg-perf-test.vercel.app/ https://www.youtube.com/watch?v=jdnnzmtHy9k

Blend2D is a CPU-only rendering engine, so I don't think it's a fair comparison to ThorVG. If we're talking about CPU rendering, ThorVG is faster than Skia. (no idea about Blend2d) But at high resolutions, CPU rendering has serious limitations anyway. Blend2D is still more of an experimental project that JIT kills the compatiblity and Vello is not yet production-ready and webgpu only. No point of arguing fast today if it's not usable in real-world scenarios.

A CPU-only demo of ThorVG, a high-performance 2D vector graphics engine

I’ve built a demo app to showcase the performance of the ThorVG engine. Key features:

- Each enemy consists of 86 particles, with up to ~300 enemies on screen.

- Full-size (2K) subtle halo glow background bitmap image and 4 × 100 star layers.

- Real-time DropShadow and BlurEffects for ships, missiles, GUI, and outlines.

- At peak load, ~25,000 drawing objects rendered together.

- Runs fully stable at 120+ FPS with the Software Renderer on 2K resolution (tested on Apple M2 Pro).

Demo video: https://www.youtube.com/watch?v=jdnnzmtHy9k

Repo: https://github.com/thorvg/thorvg.janitor

This demo specifically highlights the Software Renderer (CPU only). GPU backends (OpenGL/WebGPU) are supported, but optimization work is ongoing.

ThorVG is an open-source high-performance 2D vector graphics engine designed for embedded, mobile, and web systems. This demo is intended as a performance showcase and stress test. Feedback and contributions are welcome!

Please check, https://www.youtube.com/watch?v=qhHMycRPQ9M&t=885s

ThorVG is essentially a real-time graphics engine. Sprite sheets are part of Godot's integration strategy, not a limitation of ThorVG.

there are some approaches: Analytic AA, SSAA, MSAA, SDFs, etc.

Current ThorVG itself is more like of a graphics engine; interactivity is typically handled at the toolkit level feature.

So far, there is only one announced performance comparison. 'rlottie' is used for animation stickers in the Telegram app.

https://lottiefiles.com/blog/working-with-lottie-animations/...

You might wanna report this to the ThorVG community. (https://github.com/thorvg/thorvg/issues) Maintainers will address it as soon as possible.

it has.

See this project, https://github.com/thorvg/thorvg

Right now, we can make use of a very useful library. ThorVG supports the widest range of the Lottie specification and is an extremely portable and lightweight engine.

I happened to come across the following page recently: https://rive.app/blog/rive-as-a-lottie-alternative

I found it interesting that Rive officially compared itself to Lottie based on fairly recent information. However, I was quite surprised by the many vague or inaccurate statements made about Lottie. As a developer familiar with Lottie, I'd like to offer a different perspective on a few key points.

1. Responsiveness

The claim that Lottie "regenerate animations" to scale for different screen sizes is puzzling. In most GUI environments, responsiveness is handled by standard layout and scrolling systems. Since Lottie animations are vector-based, they naturally scale according to their aspect ratio within the assigned layout. There is no need to regenerate the animation—rendering scalable vector graphics in real time is already built into the design.

2. Dynamic Data Integration

It’s inaccurate to describe Lottie as strictly static. Event Lottie supports scripting and allows runtime updates of animation properties, enabling dynamic behavior driven by external data or user interaction.

3. Blurs and Shadows

Lottie fully supports vector-based effects such as Gaussian blur and drop shadows. These are rendered as scalable vector effects— How this specifically increases file size. Doesn't make sense.

4. Masking

Lottie has multiple types of masking, including at least four distinct modes. One of the most powerful is the Matte feature, which goes well beyond basic alpha masking and allows for advanced compositing techniques.

5. File Size and Rendering

Relying solely on a binary format for production use can be limiting in terms of flexibility. Lottie's text-based JSON format is easily readable, editable, and compressible during the build or packaging process. It allows for streamlined workflows where designers and developers can collaborate effectively before optionally converting to a binary format for optimization.

6. GPU-Accelerated Rendering

GPU acceleration is available in many Lottie runtimes, moreover, Lottie's lightweight and flexible architecture enables it to run on a wide range of devices, including low-power IoT hardware. This level of adaptability is a key strength, not a weakness.

7. Asset Management

Whether to embed assets or link to them externally is entirely up to the developer. Lottie offers flexibility in this regard—it is not restricted to embedded assets only.

8. Platform Support

Lottie already supports a broad range of platforms. There are 3rd-party user plugins integrated into major engines like Unity and even Godot has upcoming support for Lottie integration officially. Even Lottie is is capable on on MCU-based chipsets, IoT, or RTOS devices.

IMHO, Publishing incorrect or false information as if it were true on an official company page is something that should be approached with caution.

The fact that apps across multiple platforms support different Lottie specifications presents a clear issue, similar to how SVG has faced compatibility issues within the industry for decades. A cross-platform designed dotLottie player is highly appealing for addressing this issue. It is similar to how 3rd party apps hope to implement the same business logic across multiple products. With a dotLottie player, apps expect to have the same killer motion design among the different targets!

To add a note, At the core of dotLottie is an super lightweight Lottie rendering engine(https://github.com/thorvg/thorvg). It is small enough (300kb) to run on low-spec devices like ESP, MPU, and MCU (it's proven within LVGL https://lvgl.io/ framework), and we can expect the hardware acceleration features for high-performance devices, including nested multi-threading task scheduler, SIMD, OpenGL, and WebGPU (though some of them are under the beta dev but aggresively working on). It has proven stable to be used in practical applications (even it's in Godot game engine) across various devices and also offers a web player through WebAssembly. We can check the ThorVG-based Lottie web player can be completed in less than 500KB (You can directly test Lottie animations at www.thorvg.org/viewer). This ensures the scalability of the dotLottie player from low-spec device environments to high-spec web environments & apps.

Please have a look at this one: https://github.com/thorvg/thorvg. ThorVG is portable and super lightweight, and it's currently undergoing development with WebGPU.