ThorVG v1.0 - A New Generation Released

A new generation logo for ThorVG - designed by LottieFiles (Celcea)

A. Overview

After one and a half years of continuous development, ThorVG reaches a major milestone with version 1.0, marking a generational leap from v0 to v1. This is not just an update — it's a rebuilt foundation for high-performance, scalable, and portable 2D vector graphics across platforms and devices. Throughout its development, ThorVG has evolved into a mature, production-ready graphics engine, demonstrating proven quality and performance in real-world applications.

In the meanwhile, ThorVG has gained rapid adoption and growing community interest, reflecting its evolution from an early-stage project into a widely recognized and practically adopted vector graphics engine — ready for real-world, cross-platform use.

ThorVG GitHub stars leading up to version 1.0

It has already been successfully integrated into several commercial and embedded products — most notably as the Vector Canvas engine behind the Artboard output in LottieCreator, and as a vector rendering backend for IoT platforms from companies like Espressif. These real-world integrations highlight ThorVG’s suitability for resource-constrained environments, reinforcing its value as a lightweight, scalable, and high-performance vector solution for both embedded and cross-platform use.

ThorVG is powering the Artboard engine behind Lottie Creator

B. What’s New in v1.0?

ThorVG v1.0 marks a major step forward since v0.15. This release brings comprehensive improvements across the engine — from rendering backends to visual fidelity and usability — making it more powerful, expressive, and production-ready than previous version.

• Advanced text rendering, rich visual effects, and precise blending support for enhanced graphical expression

• Expanded Lottie animation capabilities for cross-platform playback, including modular Web Player presets optimized for size, performance, and rendering mode (CPU/GPU)

• Significant performance improvements, across CPU-/GPU-bound and embedded environments

• A new era of Web integration with WebGL, WebGPU, and the lightweight WebCanvas for seamless browser rendering

• A more precise, elegant, and developer-friendly API design for real-world application needs

• Official Swift integration and supplement with a plenty of examples and a tutorial for easy and fast onboarding.

• Numerous bug fixes and improved stability for production use.

B.1 Migration Notice

As part of the v1.0 transition, several core components have been refactored and unified, resulting in changes to the library structure and usage patterns. This includes the integration of previously separate modules, a streamlined API, and updated workflows for initialization and rendering.

We recommend developers to carefully review this release note and consult the latest documentation and examples before upgrading existing projects or starting new ones with v1.0. See the F.1 API Changes for details.

Download Here

C. Major Enhancements

C.1 Richer Text

ThorVG v1.0 introduces more powerful and flexible text rendering capabilities, offering richer typographic control and enhanced visual consistency across platforms. These enhancements make ThorVG’s text engine better suited for UI components, animations, and dynamic layouts where precise and adaptable typography is essential.

The following is a list of new text features introduced in ThorVG v1.0:

Text Layout & Alignment

Support for horizontal and vertical alignment, allowing precise control over text positioning in various UI contexts.

ThorVG Text Layout & Alignment

Text Line Wrapping

Added automatic line breaking with selectable modes - character-based, word-based, smart wrapping, and ellipsis truncation for overflow handling.

ThorVG Text Line Wrapping

Text Line Breaking & Character Spacing

ThorVG v1.0 adds support for manual line breaking, allowing developers to explicitly control line breaks using newline characters such as \\n. This enables precise formatting of multi-line text blocks, especially in dynamic layouts or text-driven animations.

Additionally, customizable character spacing is now supported, allowing for fine-tuned adjustments to improve legibility or achieve specific typographic styles.

ThorVG Text Spacing

Text Outlines

Support for outlined text, enabling stylistic effects and improved contrast in diverse backgrounds.

ThorVG Text Outline

C.2 Blendings

ThorVG v1.0 introduces a more comprehensive and consistent blend mode system, significantly improving the behavior of blending modes and aligning both formulas and composition logic with industry-standard models, such as those defined in Lottie, SVG, and the W3C Compositing and Blending specification. These improvements ensure greater visual consistency and cross-platform compatibility, particularly in web and animation workflows.

HSL-Based Blending Options

The following Hue, Saturation, Color, and Luminosity blend modes are now implemented and supported, using HSL color space compositing:

