diff --git a/CMakeLists.txt b/CMakeLists.txt
index afec6e006..a7d4154b5 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@ cmake_minimum_required(VERSION 3.24.0)
 cmake_policy(SET CMP0005 NEW)
 cmake_policy(SET CMP0048 NEW) # manages project version
 
-project(QtMeshEditor VERSION 2.18.1 LANGUAGES C CXX)
+project(QtMeshEditor VERSION 2.19.0 LANGUAGES C CXX)
 message(STATUS "Building QtMeshEditor version ${PROJECT_VERSION}")
 
 set(QTMESHEDITOR_VERSION_STRING "\"${PROJECT_VERSION}\"")
diff --git a/docs/index.html b/docs/index.html
index ec5b6e576..06c15b7d8 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -4,7 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>QtMeshEditor - Free 3D Asset Tool for Indie Game Developers</title>
-    <meta name="description" content="Free 3D asset tool for indie game developers. Merge Mixamo animations, convert between 40+ formats, edit materials with AI. GUI, CLI, and REST API.">
+    <meta name="description" content="Free 3D asset tool for indie game developers. Merge Mixamo and Unreal Engine animations, convert between 40+ formats, edit materials with AI. GUI, CLI, and REST API.">
     <style>
         @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&family=Source+Code+Pro:wght@400;600&display=swap');
 
@@ -530,8 +530,8 @@ <h1 class="logo">QtMeshEditor</h1>
 
         <!-- Hero: Animation Merging Demo -->
         <section class="section">
-            <h2 class="section-title">Merge Mixamo Animations in Seconds</h2>
-            <p class="section-subtitle">Download individual animations from <strong style="color: var(--neon-cyan);">Mixamo</strong>, drop them into QtMeshEditor, and merge them into a single mesh &mdash; export as glTF, Collada, OBJ, or Ogre Mesh.</p>
+            <h2 class="section-title">Merge Animations from Mixamo &amp; Unreal Engine</h2>
+            <p class="section-subtitle">Download individual animations from <strong style="color: var(--neon-cyan);">Mixamo</strong> or export retargeted animations from <strong style="color: var(--neon-cyan);">Unreal Engine</strong>, drop them into QtMeshEditor, and merge them into a single mesh &mdash; export as glTF, Collada, OBJ, or Ogre Mesh.</p>
             <div class="hero-demo">
                 <img src="https://github.com/user-attachments/assets/16e81f29-f64c-402d-aac4-dbb1bc2f3aef" alt="Merge animations demo - combining multiple FBX files into one mesh">
                 <p class="hero-demo-caption">Load animation files &rarr; Select all &rarr; Click Merge &rarr; Export to your engine</p>
@@ -545,7 +545,7 @@ <h2 class="section-title">Why QtMeshEditor?</h2>
                 <div class="feature-card">
                     <div class="feature-icon">🔀</div>
                     <h3 class="feature-title">Animation Merging</h3>
-                    <p class="feature-desc">Combine skeletal animations from multiple files into one mesh. Works with any source where each animation is a separate file. GUI, CLI, and API support.</p>
+                    <p class="feature-desc">Combine skeletal animations from multiple files into one mesh. Works with Mixamo, Unreal Engine retargets, and any source where each animation is a separate FBX file. GUI, CLI, and API support.</p>
                 </div>
 
                 <div class="feature-card">
@@ -594,11 +594,17 @@ <h2 class="section-title">Game Dev Workflows</h2>
                 <div class="feature-card">
                     <h3 class="feature-title">Animation Pipeline</h3>
                     <p class="feature-desc">
-                        1. Download animations as FBX (e.g. from Mixamo)<br>
+                        <strong style="color: var(--neon-cyan);">Mixamo workflow:</strong><br>
+                        1. Download animations as FBX from Mixamo<br>
                         2. Drag all files into QtMeshEditor<br>
                         3. Select all entities and click Merge<br>
-                        4. Export as glTF, Collada, or OBJ<br>
-                        5. Import into your game engine
+                        4. Export as glTF, Collada, or OBJ<br><br>
+                        <strong style="color: var(--neon-cyan);">Unreal Engine workflow:</strong><br>
+                        1. Export your UE skeletal mesh as FBX<br>
+                        2. Export retargeted animations as FBX<br>
+                        3. Load the mesh, then import each animation<br>
+                        &nbsp;&nbsp;&nbsp;(auto-detected as animation-only &rarr; instant merge)<br>
+                        4. Export to glTF or any supported format
                     </p>
                 </div>
 
@@ -701,6 +707,7 @@ <h2 class="section-title">Animation Merging</h2>
                 <div class="install-step">
                     <h3>GUI &mdash; Drag, Select, Merge</h3>
                     <p>Load all your animation files, select all entities in the scene, then click the <strong style="color: var(--neon-cyan);">Merge Animations</strong> button in the toolbar. All animations are combined into the first entity.</p>
