@@ -4395,13 +4395,36 @@ transformation they encode is accumulated in their direct children; frames are p
         - ``massscale="k" scaling="geometry"``
       * - a change of the units of length and mass
         - ``scale="s" massscale="k"``
+      * - a body stretched along the frame's axes, see below
+        - ``scale="sx sy sz" scaling="geometry"``
 
    Scales of nested frames compose by multiplication. A single value applies to all three axes. Values must be finite
-   and positive, and the three values must currently be equal: anisotropic scaling is not yet supported.
+   and positive.
+
+   Three different values stretch the contents along the frame's axes, which requires :at:`scaling` "geometry".
+   Positions are mapped exactly and orientations are kept, so each shape inside is stretched in its own coordinates,
+   which only some shapes can represent:
+
+   - meshes always, with an instance of the mesh for each distinct stretch;
+   - boxes, ellipsoids, planes and height fields aligned with the frame's axes;
+   - capsules and cylinders aligned with the frame's axes and stretched equally across their own axis. The caps of a
+     capsule stay hemispherical: with :math:`a` the factor across its axis and :math:`c` the factor along it, its
+     radius :math:`r` becomes :math:`a r` and its half-length :math:`h` becomes :math:`c h`, so that its total length
+     is :math:`2 (c h + a r)` rather than :math:`2 c (h + r)`;
+   - spheres only when scaled uniformly; use an ellipsoid otherwise.
+
+   Hinge and slide joints must also be aligned with the frame's axes. Anything else is a compile error; alignment is
+   checked to within about 2 degrees. Sites are never an error: a site box, ellipsoid, capsule or cylinder is stretched
+   by the factor along each of its own axes, with the radius of a capsule or cylinder taking the geometric mean of the
+   two factors across it, which is approximate when the site is not aligned. Explicit inertias transform exactly.
+   Sphere sites, and lengths without a direction like margins, contact widths and tendon widths, take the geometric mean
+   of the three factors.
 
    A mesh or height field used at several scales compiles to an instance per scale; the first keeps its name and the
-   others are named ``name@1``, ``name@2``, ... The bones of a skin must have the same scale, and elements with
-   plugins and tactile sensors cannot be scaled.
+   others are named ``name@1``, ``name@2``, ... A model saved compiled writes a mesh instance which is not stretched
+   along its own axes as vertices and faces; its texture coordinates are kept only if they are given per vertex, and its
+   normals are recomputed. The bones of a skin must have the same scale, and elements with plugins and tactile sensors
+   cannot be scaled.
 
 .. _frame-scaling:
 
 
@@ -10,13 +10,10 @@ Significant new features
 - Frames can now resize their contents at compile time, without modifying the spec, using the new
   :ref:`scale<frame-scale>`, :ref:`scaling<frame-scaling>` and :ref:`massscale<frame-massscale>` attributes. Under the
   default ``similar`` policy a scaled model moves like the original in proportionally scaled gravity; under ``geometry``
-  only shapes and inertias change. Masses follow volumes unless ``massscale`` sets their factor. Elements outside the
-  kinematic tree, like actuators, tendons, equalities, contact pairs and sensors, take the scale of the elements they
-  refer to, and keyframes are scaled like the joints, bodies and actuators they set. :ref:`mj_copyBack` and the
-  operations which write compiled inertials to the spec write values in its units. A mesh or height field which is used
-  at several scales compiles to an instance per scale, named after it (``name@1``, ``name@2``, ...). A flex takes the
-  scale of the lowest frame or body containing its bodies, with its vertices scaled by their own bodies; a skin scales
-  with its bones, which must all have the same scale. See :ref:`frame/scale<frame-scale>` for details.
+  only shapes and inertias change, and the scale may be anisotropic. Masses follow volumes unless ``massscale`` sets
+  their factor. Everything which refers to the contents of a frame follows its scale: actuators, tendons, equalities,
+  contact pairs, sensors, keyframes, meshes, height fields, flexes and skins. :ref:`mj_copyBack` and the operations
+  which write compiled inertials to the spec write values in its units. See :ref:`frame/scale<frame-scale>` for details.
 - Models can now be saved as written. With the new :ref:`savecompiled<compiler-savecompiled>` compiler attribute set to
   "false", a model is saved as it is in the :ref:`mjSpec`, with its default classes, frames and exact numbers, and reads
   back as the same spec. With :ref:`savecanonical<compiler-savecanonical>` "false" it also keeps the notation it was
 