• Hue: Combines hue from source with saturation/luminosity from destination

• Saturation: Source saturation + destination hue/luminosity

• Color: Source hue/saturation + destination luminosity

• Luminosity: Source luminosity + destination hue/saturation

These modes improve compatibility with Lottie Layer Effects and future SVG blending support.

ThorVG Blendings Modes

C.3 Effects

ThorVG v1.0 brings significant improvements and extensions to scene-level visual effects, making vector graphics more expressive and visually rich.

DropShadow

Apply a drop shadow effect with a Gaussian Blur filter.

ThorVG DropShadow Effect

Fill, Tint, Tritone

Methods of color replacement that alter the appearance of graphics by redefining how colors are applied, blended, or mapped based on tone.

ThorVG Color Relacement Effects

These updates not only improve standalone rendering capabilities, but also enable support for higher-level effect systems:

• Lottie Layer Effects are now supported based on this extended scene effect engine

• SVG Gaussian Filter effects can also be supported via the GaussianBlur implementation

Together, these enhancements allow ThorVG to render more visually dynamic content, with effects that are both performant and consistent across platforms.

C.4 Interactivity

New utility features have been added to enhance interactive capabilities in ThorVG. These include support for querying spatial information and performing hit detection on rendered objects.

Bounding Box

Easily obtain both AABB (Axis-Aligned Bounding Box) and OBB (Oriented Bounding Box) data for objects displayed on the canvas.

Bounding Boxes of ThorVG paint objects

Hit Detection (Intersects)

Query whether a given point or region intersects with any visible object, enabling user interaction, selection, or event handling based on object geometry.

Hit detection test with ThorVG paint objects

These features provide the foundation for building interactive applications such as editors, viewers, and custom UI systems directly on top of the ThorVG engine.

C.5 Lottie Animation

ThorVG v1.0 delivers major improvements in Lottie animation support, extending compatibility, flexibility, and interactivity across platforms. It not only broadens the range of supported Lottie features and expressions, but also introduces developer-facing tools to control animation behavior dynamically at runtime — making it one of the most powerful Lottie playback libraries available. From this section, it highlights the major updates and improvements in Lottie support.

See the feature coverage

.lot File Type

As of today, the .lot file extension is the newly recognized official IANA standard for Lottie files. ThorVG now officially supports .lot as the standard Lottie file format, in addition to the traditional .json extension.

Tweening

Introduced support for interpolation between non-linearly adjacent keyframes, enabling smoother transitions and more precise timing control. This enhancement is particularly powerful when it’s used with state-based (a.k.a. Marker-based) animation playback in Lottie.

In many cases, animations are designed to transition between states in complex, non-linear ways. Traditional Lottie, with its strictly time-sequential structure, struggles to handle such scenarios—often resulting in abrupt resets or awkward jumps when transitioning between non-consecutive keyframes.

Lottie Transition without Tweening

Lottie Transition without Tweening

With tweening, developers can now interpolate directly between two distinct keyframes, even if they are not linearly adjacent in the timeline. This allows for more natural and fluid visual effects during state transitions, significantly improving the flexibility and realism of interactive animations.

Lottie Transition with Tweening

Lottie Transition with Tweening

Interactive Lottie with Expressions (Experimental)

ThorVG now supports overwriting Expression variable values at runtime (as experimental feature), enabling dynamic execution of script logic based on user input. This makes it especially powerful for creating interactive animations with Lottie assets, allowing for customized variations beyond the original design.

Interactive Lottie with Expressions

Moreover, the ability for developers or designers to add logic through Expressions during the design phase is highly promising. By defining or constraining the range of user inputs and handling exceptions in advance, it becomes possible to guard against unexpected cases that may arise from design changes, while still offering developers flexibility within a safe and controlled environment.

Remark this, the basic mechanism here is to identify the variables (ct_xcoord, ct_ycoord, ct_val) to control in advance and modify it at the programming level.

Asset Resolver API

ThorVG now supports a customizable Asset Resolver mechanism, enabling greater flexibility when loading external resources (e.g., images) referenced within Lottie animations.

Previously, asset loading—such as images embedded via relative paths—was limited to fixed lookup behavior. With the new Asset Resolver API, developers can now register their own resolver callbacks to dynamically handle asset path resolution based on runtime context, platform, or application-specific logic.