+                    <p style="margin-top: 0.8em;">For <strong style="color: var(--neon-cyan);">Unreal Engine retarget FBX</strong> files (mesh-less, animation-only exports): load your UE skeletal mesh first, then import the retarget FBX. QtMeshEditor auto-detects it as animation-only and offers an instant merge dialog &mdash; no extra steps needed. Z-up / Y-up coordinate conversion is handled automatically.</p>
                 </div>
 
                 <div class="install-step">
diff --git a/src/AnimationMerger.cpp b/src/AnimationMerger.cpp
index 49d22a0c0..27052fdb8 100644
--- a/src/AnimationMerger.cpp
+++ b/src/AnimationMerger.cpp
@@ -3,15 +3,32 @@
 #include <OgreSkeletonInstance.h>
 #include <OgreAnimation.h>
 #include <QSet>
+#include <QMap>
 #include <QRegularExpression>
 #include <unordered_map>
 
-// Remove common Mixamo noise from animation names before slugifying.
+// Registry: skeleton name → up-axis (1=Y-up, 2=Z-up).
+// Populated by AnimationMerger::registerSkeletonUpAxis() at import time.
+static QMap<QString, int> s_skeletonUpAxis;
+
+void AnimationMerger::registerSkeletonUpAxis(const std::string& name, int upAxis) {
+    s_skeletonUpAxis[QString::fromStdString(name)] = upAxis;
+}
+
+static int lookupUpAxis(const std::string& name) {
+    return s_skeletonUpAxis.value(QString::fromStdString(name), 1); // default Y-up
+}
+
+// Remove common noise tokens from animation names before slugifying.
 // e.g. "Armature|mixamo.com|Layer0" → "Armature|Layer0"
