# Draft Blog Post: Layered Animation Workshop 2025

## Table of Contents

[TOC]

## Intro

Day before Blender Conference 2025 (Tuesday 2025-09-16).

**Present:**
- [Christoph Lendenfeld](https://projects.blender.org/ChrisLend)
- [Demeter Dzadik](https://projects.blender.org/Mets)
- [Falk David](https://projects.blender.org/filedescriptor)
- [Marion Stalke](https://projects.blender.org/EosFoxx)
- [Nacho de Andrés](https://projects.blender.org/nda)
- [Nathan Vegdahl](https://projects.blender.org/cessen)
- [Nika Kutsniashvili](https://projects.blender.org/nickberckley)
- [Rik Schutte](https://projects.blender.org/Rikstopher)
- [Sybren Stüvel](https://projects.blender.org/dr.sybren)

**Remote:**
- [Brad Clark](https://projects.blender.org/BClark)
- [Dorothee Dittrich](https://www.linkedin.com/in/dorothee-dittrich-4945a9242/)

### Goal

How to make animators not drown in the soup of Actions, when each Action can have its own independent set of Layers.

### Definition of Success

**Have a concrete high-level overview of how an animator is going to work with the layered animation system**, including:

- Graph Editor (semi-successful. For now: just show data from active layer)
- Dope Sheet (we have a first design)
- An answer to whether we want a separate Action Layers editor; a common side-bar for animation editors; or a "layers" mode of the Dope Sheet. (for now: side-bar)
- Know whether we'll work with zooming to expose more detail, vs. collapsing, vs. separate editors / modes. (for now: collapsing)
- Wireframe sketches of the editors (some are in the BConf presentation, others are in paper on Sybren's desk)

## Related Works

- [Last Year's workshop](https://code.blender.org/2025/01/layered-animation-workshop-2024/): making some technical decisions about blending layers and key insertion behaviour.
- [Slotted Actions landed in Blender 4.4](https://developer.blender.org/docs/release_notes/4.4/animation_rigging/), previously called "Multi-datablock animation" or "Multi-ID animation".
- [February 2024 progress report](https://code.blender.org/2024/02/animation-2025-progress-planning/). Still mentions "Animation data-block"; we later pivoted to adding slots & layers to Actions directly (instead of adding a new datablock type).
- [June 2023 workshop](https://code.blender.org/2023/07/animation-workshop-june-2023/), which paints a pretty nice overview of where we want to go with layered animation.

## Splitting Up

Two groups to discuss two points of view.

### Animating from Scratch

TODO

### Making Sense of an Existing File

This group approached things from the perspective of an animator who needs to work on someone else's file (or their own a month later!).

We focused on what would be needed to work with a "nightmare" layered animation file, where animation data is scattered all over the place in a completely disorganized, non-sensical way. If we can make working with such a file feasible, then less extreme situations should be reasonable to work with.

We also came up with two broad catagories of tasks an animator might want to accomplish within an existing file: timing adjustments and animation fixes.

Based on that, we landed on the following general requirements the animation editors:

- The dopesheet and graph editor must both be capable of displaying and working with animation data from *multiple actions and layers* at once. An editor that can only see one layer's/action's data at a time is a no-go.
- We need powerful filtering functionality to filter down to just the subset of data (datablocks, layers, etc.) you want to edit.
- We want a way to save the current selection of bones or channels for display in the animation editors.
- It should be easy to isolate playback and visualization of subsets of animation data, for a "divide and conquer" approach to tracking down issues.

#### Resulting UX Design

Based on those general requirements, we landed on a design where:

- Layers are managed in a separate editor or side panel, not as e.g. a zooming part of the dopesheet. This is mainly to allow easily filtering animation data in the dope sheet by selected layer(s), which is tricky if the primary layer interface is the dopesheet itself.
- Layers are still *represented* in the graph editor and dopesheet as an additional level in the channel hierarchy. This way the data from multiple layers can be displayed, distinguished, and worked with at once.
- Keys that animate the layers themselves (e.g. layer influence) should also be represented in the graph editor and dopesheet, as channels under the layer. This is important so that these keys can be e.g. retimed together with all the other keys.
- Eventually, we want to be able to visualize the *final evaluated* curve (i.e the result from mixing all the layers) for a channel in the graph editor. This can help animators better see what their layered animation setup is really doing, and also can help track down issues by muting/soloing different layers and seeing the effect on the final curve.

## Conclusions

- Both groups came up with very similar designs.
- So far it seems pretty straight-forward to implement.
- Will build initial design, then iterate on that.
- Likely first on a branch, then as an experimental feature.

## Next Steps

Will likely take at least a year (assuming the same development team, who will also be working on non-animation things, fixing bugs in older code, etc.)

- Animation Filtering replacement
- Written about in a way that non-developers can follow
- Will make it considerably faster to add layered animation
- Unlocking multi-layered animation
- Unlocking is easy, but each tool will have to be investigated to see how it should handle multiple layers.
- Adding a user interface to select/manage those layers.
- Animation Tools framework
- Make it easy for code (both C++ and Python) to do the right thing.
- One code base to work with both bones and objects.
- Porting everything to the new framework
- This will be on a tool-by-tool basis.
- Community help would be much appreciated.
- Adding more features to get feature parity (with the layered aspect of) the NLA
- Animated layer influence weight
- Layer-level F-Curve modifiers
- Retiming curve