This is especially useful in environments where resource paths are virtualized or packaged differently, such as:

• Sandboxed platforms (e.g., Android, WebAssembly)

• Resource management systems

• Multi-language or theme-based asset overrides

You can register a resolver function that maps logical asset names to actual file paths or memory streams, improving control and modularity of your rendering pipeline.

Revised Slot Overriding

A reworked, reusable slot override mechanism now allows more reliable animation control via slot handles. This also adds support for overriding previously missing properties like transform, expressions, and images.

With the revised Lottie slot overriding system, developers can generate slot handles from Lottie slots and apply or cancel them at any time as needed.

Layer Effects

ThorVG now offers expanded support for Lottie's LayerEffect feature, enabling rich visual enhancements directly on animation layers. Please see the Effects section in this page for more details.

• GaussianBlur (since v0.15)

• DropShadow

• Stroke

• Fill

• Tint

• Tritone

• Effects with Expressions Control (Custom Effects)

  
  

As some effects may be performance-intensive, ThorVG introduces a quality-performance tuning option for effect rendering — ideal for optimizing on CPU-limited platforms. This allows developers to control the rendering fidelity and optimize performance based on the target platform.

Expressions

Support for expressions has been extended with the addition of the following key functions and properties:

• wiggle, temporalWiggle: Apply time-based random motion

• pointOnPath: Calculate a position along a path

• propertyIndex, groupIndex: Reference the index of a property or group

• value, property, effect: Access property values and external effects

More Spec Compliance

• TextFollowPath - A new spec support that enables text to follow arbitrary vector paths.

  
  

  Lottie TextFollowPath

• TextAlignment Options - Providing more accurate rendering of text layers based on their horizontal and vertical alignment settings.

  
  

  Lottie Texts

• Mask Expansion - New dilate functionality for mask expansion, allowing more control over how mask shapes affect visual composition.

  
  

  Lottie Mask Expansion (Dilate)

  
  

SVG

Accessing SVG Elements by ID

ThorVG now allow accessing and modifying individual SVG elements using their unique id attributes, as defined in the original SVG file. This feature enables developers to directly target and manipulate specific vector shapes within an imported SVG scene—ideal for interactive or dynamic use cases (e.g., theming, highlighting).

SVG Gaussian Filter

Gaussian filter effects is supported via the ThorVG GaussianBlur implementation. (See C.3 Effects section)

Smart Rendering

ThorVG software engine now supports smart partial rendering, which enables more efficient rendering workflows by updating only the portions of a vector scene that have changed. By internally tracking modified regions, it minimizes unnecessary redraws and optimizes overall performance. This feature provides significant benefits in scenarios such as UI rendering, design tools, or applications where large parts of the scene remain static and only small elements update between frames. In such cases, avoiding full-scene rendering can greatly reduce computational workload and improve energy efficiency—making it particularly valuable on mobile and embedded systems.

The following figure illustrates the geometry changes and highlights the minimal redraw region (outlined in red) that needs to be updated. Only the modified area between the previous and current frames is selectively redrawn, significantly improving performance.

Dirty Region Tracking

Core Approaches

To achieve this, ThorVG v1.0 applies a combination of algorithmic techniques specifically tailored for partial rendering. The following are the core strategies that power this system:

• Line Sweep Algorithm: Shapes are sorted by x-coordinates, and a sweep-line strategy is applied to reduce unnecessary dirty region checks. This reduces complexity from O(N × M) to O(N + M + K + N log N) where N: number of shapes, M: number of dirty region, K: number of actual overlaps.

• Subdivision & Conditional Merging: Fine-grained region subdivision is balanced with smart merging to avoid fragmentation, prioritizing horizontal merging for better memory cache usage.

• Spatial Partitioning (4×4 grid, by default): The rendering surface is divided into 16 regions, allowing shapes to check only the relevant dirty regions, dramatically reducing overhead in complex UI updates.

These techniques work together to deliver smoother and faster rendering, especially in embedded or real-time systems where partial updates are frequent. We’ll revisit this in a separate blog post with more details.