-static QString cleanMixamoNoise(const QString& name)
+// e.g. "Armature|unreal_take|Layer0" → "Armature|Layer0"
+// e.g. "Unreal Take" (UE FBX take name, space variant) → ""
+static QString cleanAnimNoise(const QString& name)
 {
     QString s = name;
     s.replace(QRegularExpression("\\|?mixamo\\.com\\|?"), "|");
+    // Match both "unreal_take" (underscore) and "Unreal Take" (space) — UE FBX exports
+    s.replace(QRegularExpression("\\|?unreal[_ ]take\\|?", QRegularExpression::CaseInsensitiveOption), "|");
     s.replace(QRegularExpression("\\|\\|+"), "|");
     if (s.startsWith('|')) s.remove(0, 1);
     if (s.endsWith('|')) s.chop(1);
@@ -36,7 +53,7 @@ static QString slugify(const QString& name)
 static QString buildAnimName(const QString& prefix, const QString& animName)
 {
     QString slugPrefix = slugify(prefix);
-    QString cleanAnim = cleanMixamoNoise(animName);
+    QString cleanAnim = cleanAnimNoise(animName);
     QString slugAnim = slugify(cleanAnim);
 
     // Both empty — shouldn't happen, but guard against it
@@ -53,21 +70,24 @@ static QString buildAnimName(const QString& prefix, const QString& animName)
 }
 
 // Deduplicate a name against an existing set, appending _2, _3, etc. if needed.
-// Strips any existing trailing _N suffix first so repeated merges produce
-// test_jump, test_jump_2, test_jump_3 (not test_jump_2_2, test_jump_2_2_2).
+// Intentional numeric suffixes (e.g. "mm_attack_03") are preserved when the
+// name is unique. _N stripping only kicks in when the name already collides,
+// so repeated merges produce jump, jump_2, jump_3 (not jump_2_2, jump_2_2_2).
 static QString deduplicateName(const QString& desired, QSet<QString>& existingNames)
 {
-    // Strip existing _N suffix to find the base name
+    // If the desired name is free, use it as-is (preserve intentional _N suffixes).
+    if (!existingNames.contains(desired)) {
+        existingNames.insert(desired);
+        return desired;
+    }
+
+    // Collision — strip any trailing _N to find the canonical base, then re-suffix.
     QString baseName = desired;
     QRegularExpression trailingSuffix("_(\\d+)$");
     auto match = trailingSuffix.match(baseName);
     if (match.hasMatch())
         baseName = baseName.left(match.capturedStart());
 
-    if (!existingNames.contains(baseName)) {
-        existingNames.insert(baseName);
-        return baseName;
-    }
     int suffix = 2;
     QString candidate;
     do {
@@ -81,8 +101,27 @@ static QString deduplicateName(const QString& desired, QSet<QString>& existingNa
 // This bypasses Ogre's _mergeSkeletonAnimations hierarchy check, which rejects skeletons
 // that are structurally compatible (same bone names) but differ in their root chain
 // (e.g. a mesh skeleton wrapping 'root' under a mesh-name bone that the animation lacks).
-static void mergeAnimationsByName(Ogre::Skeleton* baseSkel, const Ogre::Skeleton* srcSkel)
+//
+// srcUpAxis / baseUpAxis: coordinate-system up-axis (1=Y-up, 2=Z-up).
+// When the source was exported from a Z-up tool (e.g. Unreal Engine) and the base
+// skeleton is Y-up (e.g. Mixamo), needsZupToYup converts the keyframe data.
+//
+// Additionally, AnimationProcessor stores translations in bone-local space (pre-multiplied
+// by the inverse binding-pose orientation).  If the source and target skeletons have
+// different binding-pose orientations for the same bone — e.g. an animation-only FBX has
+// identity root while a mesh FBX has a baked R_x(+90°) root — the stored delta must be
+// re-expressed in the target bone's local space.
+// We apply: corrected = (q_src⁻¹ * q_dst) * stored
+static void mergeAnimationsByName(Ogre::Skeleton* baseSkel, const Ogre::Skeleton* srcSkel,
+                                   int srcUpAxis = 1, int baseUpAxis = 1)
 {
+    const bool needsZupToYup = (srcUpAxis == 2 && baseUpAxis == 1);
+
+    // Z-up (Assimp/FBX after ConvertToLeftHanded) → Y-up (Ogre) for translations:
+    //   R_x(-90°): (x,y,z) → (x, z, -y)
+    // Rotations are stored in bone-local space and pass through unchanged —
+    // the baked dest bone orientation provides the correct world-space result.
+
     // Build name→handle map for the base skeleton
     std::unordered_map<std::string, unsigned short> baseHandleByName;
     for (unsigned short i = 0; i < baseSkel->getNumBones(); ++i)
@@ -110,12 +149,44 @@ static void mergeAnimationsByName(Ogre::Skeleton* baseSkel, const Ogre::Skeleton
             dstTrack->setAssociatedNode(baseSkel->getBone(baseHandle));
             dstTrack->setUseShortestRotationPath(srcTrack->getUseShortestRotationPath());
 
+            // Per-bone binding-pose orientation correction.
+            // AnimationProcessor stores translate/rotate keyframes in the source bone's
+            // local space (divided by the source bone's binding-pose orientation).
+            // If source and target have different binding poses for this bone, re-express
+            // the stored values in the target bone's local space:
+            //   corrected = (q_dst⁻¹ * q_src) * stored
+            const Ogre::Quaternion q_src = srcSkel->getBone(srcHandle)->getOrientation();
+            const Ogre::Quaternion q_dst = baseSkel->getBone(baseHandle)->getOrientation();
+            const Ogre::Quaternion boneCorrection = q_src.Inverse() * q_dst;
+            const bool needsBoneCorrection = !boneCorrection.equals(Ogre::Quaternion::IDENTITY, Ogre::Radian(1e-4f));
+
             for (unsigned short k = 0; k < srcTrack->getNumKeyFrames(); ++k)
             {
                 const auto* kf = srcTrack->getNodeKeyFrame(k);
                 auto* dstKf = dstTrack->createNodeKeyFrame(kf->getTime());
-                dstKf->setTranslate(kf->getTranslate());
-                dstKf->setRotation(kf->getRotation());
+
+                Ogre::Vector3 t = kf->getTranslate();
+                Ogre::Quaternion r = kf->getRotation();
+
+                // Step 1: correct translation for binding-pose orientation mismatch.
+                // Translations are stored in bone-local space (AnimationProcessor divides by
+                // the source bone's binding-pose orientation). If the target bone has a
+                // different binding-pose orientation, re-express the vector in that space.
+                // Rotations do NOT need this correction — the target binding pose already
+                // provides the equivalent compensation via the scene-node/skeleton setup.
+                if (needsBoneCorrection) {
+                    t = boneCorrection * t;
+                }
+                // Step 2: convert coordinate system (Z-up source → Y-up base).
+                // R_x(-90°) maps (x,y,z) → (x, z, -y): Z-up axis becomes Y-up.
+                // Rotations pass through unchanged — bone-local storage makes them
+                // self-consistent once the dest binding pose is baked to Y-up.
+                if (needsZupToYup) {
+                    t = Ogre::Vector3(t.x, t.z, -t.y);
+                }
+
+                dstKf->setTranslate(t);
+                dstKf->setRotation(r);
                 dstKf->setScale(kf->getScale());
             }
         }
@@ -268,7 +339,9 @@ Ogre::Entity* AnimationMerger::mergeAnimations(
         for (const auto& [tempName, finalName] : srcTempToFinal)
             renameAnimation(srcSkel.get(), tempName, finalName);
 
-        mergeAnimationsByName(baseSkel.get(), srcSkel.get());
+        mergeAnimationsByName(baseSkel.get(), srcSkel.get(),
+                              lookupUpAxis(srcSkel->getName()),
+                              lookupUpAxis(baseSkel->getName()));
         mergedCount += numAnims;
     }
 
@@ -314,7 +387,9 @@ Ogre::Entity* AnimationMerger::mergeAnimations(
         for (const auto& [tempName, finalName] : srcTempToFinal)
             renameAnimation(srcSkel.get(), tempName, finalName);
 
-        mergeAnimationsByName(baseSkel.get(), srcSkel.get());
+        mergeAnimationsByName(baseSkel.get(), srcSkel.get(),
+                              lookupUpAxis(srcSkel->getName()),
+                              lookupUpAxis(baseSkel->getName()));
         mergedCount += numAnims;
     }
 
@@ -349,12 +424,16 @@ Ogre::Entity* AnimationMerger::mergeAnimations(
                 // This was a base animation — prefix it (unless already prefixed)
                 QString origSlug = slugify(origQName);
                 if (origSlug.startsWith(baseSlug + "_") || origSlug == baseSlug)
-                    desired = slugify(cleanMixamoNoise(origQName)); // already prefixed
+                    desired = slugify(cleanAnimNoise(origQName)); // already prefixed
                 else
                     desired = buildAnimName(baseRawName, origQName); // needs prefix
             } else {
-                // This was merged from a source — already has prefix, just clean
-                desired = slugify(cleanMixamoNoise(origQName));
+                // This was merged from a source — already renamed in Step 1b, just clean.
+                desired = slugify(cleanAnimNoise(origQName));
+                // If cleaning removes the entire name (e.g. "unreal_take" → ""),
+                // keep the already-processed name from Step 1b as-is.
+                if (desired.isEmpty())
+                    desired = slugify(origQName);
             }
 
             QString finalName = deduplicateName(desired, finalNames);
diff --git a/src/AnimationMerger.h b/src/AnimationMerger.h
index 06a72f1ac..7b6eb02f2 100644
--- a/src/AnimationMerger.h
+++ b/src/AnimationMerger.h
@@ -12,6 +12,12 @@ class AnimationMerger {
     /// Check if two skeletons have compatible bone hierarchies (matched by name).
     static bool areSkeletonsCompatible(const Ogre::SkeletonPtr& a, const Ogre::SkeletonPtr& b);
 
+    /// Register the coordinate-system up-axis for a named skeleton.
+    /// 1 = Y-up (Mixamo/default), 2 = Z-up (Unreal Engine).
+    /// Must be called by the importer immediately after loading so that
+    /// mergeAnimations() can apply the correct coordinate transform.
+    static void registerSkeletonUpAxis(const std::string& skeletonName, int upAxis);
+
     /// Rename an animation on a skeleton by cloning with a new name and removing the old.
     /// Ogre::Animation has no setName(), so this clone-and-remove pattern is the only way.
     static void renameAnimation(Ogre::Skeleton* skel,
diff --git a/src/AnimationMerger_test.cpp b/src/AnimationMerger_test.cpp
index a281a3ee0..fad26bfac 100644
--- a/src/AnimationMerger_test.cpp
+++ b/src/AnimationMerger_test.cpp
@@ -316,6 +316,75 @@ TEST_F(AnimationMergerTest, MergeAnimationsDeduplication)
     Ogre::SkeletonManager::getSingleton().remove(skelC);
 }
 
+TEST_F(AnimationMergerTest, MergeAnimationsUnrealTakeCleanup)
+{
+    // Animation-only FBX from Unreal Engine retarget: animation is named "Unreal Take"
+    // (with a space). After cleanup it should fall back to the skeleton/file name.
+    auto skelBase = createTestSkeleton("ue_base_skel", {"root", "spine"}, {"idle"});
+    auto skelAnim = createTestSkeleton("mm_attack_03.skeleton", {"root", "spine"}, {"Unreal Take"});
+
+    auto meshBase = createInMemoryMesh("ue_base_mesh", skelBase);
+
+    auto* sceneMgr = Manager::getSingleton()->getSceneMgr();
+    auto* nodeBase = sceneMgr->getRootSceneNode()->createChildSceneNode("ueBaseNode");
+    auto* entityBase = sceneMgr->createEntity("ueBaseEntity", meshBase);
+    nodeBase->attachObject(entityBase);
+
+    QString err;
+    auto* merged = AnimationMerger::mergeAnimations(entityBase, {}, {skelAnim}, err);
+
+    ASSERT_NE(merged, nullptr) << err.toStdString();
+    auto* skel = merged->getMesh()->getSkeleton().get();
+
+    // "Unreal Take" cleaned to "" → falls back to skeleton name "mm_attack_03"
+    EXPECT_TRUE(skel->hasAnimation("mm_attack_03"))
+        << "Expected animation named after source file, not 'Unreal Take' or empty";
+    EXPECT_FALSE(skel->hasAnimation("unreal_take"))
+        << "Noise token should have been removed";
+    EXPECT_FALSE(skel->hasAnimation(""))
+        << "Animation name must not be empty";
+
+    nodeBase->detachAllObjects();
+    sceneMgr->destroyEntity(entityBase);
+    sceneMgr->destroySceneNode(nodeBase);
+    Ogre::MeshManager::getSingleton().remove(meshBase);
+    Ogre::SkeletonManager::getSingleton().remove(skelBase);
+    Ogre::SkeletonManager::getSingleton().remove(skelAnim);
+}
+
+TEST_F(AnimationMergerTest, MergeAnimationsNumericSuffixPreserved)
+{
+    // Intentional numeric suffix in file name must not be stripped by deduplication.
+    // "mm_attack_03.skeleton" → animation should be "mm_attack_03", not "mm_attack".
+    auto skelBase = createTestSkeleton("numsfx_base_skel", {"root"}, {"idle"});
+    auto skelAnim = createTestSkeleton("mm_attack_03.skeleton", {"root"}, {"Unreal Take"});
+
+    auto meshBase = createInMemoryMesh("numsfx_base_mesh", skelBase);
+
+    auto* sceneMgr = Manager::getSingleton()->getSceneMgr();
+    auto* nodeBase = sceneMgr->getRootSceneNode()->createChildSceneNode("numsfxBaseNode");
+    auto* entityBase = sceneMgr->createEntity("numsfxBaseEntity", meshBase);
+    nodeBase->attachObject(entityBase);
+
+    QString err;
+    auto* merged = AnimationMerger::mergeAnimations(entityBase, {}, {skelAnim}, err);
+
+    ASSERT_NE(merged, nullptr) << err.toStdString();
+    auto* skel = merged->getMesh()->getSkeleton().get();
+
+    EXPECT_TRUE(skel->hasAnimation("mm_attack_03"))
+        << "Numeric suffix _03 should be preserved (not stripped to mm_attack)";
+    EXPECT_FALSE(skel->hasAnimation("mm_attack"))
+        << "Deduplication must not preemptively strip intentional _N suffixes";
+
+    nodeBase->detachAllObjects();
+    sceneMgr->destroyEntity(entityBase);
+    sceneMgr->destroySceneNode(nodeBase);
+    Ogre::MeshManager::getSingleton().remove(meshBase);
+    Ogre::SkeletonManager::getSingleton().remove(skelBase);
+    Ogre::SkeletonManager::getSingleton().remove(skelAnim);
+}
+
 // Standalone test that doesn't need Ogre initialization
 TEST(AnimationMergerStandaloneTest, MergeNoSkeletonError)
 {
diff --git a/src/Assimp/AnimationProcessor.cpp b/src/Assimp/AnimationProcessor.cpp
index 7c79e444d..42dea8a98 100644
--- a/src/Assimp/AnimationProcessor.cpp
+++ b/src/Assimp/AnimationProcessor.cpp
@@ -31,14 +31,20 @@ void AnimationProcessor::processAnimationChannel(aiNodeAnim* nodeAnim, Ogre::Ani
     // Create a map to store keyframes by time
     std::map<double, std::tuple<Ogre::Vector3, Ogre::Quaternion, Ogre::Vector3>> keyframes;
 
-    // Get the bone's T-pose position
+    // Get the bone's T-pose position and orientation
     auto boneTPosePosition = bone->getPosition();
-    // Process the position keys
+    Ogre::Quaternion boneTPoseInverseRotation = bone->getOrientation().Inverse();
+
+    // Process the position keys.
+    // Ogre applies translation keyframes in bone-local space (TS_LOCAL):
+    //   mPosition += mOrientation * delta
+    // So we must store the delta in bone-local space by pre-multiplying with the
+    // inverse of the bone's T-pose orientation.
     for(auto i = 0u; i < nodeAnim->mNumPositionKeys; i++) {
         aiVectorKey positionKey = nodeAnim->mPositionKeys[i];
         Ogre::Vector3 position(positionKey.mValue.x, positionKey.mValue.y, positionKey.mValue.z);
-        // Convert the position from local space to model space
-        position = position - boneTPosePosition;
+        // Compute delta in parent-local space, then rotate into bone-local space
+        position = boneTPoseInverseRotation * (position - boneTPosePosition);
 
         keyframes[positionKey.mTime] = std::make_tuple(
             position,
@@ -48,7 +54,6 @@ void AnimationProcessor::processAnimationChannel(aiNodeAnim* nodeAnim, Ogre::Ani
     }
 
     // Process the rotation keys
-    Ogre::Quaternion boneTPoseInverseRotation = bone->getOrientation().Inverse();
     for(auto i = 0u; i < nodeAnim->mNumRotationKeys; i++) {
         aiQuatKey rotationKey = nodeAnim->mRotationKeys[i];
         Ogre::Quaternion rot(rotationKey.mValue.w, rotationKey.mValue.x, rotationKey.mValue.y, rotationKey.mValue.z);
diff --git a/src/Assimp/BoneProcessor.cpp b/src/Assimp/BoneProcessor.cpp
index 09f34b42c..08edc766a 100644
--- a/src/Assimp/BoneProcessor.cpp
+++ b/src/Assimp/BoneProcessor.cpp
@@ -43,6 +43,22 @@ void BoneProcessor::processBones(Ogre::SkeletonPtr skeleton, const aiScene *scen
 
         processAnimationOnlyHierarchy(scene->mRootNode, animatedNodes);
     }
+
+}
+
+void BoneProcessor::bakeZupToYup(const Ogre::SkeletonPtr& skeleton)
+{
+    // Bake Z-up → Y-up into root bone rest poses so no scene-node rotation is needed.
+    // Only root bones (no parent in the Ogre skeleton) need to be rotated; child bones'
+    // local transforms are relative to their parent and are correct as-is.
+    const Ogre::Quaternion R_x90(Ogre::Degree(90), Ogre::Vector3::UNIT_X);
+    for (unsigned short i = 0; i < skeleton->getNumBones(); ++i) {
+        Ogre::Bone* bone = skeleton->getBone(i);
+        if (bone->getParent() == nullptr) {
+            bone->setPosition(R_x90 * bone->getPosition());
+            bone->setOrientation(R_x90 * bone->getOrientation());
+        }
+    }
 }
 
 void BoneProcessor::processBoneHierarchy(aiNode* node) {
diff --git a/src/Assimp/BoneProcessor.h b/src/Assimp/BoneProcessor.h
index 1cb54e7cd..4f821735c 100644
--- a/src/Assimp/BoneProcessor.h
+++ b/src/Assimp/BoneProcessor.h
@@ -7,6 +7,12 @@ class BoneProcessor {
     public:
         void processBones(Ogre::SkeletonPtr skeleton, const aiScene* scene);
 
+        // Bake Z-up → Y-up into root bone rest poses.
+        // Call this AFTER processAnimations() so animation deltas are computed
+        // against the original (pre-bake) T-pose — avoids a basis mismatch for
+        // embedded animations in Z-up mesh FBX files.
+        static void bakeZupToYup(const Ogre::SkeletonPtr& skeleton);
+
     private:
         void createBone(const std::string& boneName);
         void processBoneHierarchy(aiNode* node);
diff --git a/src/Assimp/Importer.cpp b/src/Assimp/Importer.cpp
index c17d68d58..97bd52b74 100644
--- a/src/Assimp/Importer.cpp
+++ b/src/Assimp/Importer.cpp
@@ -80,8 +80,21 @@ Ogre::MeshPtr AssimpToOgreImporter::loadModel(const std::string& path, bool conv
         return {};
     }
 
-    modelName = scene->mName.C_Str();
-    if(modelName.empty()) modelName = path.substr(path.find_last_of("/\\") + 1);
+    // Always prefer the path-based filename — FBX metadata names (scene->mName) are
+    // often generic ("unreal_take", "RootNode", "Scene", etc.) and don't reflect the
+    // actual file the user imported.
+    {
+        std::string filename = path.substr(path.find_last_of("/\\") + 1);
+        auto dot = filename.find_last_of('.');
+        std::string pathName = (dot != std::string::npos) ? filename.substr(0, dot) : filename;
+        if (!pathName.empty())
+            modelName = pathName;
+        else {
+            modelName = scene->mName.C_Str();
+            if (modelName.empty())
+                modelName = "model";
+        }
+    }
 
     // Remove stale resources from a previous import of the same file
     if (auto oldMesh = Ogre::MeshManager::getSingleton().getByName(modelName))
@@ -98,22 +111,35 @@ Ogre::MeshPtr AssimpToOgreImporter::loadModel(const std::string& path, bool conv
     for(unsigned i = 0; i < scene->mNumMeshes && !hasBones; ++i)
         hasBones = scene->mMeshes[i]->mNumBones > 0;
 
+    const bool isZup = (m_sceneUpAxis == 2);
+
     if(hasBones || scene->HasAnimations()) {
         skeleton = Ogre::SkeletonManager::getSingleton().create(modelName+".skeleton", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
         BoneProcessor boneProcessor;
+        // Create bones at their native FBX-space positions (no Z-up bake yet).
         boneProcessor.processBones(skeleton, scene);
 
-        // Save the bind pose so that animation deltas are applied relative to
-        // the correct base transforms.  Binary SkeletonSerializer calls this
-        // automatically on load, but for in-memory skeletons we must do it
-        // explicitly before creating animations.
+        // Save the bind pose BEFORE processing animations so that animation
+        // deltas are computed relative to the original (unbaked) T-pose.
+        // This avoids a basis mismatch for Z-up files that have embedded animations:
+        // if we baked first, AnimationProcessor would measure deltas against the
+        // already-baked bone orientations while the keyframe data is still in Z-up.
         skeleton->setBindingPose();
 
         if(scene->HasAnimations()) {
-            // Process animations
             AnimationProcessor animationProcessor(skeleton);
             animationProcessor.processAnimations(scene);
         }
+
+        // Now bake Z-up → Y-up into root bone rest poses — mesh skeletons only.
+        // Animation-only skeletons stay in native Z-up so AnimationMerger's
+        // boneCorrection can apply the single correct conversion on merge.
+        if (isZup && !animationOnly) {
+            BoneProcessor::bakeZupToYup(skeleton);
+            // Re-snapshot the binding pose after baking so Ogre's reset() returns
+            // to the correct Y-up rest pose.
+            skeleton->setBindingPose();
+        }
     }
 
     // For animation-only files there is no geometry to process.
@@ -121,7 +147,7 @@ Ogre::MeshPtr AssimpToOgreImporter::loadModel(const std::string& path, bool conv
         return {};
 
     // Process the root node recursively (meshes)
-    MeshProcessor meshProcessor(skeleton);
+    MeshProcessor meshProcessor(skeleton, isZup);
     meshProcessor.processNode(scene->mRootNode, scene);
     Ogre::MeshPtr ogreMesh = meshProcessor.createMesh(modelName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, materialProcessor);
 
diff --git a/src/Assimp/MeshProcessor.cpp b/src/Assimp/MeshProcessor.cpp
index a3832cf69..8cb5229f2 100644
--- a/src/Assimp/MeshProcessor.cpp
+++ b/src/Assimp/MeshProcessor.cpp
@@ -37,7 +37,8 @@ static void bindVector4Buffer(Ogre::VertexData* vertexData, unsigned short sourc
     vertexData->vertexBufferBinding->setBinding(source, buf);
 }
 
-MeshProcessor::MeshProcessor(Ogre::SkeletonPtr skeleton):skeleton(skeleton) {}
+MeshProcessor::MeshProcessor(Ogre::SkeletonPtr skeleton, bool isZup)
+    : skeleton(skeleton), m_isZup(isZup) {}
 
 void MeshProcessor::processNode(aiNode* node, const aiScene* scene) {
     // Process each mesh located at the current node
@@ -55,14 +56,21 @@ void MeshProcessor::processNode(aiNode* node, const aiScene* scene) {
 SubMeshData* MeshProcessor::processMesh(aiMesh* mesh, const aiScene* scene) {
     SubMeshData* subMeshData = new SubMeshData();
 
+    // Rotation applied to vertex data when the source file uses a Z-up coordinate system.
+    // Baking it here avoids a scene-node rotation and keeps the entity in its natural pose.
+    const Ogre::Quaternion R_x90(m_isZup ? Ogre::Quaternion(Ogre::Degree(90), Ogre::Vector3::UNIT_X)
+                                         : Ogre::Quaternion::IDENTITY);
+
     // Initialize blend indices and blend weights
     for(auto i = 0u; i < mesh->mNumVertices; i++) {
         // Process vertices
-        subMeshData->vertices.push_back(Ogre::Vector3(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z));
+        Ogre::Vector3 v(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
+        subMeshData->vertices.push_back(m_isZup ? R_x90 * v : v);
 
         // Process normals
         if(mesh->HasNormals()) {
-            subMeshData->normals.push_back(Ogre::Vector3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z));
+            Ogre::Vector3 n(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
+            subMeshData->normals.push_back(m_isZup ? R_x90 * n : n);
         }
 
         // Process texture coordinates
@@ -106,6 +114,7 @@ SubMeshData* MeshProcessor::processMesh(aiMesh* mesh, const aiScene* scene) {
             Ogre::Vector3 T(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z);
             Ogre::Vector3 B(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z);
             Ogre::Vector3 N(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
+            if (m_isZup) { T = R_x90 * T; B = R_x90 * B; N = R_x90 * N; }
             // Compute handedness: if cross(N,T) is opposite to B, the tangent space is left-handed
             float handedness = (N.crossProduct(T).dotProduct(B) < 0.0f) ? -1.0f : 1.0f;
             subMeshData->tangents.push_back(Ogre::Vector4(T.x, T.y, T.z, handedness));
diff --git a/src/Assimp/MeshProcessor.h b/src/Assimp/MeshProcessor.h
index 81614a40f..ac5f35d81 100644
--- a/src/Assimp/MeshProcessor.h
+++ b/src/Assimp/MeshProcessor.h
@@ -18,16 +18,17 @@ struct SubMeshData {
 
 class MeshProcessor {
 public:
-    MeshProcessor(Ogre::SkeletonPtr skeleton);
+    MeshProcessor(Ogre::SkeletonPtr skeleton, bool isZup = false);
     void processNode(aiNode* node, const aiScene* scene);
     Ogre::MeshPtr createMesh(const Ogre::String& name, const Ogre::String& group, MaterialProcessor &materialProcessor);
 
 protected:
     // Protected for testing purposes
     SubMeshData* processMesh(aiMesh* mesh, const aiScene* scene);
-    
+
 private:
     std::vector<SubMeshData*> subMeshesData;
     std::vector<Ogre::VertexBoneAssignment> boneAssignments;
     Ogre::SkeletonPtr skeleton;
+    bool m_isZup;
 };
diff --git a/src/MeshImporterExporter.cpp b/src/MeshImporterExporter.cpp
index 4294f2e12..982238fd3 100755
--- a/src/MeshImporterExporter.cpp
+++ b/src/MeshImporterExporter.cpp
@@ -40,6 +40,7 @@ THE SOFTWARE.
 #include "OgreXML/OgreXMLSkeletonSerializer.h"
 #include "OgreXML/pugixml.hpp"
 
+#include "AnimationMerger.h"
 #include "Manager.h"
 #include "SelectionSet.h"
 #include "SentryReporter.h"
@@ -844,6 +845,8 @@ void MeshImporterExporter::importer(const QStringList &_uriList, unsigned int ad
             {
                 sn = Manager::getSingleton()->addSceneNode(QString(file.baseName()));
                 en = Manager::getSingleton()->createEntity(sn, Ogre::MeshManager::getSingleton().load(file.fileName().toStdString().data(), file.path().toStdString().data()));
+                if (en->getMesh() && en->getMesh()->getSkeleton())
+                    AnimationMerger::registerSkeletonUpAxis(en->getMesh()->getSkeleton()->getName(), 1);
             }
             else if(!file.suffix().compare("xml",Qt::CaseInsensitive))
             {
@@ -853,6 +856,8 @@ void MeshImporterExporter::importer(const QStringList &_uriList, unsigned int ad
 
                 sn = Manager::getSingleton()->addSceneNode(meshName);
                 en = Manager::getSingleton()->createEntity(sn, mesh);
+                if (en->getMesh() && en->getMesh()->getSkeleton())
+                    AnimationMerger::registerSkeletonUpAxis(en->getMesh()->getSkeleton()->getName(), 1);
             }
             else
             {
@@ -868,8 +873,14 @@ void MeshImporterExporter::importer(const QStringList &_uriList, unsigned int ad
                     // Collect into the caller-provided list; callers that want UI notifications
                     // should pass outAnimOnlySkeletons and handle presentation themselves.
                     Ogre::SkeletonPtr skel = importer.getLoadedSkeleton();
-                    if (skel && outAnimOnlySkeletons)
-                        outAnimOnlySkeletons->append(skel);
+                    if (skel) {
+                        // Animation-only skeletons are NOT baked — register native up-axis
+                        // so AnimationMerger can apply the correct Z-up → Y-up conversion
+                        // when merging into a baked (Y-up) mesh skeleton.
+                        AnimationMerger::registerSkeletonUpAxis(skel->getName(), importer.getSceneUpAxis());
+                        if (outAnimOnlySkeletons)
+                            outAnimOnlySkeletons->append(skel);
+                    }
                     continue;
                 }
 
@@ -877,12 +888,13 @@ void MeshImporterExporter::importer(const QStringList &_uriList, unsigned int ad
                 sn = Manager::getSingleton()->addSceneNode(QString(meshName));
                 en = Manager::getSingleton()->createEntity(sn, mesh);
 
-                // Auto-correct Z-up coordinate systems (e.g. Unreal Engine FBX exports).
-                // Rotate the scene node so the mesh stands upright in Ogre's Y-up world.
-                // Bone data and animations remain in their native space — the node rotation
-                // is purely a display correction and does not affect animation playback.
-                if (importer.getSceneUpAxis() == 2)
-                    sn->rotate(Ogre::Vector3::UNIT_X, Ogre::Degree(90));
+                // Register the original coordinate system. Baking is purely a display
+                // fix (vertices + root-bone rest poses rotated); it does not change the
+                // bone-orientation relationships that AnimationMerger relies on for the
+                // per-bone boneCorrection, so the native upAxis is still correct here.
+                if (en->getMesh() && en->getMesh()->getSkeleton())
+                    AnimationMerger::registerSkeletonUpAxis(
+                        en->getMesh()->getSkeleton()->getName(), importer.getSceneUpAxis());
             }
 
             sn->setPosition(0,0,0);
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 14b37246a..e0244f8e3 100755
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -716,9 +716,14 @@ void MainWindow::importMeshs(const QStringList &_uriList)
                 QMessageBox::Yes | QMessageBox::No);
             if (btn == QMessageBox::Yes) {
                 QString errMsg;
-                AnimationMerger::mergeAnimations(baseEntity, {}, {skel}, errMsg);
-                if (!errMsg.isEmpty())
-                    QMessageBox::warning(this, "Merge failed", errMsg);
+                Ogre::Entity* merged = AnimationMerger::mergeAnimations(baseEntity, {}, {skel}, errMsg);
+                if (!merged) {
+                    QMessageBox::warning(this, "Merge failed",
+                        errMsg.isEmpty() ? "Merge failed (unknown error)" : errMsg);
+                } else {
+                    // Re-select so the inspector panel refreshes its animation list.
+                    SelectionSet::getSingleton()->append(baseEntity);
+                }
             }
         } else {
             QMessageBox::information(this, "Animation-only file",