Spine 4.3
Sliders. Transform constraints. Rig smarter.
We are thrilled to announce a new Spine release! 4.3 brings powerful new features that give you more control over your skeletons, along with a host of improvements to streamline your workflows.
Let's take a look at the highlights!
Transform Constraints
Transform constraints have received a major overhaul in 4.3. You can now map transform properties to different property types. For example, translating a bone can cause other bones to rotate or scale. Any combination is possible! You can also clamp constrained values to a range, and choose world or local space for both the source and constrained bones.
These changes open up a huge range of possibilities for automatic skeleton movement, from flipping sprites based on direction to creating mechanical linkages and complex rigs with minimal animation effort.
This scroll converts translation to rotation and scale using the new transform constraint. Movement of a single bone rolls and unrolls the entire scroll.
A whole host of changes
Spine 4.3 is packed with tons of other improvements. Here are some of the highlights:
Smarter mesh tracing
Trace multiple meshes at once instead of repeating the same operation one by one. Not only is the process much faster, the trace results are now more accurate.
Mesh tracing also adds a uniform slider, producing meshes that bend more naturally at joints.
Paint weights across multiple meshes
Set weights across multiple mesh attachments instead of being limited to one at a time.
You can also bind, weld, smooth, auto weight, and prune multiple meshes at once.
Problems view with fixes
The new Problems view gathers warnings and project issues in one place, so you no longer need to hunt through the tree for warning icons. Selecting a problem takes you directly to the item that needs attention.
Many problems can be resolved automatically with a single click!
HTML export
Spine can now export a ready-to-open HTML page showing your animations. Choose the Spine Player for a fully featured embedded player, or Spine Web Components when you want the animation to fit naturally into a modern web page.
HTML export also supports combining skins, making it easier to preview and share skin setups without writing custom code.
Draw order folder keying
Draw order folders can now have their own keys, separate from the main draw order timeline. This lets you animate the contents of a single folder without conflicting with keys for the rest of the skeleton.
You can key different folders on different tracks, layering complex draw order changes.
New clipping options
Clipping attachments now support inverse clipping, so you can hide what is inside the clipping shape instead of what is outside it. This makes many cutout and reveal effects easier to build.
Clipping is also more efficient and uses less CPU, especially when using the new convex hull setting.
More flexible linked meshes
Linked meshes are no longer limited to the same slot as their source mesh. You can place a linked mesh in another slot while still sharing the source mesh geometry and weights.
This makes it easier to reuse the same mesh setup across skins, layered attachments, and alternate rig structures without duplicating work.
Volumetric scaling
Physics and IK constraints now have a volume preserving scaleY setting, where scaleY grows or shrinks opposite to scaleX. This creates a nice squash-and-stretch effect for stretchy limbs, cartoony rigs, or a subtle bounce.
Dopesheet-centric sync mode
Spine already had a graph-centric sync mode, where selecting a key in the graph showed that timeline in the dopesheet. Now you can go the other way.
Selecting a key in the dopesheet shows that timeline in the graph, giving you quick access to curves while looking through many keys, which the dopesheet excels at.
Improved curve editing
When key values change, Spine now does a better job adjusting Bezier handles so your curves keep their shape, greatly reducing the need for manual cleanup.
The new "last chosen" default curve option uses the last chosen curve type for newly created keys.
Key constrained values
The "Key Constrained" hotkey lets you key values after constraints are applied. This can be useful to convert motion from physics or other constraints into keys.
Math in numeric fields
Numeric fields now understand math expressions, so you can type calculations directly where you enter values. Use value or v to reference the current value, for example: 10 + v * 8
Prefixes such as +=, -=, *=, and /= modify the current value. You can also use constants like boneLength and boneRotation, plus functions like random and clamp.
Those are only a few of the improvements in 4.3. Many other additions are smaller on their own, but together they make everyday rigging, animation, importing, and exporting much smoother.
Improved skin workflows
Skins can be merged via drag and drop, with smarter filtering and many quality of life improvements, including automatically adding other necessary bones and constraints.
Package projects as ZIPs
The "Package Project" command creates a ZIP containing the project and its images. It is a quick way to share a complete project with teammates, clients, or support without manually collecting files.
Relative export paths
Exports now use relative paths, making it easier to export files to the right place from different folders and computers.
Only pinned skins filter
"Show all skin attachments" now has an "Only pinned skins" option, keeping skin workflows cleaner when many skins are present.
PSDs in the Images node
PSD files are now managed directly from the Images node, improving repeat PSD import and sync workflows. Also attachments now show the PSD they came from.
Atlas per skin packing
Texture packing can now create a separate atlas for each skin. This is useful for projects that package, load, or stream skins separately. The runtimes have also been updated to support this workflow.
Refined editor UI
Icons, sliders, disabled states, warnings, and constraint visuals have been improved throughout the editor.
Improved export
Image, video, data, and CLI exports are multithreaded and much faster. The CLI also gained many import/export options, making automated pipelines easier and more flexible.
More hotkeys
New hotkeys include selecting, holding, flipping, and navigating keys, plus zooming, flipping the viewport, draw order actions, image paths, sequences, and mesh editing.
If you want even more details, expand the changelog highlights below.
Other changelog highlights include:
- Added bone icon size and rotation controls.
- Added breadcrumbs for editor selection.
- Added reset buttons to paths, bounding boxes, clipping attachments, and draw order folders.
- Added view sidebar button icons.
- Added "Check All" to the dialog shown when mesh images are resized.
- Added brute force setting to texture packing.
- Added "Sequence" and "Region - Mesh" hotkeys.
- Added selectable image paths with a file dialog and an "Image Path" hotkey.
- Added folder duplication, including all contents.
- PSD import improves smart object reuse, source mesh matching, missing PSD warnings, linked meshes in other slots,
[rotate:degrees]tags, output path defaults, scale and merge tags, and delete versus overwrite behavior. - Smaller project file sizes.
- Improved tree performance, tree annotations, selection behavior, and scrolling/panning.
- Improved project warnings, attachment warnings, and missing file reporting.
- Improved mesh editing stability, vertex handling, and invalid mesh recovery.
- Improved auto weights and weight painting workflows.
- Improved physics smoothness, responsiveness, and deterministic behavior.
- Improved preview animation mixing and export preview responsiveness.
- Improved JSON readability, size, and numeric precision.
- Improved constraint sorting, icons, inactive states, and constraint warnings.
- Improved file dialogs, file monitoring, and Windows network path security.
- Many crash fixes, export fixes, import fixes, and undo/redo fixes.
Web Components
Spine 4.3 introduces Spine Web Components, a set of custom HTML elements that make it easy to embed Spine animations directly into any web page. No JavaScript coding required: just add a tag to your HTML!
Web Components are very efficient. A web page can have dozens of skeletons at once without performance issues.
The <spine-skeleton> element lets you display and interact with Spine skeletons with simple HTML attributes for the atlas, skeleton data, animation, and skin. It handles loading, rendering, and playback automatically.
<script
src="/spine-webcomponents.min.js"
></script>
<spine-skeleton
atlas="spineboy-pma.atlas"
skeleton="spineboy-pro.json"
animation="walk"
></spine-skeleton>Web Components are perfect for landing pages, portfolios, interactive documentation, and anywhere you want to showcase Spine animations on the web without writing code. In fact, all the interactive examples on this page are shown using Spine Web Components!
A new foundation for spine-cpp, spine-c, and downstream runtimes
Spine 4.3 includes a major refactor of our native runtime stack, letting us support more languages with even higher quality. spine-cpp is now the shared implementation for every C-family runtime we ship, while spine-c, spine-ios / SpineSwift, and spine-flutter have all been rewritten as auto-generated wrappers on top of it.
spine-cpp has been expanded to support this new stack. Headers moved from spine-cpp/spine-cpp/include/spine/ to spine-cpp/include/spine/, and the public API was reshaped around the 4.3 model: split bone pose and applied pose, Pose / Posed / PosedActive base classes, a unified constraint timeline hierarchy, the new Sequence model, convex and inverse clipping, additive blending instead of holdPrevious, sliders, and more. It also gained a lightweight RTTI system, which allows us to generate idiomatic bindings in other languages.
spine-c has been completely rewritten as an auto-generated C wrapper around spine-cpp. The old hand-maintained sp* API is gone. The new API uses opaque spine_xxx handles, exposes the full C++ type hierarchy through generated cast functions, includes nullability hints (/*@null*/) and Doxygen-style docs in the generated headers, and reaches full feature parity with C++. This is a breaking change for spine-c users. The new API and documentation live at esotericsoftware.com/spine-c.
spine-ios / SpineSwift and spine-flutter are now fully auto-generated on top of the new C runtime. Both expose the complete spine-cpp type hierarchy as real Swift and Dart classes with proper inheritance, such as Bone : PosedActive, Posed, Update, language-native nullability (Bone? in Swift and Dart) instead of opaque pointers, and inline doc comments propagated from spine-cpp. The internal rewrite is large, but migrating typical app code is mostly mechanical: imports change (Spine / SpineCppLite become SpineSwift / SpineiOS), a handful of methods were renamed to match spine-cpp (setAnimationByName to setAnimation, setToSetupPose to setupPose, parentMesh to sourceMesh, AnimationState.getCurrent to getTrack), and getter/setter pairs in Dart became idiomatic properties (getData().setDefaultMix(0.2) becomes data.defaultMix = 0.2). The updated example apps on the 4.3 branch show the full migration surface.
The other native runtimes built on this stack (spine-sfml, spine-sdl, spine-glfw, spine-godot, and spine-ue) have also been updated to the new spine-cpp and spine-c APIs. If you use any of these, read the runtime-specific entries in the Spine Runtimes changelog before upgrading.
spine-cocos2dx has been removed in 4.3. Cocos2d-x has not had a stable release since v4.0 in 2020, and it no longer builds out of the box against current Xcode and iOS SDKs without manual patches. If you are still shipping with cocos2d-x, stay on the 4.2 branch of spine-cocos2dx.
Snapshot testing against spine-libgdx
Spine 4.3 also introduces a snapshot testing harness for the core language runtimes. spine-libgdx remains our reference implementation, and we use LSP-based analysis of its public API to automatically generate matching serializers for the other runtimes. Each supported runtime has a HeadlessTest that loads a skeleton, builds a Skeleton and AnimationState, applies an animation, and serializes the entire object graph to deterministic JSON. The harness then diffs that output against the spine-libgdx output byte for byte, so we can pinpoint exactly which field or computation diverged.
In 4.3, the snapshot harness compares spine-cpp against the spine-libgdx reference. Wiring up the other core language runtimes (spine-c, spine-ts, spine-haxe, and spine-csharp) is in progress. Engine integrations such as Unity, Godot, and Unreal aren’t targeted directly; they’re validated transitively through the core runtime they’re built on.
Runtime changes
All official runtimes have been updated for Spine 4.3 and support the new editor features. The most important runtime changes are:
- Sliders are supported through new
Slider,SliderData,SliderTimeline, andSliderMixTimelineAPIs. - Transform constraints have been updated for the 4.3 constraint overhaul, including property mapping, clamping, offsets, and local/world space behavior.
- The new pose model explicitly separates setup, unconstrained, constrained, and applied state. For example, bones expose pose and applied pose data, while slots and constraints expose their own pose objects.
- The AnimationState hold system has been improved to avoid dipping during crossfades without requiring
holdPreviousorinterruptAlpha. Timelineapplymethods now use the newfromSetup,add, andoutparameters, and track entries expose additive blending directly. TrackEntry.mixInterpolationallows non-linear interpolation for AnimationState mixes, making crossfades feel smoother or more stylized than a standard linear mix.- Physics behavior is more correct and responsive, especially at low update or render rates. The runtimes also gained skeleton-level wind and gravity controls and improved handling for physics reset timelines.
- Clipping now supports convex and inverse clipping, with improved clipping performance and fixes for inverse clipping edge cases.
- Draw order folders are supported by the new
DrawOrderFolderTimeline, allowing animations to key draw order folder changes. - Per-skin atlas workflows are supported more directly:
AtlasAttachmentLoadercan allow missing regions for skeletons exported with per-skin atlases, andAttachmentLoaderAPIs now receive both the skin placeholder and resolved attachment name. - Linked mesh APIs have been updated so linked meshes can use source meshes from other slots and inherit deform and sequence timelines correctly.
- Sequence attachments have been refactored to precompute per-frame regions, UVs, and offsets, improving correctness and making sequence rendering safer across runtimes.
Please refer to the Spine Runtimes changelog for game engine and language specific changes.
As always, you will need to re-export your skeletons with Spine editor 4.3 if you want to use the Spine Runtimes 4.3. See our Spine Versioning Guide for more information.
spine-ts: Stronger web runtimes
The TypeScript runtime and its web backends received many practical improvements in 4.3:
- WebGL, Three.js, Pixi, Phaser, Player, and Web Components can handle PMA versus straight-alpha textures automatically. Straight-alpha textures are uploaded as PMA when needed, so you can use formats like WebP for smaller downloads while still getting PMA rendering benefits such as correct blend modes.
- The shared
SkeletonRendererCorereduces duplication across renderers. - Pixi, Phaser, and Three.js gained physics position and rotation inheritance settings.
spine-unity: Multithreaded and modular
Our spine-unity runtime now supports threaded animation and mesh generation, giving you a significant performance boost at the flip of a switch!
All you have to do is enable a setting in Spine Preferences. If you perform main-thread-only tasks in skeleton event callbacks, don't worry, we automatically invoke all callbacks on the main thread for you. We also kept the update cycle free of allocations, something that trips up simpler threading implementations. Since off-the-shelf options couldn't deliver that, we built our own work-stealing scheduler that balances load efficiently across cores, with configurable settings to tune the system to your needs.
It's built on standard C# threads, so you don't need any newer Unity features like ECS or the Job System. It's compatible all the way back to Unity 2017.1.
On top of that, we've split the Skeleton components into rendering and animation components, allowing SkeletonMecanim to animate a SkeletonGraphic UI element for the first time.
SkeletonRenderer and SkeletonGraphic components now cover rendering while SkeletonAnimation and SkeletonMecanim handle animation. Components upgrade automatically as you open each scene, so you can verify that everything still works scene by scene. Once you're sure everything runs correctly, a single button press upgrades your entire project. If your code touches the affected APIs, you may need to make a few adjustments. We've put together a complete upgrade guide to walk you through them. A dialog with all the relevant information appears after installing the spine-unity 4.3 runtime, so neither you nor your colleagues will miss the change.
Building on the latest Unity UI Toolkit improvements, the Spine UI Toolkit UPM package now supports PMA atlas textures, all blend modes, and back-face triangle rendering. The new Detect button on SpineVisualElement picks the right material for you automatically, one click and you're done.
To round things off, we've also added numerous quality-of-life improvements. Among them is automatic detection of PMA vs. straight alpha mismatch when importing new skeletons. A simple dialog appears to help you resolve any issues more easily. Switching between PMA and straight alpha workflow settings is now also just a click away in Spine Preferences. And skin repacking now handles blend modes too, lifting a past limitation.
Up next
We are very happy with Spine 4.3! Sliders and the new transform constraints give you powerful new ways to build complex rigs with less effort, while the many quality of life improvements make your everyday workflow faster and smoother.
Thanks to everyone in our community who reported issues, tested the beta, and gave their suggestions and feedback to help shape our new features. Your input is invaluable!
Happy animating!
–Your Spine Team
Discuss this post on the Spine forum.