In our local test, we placed a high-resolution background image (2600×1463) and thousands of particles (raindrops). Rendering Performance improved by up to 50%

Click to view ThorVG Smart Rendering Demo

Please note that in highly dynamic content—such as fast-paced games or full-screen animations where nearly all objects change every frame—partial rendering offers little to no performance benefit, and may even introduce minor overhead. In such cases, full-scene rendering is typically the better choice.

For this reason, ThorVG supports both partial and full rendering configurations, giving you the flexibility to choose the optimal approach for your use case. You can profile performance in your product and make an informed decision using the Canvas option.

Product-Ready WebGL & WebGPU

We are excited to announce that both WebGL and WebGPU backends are now officially production-ready. These GPU-based renderers now offer full feature parity with the traditional CPU backend, supporting all ThorVG Canvas capabilities with the same visual quality and consistency.

Compared to version v0.15, Both GPU rendering performance has more than 150% boost, providing significant improvements in real-time vector graphics rendering on the web.

ThorVG officially supports WebGL2 engine

D. Performance

ThorVG v1.0 introduces performance enhancements over v0.15, with measurable gains across both CPU and GPU rendering paths.

Benchmark Summary (Score)

Renderer	Metric	v0.15	v1.0	Improvement
CPU (SW)	Avg. Stress	60	61	+3%
GPU (GL)	Avg. Stress	39	63	+58%
WebGPU	Avg. Stress	X	60	-
Common	Memory Usage	140	117	-16%

Tests on Intel Core i5 CPU with Intel Arc using real-world Lottie and heavy vector primitive drawings.

Key Optimizations

• Enhanced rendering pipeline efficiency

• Reduced frame buffer allocation overhead

• Optimized Lottie composition parsing

• Improved GPU batch rendering and caching

These improvements result in smoother playback, lower CPU usage, and a more responsive animation experience across supported platforms.

D.1 CPU Rasterization

ThorVG is optimized for CPU-based rasterization, with a strong focus on vector rendering in environments where GPU resources are limited, unavailable, or intentionally avoided. In representative CPU benchmarks, ThorVG demonstrates an average of ~1.8× faster performance to a widely-used vector graphics engine across common vector rendering workloads. The advantage is particularly clear in geometry-heavy scenarios such as rectangles, strokes, rotations, and circle rendering.

ThorVG maintains superior CPU performance even in geometry-heavy scenes, ensuring smooth rendering without relying on GPU acceleration.

Test Configuration

• 5k semi-transparent primitives per test (shapes, strokes, images)

• Image filtering was performed using bilinear interpolation.

• Test Platform: Apple M1 (macOS 15)

• Render size: 2560 × 1440 (2K) for each test case

• Versions: ThorVG v1.0.0, Skia v144

Stress Test Suites

D.2 ThorVG Janitor

For a real-world demonstration of ThorVG’s rendering performance, you can explore ThorVG Janitor, an interactive game designed to showcase CPU engine performance under heavy graphical workloads. The scene features hundreds of enemies composed of particle-based graphics, layered starfield backgrounds with full-size bitmap image, real-time visual effects such as DropShadow and Blur, and up to 25k paint objects rendered simultaneously. Even under peak load at 2K (2048x1152) resolution, it maintains stable performance above 120 FPS, highlighting ThorVG’s efficiency and suitability for complex, effect-rich environments.

ThorVG Janitor

E. Platforms & Extensions

E.1 WebCanvas

In this release, we are officially expanding the ThorVG ecosystem toward the web toolkit. WebCanvas enables 2D vector rendering directly in the browser using the ThorVG engine, making it ideal for interactive web applications, animations, and vector-based UI rendering. By leveraging WebAssembly(WASM), the ThorVG C++ engine is compiled for the web and wrapped with a JavaScript interface, offering higher performance compared to traditional JavaScript-based animation engines. Furthermore, by supporting not only WebGL but also the next-generation graphics API, WebGPU, ThorVG positions itself as a forward-looking engine that embraces the future of graphics processing.

ThorVG WebGPU Integration

Key Features

• High-Performance Rendering with WebAssembly: Powered by the ThorVG C++ engine compiled to WebAssembly, delivering native-like performance and lower overhead compared to traditional JavaScript-based animation engines.