@@ -950,12 +950,12 @@ bool mjCFlexcomp::MakeMesh(
       return false;
     }
 
-    if (cmesh->instancescale_ != 1) {
-      unscaled                 = std::make_unique<mjCMesh>(*cmesh);
-      unscaled->model          = cmesh->model;
-      unscaled->compiler       = cmesh->compiler;
-      unscaled->instancescale_ = 1;
-      cmesh                    = unscaled.get();
+    if (cmesh->instancemap_ != decltype(cmesh->instancemap_){1, 0, 0, 0, 1, 0, 0, 0, 1}) {
+      unscaled               = std::make_unique<mjCMesh>(*cmesh);
+      unscaled->model        = cmesh->model;
+      unscaled->compiler     = cmesh->compiler;
+      unscaled->instancemap_ = {1, 0, 0, 0, 1, 0, 0, 0, 1};
+      cmesh                  = unscaled.get();
     }
 
     try {
 
@@ -296,7 +296,9 @@ void mjCMesh::NameSpace(const mjCModel* m) {
 
 void mjCMesh::CopyFromSpec() {
   *static_cast<mjsMesh*>(this) = spec;
-  for (int i = 0; i < 3; i++) { scale[i] *= instancescale_; }
+  if (InstanceDiagonal()) {
+    for (int i = 0; i < 3; i++) { scale[i] *= instancemap_[4 * i]; }
+  }
 
   file_         = spec_file_;
   content_type_ = spec_content_type_;
@@ -324,6 +326,8 @@ void mjCMesh::CopyFromSpec() {
   tree_ = mjCBoundingVolumeHierarchy();
   face_aabb_.clear();
   octree_.Clear();
+  mjuu_setvec(aamm_, 1e10, 1e10, 1e10);
+  mjuu_setvec(aamm_ + 3, -1e10, -1e10, -1e10);
 }
 
 
@@ -347,7 +351,7 @@ void mjCMesh::LoadSDF() {
                    id);
   }
 
-  if (instancescale_ != 1) {
+  if (instancemap_ != decltype(instancemap_){1, 0, 0, 0, 1, 0, 0, 0, 1}) {
     throw mjCError(this, "SDF mesh '%s' cannot be scaled by a frame", name.c_str());
   }
   if (scale[0] != 1 || scale[1] != 1 || scale[2] != 1) {
@@ -515,10 +519,27 @@ void mjCMesh::CacheMesh(mjCCache* cache, const mjResource* resource) {
 // id of the mesh in the asset cache: that of its file, and its factor for an instance at another
 // scale
 std::string mjCMesh::CacheId(const mjResource* resource) const {
-  if (instancescale_ == 1) { return resource->name; }
-  char factor[32];
-  std::snprintf(factor, sizeof(factor), "@%a", instancescale_);
-  return std::string(resource->name) + factor;
+  const auto& m = instancemap_;
+  if (InstanceDiagonal() && m[0] == m[4] && m[4] == m[8]) {
+    if (m[0] == 1) { return resource->name; }
+    char factor[32];
+    std::snprintf(factor, sizeof(factor), "@%a", m[0]);
+    return std::string(resource->name) + factor;
+  }
+  std::string id = std::string(resource->name) + "@";
+  for (double x : m) {
+    char factor[32];
+    std::snprintf(factor, sizeof(factor), "%a,", x);
+    id += factor;
+  }
+  return id;
+}
+
+
+// true if the map of this instance is diagonal, which then multiplies the scale of the mesh
+bool mjCMesh::InstanceDiagonal() const {
+  const auto& m = instancemap_;
+  return !m[1] && !m[2] && !m[3] && !m[5] && !m[6] && !m[7];
 }
 
 namespace {
@@ -1278,6 +1299,26 @@ void mjCMesh::ApplyTransformations(double* dvert) {
     }
   }
 
+  // the map of an instance which does not multiply the scale; normals by the inverse transpose
+  if (!InstanceDiagonal()) {
+    const double* m = instancemap_.data();
+    for (int i = 0; i < nvert(); i++) { mjuu_mulvecmat(&dvert[3 * i], &dvert[3 * i], m); }
+    double cof[9] = {m[4] * m[8] - m[5] * m[7],
+                     m[5] * m[6] - m[3] * m[8],
+                     m[3] * m[7] - m[4] * m[6],
+                     m[2] * m[7] - m[1] * m[8],
+                     m[0] * m[8] - m[2] * m[6],
+                     m[1] * m[6] - m[0] * m[7],
+                     m[1] * m[5] - m[2] * m[4],
+                     m[2] * m[3] - m[0] * m[5],
+                     m[0] * m[4] - m[1] * m[3]};
+    for (int i = 0; i < nnormal(); i++) {
+      double n[3] = {normal_[3 * i], normal_[3 * i + 1], normal_[3 * i + 2]};
+      mjuu_mulvecmat(n, n, cof);
+      for (int k = 0; k < 3; k++) { normal_[3 * i + k] = (float)n[k]; }
+    }
+  }
+
   // normalize normals
   for (int i = 0; i < nnormal(); i++) {
     // compute length
@@ -3520,17 +3561,26 @@ void mjCSkin::ResolveReferences(const mjCModel* m) {
 
 
 // scale the compiled copy by the gauge of the bones: the vertices and the bind poses are given in
-// the same coordinates, in which the offsets of the vertices from the bones scale with the bones
+// the same coordinates, in which the offsets of the vertices from the bones scale with the bones,
+// whose maps, expressed there through their bind orientations, must agree
 void mjCSkin::ApplyGauge() {
-  scale_ = 1;
+  scaled_ = false;
   if (bodyid.empty()) { return; }
-  const mjCGauge g = model->Bodies()[bodyid[0]]->ContentGauge();
-  for (int b : bodyid) {
-    if (model->Bodies()[b]->ContentGauge().shape != g.shape) {
-      throw mjCError(this, "the bones of a skin must have the same scale");
+  std::vector<mjCGauge> gauges;
+  for (int i = 0; i < bodyid.size(); i++) {
+    const float* q       = bindquat_.data() + 4 * i;
+    double       conj[4] = {q[0], -q[1], -q[2], -q[3]};
+    gauges.push_back(model->Bodies()[bodyid[i]]->ContentGauge().Rotated(conj));
+  }
+  const mjCGauge& g = gauges[0];
+  for (const mjCGauge& b : gauges) {
+    bool same = b.uniform == g.uniform && b.shape == g.shape;
+    for (int k = 0; k < 9 && same && !g.uniform; k++) {
+      same = std::abs(b.map[k] - g.map[k]) <= 1e-6 * g.shape;
     }
+    if (!same) { throw mjCError(this, "the bones of a skin must have the same scale"); }
   }
-  if (g.shape == 1) { return; }
+  if (g.uniform && g.shape == 1) { return; }
   auto points = [&g](std::vector<float>& pos) {
     for (int i = 0; i < pos.size() / 3; i++) {
       double x[3] = {pos[3 * i], pos[3 * i + 1], pos[3 * i + 2]};
@@ -3541,7 +3591,7 @@ void mjCSkin::ApplyGauge() {
   points(vert_);
   points(bindpos_);
   inflate *= g.Shape(1);
-  scale_   = g.shape;
+  scaled_  = true;
 }
 
 
 
@@ -2050,33 +2050,35 @@ std::vector<mjCHField*> mjCModel::CompiledHFields() const {
 
 // give each use of an asset the instance of the asset at the scale of the use: the asset itself at
 // the scale of its first use, and instances named after it at the others
+using InstanceMap = std::array<double, 9>;
+
 template <class T>
-static void Instantiate(const mjCModel*                            model,
-                        mjtObj                                     type,
-                        std::vector<T*>&                           assets,
-                        std::vector<T*>&                           instances,
-                        const std::vector<std::pair<T**, double>>& uses,
-                        bool                                       reuse) {
+static void Instantiate(const mjCModel*                                 model,
+                        mjtObj                                          type,
+                        std::vector<T*>&                                assets,
+                        std::vector<T*>&                                instances,
+                        const std::vector<std::pair<T**, InstanceMap>>& uses,
+                        bool                                            reuse) {
   if (!reuse) {
     for (T* instance : instances) { delete instance; }
     instances.clear();
-    std::unordered_map<const T*, double> first;
+    std::unordered_map<const T*, InstanceMap> first;
     for (const auto& [use, scale] : uses) { first.emplace(*use, scale); }
     for (T* asset : assets) {
-      auto   it    = first.find(asset);
-      double scale = it == first.end() ? 1 : it->second;
-      if (asset->instancescale_ != scale) {
-        asset->instancescale_ = scale;
+      auto        it    = first.find(asset);
+      InstanceMap scale = it == first.end() ? InstanceMap{1, 0, 0, 0, 1, 0, 0, 0, 1} : it->second;
+      if (asset->instancemap_ != scale) {
+        asset->instancemap_ = scale;
         asset->CopyFromSpec();
       }
     }
   }
 
   for (const auto& [use, scale] : uses) {
     T* asset = *use;
-    if (asset->instancescale_ == scale) { continue; }
-    auto same = [asset, scale](const T* instance) {
-      return instance->primary_ == asset && instance->instancescale_ == scale;
+    if (asset->instancemap_ == scale) { continue; }
+    auto same = [asset, &scale](const T* instance) {
+      return instance->primary_ == asset && instance->instancemap_ == scale;
     };
     auto it = std::find_if(instances.begin(), instances.end(), same);
     if (it == instances.end()) {
@@ -2088,13 +2090,13 @@ static void Instantiate(const mjCModel*                            model,
       if (model->FindObject(type, name)) {
         throw mjCError(asset, "the name '%s' of an instance of this asset is taken", name.c_str());
       }
-      T* instance              = new T(*asset);
-      instance->model          = asset->model;
-      instance->compiler       = asset->compiler;
-      instance->name           = name;
-      instance->primary_       = asset;
-      instance->instancescale_ = scale;
-      instance->id             = assets.size() + instances.size();
+      T* instance            = new T(*asset);
+      instance->model        = asset->model;
+      instance->compiler     = asset->compiler;
+      instance->name         = name;
+      instance->primary_     = asset;
+      instance->instancemap_ = scale;
+      instance->id           = assets.size() + instances.size();
       instance->CopyFromSpec();
       instances.push_back(instance);
       it = instances.end() - 1;
@@ -2122,14 +2124,14 @@ static void Instantiate(const mjCModel*                            model,
 // give the geoms and sites which use a mesh or a height field the instance of the asset at the
 // scale of their use, in the order of their ids, made again unless the assets are reused
 void mjCModel::MakeInstances(bool reuse) {
-  std::vector<std::pair<mjCMesh**, double>>   meshuses;
-  std::vector<std::pair<mjCHField**, double>> hfielduses;
+  std::vector<std::pair<mjCMesh**, InstanceMap>>   meshuses;
+  std::vector<std::pair<mjCHField**, InstanceMap>> hfielduses;
   for (mjCGeom* geom : geoms_) {
-    if (geom->mesh) { meshuses.emplace_back(&geom->mesh, geom->Gauge().shape); }
-    if (geom->hfield) { hfielduses.emplace_back(&geom->hfield, geom->Gauge().shape); }
+    if (geom->mesh) { meshuses.emplace_back(&geom->mesh, geom->ShapeMap()); }
+    if (geom->hfield) { hfielduses.emplace_back(&geom->hfield, geom->ShapeMap()); }
   }
   for (mjCSite* site : sites_) {
-    if (site->mesh) { meshuses.emplace_back(&site->mesh, site->Gauge().shape); }
+    if (site->mesh) { meshuses.emplace_back(&site->mesh, site->ShapeMap()); }
   }
   Instantiate(this, mjOBJ_MESH, meshes_, meshinstances_, meshuses, reuse);
   Instantiate(this, mjOBJ_HFIELD, hfields_, hfieldinstances_, hfielduses, reuse);