GITNUXSOFTWARE ADVICE
Art DesignTop 10 Best 2D Bone Animation Software of 2026
Top 10 2D Bone Animation Software picks ranked with technical comparison of Spine, DragonBones, and Moho for animators and studios.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Spine
Skin and attachment swapping with timeline-driven slot changes in the exported skeleton data.
Built for fits when teams need controlled skeletal animation exports with code integration for many characters..
DragonBones
Editor pickBone and slot armature schema with skins and attachment-driven animation timelines.
Built for fits when teams need repeatable 2D rig exports and CI asset automation without heavy backend control..
Moho
Editor pickBone rigging with transform and deformation applied directly to layered artwork
Built for fits when teams build character rigs interactively and integrate finished animation assets downstream..
Related reading
Comparison Table
This comparison table evaluates 2D bone animation tools by integration depth, data model, and the automation and API surface available for pipelines and internal tools. It also flags admin and governance controls such as RBAC, audit logging, and provisioning workflows, plus extensibility and configuration options that affect asset throughput. The ranking covers major options including Spine, DragonBones, and Moho to show tradeoffs across schema design, rig runtime expectations, and toolchain fit.
Spine
2D skeletal rigging2D skeletal animation software that rigs characters with bones and skinning for smooth runtime-ready exports.
Skin and attachment swapping with timeline-driven slot changes in the exported skeleton data.
Spine authoring centers on a bone-and-skin data model with attachment swapping, skin variants, and constraint-driven motion that maps directly to exported animation state. The editor organizes timelines for transforms, events, and slot attachments so exported data can be consumed deterministically by runtime code. Integration depth is shaped by the separation between authored assets and the export artifacts that downstream renderers load.
A tradeoff appears in pipeline integration because teams must manage versioning of exported skeleton data alongside code that binds skins, slots, and events at runtime. Spine fits best when a studio needs consistent animation throughput and stable schemas across levels or characters, since constraints and timelines become long-lived integration contracts.
- +Skeletal data model supports skins, attachments, and constraints
- +Deterministic animation timelines map cleanly to exported runtime artifacts
- +Event hooks integrate with code-driven gameplay triggers
- +Clear separation between authored assets and runtime consumption
- –Runtime integration requires stable mapping of slots, skins, and events
- –Schema changes can create refactoring work across animation bindings
Best for: Fits when teams need controlled skeletal animation exports with code integration for many characters.
More related reading
DragonBones
open-source skeletal animation2D skeletal animation toolset for building bone-based rigs and exporting animations for multiple runtimes.
Bone and slot armature schema with skins and attachment-driven animation timelines.
This tool fits teams that need repeatable 2D animation assembly and consistent rig semantics across characters. The core data model uses armatures with hierarchical bones and slot attachments that map to skins and animation timelines, which keeps exported output deterministic for build automation. The editor workflow is strongest when rigs and timelines are authored once and then reused across multiple scenes. Automation is largely file-driven since the public interface is centered on exported assets rather than runtime management calls.
A practical tradeoff is that deeper governance and API-driven provisioning are not the focus of the project compared with tools that ship a management backend. Teams typically wrap DragonBones exports inside their own asset pipeline steps, such as validation of skeleton structure and batch texture atlas assembly. This fits situations where throughput matters for CI builds that compile animation assets and where the schema consistency is the primary control lever.
- +Armature and slot model maps cleanly to rigged character reuse
- +Skin and attachment semantics keep exports consistent across variations
- +Exported asset structure supports CI-driven automation workflows
- +Timeline authoring aligns with deterministic build outputs
- –Limited server-side automation and API surface for runtime governance
- –Automation is primarily file-based, which shifts validation responsibility outward
- –Cross-tool integration depends on downstream engine import conventions
Best for: Fits when teams need repeatable 2D rig exports and CI asset automation without heavy backend control.
Moho
2D character animation2D vector animation software with skeletal bone rigging features for character animation and deforming meshes.
Bone rigging with transform and deformation applied directly to layered artwork
Moho’s core workflow centers on defining rigs with bones and applying them to shapes or bitmap layers, then animating via timeline controls. The data model stays within a project-centric structure that ties sprites, layer visibility, and bone transforms to a single asset file. This keeps authoring throughput high for teams that hand off finished animation assets. Integration is mostly oriented toward exporting and consuming assets rather than programmatically provisioning rigs via a formal API.
A concrete tradeoff is that customization and automation tend to happen through project settings and manual rig edits rather than through programmable schema and provisioning endpoints. This can slow large-scale automation when rigs must be generated or validated from external specifications. A good usage situation is producing character animation sequences where rigs are built interactively and later integrated as timeline outputs into a downstream renderer or game pipeline.
- +Bone rigging and deformation tools are integrated into the same authoring timeline
- +Layer-based workflow maps sprites and transforms into a consistent project data model
- +Export-oriented outputs fit typical animation pipelines and handoff to downstream tools
- +Playback controls support iterative animation review without re-import cycles
- –Extensibility via API and automation hooks is limited for external rig generation
- –Rig schema validation and provisioning are not exposed as first-class automation surfaces
- –Large batch workflows rely on manual project setup and export steps
- –Fine-grained governance controls like RBAC and audit logs are not part of the core toolchain
Best for: Fits when teams build character rigs interactively and integrate finished animation assets downstream.
Adobe Animate
authoring suite2D animation authoring tool that supports bone-style character rigging workflows for creating animated assets.
Bone rigging with timeline animation control for 2D character movement.
Adobe Animate is a 2D animation authoring tool that can rig characters with bone-based workflows for frame-by-frame or timeline motion. It supports exports and formats such as SVG animation, video rendering, and timeline-driven assets that can be integrated into web, mobile, and publishing pipelines.
Integration depth depends on how the animation is consumed, since the core data model and rig structure live inside Animate’s authoring project rather than a standalone external schema. Automation and governance controls are mainly available through Adobe’s broader enterprise tooling and extensibility points, with limited public, rig-level API surface for programmatic bone data manipulation.
- +Bone rigging workflow inside the timeline for character motion control
- +Multiple export targets including SVG animation and rendered video outputs
- +Extensible via Adobe ecosystem tools for publishing and asset workflows
- +Project-based timeline structure supports consistent production revisions
- –Rig data model stays within Animate projects rather than an exposed external schema
- –Limited public API for programmatic bone transforms and rig structure updates
- –Automation is stronger for publishing steps than for rig-level batch edits
- –Governance relies on Adobe enterprise account controls rather than app-specific RBAC
Best for: Fits when teams need timeline bone animation outputs integrated into an Adobe-driven publishing pipeline.
Live2D Cubism Editor
interactive character rigs2D character animation editor that creates puppet-like rigs with deformable parts for interactive character motion.
Physics binding for Cubism parameters within the rigging and preview loop.
Live2D Cubism Editor provides bone-based 2D rigging and mesh deformation authoring for Cubism assets, including physics and motion bindings. The data model is centered on Cubism parameters, parts, and physics settings that map to runtime motion control.
Integration depth is mainly via Cubism asset export formats and editor workflows rather than a documented external API for automation. Automation and extensibility depend on project conventions since the editor surface is focused on authoring and preview instead of schema provisioning, RBAC, or audit logging.
- +Bone rigging workflow with parameter-driven motion authoring
- +Physics setup tied to rig parameters for consistent secondary motion
- +Direct mesh deformation controls per model to refine silhouettes
- –Limited documented automation and API surface for provisioning and orchestration
- –Governance controls like RBAC and audit logs are not part of the authoring tool
- –Integration depth is export-driven rather than schema-first extensibility
Best for: Fits when teams need deterministic Cubism rigging and physics setup inside the editor workflow.
Rive
realtime 2D animationRealtime 2D animation tool that uses a node-based workflow to animate vector shapes and rigs for interactive playback.
State machines that drive bone animations from runtime inputs.
Rive is built for 2D bone-style character animation with authoring that exports animation assets for embedding in apps and websites. The data model centers on Rive projects with state machines, artboards, and timeline controls that map animation behavior to runtime inputs.
Integration depth is driven by a documented runtime SDK and asset pipeline, which supports extensibility through scripting hooks and event outputs. Automation and API surface are most actionable around asset embedding and runtime parameter control rather than provisioning or admin workflows.
- +State machine driven animation reduces custom branching in runtime code
- +Rive runtime SDK supports parameter updates for interactive character motion
- +Event outputs enable coordination between animation and app logic
- +Bone rigging workflow supports reuse across multiple character variants
- –Administration and governance controls are limited for multi-team platform operations
- –Automation options focus on runtime interaction, not project provisioning
- –API coverage centers on playback control rather than full asset lifecycle management
- –Complex rigs can increase iteration time when coordinating multiple animations
Best for: Fits when teams need interactive 2D bone animation driven by runtime events and parameters.
Adobe After Effects
motion graphics rigging2D motion graphics tool that enables bone-driven character animation using built-in tools and common rig workflows.
Extend After Effects with the built-in scripting API to automate composition and rendering workflows.
Adobe After Effects supports 2D bone animation through character rig workflows that rely on external tools and exports such as Dragon Bones or custom pipelines. It integrates tightly with Adobe Creative Cloud, so compositions, assets, and rendering can connect to production tooling that expects Adobe formats.
Its automation and extensibility center on the scripting layer, which enables repeatable project setup, batch rendering, and custom behaviors over a composition-centric data model. Governance depends on the surrounding Adobe ecosystem, since After Effects itself provides project structures but not a dedicated RBAC or audit-log system for rig data.
- +Scripting layer automates comp setup and render queue runs
- +Compositions provide a clear hierarchy for rig-driven animation timelines
- +Tight Creative Cloud integration improves asset and version handoffs
- +Extensibility supports custom tool logic around existing animation workflows
- –Bone data model is not first-class inside After Effects
- –Rig interoperability often depends on external export and import steps
- –No built-in RBAC or audit log for rig assets and automation actions
- –Automation targets compositions more than structured bone schemas
Best for: Fits when production teams need scripted animation assembly in an Adobe-centric pipeline.
Blender 2D Animation (Grease Pencil + Rigging)
open-source riggingOpen-source 2D-capable animation pipeline using armature rigs and deformation tools for bone-based character motion.
Grease Pencil bone deform using armature constraints on stroke geometry.
Blender’s Grease Pencil and 2D rigging workflow provides a single scene graph for drawing, rigging, and animating in one data model. Bone-based deformation works directly on Grease Pencil strokes, enabling character-like motion without exporting to a separate rigging system.
Integration depth is high because animation data, modifiers, and constraints live inside Blender’s unified project structure. Automation and extensibility rely on Blender’s Python API, which can script scene setup, rig creation, and batch rendering across projects.
- +Single scene data model for drawings, rigs, and animation
- +Bone-driven deformation supports character motion on stroke data
- +Python API enables scripted rigging, constraints, and batch renders
- +Modifiers and constraints integrate with the same timeline system
- –Rigging on 2D strokes can require manual setup and iterations
- –Automation demands Python skill and careful operator ordering
- –No RBAC or audit log controls for team governance inside Blender
- –Large rigs can slow viewport playback and render throughput
Best for: Fits when teams need bone-driven Grease Pencil animation with Python automation.
Aseprite
pixel animation editorSprite animation editor that supports rig-adjacent workflows through scripting and frame-based assembly for 2D character sequences.
Timeline keyframes with layer-based animation workflow for frame-accurate exports.
Aseprite runs as a desktop 2D pixel art editor with keyframe animation suited for bone-based workflows via manual rigging or external rig pipelines. The data model centers on spritesheets, layers, cels, and timeline keyframes so animation can be authored, exported, and re-imported across tools.
Integration depth is limited because it does not provide a formal plugin ecosystem, RBAC, or server-side automation surface for governance. Automation is mainly driven by local scripting support and command-line usage, while API coverage for provisioning and audit log style controls is not positioned as an admin-managed system.
- +Keyframe timeline editing tied to layers and cels
- +Layered sprite authoring with consistent export for animation pipelines
- +Local scripting enables repeatable export and batch processing
- +Deterministic frame stepping supports controlled animation iteration
- –No documented cloud API for automation, provisioning, or RBAC governance
- –Bone rigging support depends on external workflows
- –Limited extensibility compared with editor ecosystems that expose plugin APIs
- –No audit log or admin controls for multi-user asset management
Best for: Fits when artists need local 2D animation authoring with export consistency, not centralized governance.
Animate CC (Open-source alternative: Synfig Studio)
open-source 2D animation2D animation studio that provides vector layers and bones-like deformation workflows for character motion.
Bones tool with hierarchical deformation directly drives character motion on the timeline.
Animate CC focuses on 2D character animation built on a timeline-centric workflow with bone-like rigs via the Bones tool. Its data model centers on symbols, layers, and library assets, which affects how rig changes propagate across compositions.
Extensibility comes through documented scripting and a plugin ecosystem, which supports automation for asset handling, exports, and repeatable publishing. Integration depth depends on how far teams can align their pipeline around Animate’s document structure, export formats, and scripting hooks.
- +Bones tool supports hierarchical transforms for 2D character rigs
- +Scripting enables automated asset import, timeline edits, and batch exports
- +Symbol and library structure supports controlled reuse across scenes
- +Extensibility via add-ons supports pipeline-specific UI and export steps
- –Rig data and symbol structure can complicate programmatic refactoring
- –Automation surface favors export and asset operations over deep rig inspection
- –Maintaining rig consistency across large symbol graphs is labor-intensive
- –API coverage varies by workflow stage and may require workarounds
Best for: Fits when teams need timeline and rig workflow automation via scripting, inside a managed asset pipeline.
Conclusion
After evaluating 10 art design, Spine stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
How to Choose the Right 2D Bone Animation Software
This guide covers 2D bone animation tools built for authoring rigs, skins, and timelines, then exporting runtime-ready animation data. It compares Spine, DragonBones, Moho, Adobe Animate, Live2D Cubism Editor, Rive, and the production-support tools Adobe After Effects, Blender Grease Pencil, Aseprite, and Animate CC.
The focus stays on integration depth, data model shape, automation and API surface, and admin and governance controls. The selection framework also highlights where deterministic export artifacts reduce downstream refactoring work.
Integration, data model fidelity, and automation surfaces that match pipeline control
A tool’s data model decides how stable rig concepts stay across authoring, export, import, and refactoring. Spine’s skin and attachment semantics with timeline-driven slot changes create predictable runtime mappings, while DragonBones’ armature and slot schema shapes how CI pipelines validate exported assets.
Automation and governance determine whether rig assets can be provisioned, audited, and controlled across teams. For deeper control, tools need documented API or scripting that supports repeatable builds and admin workflows, not just export-driven batch steps.
Schema-stable rigs with skins, attachments, and timeline slot semantics
Spine supports deterministic animation timelines that map cleanly to exported runtime artifacts, and it specifically enables skin and attachment swapping through timeline-driven slot changes. DragonBones also organizes the rig around armatures, bones, slots, skins, and animation timelines, which keeps export semantics consistent across character variations.
Deterministic exported artifacts for CI-driven automation
DragonBones exports an established asset structure that fits CI-driven automation workflows where validation happens on exported files. Spine similarly produces predictable exported artifacts that reduce runtime ambiguity when slots, skins, and events must stay aligned.
Event hooks and runtime coordination surfaces
Spine includes event hooks that integrate with code-driven gameplay triggers, which supports tightly synchronized animation and logic. Rive offers event outputs and state machine inputs, which coordinates interactive animation behavior using runtime parameters.
Documented runtime SDK and parameter-driven playback control
Rive is built around a documented runtime SDK where parameter updates drive interactive character motion. Live2D Cubism Editor ties physics setup and motion authoring to Cubism parameters, which keeps secondary motion consistent with the parameter model.
Automation and scripting depth for rig creation, batch exports, and pipeline assembly
Adobe After Effects provides a scripting layer for repeatable project setup and batch rendering, which is useful when bone data enters as external assets. Blender Grease Pencil depends on Blender’s Python API for scene setup, rig creation, and batch rendering across projects when Grease Pencil bone deform is the core authoring model.
Admin and governance controls for multi-team rig asset management
Few authoring-focused tools expose RBAC and audit-log style controls, and Moho and Live2D Cubism Editor explicitly lack core governance features like RBAC and audit logs. Spine and DragonBones shift governance to predictable exports and downstream validation, while Rive and Animate CC focus automation more on asset workflows than provisioning and admin governance.
A rig export and control checklist for selecting the right 2D bone animation tool
Choosing the right tool starts with the integration contract between authored rigs and downstream runtime consumption. Spine and DragonBones help when the pipeline needs deterministic mappings for bones, slots, skins, and events, while Rive focuses on runtime parameter control through state machines.
The second step checks whether automation and governance can be enforced by tooling rather than by manual review. Blender and Adobe After Effects add scripting for batch operations, while Moho, Live2D Cubism Editor, and Adobe Animate keep governance and rig-level API surfaces limited.
Map rig concepts to the tool’s data model and export contract
If the pipeline depends on skins and attachment swaps driven by animation timelines, Spine’s skin and attachment swapping through timeline-driven slot changes is a strong fit. If the pipeline standardizes around armatures, slots, and skin semantics for repeatable exports, DragonBones offers that bone and slot armature schema.
Validate deterministic runtime behavior requirements like slot and event alignment
Spine requires stable mapping of slots, skins, and events for runtime integration, so the export-to-runtime binding should be treated as a controlled interface. DragonBones also leans on predictable scene graph structure, so downstream engine import conventions become part of the integration contract.
Decide whether automation needs asset-file builds or rig-level orchestration
If automation is primarily file-based export and CI validation, DragonBones aligns well because automation fits exported asset structure workflows. If the pipeline needs interactive behavior driven by runtime parameters, Rive’s state machines and runtime parameter updates can reduce custom runtime branching.
Check whether the tool supports an automation and API surface for the pipeline stage that needs control
Spine supports a scripting-oriented workflow for code-driven pipelines and repeatable builds when coupled with asset tooling. Rive supports extensibility through scripting hooks and event outputs for runtime interaction, while Adobe After Effects scripting targets composition setup and render queue runs around externally exported bone assets.
Confirm governance requirements before committing to an authoring-only tool
If RBAC and audit-log style controls are required for rig asset administration, tools like Moho and Live2D Cubism Editor are weaker because governance controls like RBAC and audit logs are not part of the core toolchain. If governance can be enforced via deterministic exports and downstream validation, Spine and DragonBones are built around predictable exported artifacts rather than app-level admin layers.
Which teams get the most control from 2D bone rig animation tools
Different tools in this set optimize for different integration contracts. Spine and DragonBones focus on structured skeleton exports, Moho and Adobe Animate focus on authoring workflows, and Rive shifts the center of gravity toward runtime state machines and parameter-driven playback.
The best fit depends on whether automation needs deterministic export artifacts, runtime-driven state behavior, or scripting for batch assembly and rendering.
Teams building many characters that must integrate into code with stable mappings
Spine fits teams needing controlled skeletal animation exports with code integration for many characters, and it adds event hooks for gameplay triggers. The skin and attachment swapping through timeline-driven slot changes helps keep character variations consistent once exported.
Studios running CI asset pipelines that validate exported rig files
DragonBones fits when the pipeline wants repeatable 2D rig exports and file-based CI automation rather than backend governance features. Its armature, slot, and skin schema maps cleanly to rigged character reuse and deterministic build outputs.
Teams authoring rigs interactively and then integrating finished animation assets downstream
Moho fits teams building character rigs interactively with bones and deformation applied directly to layered artwork. Adobe Animate fits when timeline bone animation outputs need to sit inside an Adobe-driven publishing pipeline.
Interactive animation systems that change animation from runtime inputs
Rive fits teams that drive bone animations from runtime events and parameters using state machines. Live2D Cubism Editor fits teams that need physics binding tied to Cubism parameters inside the editor preview loop.
Production teams that need scripting for batch assembly or scene-level automation around rig exports
Adobe After Effects fits production pipelines that use scripting for composition setup and batch rendering when bone assets arrive through external exports. Blender Grease Pencil fits teams that want a single scene data model using Grease Pencil bone deform with Python-driven rig creation and batch rendering.
Pitfalls that break integration, automation, and governance for 2D bone animation workflows
Several tools in this set make integration and governance tradeoffs that show up later during runtime binding, automation, or multi-team review. The common failures usually stem from mismatched data models or automation expectations.
The fixes are specific to each tool’s strengths, especially how rigs are represented for export and how events or parameters connect to runtime logic.
Assuming rig data model compatibility across tools without mapping slots, skins, and events
Spine integration depends on stable mapping of slots, skins, and events, so export bindings must be treated as a schema interface. DragonBones also expects downstream engine import conventions to match its exported asset structure, so mismatched import mapping creates refactoring work.
Planning for RBAC and audit logs inside the authoring tool when governance controls are not part of the core toolchain
Moho lacks fine-grained governance controls like RBAC and audit logs, and Live2D Cubism Editor also does not include these controls. Adobe Animate and Rive focus on authoring and runtime interaction automation, so governance is handled outside the app rather than through app-level admin features.
Overestimating rig-level automation when the tool’s automation surface focuses on export or runtime interaction
DragonBones shifts automation toward file-based CI workflows instead of exposing a large server-side API surface. Rive’s automation options are most actionable around asset embedding and runtime parameter control, so rig provisioning and lifecycle automation require pipeline work outside the tool.
Using a timeline-centric compositor tool as the source of truth for bone schema
Adobe After Effects supports scripting for composition and rendering, but its bone data model is not first-class, so rig interoperability depends on external export and import steps. Aseprite also centers on spritesheets and frame keyframes, so bone rigging support depends on external rig pipelines rather than a unified bone schema.
How We Selected and Ranked These Tools
We evaluated Spine, DragonBones, Moho, Adobe Animate, Live2D Cubism Editor, Rive, Adobe After Effects, Blender Grease Pencil, Aseprite, and Animate CC using scores for features, ease of use, and value. Features carried the most weight in the overall score at 40 percent, while ease of use and value each accounted for the remaining share. This ranking reflects criteria-based scoring tied to each tool’s stated capabilities for rig data model, exported artifacts, automation and scripting surfaces, and governance support.
Spine separated itself from the lower-ranked tools through a concrete skeletal data model that supports skins, attachments, and constraints with deterministic animation timelines and event hooks. That combination lifted the features score by aligning the authored rig concepts with runtime-ready exports and code-driven gameplay triggers.
Frequently Asked Questions About 2D Bone Animation Software
Which tool exports the most predictable 2D skeletal data model for engine pipelines?
What’s the practical difference between Spine and DragonBones when animators need to swap skins or attachments mid-timeline?
Which 2D bone tool offers the strongest editor-to-runtime extensibility for programmatic automation?
Do any of these tools provide an admin-style governance layer with RBAC and audit logs for rig data?
Which software is best when a pipeline needs to integrate animations through explicit schema or data structures?
How do teams typically handle automation for rig generation and batch publishing across many characters?
Which tool is the best fit for interactive, runtime-driven character motion rather than offline timeline playback?
What’s the most common integration challenge when switching from DragonBones to Spine or vice versa?
Which option supports bone-driven deformation on layered art without requiring separate rig exports?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Art Design alternatives
See side-by-side comparisons of art design tools and pick the right one for your stack.
Compare art design tools→FOR SOFTWARE VENDORS
Not on this list? Let’s fix that.
Our best-of pages are how many teams discover and compare tools in this space. If you think your product belongs in this lineup, we’d like to hear from you—we’ll walk you through fit and what an editorial entry looks like.
Apply for a ListingWHAT THIS INCLUDES
Where buyers compare
Readers come to these pages to shortlist software—your product shows up in that moment, not in a random sidebar.
Editorial write-up
We describe your product in our own words and check the facts before anything goes live.
On-page brand presence
You appear in the roundup the same way as other tools we cover: name, positioning, and a clear next step for readers who want to learn more.
Kept up to date
We refresh lists on a regular rhythm so the category page stays useful as products and pricing change.