• Dual Rendering Backend: WebGL & WebGPU: Supports both WebGL and the next-generation WebGPU, optimized for modern browsers and high-performance rendering pipelines. Designed to empower developers with cutting-edge graphics capabilities.

• JavaScript Interface Wrapping: Exposes a clean and efficient JS API for easy integration into web applications.

• Ideal for Rich Interactive Applications: Suited for animations, dynamic vector UI rendering, and complex graphic scenes—supporting formats such as SVG and Lottie—directly in the browser.

Tutorial

Get started quickly with our step-by-step guide. Our tutorial explains how to install ThorVG WebCanvas and how to draw various graphic elements with simple examples.

Click to open the WebCanvas Tutorial

Playground

ThorVG Playground is an interactive space where you can explore various graphic features and see the results in real time. From basic shapes to styles and animations, each example showcases the powerful vector graphics capabilities of ThorVG.

ThorVG Playground

E.2 Lottie Player Web Presets

We’ve introduced enhanced Lottie Player Presets as part of the thorvg.web — giving developers flexibility to choose the optimal balance of features, performance, and bundle size for their projects.

Standard Presets

• sw: CPU‑based renderer with full Lottie support — well-suited for multiple small animations rather than one single full-screen rendering.

• gl: WebGL‑accelerated renderer with full Lottie support — ensures broad compatibility and stable hardware‑accelerated playback across all major browsers.

• wg: WebGPU‑accelerated renderer with full Lottie support — designed for next‑generation GPU pipelines, offering improved performance scalability and future‑proof graphics capabilities in modern browsers.

  
  

Lite Presets

• sw‑lite: Lightweight CPU renderer supporting basic Lottie (PNG only, no fonts/expressions) — great for minimal footprint use cases.

• gl‑lite: Lightweight WebGL renderer with basic Lottie (PNG only, no fonts/expressions) — great for minimal footprint use cases.

• wg‑lite: Lightweight WebGPU renderer with basic Lottie (PNG only, no fonts/expressions) — great for minimal footprint use cases.

These presets allow you to select the renderer that best suits your project’s performance and size requirements, whether for full‑feature playback or resource‑constrained environments.

Preset	Renderer	Features	Bundle Size	Use Case
sw	Software	lottie + expressions, jpg, png, webp, ttf	~700kb	Full-featured applications with CPU rendering
gl	WebGL	lottie + expressions, jpg, png, webp, ttf	~700kb	Full-featured applications with WebGL acceleration
wg	WebGPU	lottie + expressions, jpg, png, webp, ttf	~700kb	Full-featured applications with WebGPU acceleration
sw-lite	Software	lottie, png	~300kb	Lightweight applications with CPU rendering
gl-lite	WebGL	lottie, png	~300kb	Lightweight applications with WebGL acceleration
wg-lite	WebGPU	lottie, png	~300kb	Lightweight applications with WebGPU acceleration

Please note that officially, ThorVG is currently operating as the rendering backend for the dotLottie player. ThorVG Lottie Player presets is provided for cases where lightweight, pure Lottie functionality is required without relying on the full features of dotLottie. The coverage of the Lottie specification and rendering quality between the Lottie players provided by dotLottie and ThorVG are identical.

E.3 ThorVG Swift

We are pleased to introduce release to the ThorVG.swift package — a lightweight Swift wrapper around the ThorVG C++ API specifically designed for Lottie animation support on Apple platforms (iOS & macOS).

Native Swift Integration

ThorVG.swift provides a seamless Swift interface over the ThorVG rendering engine, enabling developers building iOS and macOS apps to leverage Lottie animation playback directly in Swift projects.

Lottie Animation Support

The current release focuses on robust Lottie animation rendering, offering both low‑level and high‑level APIs to suit different needs:

• Low‑Level API for frame‑by‑frame control and custom buffer rendering

• High‑Level Views API with ready‑to‑use SwiftUI and UIKit components

  
  

These APIs simplify animation integration while maintaining performance.

Swift Package Manager (SPM) Ready

The package is fully compatible with Swift Package Manager — simply add https://github.com/thorvg/thorvg.swift to your dependencies and start using ThorVG in your Swift application without additional hassle.

Enhanced View Components

High‑level components such as LottieView, LottieUIKitView, and LottieViewModel provide:

• Playback control (play, pause, stop, seek)

• Loop modes and speed configuration

• Content aspect handling

• Progress updates and error reporting

  
  

These abstractions make it easier to integrate and control animations in SwiftUI or UIKit apps.

E.4 ThorVG Examples

To improve repository maintainability and CI workflow efficiency, the example projects previously included within the main ThorVG repository have been moved to a new standalone project: thorvg.example. This change was made to:

• Prevent example code from cluttering the core library structure

• Reduce the size of the main repository

• Enhance CI pipeline performance by isolating non-essential example resources

  
  

Users who are looking for usage examples, demos, or sample applications are encouraged to refer to the new thorvg.example repository.

ThorVG Examples

E.5 ThorVG for VS Code

To enhance the developer experience, ThorVG now provides a dedicated VSCode extension — thorvg.vscode — offering lightweight tools for building, editing, and previewing ThorVG assets directly within the Visual Studio Code environment. Whether you're developing animations or testing rendering on multiple platforms, the thorvg.vscode extension makes it easier to work with ThorVG in your day-to-day workflow.

Install via the Visual Studio Code Marketplace

Key Features

• Liveview:  Instantly preview Lottie (.json, .lot) and SVG files, automatically updates as you edit

• Animation Controls: Play, pause, loop, and adjust playback speed

• Performance Stats: Monitor FPS, memory usage, and rendering performance in real time

F. API & Structural Changes

F.1 API Changes

ThorVG v1.0 introduces substantial API restructuring aimed at performance, usability, consistency, and C-compatibility. These changes reflect a deliberate shift toward a cleaner, more predictable API surface, improved memory management, and clearer semantics for vector graphics operations.

As part of this transition, several legacy APIs were removed or redesigned, leading to intentional API and ABI breaks. This document serves as a guide to help users understand the scope of these changes and smoothly migrate to the new APIs using clear and intuitive replacements.

• Memory Management Refactored: Replaced std::unique_ptr with raw pointers using reference counting for finer control and reduced overhead.

• Simplified String Parameters: All APIs now use const char* instead of std::string, improving performance and C-compatibility.

• Class Structure Updated: All public types have been converted from class to struct, promoting a data-oriented design.

• Enumeration Adjustments: Replaced enum class with enum struct to improve usability and consistency.

• Canvas Engine Simplification: The CanvasEngine enum has been removed, and initialization is now more straightforward.

• Composite to Mask Transition: CompositeMethod has been split into MaskMethod and a dedicated clip() API, clarifying masking behavior.

• API Naming Improvements: Many method names were revised for clarity and expressiveness. For example: stroke() → strokeWidth(), strokeFill(), etc.

Please refer this page for full update list.

F.2 Integration Changes

To distinguish the new ThorVG v1.0 API from the legacy version, the project name and header include path have been updated. When using ThorVG v1.0, you must refer to the throvg package name as thorvg-1, and include the header file as:

• pkgconfig name

• ThorVG native headers inclusion

F.3 TVG Picture Removal

In this generation, support for TVG Picture (TVG) has been officially removed. This decision was made to pave the way for a new ThorVG Picture format, designed with animation as a foundational concept.

By streamlining the codebase and retiring the legacy static picture format, we are focusing on delivering a more robust and extensible solution for animation-centric vector graphics workflows.

While a direct replacement may not be available in the short term, this is a deliberate step toward providing a more thoughtful and effective feature in the future — so we encourage you to stay tuned and look forward to what's coming next.

G. Closing Notes

We would like to extend our deepest thanks to all the contributors, developers, and early adopters who helped shape ThorVG v1.0. Your code, feedback, and passion have been instrumental in making this release possible.

• ThorVG Contributors

• ThorVG Web Contributors

• Godot

• LVGL

• Canva Pty Ltd

A special thank you goes to LottieFiles for their continued support and collaboration. Their insights, technical feedback, and real-world use cases have been invaluable in guiding ThorVG’s evolution — particularly in shaping its Lottie animation capabilities and web integration. ThorVG has grown stronger and more versatile thanks to their active engagement.

Together, we’re building something powerful — lightweight, open, and ready for the future of vector graphics!